Subversion Repositories tinyvliw8

/**

 * \file   parser.y

 * \author Oliver Stecklina 

 * \date   12.12.2015

 *

 * \brief  Yacc parser file

 *

 * 

 *    Copyright (C) 2015 IHP GmbH, Frankfurt (Oder), Germany

 *

 * This code is free software. It is licensed under the EUPL, Version 1.1

 * or - as soon they will be approved by the European Commission - subsequent

 * versions of the EUPL (the "License").

 * You may redistribute this code and/or modify it under the terms of this

 * License.

 * You may not use this work except in compliance with the License.

 * You may obtain a copy of the License at:

 *

 * http://joinup.ec.europa.eu/software/page/eupl/licence-eupl

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" basis,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * 

 */

%{

        #include 

        #include 

        #include "instr.h"

        static instr_t _instr[2];

        static unsigned char _instr_num = 0;

    extern int yylex();

        extern int get_linenum();

        unsigned char _sign;

    void yyerror(const char *s) {

                printf("ERROR: %s near line %d\n", s, get_linenum());

        }

        void _instr_clean(void)

        {

                memset((char *) &_instr[0], 0x00, 2 * sizeof(instr_t));

                _instr[0].source.next = &_instr[0].source;

                _instr[0].source.prev = &_instr[0].source;

                _instr[1].source.next = &_instr[1].source;

                _instr[1].source.prev = &_instr[1].source;

                _instr_num = 0;

        }

%}

%union {

        char* str;

        int   num;

}

%start PROGRAM

%token CONSTSEC

%token RESSEC

%token CODESEC

%token  IRQSEC

%token LOADI

%token LOAD

%token STOREI

%token STORE

%token RLA

%token RLC

%token RRA

%token RRC

%token MOVE

%token ADDI

%token ADD

%token OR

%token XOR

%token XNOR

%token NOR

%token AND

%token NAND

%token JMP

%token JNZ

%token JZ

%token JC

%token COLON

%token PLUS

%token MINUS

%token TILDE

%token PIPE

%token DOLLAR

%token HASH

%token AT

%token  REG

%token  HEXNUM

%token  HEXADDR

%token  NAME

%token  UNAME

%token NEWLINE

%token SEMICOLON

%token COMMA

   %%

PROGRAM:

        constseq resseq codeseq irqseq

empty:

constseq:

          CONSTSEC linebreak consts

        | empty

resseq:

        RESSEC linebreak ress

        | empty

codeseq:

          CODESEC { _instr_clean(); } linebreak code

        | empty

irqseq:

          irq irq irq irq

        | irq irq irq

        | irq irq

        | irq

        | empty

irq:

          IRQSEC linebreak instr { instr_irq($1); instr_add(&_instr[0], _instr_num); _instr_clean(); }

ress:

          res ress

        | res

res:

        NAME HEXNUM SEMICOLON linebreak

consts:

          cvar consts

        | cvar

cvar:

        UNAME HEXNUM SEMICOLON linebreak

linebreak:

          linebreak NEWLINE

        | NEWLINE

code:

          cinstr code

        | cinstr

cinstr:

          NAME COLON linebreak instr { instr_label($1); instr_add(&_instr[0], _instr_num); _instr_clean(); }

        | instr                      { instr_add(&_instr[0], _instr_num); _instr_clean(); }

instr:

          cmd SEMICOLON linebreak

        | cmd PIPE cmd SEMICOLON linebreak

cmd:

          ldsti REG COMMA src     { instr_add_dest(&_instr[_instr_num].dest, $2); _instr_num++; }

        | logici REG COMMA alusrc { instr_add_dest(&_instr[_instr_num].dest, $2); _instr_num++; }

        | alui REG COMMA alusrc   { instr_add_dest(&_instr[_instr_num].dest, $2); _instr_num++; }

        | sh                      { _instr_num++; }

        | jmpi jmpdst             { _instr_num++; }

sh:

          shi REG COMMA srcreg  { instr_add_dest(&_instr[_instr_num].dest, $2); }

        | MOVE REG COMMA movsrc { instr_add_dest(&_instr[_instr_num].dest, $2); _instr[_instr_num].opcode = instr_opcode_mov; }

shi:

          RLA { _instr[_instr_num].opcode = instr_opcode_rla; }

        | RLC { _instr[_instr_num].opcode = instr_opcode_rlc; }

        | RRA { _instr[_instr_num].opcode = instr_opcode_rra; }

        | RRC { _instr[_instr_num].opcode = instr_opcode_rrc; }

movsrc:

          srcreg

        | HASH HEXNUM { instr_add_source(&_instr[_instr_num].source, instr_operand_type_const, &($2)); }

jmpi:

          JMP { _instr[_instr_num].opcode = instr_opcode_jmp; }

        | JZ  { _instr[_instr_num].opcode = instr_opcode_jz; }

        | JC  { _instr[_instr_num].opcode = instr_opcode_jc; }

        | JNZ { _instr[_instr_num].opcode = instr_opcode_jnz; }

alui:

          ADD  { _instr[_instr_num].opcode = instr_opcode_add; }

        | ADDI { _instr[_instr_num].opcode = instr_opcode_addi; }

jmpdst:

          DOLLAR NAME { instr_add_source(&_instr[_instr_num].source, instr_operand_type_label, $2); }

        | sign HEXADDR { instr_add_source(&_instr[_instr_num].source, instr_operand_type_const, &($2)); instr_source_flag(&_instr[_instr_num].source, _sign);}

ldsti:

          LOAD   { _instr[_instr_num].opcode = instr_opcode_ld; }

        | LOADI  { _instr[_instr_num].opcode = instr_opcode_ldi; }

        | STORE  { _instr[_instr_num].opcode = instr_opcode_st; }

        | STOREI { _instr[_instr_num].opcode = instr_opcode_sti; }

sign:

          PLUS  { _sign = 0x00; }

        | MINUS { _sign = INSTR_FLAG_MINUS; }

src:

          AT REG { instr_add_source(&_instr[_instr_num].source, instr_operand_type_reg, &($2)); }

        | HASH HEXNUM { instr_add_source(&_instr[_instr_num].source, instr_operand_type_const, &($2)); }

        | DOLLAR UNAME { instr_add_source(&_instr[_instr_num].source, instr_operand_type_label, $2); }

        | DOLLAR NAME { instr_add_source(&_instr[_instr_num].source, instr_operand_type_label, $2); }

logici:

          OR   { _instr[_instr_num].opcode = instr_opcode_or; }

        | NOR  { _instr[_instr_num].opcode = instr_opcode_nor; }

        | AND  { _instr[_instr_num].opcode = instr_opcode_and; }

        | NAND { _instr[_instr_num].opcode = instr_opcode_nand; }

        | XOR  { _instr[_instr_num].opcode = instr_opcode_xor; }

        | XNOR { _instr[_instr_num].opcode = instr_opcode_xnor; }

alusrc:

          HASH HEXNUM { instr_add_source(&_instr[_instr_num].source, instr_operand_type_const, &($2)); }

        | srcreg

        | srcreg COMMA srcreg

srcreg:

          REG { instr_add_source(&_instr[_instr_num].source, instr_operand_type_reg, &($1)); }

        | TILDE REG { instr_add_source(&_instr[_instr_num].source, instr_operand_type_reg, &($2)); instr_source_flag(&_instr[_instr_num].source, INSTR_FLAG_TILDE);}