#include <rz_util/rz_annotated_code.h>
#include <rz_util.h>
#include <rz_core.h>
#include <rz_types.h>
#include <rz_vector.h>

Macros
#define	PALETTE(x) (cons && cons->context->pal.x) ? cons->context->pal.x

#define	PRINT_COLOR(x)

Functions
RZ_API void	rz_core_annotated_code_print_json (RzAnnotatedCode *code)

static void	print_offset_in_binary_line_bar (RzAnnotatedCode *code, ut64 offset, size_t width)

RZ_API void	rz_core_annotated_code_print (RzAnnotatedCode code, RzVector line_offsets)

static bool	foreach_offset_annotation (void user, const ut64 offset, const void val)

RZ_API void	rz_core_annotated_code_print_comment_cmds (RzAnnotatedCode *code)

Macro Definition Documentation

◆ PALETTE

#define PALETTE ( x ) (cons && cons->context->pal.x) ? cons->context->pal.x

Definition at line 97 of file cannotated_code.c.

◆ PRINT_COLOR

#define PRINT_COLOR ( x )

Value:

    do { \
        if (cons->context->color_mode) { \
            rz_cons_printf("%s", (x)); \
        } \
    } while (0)

Definition at line 98 of file cannotated_code.c.

Function Documentation

◆ foreach_offset_annotation()

static bool foreach_offset_annotation	(	void *	user,
		const ut64	offset,
		const void *	val
	)

static

Definition at line 261 of file cannotated_code.c.

                                                                                       {
     RzAnnotatedCode *code = user;
     const RzCodeAnnotation *annotation = val;
     char *b64statement = rz_base64_encode_dyn((const ut8 *)(code->code + annotation->start),
         annotation->end - annotation->start);
     rz_cons_printf("CCu base64:%s @ 0x%" PFMT64x "\n", b64statement, annotation->offset.offset);
     free(b64statement);
     return true;
 }

References rz_code_annotation_t::end, free(), rz_code_annotation_t::offset, PFMT64x, rz_base64_encode_dyn(), rz_cons_printf(), rz_code_annotation_t::start, and val.

Referenced by rz_core_annotated_code_print_comment_cmds().

◆ print_offset_in_binary_line_bar()

static void print_offset_in_binary_line_bar	(	RzAnnotatedCode *	code,
		ut64	offset,
		size_t	width
	)

static

Parameters

width maximum nibbles per address

Definition at line 108 of file cannotated_code.c.

                                                                                               {
     static const char *fmt[9] = {
         "0x%08" PFMT64x,
         "0x%09" PFMT64x,
         "0x%010" PFMT64x,
         "0x%011" PFMT64x,
         "0x%012" PFMT64x,
         "0x%013" PFMT64x,
         "0x%014" PFMT64x,
         "0x%015" PFMT64x,
         "0x%016" PFMT64x
     };
     if (width < 8) {
         width = 8;
     }
     if (width > 16) {
         width = 16;
     }
     width -= 8;
  
     RzCons *cons = rz_cons_singleton();
     rz_cons_printf("    ");
     if (offset == UT64_MAX) {
         rz_cons_print("          ");
         while (width > 0) {
             rz_cons_print(" ");
             width--;
         }
     } else {
         PRINT_COLOR(PALETTE(offset)
                 : Color_GREEN);
         rz_cons_printf(fmt[width], offset);
         PRINT_COLOR(Color_RESET);
     }
     rz_cons_printf("    |");
 }

References Color_GREEN, Color_RESET, PALETTE, PFMT64x, PRINT_COLOR, rz_cons_printf(), rz_cons_singleton(), UT64_MAX, and width.

Referenced by rz_core_annotated_code_print().

◆ rz_core_annotated_code_print()

RZ_API void rz_core_annotated_code_print	(	RzAnnotatedCode *	code,
		RzVector *	line_offsets
	)

Definition at line 145 of file cannotated_code.c.

                                                                                           {
     if (code->annotations.len == 0) {
         rz_cons_printf("%s\n", code->code);
         return;
     }
  
     size_t cur = 0;
     size_t line_idx = 0;
     size_t len = strlen(code->code);
  
     size_t offset_width = 0;
     if (line_offsets) {
         ut64 *offset;
         ut64 offset_max = 0;
         rz_vector_foreach(line_offsets, offset) {
             if (*offset != UT64_MAX && *offset > offset_max) {
                 offset_max = *offset;
             }
         }
         while (offset_max) {
             offset_width += 1;
             offset_max >>= 4;
         }
         if (offset_width < 4) {
             offset_width = 4;
         }
     }
  
     RzCons *cons = rz_cons_singleton();
     RzCodeAnnotation *annotation;
     rz_vector_foreach(&code->annotations, annotation) {
         if (annotation->type != RZ_CODE_ANNOTATION_TYPE_SYNTAX_HIGHLIGHT) {
             continue;
         }
  
         // (1/3)
         // now we have a syntax highlighting annotation.
         // pick a suitable color for it.
         const char *color = Color_RESET;
         switch (annotation->syntax_highlight.type) {
         case RZ_SYNTAX_HIGHLIGHT_TYPE_COMMENT:
             color = PALETTE(comment)
                 : Color_WHITE;
             break;
         case RZ_SYNTAX_HIGHLIGHT_TYPE_KEYWORD:
             color = PALETTE(pop)
                 : Color_MAGENTA;
             break;
         case RZ_SYNTAX_HIGHLIGHT_TYPE_DATATYPE:
             color = PALETTE(func_var_type)
                 : Color_BLUE;
             break;
         case RZ_SYNTAX_HIGHLIGHT_TYPE_FUNCTION_NAME:
             color = PALETTE(fname)
                 : Color_RED;
             break;
         case RZ_SYNTAX_HIGHLIGHT_TYPE_CONSTANT_VARIABLE:
             color = PALETTE(num)
                 : Color_YELLOW;
         default:
             break;
         }
  
         // (2/3)
         // the chunk before the syntax highlighting annotation should not be colored
         for (; cur < annotation->start && cur < len; cur++) {
             // if we are starting a new line and we are printing with offsets
             // we need to prepare the bar with offsets on the left handside before that
             if (line_offsets && (cur == 0 || code->code[cur - 1] == '\n')) {
                 ut64 offset = 0;
                 if (line_idx < line_offsets->len) {
                     offset = *(ut64 *)rz_vector_index_ptr(line_offsets, line_idx);
                 }
                 print_offset_in_binary_line_bar(code, offset, offset_width);
                 line_idx++;
             }
             rz_cons_printf("%c", code->code[cur]);
         }
  
         // (3/3)
         // everything in between the "start" and the "end" inclusive should be highlighted
         PRINT_COLOR(color);
         for (; cur < annotation->end && cur < len; cur++) {
             // if we are starting a new line and we are printing with offsets
             // we need to prepare the bar with offsets on the left handside before that
             if (line_offsets && (cur == 0 || code->code[cur - 1] == '\n')) {
                 ut64 offset = 0;
                 if (line_idx < line_offsets->len) {
                     offset = *(ut64 *)rz_vector_index_ptr(line_offsets, line_idx);
                 }
                 PRINT_COLOR(Color_RESET);
                 print_offset_in_binary_line_bar(code, offset, offset_width);
                 PRINT_COLOR(color);
                 line_idx++;
             }
             rz_cons_printf("%c", code->code[cur]);
         }
         PRINT_COLOR(Color_RESET);
     }
     // the rest of the decompiled code should be printed
     // without any highlighting since we don't have any annotations left
     for (; cur < len; cur++) {
         // if we are starting a new line and we are printing with offsets
         // we need to prepare the bar with offsets on the left handside before that
         if (line_offsets && (cur == 0 || code->code[cur - 1] == '\n')) {
             ut64 offset = 0;
             if (line_idx < line_offsets->len) {
                 offset = *(ut64 *)rz_vector_index_ptr(line_offsets, line_idx);
             }
             print_offset_in_binary_line_bar(code, offset, offset_width);
             line_idx++;
         }
         rz_cons_printf("%c", code->code[cur]);
     }
 }

References color, Color_BLUE, Color_MAGENTA, Color_RED, Color_RESET, Color_WHITE, Color_YELLOW, rz_code_annotation_t::end, create_tags_rz::fname, len, num, PALETTE, PRINT_COLOR, print_offset_in_binary_line_bar(), RZ_CODE_ANNOTATION_TYPE_SYNTAX_HIGHLIGHT, rz_cons_printf(), rz_cons_singleton(), RZ_SYNTAX_HIGHLIGHT_TYPE_COMMENT, RZ_SYNTAX_HIGHLIGHT_TYPE_CONSTANT_VARIABLE, RZ_SYNTAX_HIGHLIGHT_TYPE_DATATYPE, RZ_SYNTAX_HIGHLIGHT_TYPE_FUNCTION_NAME, RZ_SYNTAX_HIGHLIGHT_TYPE_KEYWORD, rz_vector_foreach, rz_vector_index_ptr(), rz_code_annotation_t::start, rz_code_annotation_t::syntax_highlight, rz_code_annotation_t::type, ut64(), and UT64_MAX.

◆ rz_core_annotated_code_print_comment_cmds()

RZ_API void rz_core_annotated_code_print_comment_cmds ( RzAnnotatedCode * code )

Definition at line 271 of file cannotated_code.c.

                                                                              {
     RzCodeAnnotation *annotation;
     HtUP *ht = ht_up_new0();
     rz_vector_foreach(&code->annotations, annotation) {
         if (annotation->type != RZ_CODE_ANNOTATION_TYPE_OFFSET) {
             continue;
         }
         // choose the "best" annotation at a single offset
         RzCodeAnnotation *prev_annot = ht_up_find(ht, annotation->offset.offset, NULL);
         if (prev_annot) {
             if (annotation->end - annotation->start < prev_annot->end - prev_annot->start) {
                 continue;
             }
         }
         ht_up_update(ht, annotation->offset.offset, annotation);
     }
     ht_up_foreach(ht, foreach_offset_annotation, code);
     ht_up_free(ht);
 }

References rz_code_annotation_t::end, foreach_offset_annotation(), NULL, rz_code_annotation_t::offset, RZ_CODE_ANNOTATION_TYPE_OFFSET, rz_vector_foreach, rz_code_annotation_t::start, and rz_code_annotation_t::type.

◆ rz_core_annotated_code_print_json()

RZ_API void rz_core_annotated_code_print_json ( RzAnnotatedCode * code )

Definition at line 10 of file cannotated_code.c.

                                                                      {
     PJ *pj = pj_new();
     if (!pj) {
         return;
     }
  
     pj_o(pj);
     pj_ks(pj, "code", code->code);
  
     pj_k(pj, "annotations");
     pj_a(pj);
  
     char *type_str;
     RzCodeAnnotation *annotation;
     rz_vector_foreach(&code->annotations, annotation) {
         pj_o(pj);
         pj_kn(pj, "start", (ut64)annotation->start);
         pj_kn(pj, "end", (ut64)annotation->end);
         switch (annotation->type) {
         case RZ_CODE_ANNOTATION_TYPE_OFFSET:
             pj_ks(pj, "type", "offset");
             pj_kn(pj, "offset", annotation->offset.offset);
             break;
         case RZ_CODE_ANNOTATION_TYPE_FUNCTION_NAME:
             pj_ks(pj, "type", "function_name");
             pj_ks(pj, "name", annotation->reference.name);
             pj_kn(pj, "offset", annotation->reference.offset);
             break;
         case RZ_CODE_ANNOTATION_TYPE_GLOBAL_VARIABLE:
             pj_ks(pj, "type", "global_variable");
             pj_kn(pj, "offset", annotation->reference.offset);
             break;
         case RZ_CODE_ANNOTATION_TYPE_CONSTANT_VARIABLE:
             pj_ks(pj, "type", "constant_variable");
             pj_kn(pj, "offset", annotation->reference.offset);
             break;
         case RZ_CODE_ANNOTATION_TYPE_LOCAL_VARIABLE:
             pj_ks(pj, "type", "local_variable");
             pj_ks(pj, "name", annotation->variable.name);
             break;
         case RZ_CODE_ANNOTATION_TYPE_FUNCTION_PARAMETER:
             pj_ks(pj, "type", "function_parameter");
             pj_ks(pj, "name", annotation->variable.name);
             break;
         case RZ_CODE_ANNOTATION_TYPE_SYNTAX_HIGHLIGHT:
             pj_ks(pj, "type", "syntax_highlight");
             type_str = NULL;
             switch (annotation->syntax_highlight.type) {
             case RZ_SYNTAX_HIGHLIGHT_TYPE_KEYWORD:
                 type_str = "keyword";
                 break;
             case RZ_SYNTAX_HIGHLIGHT_TYPE_COMMENT:
                 type_str = "comment";
                 break;
             case RZ_SYNTAX_HIGHLIGHT_TYPE_DATATYPE:
                 type_str = "datatype";
                 break;
             case RZ_SYNTAX_HIGHLIGHT_TYPE_FUNCTION_NAME:
                 type_str = "function_name";
                 break;
             case RZ_SYNTAX_HIGHLIGHT_TYPE_FUNCTION_PARAMETER:
                 type_str = "function_parameter";
                 break;
             case RZ_SYNTAX_HIGHLIGHT_TYPE_LOCAL_VARIABLE:
                 type_str = "local_variable";
                 break;
             case RZ_SYNTAX_HIGHLIGHT_TYPE_CONSTANT_VARIABLE:
                 type_str = "constant_variable";
                 break;
             case RZ_SYNTAX_HIGHLIGHT_TYPE_GLOBAL_VARIABLE:
                 type_str = "global_variable";
                 break;
             }
             if (type_str) {
                 pj_ks(pj, "syntax_highlight", type_str);
             }
             break;
         }
         pj_end(pj);
     }
     pj_end(pj);
  
     pj_end(pj);
     rz_cons_printf("%s\n", pj_string(pj));
     pj_free(pj);
 }

Macros

Functions