wmlsdasm.c File Reference

#include "wsint.h"
#include "gwlib/gwlib.h"
#include <sys/stat.h>

Go to the source code of this file.

Functions
static void	usage (void)
const char *	lookup_function (WsBc *bc, WsUInt8 index)
int	main (int argc, char *argv[])

Variables
static char *	program

Function Documentation

lookup_function()

const char * lookup_function	(	WsBc *	bc,
		WsUInt8	index
	)

Definition at line 311 of file wmlsdasm.c.

References WsBcRec::function_names, WsBcFunctionNameRec::index, WsBcFunctionNameRec::name, and WsBcRec::num_function_names.

Referenced by main().

{
    WsUInt8 i;

    for (i = 0; i < bc->num_function_names; i++)
        if (bc->function_names[i].index == index)
            return bc->function_names[i].name;

    return NULL;
}

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 97 of file wmlsdasm.c.

References WsBcFunctionRec::code, WsBcFunctionRec::code_size, WsBcRec::constants, WsBcRec::function_names, WsBcRec::functions, getopt(), WsBcFunctionNameRec::index, lookup_function(), WsBcFunctionNameRec::name, name, WsBcRec::num_constants, WsBcRec::num_function_names, WsBcRec::num_functions, WsBcRec::num_pragmas, optind, program, WsBcConstantRec::type, WsBcConstantRec::u, usage(), WsBcConstantRec::v_float, WsBcConstantRec::v_int, WsBcConstantRec::v_string, ws_asm_dasm(), WS_BC_CONST_TYPE_EMPTY_STRING, WS_BC_CONST_TYPE_FLOAT32, WS_BC_CONST_TYPE_FLOAT32_NAN, WS_BC_CONST_TYPE_FLOAT32_NEGATIVE_INF, WS_BC_CONST_TYPE_FLOAT32_POSITIVE_INF, WS_BC_CONST_TYPE_INT, WS_BC_CONST_TYPE_UTF8_STRING, ws_bc_decode(), ws_bc_free(), ws_create(), ws_destroy(), WS_FALSE, ws_malloc(), WS_TRUE, and ws_utf8_get_char().

{
    int i;
    int opt;
    WsBool print_constants = WS_FALSE;
    WsBool print_function_names = WS_FALSE;
    WsBool print_functions = WS_FALSE;
    WsUInt8 k;
    WsUInt16 j;

    program = strrchr(argv[0], '/');
    if (program)
        program++;
    else
        program = argv[0];

    /* Process command line arguments. */
    while ((opt = getopt(argc, argv, "cfnh")) != EOF) {
        switch (opt) {
        case 'c':
            print_constants = WS_TRUE;
            break;

        case 'f':
            print_functions = WS_TRUE;
            break;

        case 'n':
            print_function_names = WS_TRUE;
            break;

        case 'h':
            usage();
            exit(0);
            break;

        case '?':
            printf("Try `%s -h' for a complete list of options.\n",
                   program);
            exit(1);
        }
    }

    for (i = optind; i < argc; i++) {
        FILE *fp;
        struct stat stat_st;
        unsigned char *data;
        size_t data_len;
        WsBc *bc;

        if (stat(argv[i], &stat_st) < 0) {
            fprintf(stderr, "%s: could not access `%s': %s\n",
                    program, argv[i], strerror(errno));
            exit(1);
        }
        data_len = stat_st.st_size;

        data = ws_malloc(data_len);
        if (data == NULL) {
            fprintf(stderr, "%s: out of memory: %s\n",
                    program, strerror(errno));
            exit(1);
        }

        fp = fopen(argv[i], "rb");
        if (fp == NULL) {
            fprintf(stderr, "%s: could not open input file `%s': %s\n",
                    program, argv[i], strerror(errno));
            exit(1);
        }

        if (fread(data, 1, data_len, fp) != data_len) {
            fprintf(stderr, "%s: could not read file `%s': %s\n",
                    program, argv[i], strerror(errno));
            exit(1);
        }
        fclose(fp);

        /* Decode byte-code. */
        bc = ws_bc_decode(data, data_len);
        if (bc == NULL) {
            fprintf(stderr, "%s: invalid byte-code file `%s'\n",
                    program, argv[i]);
            continue;
        }

        /* Print all requested data. */
        printf("\n%s:\t%lu bytes\n\n", argv[i], (unsigned long) data_len);

        if (print_constants) {
            printf("Disassembly of section Constants:\n\n");
            for (j = 0; j < bc->num_constants; j++) {
                printf("%4d:\t", j);
                switch (bc->constants[j].type) {
                case WS_BC_CONST_TYPE_INT:
                    printf("%ld\n", (long) bc->constants[j].u.v_int);
                    break;

                case WS_BC_CONST_TYPE_FLOAT32:
                    printf("%f\n", bc->constants[j].u.v_float);
                    break;

                case WS_BC_CONST_TYPE_FLOAT32_NAN:
                    printf("NaN\n");
                    break;

                case WS_BC_CONST_TYPE_FLOAT32_POSITIVE_INF:
                    printf("+infinity\n");
                    break;

                case WS_BC_CONST_TYPE_FLOAT32_NEGATIVE_INF:
                    printf("-infinity\n");
                    break;

                case WS_BC_CONST_TYPE_UTF8_STRING:
                    {
                        size_t pos = 0;
                        size_t column = 8;
                        unsigned long ch;

                        printf("\"");

                        while (ws_utf8_get_char(&bc->constants[j].u.v_string,
                                                &ch, &pos)) {
                            if (ch < ' ') {
                                printf("\\%02lx", ch);
                                column += 3;
                            } else if (ch <= 0xff) {
                                printf("%c", (unsigned char) ch);
                                column++;
                            } else {
                                printf("\\u%04lx", ch);
                                column += 5;
                            }
                            if (column >= 75) {
                                printf("\"\n\t\"");
                                column = 8;
                            }
                        }
                        printf("\"\n");
                    }
                    break;

                case WS_BC_CONST_TYPE_EMPTY_STRING:
                    printf("\"\"\n");
                    break;
                }
            }
        }

        if (print_function_names) {
            printf("Disassembly of section Function names:\n\n");
            for (k = 0; k < bc->num_function_names; k++)
                printf("  %-40.40s%8d\n",
                       bc->function_names[k].name,
                       bc->function_names[k].index);
        }

        if (print_functions) {
            WsCompilerPtr compiler = ws_create(NULL);

            printf("Disassembly of section Functions:\n");

            for (k = 0; k < bc->num_functions; k++) {
                const char *name = lookup_function(bc, k);

                printf("\nFunction %u", (unsigned int) k);

                if (name)
                    printf(" <%s>", name);

                printf(":\n");

                ws_asm_dasm(compiler, bc->functions[k].code,
                            bc->functions[k].code_size);
            }

            ws_destroy(compiler);
        }

        if (!print_constants && !print_function_names && !print_functions) {
            printf("Sections:\n\
                   Name\t\t   Items\n\
                   Constants\t%8d\n\
                   Pragmas\t%8d\n\
                   Function names\t%8d\n\
                   Functions\t%8d\n",
                   bc->num_constants,
                   bc->num_pragmas,
                   bc->num_function_names,
                   bc->num_functions);
        }

        ws_bc_free(bc);
    }

    return 0;
}

usage()

static void usage ( void  )

static

Definition at line 298 of file wmlsdasm.c.

References program.

Referenced by main().

{
    printf("Usage: %s OPTION... FILE...\n\
           \n\
           -c            print constants\n\
           -f            disassemble functions\n\
           -n            print function names\n\
           -h            print this help message and exit successfully\n\
           \n",
           program);
}

Variable Documentation

program

char* program

static

Definition at line 93 of file wmlsdasm.c.

Referenced by main(), and usage().