cannotated_code.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2020 NIRMAL MANOJ C <nimmumanoj@gmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
#include <rz_util/rz_annotated_code.h>
 
#include <rz_util.h>
#include <rz_core.h>
#include <rz_types.h>
#include <rz_vector.h>
 
RZ_API void rz_core_annotated_code_print_json(RzAnnotatedCode *code) {
    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);
}
 
#define PALETTE(x) (cons && cons->context->pal.x) ? cons->context->pal.x
#define PRINT_COLOR(x) \
    do { \
        if (cons->context->color_mode) { \
            rz_cons_printf("%s", (x)); \
        } \
    } while (0)
 
static void print_offset_in_binary_line_bar(RzAnnotatedCode *code, ut64 offset, size_t width) {
    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("    |");
}
 
RZ_API void rz_core_annotated_code_print(RzAnnotatedCode *code, RzVector /*<ut64>*/ *line_offsets) {
    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]);
    }
}
 
static bool foreach_offset_annotation(void *user, const ut64 offset, const void *val) {
    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;
}
 
RZ_API void rz_core_annotated_code_print_comment_cmds(RzAnnotatedCode *code) {
    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);
}