directive.h File Reference

step 1 and 3 processing for directive tokens More...

#include "tokenslist.h"
#include "state.h"

Go to the source code of this file.

Enumerations
enum	DIRCommand {   DIR_STOP = -1, DIR_NOP = 0, DIR_IF_TRUE, DIR_IF_FALSE,   DIR_ENDIF }
	Internal command type for directives. More...

Functions
enum DIRCommand	do_directive_token (State *s, TokensListElement *ptr, int skip)
	process a directive token More...
int	directive_compile (State *s, Token *t, char **dataptr)
	Compile a directive into binary data. More...

Detailed Description

step 1 and 3 processing for directive tokens

Public interface for directive.h

Definition in file directive.h.

Enumeration Type Documentation

DIRCommand

enum DIRCommand

Internal command type for directives.

Token processor functions return these to signal different commands to pass one

Enumerator
DIR_STOP	An error occured, stop compilation.
DIR_NOP	Nothing special, do nothing.
DIR_IF_TRUE	A conditional evaluated to true.
DIR_IF_FALSE	A conditional evaluated to false.
DIR_ENDIF	An endif was encountered, should pop from state stack.

Definition at line 19 of file directive.h.

                {
    DIR_STOP = -1,
    DIR_NOP = 0,
    DIR_IF_TRUE,
    DIR_IF_FALSE,
    DIR_ENDIF,
};

Function Documentation

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().