code_gen.c-Dateireferenz

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <ctype.h>
#include <sys/stat.h>
#include "stubs_load.h"
#include "firmware_load.h"
#include "chdk_dasm.h"

Include-Abhängigkeitsdiagramm für code_gen.c:

gehe zum Quellcode dieser Datei

Datenstrukturen
struct	_op

Makrodefinitionen
#define	NULL_OP   0
#define	FILE_OP   1
#define	ENDFILE_OP   2
#define	COPY_OP   3
#define	COPY_LINE   4
#define	FUNC_OP   5
#define	ENDFUNC_OP   6
#define	ASM_OP   7
#define	ENDASM_OP   8
#define	FW_OP   9
#define	PATCHSUB_OP   10
#define	PATCHVAL_OP   11
#define	REM_OP   12
#define	SKIP_OP   13
#define	CONTFW_OP   14
#define	LI_OP   15

Typdefinitionen
typedef struct _op	op

Funktionen
char *	skip_space (char *c)
char *	skip_token (char *c)
char *	skip_string (char *c)
char *	next_token (char *line)
void	parse_line (char *line)
char *	next_line (char *line)
void	print_args ()
void	set_op_name (op *p, char *nm)
void	set_op_comment (op *p, char *s)
op *	new_op (int type)
void	chk_args (int count, char *msg, op *p)
void	parse_FILE ()
void	parse_ENDFILE ()
void	parse_COPY ()
void	parse_FUNC ()
void	parse_ENDFUNC ()
void	parse_ASM ()
void	parse_ENDASM ()
void	parse_FW ()
void	parse_PATCHSUB ()
void	parse_PATCHVAL ()
void	parse_REM ()
void	parse_SKIP ()
void	parse_CONTFW ()
void	parse_LI ()
void	op_prelabel (op *p)
void	op_COPY (op *p)
void	op_FUNC (op *p)
void	op_FW (op *p)
void	op_PATCHSUB (op *p)
void	op_PATCHVAL (op *p)
void	op_REM (op *p)
void	do_ops (op *p)
int	run_op (char *name, void(*func)())
void	parse_ops ()
void	usage (char *err)
void	error (__attribute__((unused)) char *fmt, __attribute__((unused)) int n)
int	main (int ac, const char *av[])

Variablen
firmware *	fw
int	lineno
int	largc
char	largs [20][256]
char *	last_line
char	token [1024]
FILE *	outfile
int	direct_copy
int	in_func
op *	op_head
op *	op_tail
op *	cur_func
op *	last_op = 0

Makro-Dokumentation

#define ASM_OP   7

Definiert in Zeile 423 der Datei code_gen.c.

#define CONTFW_OP   14

Definiert in Zeile 430 der Datei code_gen.c.

#define COPY_LINE   4

Definiert in Zeile 420 der Datei code_gen.c.

#define COPY_OP   3

Definiert in Zeile 419 der Datei code_gen.c.

#define ENDASM_OP   8

Definiert in Zeile 424 der Datei code_gen.c.

#define ENDFILE_OP   2

Definiert in Zeile 418 der Datei code_gen.c.

#define ENDFUNC_OP   6

Definiert in Zeile 422 der Datei code_gen.c.

#define FILE_OP   1

Definiert in Zeile 417 der Datei code_gen.c.

#define FUNC_OP   5

Definiert in Zeile 421 der Datei code_gen.c.

#define FW_OP   9

Definiert in Zeile 425 der Datei code_gen.c.

#define LI_OP   15

Definiert in Zeile 431 der Datei code_gen.c.

#define NULL_OP   0

Definiert in Zeile 416 der Datei code_gen.c.

#define PATCHSUB_OP   10

Definiert in Zeile 426 der Datei code_gen.c.

#define PATCHVAL_OP   11

Definiert in Zeile 427 der Datei code_gen.c.

#define REM_OP   12

Definiert in Zeile 428 der Datei code_gen.c.

#define SKIP_OP   13

Definiert in Zeile 429 der Datei code_gen.c.

Dokumentation der benutzerdefinierten Typen

typedef struct _op op

Dokumentation der Funktionen

void chk_args	(	int	count,
		char *	msg,
		op *	p
	)

Definiert in Zeile 531 der Datei code_gen.c.

{
    if (largc != count+1)
    {
        fprintf(stderr,"ERROR - %s\n",msg);
        fprintf(stderr,"LINE - %d, SOURCE - %s\n",p->lineno,p->source);
        exit(1);
    }
}

void do_ops

(

op *

p)

Definiert in Zeile 997 der Datei code_gen.c.

{
    switch (p->operation)
    {
    case FILE_OP:
        // Open an output file
        outfile = fopen(p->name, "w");
        fprintf(outfile, "/*\n * %s - auto-generated by CHDK code_gen.\n */\n", p->name);
        break;
    case ENDFILE_OP:
        // Close output file
        if (outfile != stdout)
        {
            fclose(outfile);
            outfile = stdout;
        }
        break;
    case COPY_OP:
        op_COPY(p);
        break;
    case COPY_LINE:
        fprintf(outfile, "%s\n", p->comment);
        break;
    case FUNC_OP:
        op_FUNC(p);
        break;
    case ENDFUNC_OP:
        // End function, writes the function end to the file
        fprintf(outfile,"}\n");
        in_func = 0;
        break;
    case ASM_OP:
        // Writes the 'asm...' stuff to the file
        fprintf(outfile,"asm volatile (\n");
        break;
    case ENDASM_OP:
        // Ends the 'asm...' block
        op_prelabel(p);
        fprintf(outfile,");\n");
        break;
    case FW_OP:
        op_FW(p);
        break;
    case PATCHSUB_OP:
        op_PATCHSUB(p);
        break;
    case PATCHVAL_OP:
        op_PATCHVAL(p);
        break;
    case REM_OP:
        op_REM(p);
        break;
    case SKIP_OP:
        // Skip N words in the firmware - used to skip over DCD in the middle of a function
        addr += (p->skip_len * 4);
        break;
    case CONTFW_OP:
        // Generate a B instruction to jump back to the firmware code at the current address
        if (options.flags & disopt_line_numbers) fprintf(outfile,"       ");
        fprintf(outfile,"\"    LDR     PC, =0x%08X \\n\"  // Continue in firmware\n",addr);
        break;
    case LI_OP:
        // set line number output state
        if (p->li_state != 0)
            options.flags |= disopt_line_numbers;
        else
            options.flags &= ~disopt_line_numbers;
        break;
    }
}

void error	(	__attribute__((unused)) char *	fmt,
		__attribute__((unused)) int	n
	)

Definiert in Zeile 1111 der Datei code_gen.c.

{
    if (last_op)
        fprintf(stderr,"Line - %d, Source --> %s\n",last_op->lineno,last_op->source);
    exit(1);
}

int main	(	int	ac,
		const char *	av[]
	)

Definiert in Zeile 1120 der Datei code_gen.c.

{
    // Check number of args
    if (ac < 4)
    {
        fprintf(stderr,"Usage: code_gen ROMBASE code_gen.txt PRIMARY.BIN [ALT_ROMBASE]\n");
        exit(1);
    }

    // Get ROMBASE value
    options.ROM_start = strtoul(av[1],0,0);
    if (options.ROM_start == 0)
    {
        fprintf(stderr,"Invalid ROMBASE.\n");
        exit(1);
    }

    // Get instruction file length
    struct stat st;
    if (stat(av[2],&st) != 0)
    {
        fprintf(stderr, "Failed to stat \"%s\".\n", av[2]);
        exit(1);
    }
    size_t len = st.st_size;

    // Open & read instruction file
    FILE *fp = fopen(av[2], "rb");
    if (!fp)
    {
        fprintf(stderr, "Failed to open \"%s\".\n", av[2]);
        exit(1);
    }

    // Allocate block for instruction file
    char *def = malloc(len+1);
    if (def == 0)
    {
        fprintf(stderr, "Not enough memory.\n");
        exit(1);
    }

    // Read instruction file
    size_t n = fread(def, 1, len, fp);
    def[n] = 0;
    fclose(fp);

    // Open Firmware dump file
    fw = malloc(sizeof(firmware));
    load_firmware(fw, av[3], av[1], (ac==5)?av[4]:0, OS_DRYOS);

    // Load function name/address values from stubs files
    fw->sv = new_stub_values();
    load_funcs(fw->sv, "funcs_by_name.csv");
    load_stubs(fw->sv, "stubs_entry.S", 0);
    load_stubs(fw->sv, "stubs_entry_2.S", 0);   // Load second so values override stubs_entry.S

    outfile = stdout;
    direct_copy = 0;
    in_func = 0;

    op_head = op_tail = 0;

    // Pre-Process
    lineno = 0;
    char *line = def;
    while ((line != 0) && (*line != 0))
    {
        char *nxt = next_line(line);

        // Check if just copying from input file to output file
        if (direct_copy)
        {
            // Check if end of copy
            if (strncmp(line,"<<<",3) == 0)
            {
                direct_copy = 0;
            }
            else
            {
                op *p = new_op(COPY_LINE);
                set_op_comment(p,line);
            }
        }
        else
        {
            parse_line(line);
            parse_ops();
        }

        line = nxt;
    }

    // Process
    op *p = op_head;
    while (p)
    {
        last_op = p;
        do_ops(p);
        p = p->next;
    }

    if (outfile != stdout)
        fclose(outfile);

    return 0;
}

op* new_op

(

int

type)

Definiert in Zeile 488 der Datei code_gen.c.

{
    op *p = malloc(sizeof(op));

    p->operation = type;

    p->source = malloc(strlen(last_line)+1);
    strcpy(p->source,last_line);
    p->lineno = lineno;

    p->name = 0;
    p->comment = 0;
    p->prelabel = 0;
    p->func_start = 0;
    p->func_end = 0;
    p->func_len = 0;
    p->patch_ref = -1;
    p->fw_start = 0;
    p->fw_end = 0;
    p->fw_func_end_offset = 0;
    p->fw_is_func_end_offset = 0;
    p->fw_func_start_offset = 0;
    p->fw_is_func_start_offset = 0;
    p->fw_len = -1;
    p->patch_new_val = 0;
    p->skip_len = 0;
    p->li_state = 0;

    if (op_tail)
    {
        op_tail->next = p;
    }
    else
    {
        op_head = p;
    }

    op_tail = p;
    p->next = 0;

    return p;
}

char* next_line

(

char *

line)

Definiert in Zeile 382 der Datei code_gen.c.

{
    char *nxt = strchr(line,'\r');
    if (nxt != 0)
    {
        *nxt++ = 0;
        if (*nxt == '\n')
            nxt++;
    }
    else
    {
        nxt = strchr(line,'\n');
        if (nxt != 0)
            *nxt++ = 0;
    }
    lineno++;
    return nxt;
}

char* next_token

(

char *

line)

Definiert in Zeile 344 der Datei code_gen.c.

{
    token[0] = 0;
    char *c = skip_space(line);
    char *n;
    if (*c)
    {
        if (*c == '"')
        {
            c++;
            n = skip_string(c);
            strncpy(token, c, n-c);
            token[n-c] = 0;
            return skip_space((*n)?n+1:n);
        }
        else
        {
            n = skip_token(c);
            strncpy(token, c, n-c);
            token[n-c] = 0;
            return skip_space(n);
        }
    }
    return c;
}

void op_COPY

(

op *

p)

Definiert in Zeile 800 der Datei code_gen.c.

{
    int x;

    op_prelabel(p);

    // Check if the copy is from another source file - if so just copy that file
    if (p->name)
    {
        FILE *fp = fopen(p->name,"r");
        if (!fp)
        {
            fprintf(stderr,"Can't open file '%s'\n",p->name);
            exit(1);
        }

        char buf[1024];
        do
        {
            x = fread(buf,1,1024,fp);
            if (x > 0) fwrite(buf,1,x,outfile);
        } while (x > 0);

        fclose(fp);
        direct_copy = 0;
    }
}

void op_FUNC

(

op *

p)

Definiert in Zeile 832 der Datei code_gen.c.

{
    char func_name[256];

    *func_name = 0;

    cur_func = p;

    if (p->name)
        strcpy(func_name, p->name);

    if (p->patch_ref >= 0)
    {
        p->func_start = patch_ref_address[p->patch_ref];
        strcpy(func_name, patch_ref_name[p->patch_ref]);
    }

    in_func = 1;

    if (p->func_start == 0) chk_args(-1,"Missing FUNC start address",p);

    if ((p->func_end == 0) && (p->func_len == 0))
    {
        op *n = p->next;
        int cont = 1;
        while (n && cont)
        {
            switch (n->operation)
            {
            case FW_OP:
                if (n->fw_is_func_end_offset)
                {
                    cont = 0;
                    p->func_len = 0;
                }
                else
                {
                    p->func_len += n->fw_len;
                }
                break;
            case PATCHSUB_OP:
            case PATCHVAL_OP:
            case REM_OP:
                p->func_len++;
                break;
            case SKIP_OP:
                p->func_len += n->skip_len;
                break;
            case ENDFUNC_OP:
                cont = 0;
                break;
            }
            n = n->next;
        }

        if (p->func_len == 0)
        {
            p->func_end = find_end(fw, p->func_start);
            if (p->func_end == 0)
                chk_args(-1,"Missing FUNC end address or length",p);
        }
    }

    if ((p->func_end == 0) && (p->func_len > 0))
        p->func_end = p->func_start + p->func_len * 4 - 4;
    if ((p->func_len == 0) && (p->func_end > 0))
        p->func_len = (p->func_end - p->func_start) / 4 + 1;
    if (p->func_end < p->func_start) chk_args(-1,"FUNC start > end",p);
    if (p->func_len != (int)((p->func_end - p->func_start) / 4 + 1)) chk_args(-1,"FUNC start/end/length mismatch",p);

    if (*func_name == 0)
        sprintf(func_name, "sub_%08X_my", p->func_start);

    options.start_address = p->func_start;
    options.end_address   = p->func_end;

    set_ignore_errors(1);
    options.flags |= disopt_remember_branches;
    disassemble1(fw, p->func_start, p->func_len);
    options.flags &= ~disopt_remember_branches;
    set_ignore_errors(0);

    fprintf(outfile,"\n/*************************************************************/");
    fprintf(outfile,"\n//** %s @ 0x%08X - 0x%08X, length=%d\n", func_name, p->func_start, last_used_addr, (last_used_addr - p->func_start) / 4 + 1 ) ;
    fprintf(outfile,"void __attribute__((naked,noinline)) %s() {\n", func_name);

    addr = p->func_start;
}

void op_FW

(

op *

p)

Definiert in Zeile 922 der Datei code_gen.c.

{
    t_address start_address = addr;
    t_address end_address = addr;

    patch_comment = p->comment;
    if (patch_comment)
    {
        options.flags |= disopt_patch_comment;
    }

    if (p->fw_start > 0)
        start_address = p->fw_start;
    if (p->fw_end > 0)
        end_address = p->fw_end;
    if (p->fw_is_func_end_offset)
        end_address = cur_func->func_end + p->fw_func_end_offset;
    if (p->fw_is_func_start_offset)
        end_address = cur_func->func_start + p->fw_func_start_offset;
    if (p->fw_len > 0)
        end_address = start_address + p->fw_len * 4 - 4;

    disassemble(fw, outfile, start_address, (end_address + 4 - start_address) / 4);
}

void op_PATCHSUB

(

op *

p)

Definiert in Zeile 949 der Datei code_gen.c.

{
    patch_func_name = p->name;
    save_patch_ref = p->patch_ref;
    patch_comment = p->comment;
    if (patch_comment)
    {
        options.flags |= disopt_patch_comment;
    }

    options.flags |= disopt_patch_branch;
    disassemble(fw, outfile, addr, 1);
    options.flags &= ~(disopt_patch_branch|disopt_patch_comment);
}

void op_PATCHVAL

(

op *

p)

Definiert in Zeile 965 der Datei code_gen.c.

{
    patch_new_val = p->patch_new_val;
    patch_comment = p->comment;
    if (patch_comment)
    {
        options.flags |= disopt_patch_comment;
    }

    options.flags |= disopt_patch_value;
    disassemble(fw, outfile, addr, 1);
    options.flags &= ~(disopt_patch_value|disopt_patch_comment);
}

void op_prelabel

(

op *

p)

Definiert in Zeile 786 der Datei code_gen.c.

{
    // If after then write label to output and remove from list (so it doesn't get written twice)
    if (in_func && (p->prelabel == 0) && (addr <= options.end_address))
    {
        if (l_search(branch_list, addr))
        {
            fprintf(outfile,"\n\"loc_%08X:\\n\"\n", addr) ; 
            l_remove(branch_list, addr);
        }
    }
}

void op_REM

(

op *

p)

Definiert in Zeile 981 der Datei code_gen.c.

{
    patch_comment = p->comment;
    if (patch_comment)
    {
        options.flags |= disopt_patch_comment;
    }

    options.flags |= disopt_comment_lines;
    disassemble(fw, outfile, addr, 1);
    options.flags &= ~(disopt_comment_lines|disopt_patch_comment);
}

void parse_ASM

(

)

Definiert in Zeile 635 der Datei code_gen.c.

{
    new_op(ASM_OP);
}

void parse_CONTFW

(

)

Definiert in Zeile 771 der Datei code_gen.c.

{
    new_op(CONTFW_OP);
}

void parse_COPY

(

)

Definiert in Zeile 558 der Datei code_gen.c.

{
    op *p = new_op(COPY_OP);
    int n;

    // Check if copy goes before or after the current instruction address label
    for (n=1; n<largc; n++)
    {
        if (strcmp(largs[n],"prelabel") == 0)
            p->prelabel = 1;
    }

    direct_copy = 1;

    // Check if the copy is from another source file - if so just copy that file
    for (n=1; n<largc; n++)
    {
        if (strcmp(largs[n],"file") == 0)
        {
            set_op_name(p,largs[++n]);
            direct_copy = 0;
        }
    }
}

void parse_ENDASM

(

)

Definiert in Zeile 641 der Datei code_gen.c.

{
    op *p = new_op(ENDASM_OP);
    int n;

    // Check if copy goes before or after the current instruction address label
    for (n=1; n<largc; n++)
    {
        if (strcmp(largs[n],"prelabel") == 0)
            p->prelabel = 1;
    }
}

void parse_ENDFILE

(

)

Definiert in Zeile 552 der Datei code_gen.c.

{
    new_op(ENDFILE_OP);
}

void parse_ENDFUNC

(

)

Definiert in Zeile 629 der Datei code_gen.c.

{
    new_op(ENDFUNC_OP);
}

void parse_FILE

(

)

Definiert in Zeile 544 der Datei code_gen.c.

{
    op *p = new_op(FILE_OP);
    chk_args(1,"Missing FILE name",p);
    set_op_name(p,largs[1]);
}

void parse_FUNC

(

)

Definiert in Zeile 587 der Datei code_gen.c.

{
    op *p = new_op(FUNC_OP);
    int n;

    for (n=1; n<largc; n++)
    {
        if (strcmp(largs[n], "name") == 0)
        {
            set_op_name(p,largs[++n]);
        }
        else if (strcmp(largs[n], "start") == 0)
        {
            p->func_start = strtoul(largs[++n],0,0);
        }
        else if (strcmp(largs[n], "end") == 0)
        {
            p->func_end = strtoul(largs[++n],0,0);
        }
        else if (strcmp(largs[n], "length") == 0)
        {
            p->func_len = strtoul(largs[++n],0,0);
        }
        else if (strcmp(largs[n], "ref") == 0)
        {
            p->patch_ref = strtol(largs[++n],0,0);
        }
        else if (strcmp(largs[n], "sig") == 0)
        {
            osig *sig = find_sig(fw->sv->stubs, largs[++n]);
            if (sig == 0) chk_args(-1,"Can't find firmware function for 'sig='",p);
            p->func_start = sig->val;
            p->name = sig->nm;
        }
        else
        {
            chk_args(-1,"Invalid FUNC argument",p);
        }
    }
}

void parse_FW

(

)

Definiert in Zeile 655 der Datei code_gen.c.

{
    op *p = new_op(FW_OP);
    int n;

    for (n=1; n<largc; n++)
    {
        switch (largs[n][0])
        {
        case '^':
            p->fw_start = strtoul(largs[n]+1,0,0);
            break;
        case '-':
            p->fw_end = strtoul(largs[n]+1,0,0);
            break;
        case '$':
            p->fw_func_end_offset = strtol(largs[n]+1,0,0) * 4;
            p->fw_is_func_end_offset = 1;
            break;
        case 'L':
            p->fw_func_start_offset = strtol(largs[n]+1,0,0) * 4 - 4;
            p->fw_is_func_start_offset = 1;
            break;
        default:
            if (strcmp(largs[n], "comment") == 0)
            {
                set_op_comment(p,largs[++n]);
            }
            else
            {
                p->fw_len = strtoul(largs[n],0,0);
                if (p->fw_len == 0) p->fw_len++;
            }
            break;
        }
    }

    if ((p->fw_start != 0) && (p->fw_end != 0))
        p->fw_len = (p->fw_end - p->fw_start) / 4 + 1;
}

void parse_LI

(

)

Definiert in Zeile 777 der Datei code_gen.c.

{
    op *p = new_op(LI_OP);
    if (largc > 1)
        p->li_state = strtol(largs[1],0,0);
}

void parse_line

(

char *

line)

Definiert in Zeile 370 der Datei code_gen.c.

{
    last_line = line;
    largc = 0;
    largs[largc][0] = 0;
    while (line && *line)
    {
        line = next_token(line);
        strcpy(largs[largc++], token);
    }
}

void parse_ops

(

)

Definiert in Zeile 1080 der Datei code_gen.c.

{
    if (largc > 0)
    {
        if (run_op("FILE",      parse_FILE))       return;
        if (run_op("ENDFILE",   parse_ENDFILE))    return;
        if (run_op(">>>",       parse_COPY))       return;
        if (run_op("FUNC",      parse_FUNC))       return;
        if (run_op("ENDFUNC",   parse_ENDFUNC))    return;
        if (run_op("ASM",       parse_ASM))        return;
        if (run_op("ENDASM",    parse_ENDASM))     return;
        if (run_op("FW",        parse_FW))         return;
        if (run_op("PATCHSUB",  parse_PATCHSUB))   return;
        if (run_op("PATCHVAL",  parse_PATCHVAL))   return;
        if (run_op("REM",       parse_REM))        return;
        if (run_op("SKIP",      parse_SKIP))       return;
        if (run_op("->FW",      parse_CONTFW))     return;
        if (run_op("LI",        parse_LI))         return;
    }
}

void parse_PATCHSUB

(

)

Definiert in Zeile 698 der Datei code_gen.c.

{
    op *p = new_op(PATCHSUB_OP);
    int n;

    for (n=1; n<largc; n++)
    {
        if (strcmp(largs[n], "name") == 0)
        {
            set_op_name(p,largs[++n]);
        }
        else if (strcmp(largs[n], "ref") == 0)
        {
            p->patch_ref = strtoul(largs[++n],0,0);
        }
        else if (strcmp(largs[n], "comment") == 0)
        {
            set_op_comment(p,largs[++n]);
        }
        else
        {
            chk_args(-1,"Invalid PATCHSUB argument",p);
        }
    }
}

void parse_PATCHVAL

(

)

Definiert in Zeile 725 der Datei code_gen.c.

{
    op *p = new_op(PATCHVAL_OP);
    int n;

    for (n=1; n<largc; n++)
    {
        if (strcmp(largs[n], "value") == 0)
        {
            p->patch_new_val = strtoul(largs[++n],0,0);
        }
        else if (strcmp(largs[n], "comment") == 0)
        {
            set_op_comment(p,largs[++n]);
        }
        else
        {
            chk_args(-1,"Invalid PATCHVAL argument",p);
        }
    }
}

void parse_REM

(

)

Definiert in Zeile 749 der Datei code_gen.c.

{
    op *p = new_op(REM_OP);

    if (largc > 1)
    {
        set_op_comment(p,largs[1]);
    }
}

void parse_SKIP

(

)

Definiert in Zeile 760 der Datei code_gen.c.

{
    op *p = new_op(SKIP_OP);

    if (largc > 1)
        p->skip_len = strtol(largs[1],0,0);
    else
        p->skip_len = 1;
}

void print_args

(

)

Definiert in Zeile 401 der Datei code_gen.c.

{
    int n;
    for (n=0; n<largc; n++) fprintf(stderr,"\t%d %s\n",n,largs[n]);
}

int run_op	(	char *	name,
		void(*)()	func
	)

Definiert in Zeile 1069 der Datei code_gen.c.

{
    if (strcmp(largs[0], name) == 0)
    {
        func();
        return 1;
    }
    return 0;
}

void set_op_comment	(	op *	p,
		char *	s
	)

Definiert in Zeile 475 der Datei code_gen.c.

{
    if (s)
    {
        p->comment = malloc(strlen(s)+1);
        strcpy(p->comment,s);
    }
    else
    {
        p->comment = 0;
    }
}

void set_op_name	(	op *	p,
		char *	nm
	)

Definiert in Zeile 462 der Datei code_gen.c.

{
    if (nm)
    {
        p->name = malloc(strlen(nm)+1);
        strcpy(p->name,nm);
    }
    else
    {
        p->name = 0;
    }
}

char* skip_space

(

char *

c)

Definiert in Zeile 326 der Datei code_gen.c.

{
    while (*c && ((*c == ' ') || (*c == '\t') || (*c == '='))) c++;
    return c;
}

char* skip_string

(

char *

c)

Definiert in Zeile 338 der Datei code_gen.c.

{
    while (*c && (*c != '"')) c++;
    return c;
}

char* skip_token

(

char *

c)

Definiert in Zeile 332 der Datei code_gen.c.

{
    while (*c && (*c != ' ') && (*c != '\t') && (*c != '=')) c++;
    return c;
}

void usage

(

char *

err)

Definiert in Zeile 1103 der Datei code_gen.c.

{
    fprintf(stderr,"code_gen <base> <primary> [alt base] - Error = %s\n",err);
    exit(1);
}

Variablen-Dokumentation

op * cur_func

Definiert in Zeile 460 der Datei code_gen.c.

int direct_copy

Definiert in Zeile 411 der Datei code_gen.c.

firmware* fw

Definiert in Zeile 316 der Datei code_gen.c.

int in_func

Definiert in Zeile 412 der Datei code_gen.c.

int largc

Definiert in Zeile 321 der Datei code_gen.c.

char largs[20][256]

Definiert in Zeile 322 der Datei code_gen.c.

char* last_line

Definiert in Zeile 323 der Datei code_gen.c.

op* last_op = 0

Definiert in Zeile 1109 der Datei code_gen.c.

int lineno

Definiert in Zeile 320 der Datei code_gen.c.

op* op_head

Definiert in Zeile 460 der Datei code_gen.c.

op * op_tail

Definiert in Zeile 460 der Datei code_gen.c.

FILE* outfile

Definiert in Zeile 410 der Datei code_gen.c.

char token[1024]

Definiert in Zeile 324 der Datei code_gen.c.