Subversion Repositories marca

/* This file is part of the assembler "spar" for marca.

   Copyright (C) 2007 Wolfgang Puffitsch

   This program is free software; you can redistribute it and/or modify it

   under the terms of the GNU Library General Public License as published

   by the Free Software Foundation; either version 2, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public

   License along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA */

%{

#include 

#include 

#include "exprs.h"

int exprslex(void);

void yyerror(int64_t *, const char *);

%}

%union {

  int64_t intval;

}

%parse-param {

  int64_t *retval, int64_t *symcount

}

%token  NUM IDENT

%token CUMOD CEQU CUGT CSHR CUMIN CLE CNEQ CMIN CLAND

%token CGE CUDIV CUGE CULE CLOR CULT CSHL CMAX CUMAX CSLR

%token HI LO

%type  PrimaryExpr UnaryExpr MultExpr AddExpr ShiftExpr

%type  RelatExpr EqualExpr AndExpr XorExpr OrExpr

%type  LAndExpr LOrExpr CondExpr MinMaxExpr HiLoExpr Expr

%start Expr

%%

PrimaryExpr : NUM

            { $$ = $1;

            }

            | IDENT

            { (*symcount)++;

              $$ = $1;

            }

            | '(' Expr ')'

            { $$ = $2;

            }

;

UnaryExpr : PrimaryExpr

          | '+' UnaryExpr

          { $$ = $2;

          }

          | '-' UnaryExpr

          { $$ = -$2;

          }

          | '~' UnaryExpr

          { $$ = ~$2;

          }

          | '!' UnaryExpr

          { $$ = !$2;

          }

;

MultExpr : UnaryExpr

         | MultExpr '*' UnaryExpr

         { $$ = $1 * $3;

         }

         | MultExpr '/' UnaryExpr

         {

           if ($3 == 0)

             {

               fprintf(stderr, "division by zero");

               $$ = 0;

             }

           else

             {

               $$ = $1 / $3;

             }

         }

         | MultExpr CUDIV UnaryExpr

         {

           if ($3 == 0)

             {

               fprintf(stderr, "division by zero");

               $$ = 0;

             }

           else

             {

               $$ = (uint64_t)$1 / (uint64_t)$3;

             }

         }

         | MultExpr '%' UnaryExpr

         {

           if ($3 == 0)

             {

               fprintf(stderr, "modulo zero");

               $$ = 0;

             }

           else

             {

               $$ = $1 % $3;

             }

         }

         | MultExpr CUMOD UnaryExpr

         {

           if ($3 == 0)

             {

               fprintf(stderr, "modulo zero");

               $$ = 0;

             }

           else

             {

               $$ = (uint64_t)$1 % (uint64_t)$3;

             }

         }

;

AddExpr : MultExpr

        | AddExpr '+' MultExpr

        { $$ = $1 + $3;

        }

        | AddExpr '-' MultExpr

        { $$ = $1 - $3;

        }

;

ShiftExpr : AddExpr

          | ShiftExpr CSHR AddExpr

          { $$ = $1 >> $3;

          }

          | ShiftExpr CSHL AddExpr

          { $$ = $1 << $3;

          }

          | ShiftExpr CSLR AddExpr

          { $$ = (uint64_t)$1 >> $3;

          }

;

RelatExpr : ShiftExpr

          | RelatExpr '<' ShiftExpr

          { $$ = $1 < $3;

          }

          | RelatExpr '>' ShiftExpr

          { $$ = $1 > $3;

          }

          | RelatExpr CLE ShiftExpr

          { $$ = $1 <= $3;

          }

          | RelatExpr CGE ShiftExpr

          { $$ = $1 >= $3;

          }

          | RelatExpr CULT ShiftExpr

          { $$ = (uint64_t)$1 < (uint64_t)$3;

          }

          | RelatExpr CUGT ShiftExpr

          { $$ = (uint64_t)$1 > (uint64_t)$3;

          }

          | RelatExpr CULE ShiftExpr

          { $$ = (uint64_t)$1 <= (uint64_t)$3;

          }

          | RelatExpr CUGE ShiftExpr

          { $$ = (uint64_t)$1 >= (uint64_t)$3;

          }

;

EqualExpr : RelatExpr

          | EqualExpr CEQU RelatExpr

          { $$ = $1 == $3;

          }

          | EqualExpr CNEQ RelatExpr

          { $$ = $1 != $3;

          }

;

AndExpr : EqualExpr

        | AndExpr '&' EqualExpr

        { $$ = $1 & $3;

        }

;

XorExpr : AndExpr

        | XorExpr '^' AndExpr

        { $$ = $1 ^ $3;

        }

;

OrExpr : XorExpr

       | OrExpr '|' XorExpr

       { $$ = $1 | $3;

       }

;

LAndExpr : OrExpr

         | LAndExpr CLAND OrExpr

         { $$ = $1 && $3;

         }

;

LOrExpr : LAndExpr

        | LOrExpr CLOR LAndExpr

        { $$ = $1 || $3;

        }

;

CondExpr : LOrExpr

         | LOrExpr '?' Expr ':' CondExpr

         { $$ = $1 ? $3 : $5;

         }

;

MinMaxExpr : CondExpr

           | MinMaxExpr CMIN CondExpr

           { $$ = $1 < $3 ? $1 : $3;

           }

           | MinMaxExpr CMAX CondExpr

           { $$ = $1 > $3 ? $1 : $3;

           }

           | MinMaxExpr CUMIN CondExpr

           { $$ = (uint64_t)$1 < (uint64_t)$3 ? $1 : $3;

           }

           | MinMaxExpr CUMAX CondExpr

           { $$ = (uint64_t)$1 > (uint64_t)$3 ? $1 : $3;

           }

;

HiLoExpr : MinMaxExpr

         | HI '(' MinMaxExpr ')'

         { $$ = ($3 >> 8) & 0xFF;

         }

         | LO '(' MinMaxExpr ')'

         { $$ = $3 & 0xFF;

         }

Expr: HiLoExpr

    { *retval = $1;

    }

;

%%

void yyerror(int64_t *r, const char *msg)

{

  fprintf(stderr, "within expression: %s\n", msg);

}