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 */

%option nounput

%{

#include 

#include 

#include "exprs.h"

#include "exprs.tab.h"

#include "spar.h"

#include "symtab.h"

int exprsparse(int64_t *, int64_t *);

static int allow_syms = 1;

static int resolve_syms = 1;

static int localize_syms = 0;

static char *localized_expr = NULL;

#define YY_USER_ACTION \

do { \

  if (localize_syms) { \

    localized_expr = xrealloc(localized_expr, \

                              strlen(localized_expr) \

                              + yyleng + 1); \

    strcat(localized_expr, yytext); \

  } \

} while(0);

%}

BNUM (0b[0-1]+)

ONUM (0[0-7]*)

DNUM ([1-9][0-9]*)

XNUM (0x[0-9a-fA-F]+)

SYM  (\.?[_\.a-zA-Z0-9@]+)

%%

"hi"   return HI;

"lo"   return LO;

"("    return '(';

")"    return ')';

"+"    return '+';

"-"    return '-';

"~"    return '~';

"!"    return '!';

"*"    return '*';

"/"    return '/';

"|/|"  return CUDIV;

"%"    return '%';

"|%|"  return CUMOD;

">>"   return CSHR;

"<<"   return CSHL;

">>>"  return CSLR;

"<"    return '<';

">"    return '>';

"<="   return CLE;

">="   return CGE;

"|<|"  return CULT;

"|>|"  return CUGT;

"|<=|" return CULE;

"|>=|" return CUGE;

"=="   return CEQU;

"!="   return CNEQ;

"&"    return '&';

"^"    return '^';

"|"    return '|';

"&&"   return CLAND;

"||"   return CLOR;

"?"    return '?';

":"    return ':';

"

">?"   return CMAX;

"|

"|>?|" return CUMAX;

{BNUM} {

          exprslval.intval = strtol(yytext+2, NULL, 2);

          return NUM;

       }

{ONUM} {

          exprslval.intval = strtol(yytext, NULL, 8);

          return NUM;

       }

{DNUM} {

          exprslval.intval = strtol(yytext, NULL, 10);

          return NUM;

       }

{XNUM} {

          exprslval.intval = strtol(yytext+2, NULL, 16);

          return NUM;

       }

{SYM}  {

          char *s = yytext;

          if (localize_syms)

            {

              s = localize_string(yytext);

              localized_expr = xrealloc(localized_expr,

                                        strlen(localized_expr)

                                        + strlen(s)

                                        - yyleng + 1);

              strcpy(localized_expr

                     + strlen(localized_expr)

                     - yyleng, s);

            }

          else if (!allow_syms)

            {

              exprslval.intval = 0;

              fprintf(stderr, "no symbol allowed here: `%s'\n", s);

              error_count++;

            }

          else if (!resolve_syms)

            {

              exprslval.intval = 0;

            }

          else if (get_sym(s) == NULL)

            {

              exprslval.intval = 0;

              fprintf(stderr, "symbol in expression not found: `%s'\n", s);

              error_count++;

            }

          else

            {

              exprslval.intval = get_sym(s)->addr;

            }

          return IDENT;

       }

[ \t\r\n]+ { /* ignore whitespace */ }

%%

int yywrap()

{

  return 1;

}

char *expr_localize(const char *expr)

{

  int64_t value = 0;

  int64_t symcount = 0;

  allow_syms = 1;

  resolve_syms = 0;

  localize_syms = 1;

  localized_expr = xmalloc(1);

  localized_expr[0] = '\0';

  exprs_scan_string(expr);

  exprsparse(&value, &symcount);

  return localized_expr;

}

int64_t expr_symcount(const char *expr)

{

  int64_t value = 0;

  int64_t symcount = 0;

  allow_syms = 1;

  resolve_syms = 0;

  localize_syms = 0;

  localized_expr = NULL;

  exprs_scan_string(expr);

  exprsparse(&value, &symcount);

  return symcount;

}

int64_t expr_nevaluate(const char *expr)

{

  int64_t value = 0;

  int64_t symcount = 0;

  allow_syms = 0;

  resolve_syms = 0;

  localize_syms = 0;

  localized_expr = NULL;

  exprs_scan_string(expr);

  exprsparse(&value, &symcount);

  return value;

}

int64_t expr_evaluate(const char *expr)

{

  int64_t value = 0;

  int64_t symcount = 0;

  allow_syms = 1;

  resolve_syms = 1;

  localize_syms = 0;

  localized_expr = NULL;

  exprs_scan_string(expr);

  exprsparse(&value, &symcount);

  return value;

}