pass_one.h File Reference

processing step one More...

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

Go to the source code of this file.

Functions
int	pass_one (State *s)
	Compilation pass 1. More...

Detailed Description

processing step one

See documentation on steps for further info!

Definition in file pass_one.h.

Function Documentation

pass_one()

int pass_one

(

State *

s

)

Compilation pass 1.

Parameters

s	compiler state

Returns

0 on success, -1 on error

First pass processing for directives, instructions and labels
See documentation on steps for further info!

Definition at line 19 of file pass_one.c.

                       {
    TokensListElement* ptr = s->tokens->head;
 
    // stack to store state of conditionals
    // top of stack is the current value
    // 1 means we disabled compilation
    // in that case we do not generate anything
    // but still process conditional compilation directives
    // so we can get the matching endif
    istack_ptr ifstack = istack_new();
 
    if (!ifstack) {
        FAIL("Pass 1 init failed!\n");
        return -1;
    }
 
    // return value from directive processing
    enum DIRCommand p;
 
    // on all tokens
    while (ptr != NULL) {
        LOG(4, "Processing token:\n");
        LOGDO(4, token_print(ptr->token));
 
        // DIRECTIVE //
        if (ptr->token->type == TT_DIRECTIVE) {
            // call processor
            p = do_directive_token(s, ptr, istack_top(ifstack, 0));
 
            // do returned command
            if (p == DIR_IF_TRUE)
                // AND the condition, so a true inside a false is false
                if (istack_push(ifstack, istack_top(ifstack, 0)) < 0) goto ERR_FREE;
            if (p == DIR_IF_FALSE)
                // a false is always false
                if (istack_push(ifstack, 1) < 0) goto ERR_FREE;
 
            // pop stack
            if (p == DIR_ENDIF)
                if (istack_pop(ifstack) < 0) {
                    ERROR("More endif's than if's!\n");
                    token_print(ptr->token);
                    goto ERR_FREE;
                }
 
            // stop on error
            if (p == DIR_STOP) goto ERR_FREE;
        }
 
        // INSTRUCTION //
        if (ptr->token->type == TT_INSTR) {
            // analyze
 
            ptr->token->instr.address = s->PC;
 
            if (token_analyze_instruction(s, ptr->token) < 0) goto ERR_FREE;
            if (token_get_operand(s, ptr->token) < 0) goto ERR_FREE;
 
            LOGDO(3, token_print(ptr->token));
            LOG(3, "Instruction: \n");
            LOGDO(3, instruction_print(ptr->token->instr.inst));
            LOG(3, "A-mode: %s\n", ADRM_NAMES[ptr->token->instr.addressmode]);
        }
 
        // LABEL //
        if (ptr->token->type == TT_LABEL) {
            // set address
 
            if (ptr->token->len >= MAP_MAX_KEY_LEN) {
                ERROR("Label is too long!");
                token_print(ptr->token);
                goto ERR_FREE;
            }
 
            char labelname[MAP_MAX_KEY_LEN];
            // pragmas are here because GCC would generate a warning
            // (thus an error)
            // that I truncate the string
            // it's right of course, but also that's my intetntion
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-truncation"
            strncpy(labelname, ptr->token->stripped, MAP_MAX_KEY_LEN - 1);
            labelname[ptr->token->len - 1] = 0;
#pragma GCC diagnostic pop
            LOG(5, "Label: %s\n", labelname);
 
            if (map_get(s->labels, labelname) >= 0) {
                ERROR("Can not re-define label '%s'\n", labelname);
                ERROR("(prev. value: $%x = %d)\n", map_get(s->labels, labelname), map_get(s->labels, labelname));
                token_print(ptr->token);
                goto ERR_FREE;
            }
 
            map_set(s->labels, labelname, s->PC);
            LOG(3, "Set label: '%s' to %d\n", labelname, s->PC);
        }
 
        // COMMON //
 
        // drop if false conditional or 0>=binsize
        if (istack_top(ifstack, 0) || ptr->token->binSize <= 0) {
            ptr = tokenslist_remove(s->tokens, ptr);
        } else {
            // increment PC, get next token
            s->PC += ptr->token->binSize;
            ptr = ptr->next;
        }
    }
    istack_free(ifstack);
    return 0;
 
 
ERR_FREE:
    FAIL("Pass 1 failed!\n");
    istack_free(ifstack);
    return -1;
}

References ADRM_NAMES, Token::binSize, DIR_ENDIF, DIR_IF_FALSE, DIR_IF_TRUE, DIR_STOP, do_directive_token(), ERROR, FAIL, TokensList::head, Token::instr, Instruction::instruction_print(), istack_el::istack_free(), istack_el::istack_new(), istack_el::istack_pop(), istack_el::istack_push(), istack_el::istack_top(), State::labels, Token::len, LOG, LOGDO, Map::map_get(), MAP_MAX_KEY_LEN, Map::map_set(), TokensListElement::next, State::PC, Token::stripped, TokensListElement::token, Token::token_analyze_instruction(), Token::token_get_operand(), Token::token_print(), State::tokens, TokensList::tokenslist_remove(), TT_DIRECTIVE, TT_INSTR, TT_LABEL, and Token::type.

Referenced by main().