Subversion Repositories forwardcom

/****************************    assem5.cpp    ********************************

* Author:        Agner Fog

* Date created:  2017-09-19

* Last modified: 2021-05-21

* Version:       1.11

* Project:       Binary tools for ForwardCom instruction set

* Module:        assem.cpp

* Description:

* Module for assembling ForwardCom .as files.

* This module contains functions for interpreting high level language constructs:

* functions, branches, and loops

*

* Copyright 2017-2021 GNU General Public License http://www.gnu.org/licenses

******************************************************************************/

#include "stdafx.h"

// Define high level block types

const int HL_SECTION     =  1;  // section

const int HL_FUNC        =  2;  // function

const int HL_IF          =  3;  // if branch

const int HL_ELSE        =  4;  // else branch

const int HL_SWITCH      =  5;  // switch-case branch

const int HL_FOR         =  6;  // for loop

const int HL_FOR_IN      =  7;  // vector loop. for (v1 in [r2-r3]) {}

const int HL_WHILE       =  8;  // while loop

const int HL_DO_WHILE    =  9;  // do-while loop

// invert condition code for branch instruction

void invertCondition(SCode & code) {

    code.instruction ^= II_JUMP_INVERT;  // invert condition code

    if ((code.dtype & TYP_FLOAT)

        && (code.instruction & 0xFF) == II_COMPARE

        && (code.instruction & 0x7F00) - 0x1000 < 0x2000) {

        // floating point compare instructions, except jump_ordered, must invert the unordered bit

        code.instruction ^= II_JUMP_UNORDERED; // inverse condition is unordered

    }

}

// if, else, switch, for, do, while statements

void CAssembler::interpretHighLevelStatement() {

    //uint32_t label = 0;

    if (tokenN > 2 && tokens[tokenB].type == TOK_SYM && tokens[tokenB+1].id == ':') {

        // line starts with a label. insert label

        // (this will prevent merging of jump instruction. merging is not allowed when there is a label between the two instructions)

        SCode codeL;

        zeroAllMembers(codeL);

        //codeL.label = tokens[tokenB].value.w; //?

        codeL.label = tokens[tokenB].id;

        codeL.section = section;

        codeBuffer.push(codeL);

        // interpret directive after label

        tokenB += 2;

        tokenN -= 2;

    }

    uint32_t tok = tokenB;

    if (tokenN > 1 && tokens[tok].type == TOK_TYP) {

        tok++;  // skip type keyword

        if (tok+1 < tokenB+tokenN && tokens[tok].type == TOK_OPR && tokens[tok].id == '+') tok++;  // skip '+' after type

    }

    // expect HLL keyword here. dispatch to the corresponding function

    switch (tokens[tok].id) {

    case HLL_IF:

        codeIf();  break;

    case HLL_SWITCH:

        codeSwitch();  break;

    case HLL_CASE:

        codeCase();  break;

    case HLL_FOR:

        codeFor();  break;

    case HLL_WHILE:

        codeWhile();  break;

    case HLL_DO:

        codeDo();  break;

    case HLL_BREAK: case HLL_CONTINUE:

        if (tok != tokenB) {

            errors.report(tokens[tok]);   // cannot have type token before break or continue

            break;

        }

        codeBreak();  break;

    case HLL_PUSH:                        // may be replaced by macro later

        codePush();  break;

    case HLL_POP:                         // may be replaced by macro later

        codePop();  break;

    default:

        errors.report(tokens[tok]);

    }

}

// finish {} block

void CAssembler::interpretEndBracket() {

    uint32_t n = hllBlocks.numEntries();

    if (n == 0) {

        errors.reportLine(ERR_BRACKET_END);  // unmatched end bracket

        return;

    }

    // dispatch depending on type of block

    switch (hllBlocks[n-1].blockType) {

    case HL_FUNC: // function

        break;

    case HL_IF: case HL_ELSE: // if branch

        codeIf2();

        break;

    case HL_FOR: // for loop

        codeFor2();

        break;

    case HL_FOR_IN: // vector loop. for (v1 in [r2-r3]) {}

        codeForIn2();

        break;

    case HL_WHILE:    // while loop

        codeWhile2();

        break;

    case HL_DO_WHILE: // do-while loop

        codeDo2();

        break;

    case HL_SWITCH: // switch-case branch

        break;

    default:

        errors.reportLine(ERR_BRACKET_END);  // should not occur

    }

}

// Interpret if statement in assembly code

void CAssembler::codeIf() {

    uint32_t state = 0;                // 0: start, 1: after type, 2: after if, 3: after (, 4: after (type, 

                                       // 5: after expression, 6: after ')', 7: after {

    uint32_t tok;                      // current token index

    SBlock block;                      // block descriptor to save

    zeroAllMembers(block);             // reset

    block.blockType = HL_IF;           // if block

    SToken token;                      // current token

    SExpression expr;                  // expression in ()

    SCode code;                        // instruction code

    zeroAllMembers(code);              // reset

    // interpret line by state machine looping through tokens

    for (tok = tokenB; tok < tokenB + tokenN; tok++) {

        if (lineError) break;

        token = tokens[tok];

        switch (state) {

        case 0:  // start. expect type or 'if'

            if (token.type == TOK_TYP) {

                code.dtype = dataType = token.id & 0xFF;

                state = 1;

            }

            else if (token.id == HLL_IF) state = 2;

            else errors.report(token);

            break;

        case 1:  // after type. expect '+' or 'if'

            if (token.type == TOK_OPR && token.id == '+') {

                code.dtype |= TYP_PLUS;

            }

            else if (token.id == HLL_IF) state = 2;

            else errors.report(token);

            break;

        case 2: // after if. expect '('

            if (token.type == TOK_OPR && token.id == '(') state = 3;

            else errors.report(token.pos, token.stringLength, ERR_EXPECT_PARENTHESIS);

            break;

        case 3: // after '('. expect type or logical expression

            if (token.type == TOK_TYP && !code.dtype) {

                code.dtype = dataType = token.id & 0xFF;

                state = 4;

                break;

            }

            EXPRESSION:

            expr = expression(tok, tokenB + tokenN-tok, (code.dtype & TYP_UNS) != 0);

            if (lineError) return;

            // insert logical expression into block

            insertAll(code, expr);

            tok += expr.tokens - 1;

            state = 5;

            break;

        case 4: // after "if (type". expect '+' or expression

            if (token.type == TOK_OPR && token.id == '+') {

                code.dtype |= TYP_PLUS;

                break;

            }

            // not a '+'. expect expression

            goto EXPRESSION;

        case 5: // after expression. expect ')'

            if (token.type == TOK_OPR && token.id == ')') state = 6;

            else {

                errors.report(token);  return;

            }

            break;

        }

    }

    // should end at state 6 because '{' should be on next pseudo-line

    if (state != 6) errors.report(token);

    if (lineError) return;

    if (linei == lines.numEntries()-1) {  // no more lines

        errors.reportLine(ERR_UNFINISHED_INSTRUCTION);

        return;

    }

    // get next line

    if (linei == lines.numEntries()-1) {    // no more lines

        errors.reportLine(ERR_UNFINISHED_INSTRUCTION);

        return;

    }

    linei++;

    tokenB = lines[linei].firstToken;       // first token in line        

    tokenN = lines[linei].numTokens;        // number of tokens in line

    lineError = false;

    // expect '{'

    if (tokens[tokenB].id != '{') {

        errors.reportLine(ERR_EXPECT_BRACKET);

        return;

    }

    // interpret the condition expression

    linei--;                                // make any error message apply to previous line

    interpretCondition(code);

    linei++;

    // make instruction code

    code.etype |= XPR_JUMPOS | XPR_SYM1;

    code.section = section;

    // check if {} contains a jump only

    uint32_t target2 = hasJump(linei+1);

    if (target2) {

        if (linei + 2 < lines.numEntries() && lines[linei+2].numTokens == 1) {

            tok = lines[linei+2].firstToken;

            if (tokens[tok].type == TOK_OPR && tokens[tok].id == '}') {

                // the {} block contains a jump and nothing else

                // make conditional jump to target2 instead

                code.sym5 = target2;

                linei += 2;                          // finished processing these two lines

                // check if it can be merged with previous instruction

                mergeJump(code);

                // finish code and fit it

                checkCode1(code);

                if (lineError) return;

                fitCode(code);       // find an instruction variant that fits

                if (lineError) return;

                codeBuffer.push(code);// save code structure

                // check if there is an 'else' after if(){}

                if (linei + 2 < lines.numEntries() && lines[linei+1].numTokens == 1 && lines[linei+2].numTokens == 1) {

                    tok = lines[linei+1].firstToken;

                    if (tokens[tok].type == TOK_HLL && tokens[tok].id == HLL_ELSE) {

                        tok = lines[linei+2].firstToken;

                        if (tokens[tok].type == TOK_OPR && tokens[tok].id == '{') {

                            // make the 'else' ignored

                            linei += 2;

                            // make block record with no label

                            block.blockNumber = ++iIf;

                            block.startBracket = tok;

                            block.jumpLabel = 0;

                            // store block in hllBlocks stack. will be retrieved at matching '}'

                            hllBlocks.push(block);

                        }

                    }

                }

                return;

            }

        }

    }

    invertCondition(code);  // invert condition. jump to else block if logical expression false

    if (code.instruction == (II_JUMP | II_JUMP_INVERT)) {

        // constant: don't jump

        code.instruction = 0;

    }

    // make block record with label name

    block.blockNumber = ++iIf;

    block.startBracket = tokenB;

    char name[32];

    sprintf(name, "@if_%u_a", iIf);

    uint32_t symi = makeLabelSymbol(name);

    block.jumpLabel = symbols[symi].st_name;

    // store block in hllBlocks stack. will be retrieved at matching '}'

    hllBlocks.push(block);

    // store jump instruction

    code.sym5 = block.jumpLabel;

    // check if it can be merged with previous instruction

    mergeJump(code);

    // finish code and fit it

    checkCode1(code);

    if (lineError) return;

    fitCode(code);       // find an instruction variant that fits

    if (lineError) return;

    codeBuffer.push(code);// save code structure

}

// Finish if statement at end bracket

void CAssembler::codeIf2() {

    SCode code;                             // code record for jump label

    zeroAllMembers(code);                   // reset

    SBlock block = hllBlocks.pop();         // pop the stack of {} blocks

    uint32_t labelA = block.jumpLabel;      // jump target label to place here

    // check if there is an 'else' following the if(){}

    if (block.blockType == HL_IF && linei+2 < lines.numEntries() && tokens[lines[linei+1].firstToken].id == HLL_ELSE) {

        // there is an else. get next line with the else

        linei++;

        if (lines[linei].numTokens > 1) errors.report(tokens[lines[linei].firstToken+1]);  // something other than '{' after else

        // check if there is a '{' following the 'else'

        linei++;

        uint32_t tokenB = lines[linei].firstToken;

        if (lines[linei].numTokens > 1 || tokens[tokenB].type != TOK_OPR || tokens[tokenB].id != '{') {

            errors.reportLine(ERR_EXPECT_BRACKET); // expecting '{'

            return;

        }

        // make block record for jump to label b

        block.blockType = HL_ELSE;           // if-else block

        block.startBracket = tokenB;

        // make label name

        char name[32];

        sprintf(name, "@if_%u_b", block.blockNumber);

        uint32_t symi = makeLabelSymbol(name);

        block.jumpLabel = symbols[symi].st_name;

        hllBlocks.push(block);     // store block in hllBlocks stack. will be retrieved at matching '}'

        // make jump instruction

        code.section = section;

        code.instruction = II_JUMP;

        code.etype = XPR_JUMPOS | XPR_SYM1;

        code.sym5 = block.jumpLabel;

        // check if it can be merged with previous instruction

        mergeJump(code);

        // finish code and save it

        checkCode1(code);

        if (lineError) return;

        fitCode(code);       // find an instruction variant that fits

        if (lineError) return;

        codeBuffer.push(code);// save code structure

    }

    // make target label here

    if (labelA) {

        zeroAllMembers(code);

        code.section = section;

        code.label = labelA;       // jump target label

        codeBuffer.push(code);    // save code structure

    }

}

// Interpret while loop in assembly code

void CAssembler::codeWhile() {

    uint32_t state = 0;                // 0: start, 1: after type, 2: after while, 3: after (, 4: after (type, 

                                       // 5: after expression, 6: after ')', 7: after {

    uint32_t tok;                      // current token index

    SBlock block;                      // block descriptor to save

    zeroAllMembers(block);             // reset

    SToken token;                      // current token

    SExpression expr;                  // expression in ()

    SCode code;                        // instruction code

    zeroAllMembers(code);              // reset

    // interpret line by state machine looping through tokens (same as for codeIf)

    for (tok = tokenB; tok < tokenB + tokenN; tok++) {

        if (lineError) break;

        token = tokens[tok];

        switch (state) {

        case 0:  // start. expect type or 'while'

            if (token.type == TOK_TYP) {

                code.dtype = dataType = token.id & 0xFF;

                state = 1;

            }

            else if (token.id == HLL_WHILE) state = 2;

            else errors.report(token);

            break;

        case 1:  // after type. expect '+' or 'while'

            if (token.type == TOK_OPR && token.id == '+') {

                code.dtype |= TYP_PLUS;

            }

            else if (token.id == HLL_WHILE) state = 2;

            else errors.report(token);

            break;

        case 2: // after if. expect '('

            if (token.type == TOK_OPR && token.id == '(') state = 3;

            else errors.report(token.pos, token.stringLength, ERR_EXPECT_PARENTHESIS);

            break;

        case 3: // after '('. expect type or logical expression

            if (token.type == TOK_TYP && !code.dtype) {

                code.dtype = dataType = token.id & 0xFF;

                state = 4;

                break;

            }

        EXPRESSION:

            expr = expression(tok, tokenB + tokenN-tok, (code.dtype & TYP_UNS) != 0);

            if (lineError) return;

            // insert logical expression into block

            insertAll(code, expr);

            tok += expr.tokens - 1;

            state = 5;

            break;

        case 4: // after "while (type". expect '+' or expression

            if (token.type == TOK_OPR && token.id == '+') {

                code.dtype |= TYP_PLUS;

                break;

            }

            // not a '+'. expect expression

            goto EXPRESSION;

        case 5: // after expression. expect ')'

            if (token.type == TOK_OPR && token.id == ')') state = 6;

            else {

                errors.report(token);  return;

            }

            break;

        }

    }

    // should end at state 6 because '{' should be on next pseudo-line

    if (state != 6) errors.report(token);

    if (lineError) return;

    if (linei == lines.numEntries()-1) {  // no more lines

        errors.reportLine(ERR_UNFINISHED_INSTRUCTION);

        return;

    }

    // get next line

    // get next line

    if (linei == lines.numEntries()-1) {    // no more lines

        errors.reportLine(ERR_UNFINISHED_INSTRUCTION);

        return;

    }

    linei++;

    tokenB = lines[linei].firstToken;       // first token in line        

    tokenN = lines[linei].numTokens;        // number of tokens in line

    lineError = false;

    // expect '{'

    if (tokens[tokenB].id != '{') {

        errors.reportLine(ERR_EXPECT_BRACKET);

        return;

    }

    // interpret the condition expression

    linei--;                                // make any error message apply to previous line

    interpretCondition(code);

    linei++;

    // make instruction code

    code.etype |= XPR_JUMPOS | XPR_SYM1;

    code.section = section;

    // make block record with label names

    block.blockType = HL_WHILE;        // while-block

    block.blockNumber = ++iLoop;

    block.startBracket = tokenB;

    char name[32];

    sprintf(name, "@while_%u_a", iLoop);

    uint32_t symi1 = makeLabelSymbol(name);

    block.jumpLabel = symbols[symi1].st_name;  // label to jump back to

    sprintf(name, "@while_%u_b", iLoop);

    uint32_t symi2 = makeLabelSymbol(name);

    block.breakLabel = symbols[symi2].st_name;  // label after loop. used if condition is false first time and for break statements

    block.continueLabel = 0xFFFFFFFF;          // this label will only be made if there is a continue statement

    // make code to check condition before first iteration

    SCode code1 = code;

    invertCondition(code1); // invert condition to jump if false

    if (code1.instruction == (II_JUMP | II_JUMP_INVERT)) {

        // constant: don't jump

        code1.instruction = 0;

    }

    code1.sym5 = block.breakLabel;

    // check if it can be merged with previous instruction

    mergeJump(code1);

    // finish code and store it

    checkCode1(code1);

    if (lineError) return;

    fitCode(code1);       // find an instruction variant that fits

    if (lineError) return;

    codeBuffer.push(code1);// save code structure

    // make loop label

    zeroAllMembers(code1);

    code1.label = block.jumpLabel;

    code1.section = section;

    codeBuffer.push(code1);// save code structure

    // make instruction to place at end of loop

    code.sym5 = block.jumpLabel;

    checkCode1(code);

    // store in codeBuffer2 for later insertion at the end of the loop

    block.codeBuffer2index = codeBuffer2.push(code);

    block.codeBuffer2num = 1;

    // store block in hllBlocks stack. will be retrieved at matching '}'

    hllBlocks.push(block);

}

// Finish while-loop at end bracket

void CAssembler::codeWhile2() {

    SCode code;                            // code record for jump back

    SBlock block = hllBlocks.pop();        // pop the stack of {} blocks

    if (block.continueLabel != 0xFFFFFFFF) {

        // place label here as jump target for continue statements

        zeroAllMembers(code);

        code.label = block.continueLabel;

        code.section = section;

        codeBuffer.push(code);

    }

    uint32_t codebuf2num = codeBuffer2.numEntries();

    if (block.codeBuffer2num && block.codeBuffer2index < codebuf2num) {

        // retrieve jumpback instruction

        code = codeBuffer2[block.codeBuffer2index];

        if (code.instruction == (II_JUMP | II_JUMP_INVERT)) {

            // constant: don't jump

            code.instruction = 0;

        }

        // check if it can be merged with previous instruction

        mergeJump(code);

        // finish code and store it

        checkCode1(code);

        if (lineError) return;

        fitCode(code);       // find an instruction variant that fits

        if (lineError) return;

        codeBuffer.push(code);  // save code

        // remove from temporary buffer

        if (block.codeBuffer2index + 1 == codebuf2num) codeBuffer2.pop();

        // place label for breaking out

        zeroAllMembers(code);

        code.label = block.breakLabel;

        code.section = section;

        codeBuffer.push(code);  // save label

        return;

    }

}

// Interpret do-while loop in assembly code

void CAssembler::codeDo() {

    SBlock block;                          // block record

    SCode code;                            // code record for label

    zeroAllMembers(block);

    zeroAllMembers(code);

    // make block record with label names

    block.blockType = HL_DO_WHILE;        // do-while-block

    block.blockNumber = ++iLoop;

    char name[32];

    sprintf(name, "@do_%u_a", iLoop);

    uint32_t symi1 = makeLabelSymbol(name);

    block.jumpLabel = symbols[symi1].st_name;  // label to jump back to

    block.breakLabel = 0xFFFFFFFF;             // this label will only be made if there is a break statement

    block.continueLabel = 0xFFFFFFFF;          // this label will only be made if there is a continue statement

    // make loop label

    code.label = block.jumpLabel;

    code.section = section;

    codeBuffer.push(code);                     // save label

    // get next line with '{'

    if (linei == lines.numEntries()-1) {    // no more lines

        errors.reportLine(ERR_UNFINISHED_INSTRUCTION);

        return;

    }

    linei++;

    tokenB = lines[linei].firstToken;       // first token in line        

    tokenN = lines[linei].numTokens;        // number of tokens in line

    lineError = false;

    // expect '{'

    if (tokens[tokenB].id != '{') {

        errors.report(tokens[tokenB]);

        return;

    }

    block.startBracket = tokenB;

    hllBlocks.push(block);                     // store block in hllBlocks stack. will be retrieved at matching '}'

}

// Finish do-while loop at end bracket

void CAssembler::codeDo2() {

    SCode code;                            // code record 

    SBlock block = hllBlocks.pop();        // pop the stack of {} blocks

    if (block.continueLabel != 0xFFFFFFFF) {

        // place label here as jump target for continue statements

        zeroAllMembers(code);

        code.label = block.continueLabel;

        code.section = section;

        codeBuffer.push(code);

    }

    // find 'while' keyword in next pseudo-line after '}'

    if (linei+1 >= lines.numEntries()) {                  // no more lines

        errors.reportLine(ERR_WHILE_EXPECTED); return;

    }

    linei++;

    tokenB = lines[linei].firstToken;       // first token in line        

    tokenN = lines[linei].numTokens;        // number of tokens in line

    lineError = false;

    // expect "while (expression)"

    uint32_t state = 0;                // 0: start, 1: after type, 2: after 'while', 3: after (, 4: after (type, 

                                       // 5: after expression, 6: after ')'

    uint32_t tok;                      // current token index

    SToken token;                      // current token

    SExpression expr;                  // expression in ()

    zeroAllMembers(code);              // reset code

    // interpret line by state machine looping through tokens

    for (tok = tokenB; tok < tokenB + tokenN; tok++) {

        if (lineError) return;

        token = tokens[tok];

        switch (state) {

        case 0:  // start. expect type or 'while'

            if (token.type == TOK_TYP) {

                code.dtype = dataType = token.id & 0xFF;

                state = 1;

            }

            else if (token.id == HLL_WHILE) state = 2;

            else errors.reportLine(ERR_WHILE_EXPECTED);

            break;

        case 1:  // after type. expect '+' or 'while'

            if (token.type == TOK_OPR && token.id == '+') {

                code.dtype |= TYP_PLUS;

            }