directive.c File Reference

Implement pass 1 and pass 3 (compile) processing for directive tokens. More...

#include "debugmalloc.h"
#include <string.h>
#include <stdlib.h>
#include "state.h"
#include "token_t.h"
#include "tokenFunc.h"
#include "logging.h"
#include "directive.h"
#include "util.h"
#include "number.h"
#include "loadfile.h"
#include "istack.h"

Go to the source code of this file.

Typedefs
typedef enum DIRCommand(*	tokenprocessor) (State *, TokensListElement *ptr)
	Token processor function. More...

Functions
enum DIRCommand	process_define (State *s, TokensListElement *ptr)
	Process an ifbeq directive. More...
enum DIRCommand	process_ifbeq (State *s, TokensListElement *ptr)
	Process an ifbeq directive. More...
enum DIRCommand	process_endif (State *s, TokensListElement *ptr)
	"Process" an endif directive More...
enum DIRCommand	process_print (State *s, TokensListElement *ptr)
	Process a print directive. More...
enum DIRCommand	process_printc (State *s, TokensListElement *ptr)
	Process a printc directive. More...
enum DIRCommand	process_include (State *s, TokensListElement *ptr)
	Process an include directive. More...
enum DIRCommand	process_ifdef (State *s, TokensListElement *ptr)
	Process an ifdef directive. More...
enum DIRCommand	process_ifndef (State *s, TokensListElement *ptr)
	Process an ifndef directive. More...
enum DIRCommand	process_org (State *s, TokensListElement *ptr)
	Process an org directive. More...
enum DIRCommand	process_data (State *s, TokensListElement *ptr)
	Process a data directive. More...
enum DIRCommand	process_pad (State *s, TokensListElement *ptr)
	Process a pad directive. More...
enum DIRCommand	do_directive_token (State *s, TokensListElement *ptr, int skip)
	process a directive token More...
int	compile_data (State *s, Token *t, char **dataptr)
	Compile a .data directive into binary data. More...
int	compile_pad (State *s, Token *t, char **dataptr)
	Compile a .pad directive into binary data. More...
int	directive_compile (State *s, Token *t, char **dataptr)
	Compile a directive into binary data. More...

Variables
struct {
tokenprocessor	p
char *	name
}	processors []
	The list of all processor functions and their tokens. More...
struct {
enum DIRCommand	ret
char *	name
}	skipProcessors []
	List of tokens to "process" when skipping tokens due to a falsy if. More...

Detailed Description

Implement pass 1 and pass 3 (compile) processing for directive tokens.

Pass 1 processing is complex processing, exact method depens on the current directive.
For this, I used an array to link directive names to different processing functions.
(also another array for disabled compilation)

Directives control conditional compilation and can modify the list of currently loaded tokens.
For this reason the common interface for processing functions receives state and full list along the current token, and returns a DIRCommand

Definition in file directive.c.

Typedef Documentation

tokenprocessor

typedef enum DIRCommand(* tokenprocessor) (State *, TokensListElement *ptr)

Token processor function.

Should process one token and return a DIRCommand
The reason why it takes a TokensListElemnt* and not just a Token* is that we need to do an insert to it's position (in require)

Definition at line 1 of file directive.c.

Function Documentation

compile_data()

int compile_data	(	State *	s,
		Token *	t,
		char **	dataptr
	)

Compile a .data directive into binary data.

Parameters

dataptr	return buffer for data
s	state object
t	token to compile

Returns

number of bytes in buffer or -1 on error

Definition at line 396 of file directive.c.

                                                     {
    // binsize is already calculated in pass 1 processing
    char* buff = malloc(t->binSize);
    int bufferIdx = 0; // p is current index in buffer
 
    // split string
    int n;
    char** arr = util_split_string(t->stripped, &n);
 
    for (int i = 1; i < n; i++) {
        LOG(4, ".data entry: '%s'\n", arr[i]);
 
        if (arr[i][0] == 'w') {
            // word (16 bit)
            // get word
            int num = number_get_number(s, &arr[i][2]);
            if (num < 0) {
                if (num == NUMBER_LABEL_NODEF)
                    ERROR("Label '%s' is not defined!\n", &arr[i][2]);
                ERROR("Invalid word in .data!\n");
                goto ERR;
            }
 
            // write
            buff[bufferIdx++] = num & 0xff;
            buff[bufferIdx++] = (num >> 8) & 0xff;
 
        } else if (arr[i][0] == '"') {
            // strings
 
            if (arr[i][strlen(arr[i]) - 1] != '"') {
                ERROR("Malformed string in .data! (no whitespaces allowed even in quotes)\n");
                goto ERR;
            }
 
            // write
            for (int j = 1; j < strlen(arr[i]) - 1; j++)
                buff[bufferIdx++] = arr[i][j];
 
        } else {
            // byte
 
            int num = number_get_number(s, arr[i]);
            if (num < 0 || num >> 8) {
                if (num == NUMBER_LABEL_NODEF)
                    ERROR("Label '%s' is not defined!\n", arr[i]);
                ERROR("Invalid byte in .data!\n");
                goto ERR;
            }
 
            // write
            buff[bufferIdx++] = num & 0xff;
        }
    }
    *dataptr = buff;
    free(arr);
    return t->binSize;
 
ERR:
    token_print(t);
    free(arr);
    free(buff);
    *dataptr = NULL;
    return -1;
}

References Token::binSize, ERROR, LOG, number_get_number(), NUMBER_LABEL_NODEF, Token::stripped, Token::token_print(), and util_split_string().

Referenced by directive_compile().

compile_pad()

int compile_pad	(	State *	s,
		Token *	t,
		char **	dataptr
	)

Compile a .pad directive into binary data.

Parameters

dataptr	return buffer for data
s	state object
t	token to compile

Returns

number of bytes in buffer or -1 on error

Definition at line 469 of file directive.c.

                                                    {
    int padwith = 0;
 
    // split string
    int n;
    char** arr = util_split_string(t->stripped, &n);
 
 
    if (n == 3) {
        padwith = number_get_number(s, arr[2]);
        if (padwith < 0 || padwith >> 8) {
            ERROR("Can not pad with invalid value!\n");
            token_print(t);
            *dataptr = NULL;
            free(arr);
            return -1;
        }
    }
 
    // allocate buffer and fill it
    char* buff = malloc(t->binSize);
    memset(buff, padwith, t->binSize);
 
    // return
    *dataptr = buff;
    free(arr);
    return t->binSize;
}

References Token::binSize, ERROR, number_get_number(), Token::stripped, Token::token_print(), and util_split_string().

Referenced by directive_compile().

directive_compile()

int directive_compile	(	State *	s,
		Token *	t,
		char **	dataptr
	)

Compile a directive into binary data.

Parameters

dataptr	return buffer for data
s	assembler state
t	token to compile

Returns

number of bytes in buffer or -1 on error

Simply relays it to compile_pad or compile_data

Definition at line 498 of file directive.c.

                                                          {
    // data or pad
    if (util_match_string(t->stripped, ".data", strlen(".data")) == 0)
        return compile_data(s, t, dataptr);
    if (util_match_string(t->stripped, ".pad", strlen(".pad")) == 0)
        return compile_pad(s, t, dataptr);
    return -1;
}

References compile_data(), compile_pad(), Token::stripped, and util_match_string().

Referenced by token_compile().

do_directive_token()

enum DIRCommand do_directive_token	(	State *	s,
		TokensListElement *	ptr,
		int	skip
	)

process a directive token

Parameters

s	state of the compiler
ptr	ptr to the current token in the list
skip	disable compilation flag (1=disabled)

Returns

DIRCommand to pass 1

Identifies directive type, and runs a processor function on it.

Definition at line 1 of file directive.c.

                                                                               {
    char* directive = ptr->token->stripped + 1;
 
    if (skip) {
        for (int i = 0; i < sizeof(skipProcessors) / sizeof(skipProcessors[0]); i++) {
            if (util_match_string(directive, skipProcessors[i].name, strlen(skipProcessors[i].name)) == 0) {
                return skipProcessors[i].ret;
            }
        }
        return DIR_NOP;
    }
 
    for (int i = 0; i < sizeof(processors) / sizeof(processors[0]); i++) {
        if (util_match_string(directive, processors[i].name, strlen(processors[i].name)) == 0) {
            return processors[i].p(s, ptr);
        }
    }
 
    ERROR("Unknown directive: %s\n", directive);
    token_print(ptr->token);
    return DIR_STOP;
}

Referenced by pass_one().

process_data()

enum DIRCommand process_data	(	State *	s,
		TokensListElement *	ptr
	)

Process a data directive.

Returns

DIR_NOP

Only counts size, generating binary will be done if all labels are defined (pass 3)

Definition at line 1 of file directive.c.

                                                               {
    // collect size
    int size = 0;
    int n;
    char** arr = util_split_string(ptr->token->stripped, &n);
    for (int i = 1; i < n; i++) {
        if (arr[i][0] == 'w')
            size += 2;
        else if (arr[i][0] == '"')
            size += strlen(arr[i]) - 2;
        else
            size += 1;
    }
    ptr->token->binSize = size;
    free(arr);
    return DIR_NOP;
}

process_define()

enum DIRCommand process_define	(	State *	s,
		TokensListElement *	ptr
	)

Process an ifbeq directive.

Returns

DIR_NOP or DIR_STOP

Parameters

s	current state
ptr	pointer to element to process

Definition at line 1 of file directive.c.

                                                                 {
 
    int n;
    char** line = util_split_string(ptr->token->stripped, &n);
 
    if (n != 3) {
        ERROR("Mismatched number of arguments for '%s'\n", line[0]); // define
        goto ERR;
    }
 
    int as_num = number_get_number(s, line[2]);
    if (as_num < 0) {
        if (as_num == NUMBER_LABEL_NODEF)
            ERROR("Can not use undefined labels with define!\n");
        FAIL("Define argument is not valid!\n");
        goto ERR;
    }
 
    if (strlen(line[1]) > MAP_MAX_KEY_LEN - 1) {
        ERROR("Too long constant name! (max is %d chars)\n", MAP_MAX_KEY_LEN - 1);
        goto ERR;
    }
 
    char def[MAP_MAX_KEY_LEN];
    strncpy(def, line[1], MAP_MAX_KEY_LEN);
 
    if (map_set(s->defines, def, as_num) < 0) goto ERR;
    free(line);
    return DIR_NOP;
 
ERR:
    FAIL("process_define() failed!\n");
    token_print(ptr->token);
    free(line);
    return DIR_STOP;
}

process_endif()

enum DIRCommand process_endif	(	State *	s,
		TokensListElement *	ptr
	)

"Process" an endif directive

Returns

DIR_ENDIF

Definition at line 1 of file directive.c.

                                                                {
    return DIR_ENDIF;
}

process_ifbeq()

enum DIRCommand process_ifbeq	(	State *	s,
		TokensListElement *	ptr
	)

Process an ifbeq directive.

Returns

DIR_IF_TRUE or DIR_IF_FALSE or DIR_STOP

Definition at line 1 of file directive.c.

                                                                {
    int n;
    char** line = util_split_string(ptr->token->stripped, &n);
 
    if (n != 3) {
        ERROR("Mismatched number of arguments for '%s'\n", line[0]); // ifbeq
        goto ERR;
    }
 
    int first_as_num = number_get_number(s, line[1]);
    int second_as_num = number_get_number(s, line[2]);
 
    if (first_as_num < 0 || second_as_num < 0) {
        if (first_as_num == NUMBER_LABEL_NODEF || second_as_num == NUMBER_LABEL_NODEF) {
            ERROR("Can not forward-ref labels with ifbeq!\n");
        } else {
            FAIL("ifbeq argument not defined!\n");
        }
        goto ERR;
    }
 
    free(line);
    return first_as_num > second_as_num ? DIR_IF_TRUE : DIR_IF_FALSE;
 
ERR:
    token_print(ptr->token);
    FAIL("process_ifbeq() failed!\n");
    free(line);
    return DIR_STOP;
}

process_ifdef()

enum DIRCommand process_ifdef	(	State *	s,
		TokensListElement *	ptr
	)

Process an ifdef directive.

Returns

DIR_STOP, DIR_IF_TRUE or DIR_IF_FALSE

Definition at line 1 of file directive.c.

                                                                {
    int n;
    char** line = util_split_string(ptr->token->stripped, &n);
 
    if (n != 2) {
        ERROR("Mismatched number of arguments for '%s'\n", line[0]); // ifdef / ifndef
        token_print(ptr->token);
        free(line);
        return DIR_STOP;
    }
    int num = map_get(s->defines, line[1]);
    free(line);
 
    return num < 0 ? DIR_IF_FALSE : DIR_IF_TRUE;
}

process_ifndef()

enum DIRCommand process_ifndef	(	State *	s,
		TokensListElement *	ptr
	)

Process an ifndef directive.

Returns

DIR_STOP, DIR_IF_TRUE or DIR_IF_FALSE

Uses process_ifdef internally

Definition at line 1 of file directive.c.

                                                                 {
    enum DIRCommand ret = process_ifdef(s, ptr);
    if (ret == DIR_IF_FALSE)
        return DIR_IF_TRUE;
    if (ret == DIR_IF_TRUE)
        return DIR_IF_FALSE;
    return DIR_STOP;
}

process_include()

enum DIRCommand process_include	(	State *	s,
		TokensListElement *	ptr
	)

Process an include directive.

Returns

DIR_NOP or DIR_STOP

Reads another file and inserts the tokens into the list.
This modifies the tokenslist directly!

Definition at line 1 of file directive.c.

                                                                  {
    int n;
    char** line = util_split_string(ptr->token->stripped, &n);
    if (n != 2) {
        ERROR("Mismatched number of arguments for '%s'\n", line[0]); // include
        free(line);
        return DIR_STOP;
    }
    TokensList* f = load_file(line[1]);
    if (f == NULL) {
        FAIL("Could not include file!\n");
        token_print(ptr->token);
        free(line);
        return DIR_STOP;
    }
    tokenslist_insert(s->tokens, ptr, f);
    tokenslist_free(f);
    free(line);
    return DIR_NOP;
}

process_org()

enum DIRCommand process_org	(	State *	s,
		TokensListElement *	ptr
	)

Process an org directive.

Returns

DIR_STOP or DIR_NOP

Modifies state PC

Definition at line 1 of file directive.c.

                                                              {
    int n;
    char** line = util_split_string(ptr->token->stripped, &n);
    if (n != 2) {
        ERROR("Mismatched number of arguments for '%s'\n", line[0]); // org
        goto ERR;
    }
    int num = number_get_number(s, line[1]);
    if (num < 0) {
        if (num == NUMBER_LABEL_NODEF) {
            ERROR("Can not use undefined labels with org!\n");
        }
        FAIL("Invalid number with .org!\n");
        goto ERR;
    }
    s->PC = num;
    free(line);
    LOG(3, "PC = %d\n", num);
    return DIR_NOP;
 
ERR:
    free(line);
    FAIL("process_org() failed!\n");
    token_print(ptr->token);
    return DIR_STOP;
}

process_pad()

enum DIRCommand process_pad	(	State *	s,
		TokensListElement *	ptr
	)

Process a pad directive.

Returns

DIR_NOP

Definition at line 1 of file directive.c.

                                                              {
    int n;
    char** line = util_split_string(ptr->token->stripped, &n);
 
    if (2 > n || 3 < n) {
        ERROR("Mismatched number of arguments for '%s'\n", line[0]); // pad
        goto ERR;
    }
 
    int target = number_get_number(s, line[1]);
    if (target < 0) {
        ERROR("Invalid argument in .pad!\n");
        goto ERR;
    }
    int size = target - s->PC;
    if (size < 0) {
        ERROR("Negative padding! PC=%x, target=%x\n", s->PC, target);
        goto ERR;
    }
    ptr->token->binSize = size;
    free(line);
    return DIR_NOP;
 
ERR:
    token_print(ptr->token);
    free(line);
    return DIR_STOP;
}

process_print()

enum DIRCommand process_print	(	State *	s,
		TokensListElement *	ptr
	)

Process a print directive.

Returns

DIR_NOP or DIR_STOP

Definition at line 1 of file directive.c.

                                                                {
    char* str = &(ptr->token->stripped[1]);
    str = util_find_string_segment(str) + 1;
    if (*(str - 1) == 0) {
        ERROR("Print with empty message!\n");
        token_print(ptr->token);
        return DIR_STOP;
    }
    printf("\e[44mMESSAGE\e[49m\t%s\n", str);
    return DIR_NOP;
}

process_printc()

enum DIRCommand process_printc	(	State *	s,
		TokensListElement *	ptr
	)

Process a printc directive.

Returns

DIR_NOP or DIR_STOP

Definition at line 1 of file directive.c.

                                                                 {
    int n;
    char** line = util_split_string(ptr->token->stripped, &n);
 
    if (n != 2) {
        ERROR("Mismatched number of arguments for '%s'\n", line[0]); // printc
        token_print(ptr->token);
        free(line);
        return DIR_STOP;
    }
 
    int v = map_get(s->defines, line[1]);
    printf("\e[44mDEFINE\e[49m:\t%s = ", line[1]);
 
    if (v < 0)
        printf("\e[31mNOT DEFINED\e[39m\n");
    else
        printf("%d\n", v);
 
    free(line);
    return DIR_NOP;
}

Variable Documentation

processors

struct { ... } processors[]

Initial value:

= {
    { process_define,   "define"    },
    { process_ifdef,    "ifdef"     },
    { process_printc,   "printc"    },
    { process_print,    "print"     },
    { process_include,  "include"   },
    { process_endif,    "endif"     },
    { process_ifndef,   "ifndef"    },
    { process_ifbeq,    "ifbeq"     },
    { process_org,      "org"       },
    { process_data,     "data"      },
    { process_pad,      "pad"       },
}

The list of all processor functions and their tokens.

Their order DOES matter as comparision can not check end of strings as tokens do not end after directive names.
(namely printc must come before print or will get falsely reconized as a print)

skipProcessors

struct { ... } skipProcessors[]

Initial value:

= {
    { DIR_ENDIF,    "endif" },
    { DIR_IF_TRUE,  "ifdef" },
    { DIR_IF_TRUE,  "ifndef"},
    { DIR_IF_TRUE,  "ifbeq" },
}

List of tokens to "process" when skipping tokens due to a falsy if.