Compiler pseudo-global state. More...

#include <state.h>

Public Member Functions
State *	state_new ()
	Create a new State object. More...

int	state_load_instr (State s, char fname)
	load instructions from a file More...

void	state_free (State *s)
	free a State object and all associated memory More...

int	state_parse_commandline (State s, int argc, char *argv)
	parse command line arguments and update state More...

Data Fields
Map *	defines
	defined constants More...

Map *	labels
	label locations More...

TokensList *	tokens
	tokens More...

Instruction *	instr
	instruction data More...

int	PC
	PC (starts at 0) More...

char	infile [STATE_MAX_STRING_LEN]
	input file name More...

char	outfile [STATE_MAX_STRING_LEN]
	output file name More...

Detailed Description

Compiler pseudo-global state.

defines
labels
tokens?
(args)
(settings)
(opcodes)

Definition at line 32 of file state.h.

Member Function Documentation

◆ state_free()

void state_free ( State * s )

free a State object and all associated memory

Parameters

s	state to free

Pointer should be NULLed after this!

Definition at line 48 of file state.c.

                           {
     if (!s) return;
     map_free(s->defines);
     tokenslist_free(s->tokens);
     map_free(s->labels);
     instruction_free(s->instr);
     free(s);
 }

Referenced by main(), and state_new().

◆ state_load_instr()

int state_load_instr	(	State *	s,
		char *	fname
	)

load instructions from a file

Parameters

fname	file path relative to CWD
s	state to load into

Returns: 0 on success, -1 on error

Definition at line 41 of file state.c.

                                             {
     s->instr = instruction_load(fname);
     if (s->instr == NULL) return -1;
     return 0;
 }

Referenced by main().

◆ state_new()

State * state_new ( )

Create a new State object.

Returns: the new object or NULL

Definition at line 16 of file state.c.

                    {
     State* ret = (State*)malloc(sizeof(State));
  
     if (ret == NULL) {
         ERROR("Memory allocation error in state_new()");
         return NULL;
     }
  
     if ((ret->defines = map_new()) == NULL) goto ERR;
     if ((ret->labels = map_new()) == NULL) goto ERR;
  
     ret->instr = NULL;
     ret->tokens = NULL;
     ret->PC = 0;
     ret->infile[0] = 0;
     strcpy(ret->outfile, "out.bin");
     return ret;
  
 ERR:
     FAIL("state_new() failed!\n");
     state_free(ret);
     return 0;
 }

Referenced by main().

◆ state_parse_commandline()

int state_parse_commandline	(	State *	s,
		int	argc,
		char **	argv
	)

parse command line arguments and update state

Parameters

s	state to update
argc	as in main()
argv	as in main()

Returns: 0 on success, -1 on error

Undestands: -o –out -d –define -l –log

last parameter is input file

prints usage if has a problem

Definition at line 81 of file state.c.

                                                              {
     for (int i = 1; i < argc; i++) {
         if (!strcmp(argv[i], "-o") || !strcmp(argv[i], "--out")) {
             // Output argument
             if (i == argc - 1) {
                 ERROR("Argument '%s' excepts parameter(s)!\n", argv[i]);
                 print_short_help();
                 return -1;
             }
             char* param = argv[++i];
             if (strlen(param) > STATE_MAX_STRING_LEN - 1) {
                 ERROR("Out parameter is too long! (max: %d chars)\n", STATE_MAX_STRING_LEN - 1);
                 return -1;
             }
             if (param[0] == '-') {
                 ERROR("Output file name can not start with a dash ('-')!\n");
                 return -1;
             }
             strncpy(s->outfile, param, STATE_MAX_STRING_LEN);
         } else if (!strcmp(argv[i], "-l") || !strcmp(argv[i], "--log")) {
             // Log argument
             if (i == argc - 1) {
                 ERROR("Argument '%s' excepts parameter(s)!\n", argv[i]);
                 print_short_help();
                 return -1;
             }
             char* param = argv[++i];
             int level;
             if (sscanf(param, "%d", &level) != 1) {
                 ERROR("Can not parse log level!\n");
                 return -1;
             }
             logging_level(level);
         } else if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--define")) {
             // Define argument
             if (i == argc - 2 || i == argc - 1) {
                 ERROR("Argument '%s' excepts parameter(s)!\n", argv[i]);
                 print_short_help();
                 return -1;
             }
             char* name = argv[++i];
             char* value = argv[++i];
             int num;
             if (sscanf(value, "%d", &num) != 1) {
                 ERROR("Can not parse value of define '%s': '%s'!\n", name, value);
                 return -1;
             }
             if (strlen(name) > MAP_MAX_KEY_LEN - 1) {
                 ERROR("Define constant name is too long! (max: %d chars)\n", MAP_MAX_KEY_LEN - 1);
                 return -1;
             }
             map_set(s->defines, name, num);
         } else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
             // help
             print_help(argv[0]);
             return -1;
         } else {
             // rest can only be inputfile
             if (strlen(argv[i]) > STATE_MAX_STRING_LEN - 1) {
                 ERROR("Input file name is too long! (max: %d chars)\n", STATE_MAX_STRING_LEN - 1);
                 return -1;
             }
             if (argv[i][0] == '-') {
                 ERROR("Input file name ('%s') can not start with a dash ('-')!\n", argv[i]);
                 return -1;
             }
             strncpy(s->infile, argv[i], STATE_MAX_STRING_LEN);
         }
     }
     if (s->infile[0] == 0) {
         ERROR("No input file was given!\n");
         print_short_help();
         return -1;
     }
     return 0;
 }