[deliverable/binutils-gdb.git] / gas / config / bfin-lex.l

/* bfin-lex.l  ADI Blackfin lexer
   Copyright 2005, 2006, 2007, 2008, 2010
   Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   GAS 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to the Free
   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
   02110-1301, USA.  */
%{

#include "as.h"
#include "bfin-defs.h"
#include "bfin-parse.h"

static long parse_int (char **end);
static int parse_halfreg (Register *r, int cl, char *hr);
static int parse_reg (Register *r, int type, char *rt);
int yylex (void);

#define _REG yylval.reg


%}

/* Define Start States ... Actually we will use exclusion.
   If no start state is specified it should match any state
   and <INITIAL> would match some keyword rules only with
   initial.  */
%s KEYWORD

%%
[sS][fF][tT][rR][eE][sS][eE][tT]        _REG.regno = REG_sftreset;  return REG;
[oO][mM][oO][dD][eE]                    _REG.regno = REG_omode;     return REG;
[iI][dD][lL][eE]_[rR][eE][qQ]           _REG.regno = REG_idle_req;  return REG;
[hH][wW][eE][rR][rR][cC][aA][uU][sS][eE] _REG.regno = REG_hwerrcause; return REG;
[eE][xX][cC][aA][uU][sS][eE]            _REG.regno = REG_excause;   return REG;
[eE][mM][uU][cC][aA][uU][sS][eE]	_REG.regno = REG_emucause;  return REG;
[zZ]                                    return Z;
[xX]                                    return X;
[wW]32                                  yylval.value = M_W32; return MMOD;
[wW]                                    return W;
[vV][iI][tT]_[mM][aA][xX]               return VIT_MAX;
[vV]               return V; /* Special: V is a statflag and a modifier.  */
[uU][sS][pP]       _REG.regno = REG_USP; return REG;
[tT][lL]                                return TL;
[tT][hH]                                return TH;
[tT][fF][uU]                            yylval.value = M_TFU; return MMOD;
[tT][eE][sS][tT][sS][eE][tT]            return TESTSET;
[tT]                                    yylval.value = M_T; return MMOD;
[sS]                                                        return S;
[sS][yY][sS][cC][fF][gG]       _REG.regno = REG_SYSCFG; return REG;
[sS][tT][iI]                            return STI;
[sS][sS][yY][nN][cC]                    return SSYNC;
[sS][pP]"."[lL]                         _REG.regno = REG_SP; _REG.flags = F_REG_LOW; return HALF_REG;
[sS][pP]"."[hH]                         _REG.regno = REG_SP; _REG.flags = F_REG_HIGH; return HALF_REG;
[sS][pP]                                _REG.regno = REG_SP; return REG;
[sS][iI][gG][nN][bB][iI][tT][sS]        return SIGNBITS;
[sS][iI][gG][nN]                        return SIGN;
[sS][eE][qQ][sS][tT][aA][tT]     _REG.regno = REG_SEQSTAT; return REG;
[sS][eE][aA][rR][cC][hH]                return SEARCH;
[sS][hH][iI][fF][tT]                    return SHIFT;
[sS][cC][oO]                            return SCO;

[sS][aA][aA]                            return SAA;
[sS]2[rR][nN][dD]                       yylval.value = M_S2RND; return MMOD;
[rR][tT][xX]                            return RTX;
[rR][tT][sS]                            return RTS;
[rR][tT][nN]                            return RTN;
[rR][tT][iI]                            return RTI;
[rR][tT][eE]                            return RTE;
[rR][oO][tT]                            return ROT;
[rR][nN][dD]20                          return RND20;
[rR][nN][dD]12                          return RND12;
[rR][nN][dD][lL]                        return RNDL;
[rR][nN][dD][hH]                        return RNDH;
[rR][nN][dD]                            return RND;

[rR][0-7]"."[lLhHbB]  return parse_halfreg(&yylval.reg, T_REG_R, yytext);

[rR][eE][tT][sS]		_REG.regno = REG_RETS; return REG;
[rR][eE][tT][iI]		_REG.regno = REG_RETI; return REG;
[rR][eE][tT][xX]		_REG.regno = REG_RETX; return REG;
[rR][eE][tT][nN]		_REG.regno = REG_RETN; return REG;
[rR][eE][tT][eE]		_REG.regno = REG_RETE; return REG;
[eE][mM][uU][dD][aA][tT]	_REG.regno = REG_EMUDAT; return REG;
[rR][aA][iI][sS][eE]		return RAISE;

[rR][0-7]           return parse_reg (&yylval.reg, T_REG_R, yytext);

[rR]      return R;
[pP][rR][nN][tT]                        return PRNT;
[pP][cC]                                return PC;
[pP][aA][cC][kK]                        return PACK;

[pP][0-5]"."[lLhH]  return parse_halfreg (&yylval.reg, T_REG_P, yytext);
[pP][0-5]           return parse_reg (&yylval.reg, T_REG_P, yytext);

[oO][uU][tT][cC]                        return OUTC;
[oO][nN][eE][sS]                        return ONES;

[nN][oO][tT]                            return NOT;
[nN][oO][pP]                            return NOP;
[mM][nN][oO][pP]                        return MNOP;
[nN][sS]                                return NS;


[mM][iI][nN]                            return MIN;
[mM][aA][xX]                            return MAX;

[mM][0-3]"."[lLhH]  return parse_halfreg (&yylval.reg, T_REG_M, yytext);
[mM][0-3]           return parse_reg (&yylval.reg, T_REG_M, yytext);

[mM]                                    return M;
[lL][tT]                                return LT;
[lL][sS][hH][iI][fF][tT]                return LSHIFT;
[lL][sS][eE][tT][uU][pP]                return LSETUP;
[lL][oO][oO][pP]			return LOOP;
[lL][oO][oO][pP]_[bB][eE][gG][iI][nN]	return LOOP_BEGIN;
[lL][oO][oO][pP]_[eE][nN][dD]		return LOOP_END;

[lL][eE]                                return LE;
[lL][cC]0 _REG.regno = REG_LC0; return REG;
[lL][tT]0 _REG.regno = REG_LT0; return REG;
[lL][bB]0 _REG.regno = REG_LB0; return REG;
[lL][cC]1 _REG.regno = REG_LC1; return REG;
[lL][tT]1 _REG.regno = REG_LT1; return REG;
[lL][bB]1 _REG.regno = REG_LB1; return REG;

[lL][0-3]"."[lLhH]  return parse_halfreg (&yylval.reg, T_REG_L, yytext);
[lL][0-3]           return parse_reg (&yylval.reg, T_REG_L, yytext);
[lL][oO]                                return LO;
[jJ][uU][mM][pP]"."[sS]                 { BEGIN 0; return JUMP_DOT_S;}
[jJ][uU][mM][pP]"."[lL]                 { BEGIN 0; return JUMP_DOT_L;}
[jJ][uU][mM][pP]                        { BEGIN 0; return JUMP;}
[jJ][uU][mM][pP]"."[xX]                 { BEGIN 0; return JUMP_DOT_L; }
[iI][uU]                                yylval.value = M_IU;   return MMOD;
[iI][sS][sS]2                           yylval.value = M_ISS2; return MMOD;
[iI][sS]                                yylval.value = M_IS;   return MMOD;
[iI][hH]                                yylval.value = M_IH;   return MMOD;
[iI][fF]                                return IF;
[iI][0-3]"."[lLhH]  return parse_halfreg (&yylval.reg, T_REG_I, yytext);
[iI][0-3]           return parse_reg (&yylval.reg, T_REG_I, yytext);
[hH][lL][tT]                            return HLT;
[hH][iI]                                return HI;
[gG][tT]                                return GT;
[gG][eE]                                return GE;
[fF][uU]                                yylval.value = M_FU; return MMOD;
[fF][pP]         _REG.regno = REG_FP; return REG;
[fF][pP]"."[lL]  _REG.regno = REG_FP; _REG.flags = F_REG_LOW; return HALF_REG;
[fF][pP]"."[hH]  _REG.regno = REG_FP; _REG.flags = F_REG_HIGH; return HALF_REG;

[eE][xX][tT][rR][aA][cC][tT]            return EXTRACT;
[eE][xX][pP][aA][dD][jJ]                return EXPADJ;
[eE][xX][cC][pP][tT]                    return EXCPT;
[eE][mM][uU][eE][xX][cC][pP][tT]        return EMUEXCPT;
[dD][iI][vV][sS]                        return DIVS;
[dD][iI][vV][qQ]                        return DIVQ;
[dD][iI][sS][aA][lL][gG][nN][eE][xX][cC][pP][tT]  return DISALGNEXCPT;
[dD][eE][pP][oO][sS][iI][tT]            return DEPOSIT;
[dD][bB][gG][hH][aA][lL][tT]            return DBGHALT;
[dD][bB][gG][cC][mM][pP][lL][xX]        return DBGCMPLX;
[dD][bB][gG][aA][lL]                    return DBGAL;
[dD][bB][gG][aA][hH]                    return DBGAH;
[dD][bB][gG][aA]                        return DBGA;
[dD][bB][gG]                            return DBG;
[cC][yY][cC][lL][eE][sS]2  { _REG.regno = REG_CYCLES2; return REG; }
[cC][yY][cC][lL][eE][sS]  { _REG.regno = REG_CYCLES; return REG; }
[cC][sS][yY][nN][cC]                    return CSYNC;
[cC][oO]                                return CO;
[cC][lL][iI]                            return CLI;

[cC][cC]     _REG.regno = REG_CC; return CCREG;
[cC][aA][lL][lL]"."[xX]                 { BEGIN 0; return CALL;}
[cC][aA][lL][lL]                        { BEGIN 0; return CALL;}
[bB][yY][tT][eE][uU][nN][pP][aA][cC][kK] return BYTEUNPACK;
[bB][yY][tT][eE][pP][aA][cC][kK]        return BYTEPACK;
[bB][yY][tT][eE][oO][pP]16[mM]          return BYTEOP16M;
[bB][yY][tT][eE][oO][pP]16[pP]          return BYTEOP16P;
[bB][yY][tT][eE][oO][pP]3[pP]           return BYTEOP3P;
[bB][yY][tT][eE][oO][pP]2[mM]           return BYTEOP2M;
[bB][yY][tT][eE][oO][pP]2[pP]           return BYTEOP2P;
[bB][yY][tT][eE][oO][pP]1[pP]           return BYTEOP1P;
[bB][yY]                                return BY;
[bB][xX][oO][rR][sS][hH][iI][fF][tT]    return BXORSHIFT;
[bB][xX][oO][rR]                        return BXOR;

[bB][rR][eE][vV]                        return BREV;
[bB][pP]                                return BP;
[bB][iI][tT][tT][sS][tT]                return BITTST;
[bB][iI][tT][tT][gG][lL]                return BITTGL;
[bB][iI][tT][sS][eE][tT]                return BITSET;
[bB][iI][tT][mM][uU][xX]                return BITMUX;
[bB][iI][tT][cC][lL][rR]                return BITCLR;
[bB][0-3]"."[lLhH]  return parse_halfreg (&yylval.reg, T_REG_B, yytext);
[bB][0-3]           return parse_reg (&yylval.reg, T_REG_B, yytext);
[bB]                                    return B;
[aA][zZ]  _REG.regno = S_AZ;   return STATUS_REG;
[aA][nN]  _REG.regno = S_AN;   return STATUS_REG;
[aA][qQ]  _REG.regno = S_AQ;   return STATUS_REG;
[aA][cC]0 _REG.regno = S_AC0;  return STATUS_REG;
[aA][cC]1 _REG.regno = S_AC1;  return STATUS_REG;
[aA][vV]0 _REG.regno = S_AV0;  return STATUS_REG;
[aA][vV]0[sS] _REG.regno = S_AV0S; return STATUS_REG;
[aA][vV]1 _REG.regno = S_AV1;  return STATUS_REG;
[aA][vV]1[sS] _REG.regno = S_AV1S; return STATUS_REG;
[vV][sS]  _REG.regno = S_VS;   return STATUS_REG;


[aA][sS][tT][aA][tT]   _REG.regno = REG_ASTAT; return REG;
[aA][sS][hH][iI][fF][tT]                return ASHIFT;
[aA][sS][lL]                            return ASL;
[aA][sS][rR]                            return ASR;
[aA][lL][iI][gG][nN]8                   return ALIGN8;
[aA][lL][iI][gG][nN]16                  return ALIGN16;
[aA][lL][iI][gG][nN]24                  return ALIGN24;
[aA]1"."[lL]    return A_ONE_DOT_L;
[aA]0"."[lL]    return A_ZERO_DOT_L;
[aA]1"."[hH]    return A_ONE_DOT_H;
[aA]0"."[hH]    return A_ZERO_DOT_H;
[aA][bB][sS]                            return ABS;
abort                                   return ABORT;
[aA]1"."[xX]    _REG.regno = REG_A1x; return REG;
[aA]1"."[wW]    _REG.regno = REG_A1w; return REG;
[aA]1           _REG.regno = REG_A1;  return REG_A_DOUBLE_ONE;
[aA]0"."[xX]    _REG.regno = REG_A0x; return REG;
[aA]0"."[wW]    _REG.regno = REG_A0w; return REG;
[aA]0           _REG.regno = REG_A0;  return REG_A_DOUBLE_ZERO;
[Gg][Oo][Tt]	return GOT;
[Gg][Oo][Tt]"17"[Mm]"4" return GOT17M4;
[Ff][Uu][Nn][Cc][Dd][Ee][Ss][Cc]"_"[Gg][Oo][Tt]"17"[Mm]"4" return FUNCDESC_GOT17M4;
[Pp][Ll][Tt][Pp][Cc]	return PLTPC;


"~"                     return TILDA;
"|="                    return _BAR_ASSIGN;
"|"                     return BAR;
"^="                    return _CARET_ASSIGN;
"^"                     return CARET;
"]"                     return RBRACK;
"["                     return LBRACK;
">>>="                  return _GREATER_GREATER_GREATER_THAN_ASSIGN;
">>="                   return _GREATER_GREATER_ASSIGN;
">>>"                   return _GREATER_GREATER_GREATER;
">>"                    return GREATER_GREATER;
"=="                    return _ASSIGN_ASSIGN;
"="                     return ASSIGN;
"<="                    return _LESS_THAN_ASSIGN;
"<<="                   return _LESS_LESS_ASSIGN;
"<<"                    return LESS_LESS;
"<"                     return LESS_THAN;
"("                     return LPAREN;
")"                     return RPAREN;
":"                     return COLON;
"/"                     return SLASH;
"-="                    return _MINUS_ASSIGN;
"+|+"					return _PLUS_BAR_PLUS;
"-|+"					return _MINUS_BAR_PLUS;
"+|-"					return _PLUS_BAR_MINUS;
"-|-"					return _MINUS_BAR_MINUS;
"--"                    return _MINUS_MINUS;
"-"                     return MINUS;
","                     return COMMA;
"+="                    return _PLUS_ASSIGN;
"++"                    return _PLUS_PLUS;
"+"                     return PLUS;
"*="                    return _STAR_ASSIGN;
"*"                     return STAR;
"&="                    return _AMPERSAND_ASSIGN;
"&"                     return AMPERSAND;
"%"                     return PERCENT;
"!"                     return BANG;
";"                     return SEMICOLON;
"=!"			return _ASSIGN_BANG;
"||"			return DOUBLE_BAR;
"@"			return AT;
<KEYWORD>[pP][rR][eE][fF][eE][tT][cC][hH]        return PREFETCH;
<KEYWORD>[uU][nN][lL][iI][nN][kK]                return UNLINK;
<KEYWORD>[lL][iI][nN][kK]                        return LINK;
<KEYWORD>[iI][dD][lL][eE]                        return IDLE;
<KEYWORD>[iI][fF][lL][uU][sS][hH]                return IFLUSH;
<KEYWORD>[fF][lL][uU][sS][hH][iI][nN][vV]        return FLUSHINV;
<KEYWORD>[fF][lL][uU][sS][hH]                    return FLUSH;
([0-9]+)|(0[xX][0-9a-fA-F]+)|([bhfodBHOFD]#[0-9a-fA-F]+)|(0"."[0-9]+) {
    yylval.value = parse_int (&yytext);
    return NUMBER;
  }
[A-Za-z_$.][A-Za-z0-9_$.]* {
    yylval.symbol = symbol_find_or_make (yytext);
    symbol_mark_used (yylval.symbol);
    return SYMBOL;
  }
[0-9][bfBF] {
    char *name;
    char *ref = strdup (yytext);
    if (ref[1] == 'b' || ref[1] == 'B')
      {
        name = fb_label_name ((int) (ref[0] - '0'), 0);
	yylval.symbol = symbol_find (name);

	if ((yylval.symbol != NULL)
             && (S_IS_DEFINED (yylval.symbol)))
          return SYMBOL;
	as_bad ("backward reference to unknown label %d:",
						  (int) (ref[0] - '0'));
      }
    else if (ref[1] == 'f' || ref[1] == 'F')
      {
        /* Forward reference.  Expect symbol to be undefined or
           unknown.  undefined: seen it before.  unknown: never seen
           it before.

           Construct a local label name, then an undefined symbol.
           Just return it as never seen before.  */

        name = fb_label_name ((int) (ref[0] - '0'), 1);
	yylval.symbol = symbol_find_or_make (name);
	/* We have no need to check symbol properties.  */
	return SYMBOL;
      }
  }
[ \t\n]                                    ;
"/*".*"*/"                                 ;
.                                          return yytext[0];
%%
static long parse_int (char **end)
{
  char fmt = '\0';
  int not_done = 1;
  int shiftvalue = 0;
  char * char_bag;
  long value = 0;
  char *arg = *end;

  while (*arg && *arg == ' ')
    arg++;

  switch (*arg)
    {
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        fmt = 'd';
        break;

      case '0':  /* Accept different formated integers hex octal and binary. */
        {
	  char c = *++arg;
          arg++;
	  if (c == 'x' || c == 'X') /* Hex input.  */
	    fmt = 'h';
	  else if (c == 'b' || c == 'B')
	    fmt = 'b';
	  else if (c == '.')
	    fmt = 'f';
	  else
            {             /* Octal.  */
	      arg--;
	      fmt = 'o';
	    }
	  break;
        }

      case 'd':
      case 'D':
      case 'h':
      case 'H':
      case 'o':
      case 'O':
      case 'b':
      case 'B':
      case 'f':
      case 'F':
        {
	  fmt = *arg++;
	  if (*arg == '#')
	    arg++;
        }
    }

  switch (fmt)
    {
      case 'h':
      case 'H':
        shiftvalue = 4;
        char_bag = "0123456789ABCDEFabcdef";
        break;

      case 'o':
      case 'O':
        shiftvalue = 3;
        char_bag = "01234567";
        break;

      case 'b':
      case 'B':
        shiftvalue = 1;
        char_bag = "01";
        break;

/* The assembler allows for fractional constants to be created
   by either the 0.xxxx or the f#xxxx format

   i.e.   0.5 would result in 0x4000

   note .5 would result in the identifier .5.

   The assembler converts to fractional format 1.15 by the simple rule:

             value = (short) (finput * (1 << 15)).  */

      case 'f':
      case 'F':
        {
          float fval = 0.0;
          float pos = 10.0;
          while (1)
            {
              int c;
              c = *arg++;

              if (c >= '0' && c <= '9')
                {
                  float digit = (c - '0') / pos;
                  fval = fval + digit;
                  pos = pos * 10.0;
                }
              else
                {
	          *--arg = c;
                  value = (short) (fval * (1 << 15));
                  break;
                }
            }
          *end = arg+1;
          return value;
        }

      case 'd':
      case 'D':
      default:
        {
          while (1)
            {
              char c;
              c = *arg++;
              if (c >= '0' && c <= '9')
                value = (value * 10) + (c - '0');
              else
                {
                  /* Constants that are suffixed with k|K are multiplied by 1024
                     This suffix is only allowed on decimal constants. */
                  if (c == 'k' || c == 'K')
                    value *= 1024;
                  else
                    *--arg = c;
                  break;
                }
            }
          *end = arg+1;
          return value;
        }
    }

  while (not_done)
    {
      char c;
      c = *arg++;
      if (c == 0 || !strchr (char_bag, c))
	{
          not_done = 0;
          *--arg = c;
        }
      else
        {
          if (c >= 'a' && c <= 'z')
            c = c - ('a' - '9') + 1;
          else if (c >= 'A' && c <= 'Z')
            c = c - ('A' - '9') + 1;

          c -= '0';
          value = (value << shiftvalue) + c;
        }
    }
  *end = arg+1;
  return value;
}


static int parse_reg (Register *r, int cl, char *rt)
{
  r->regno = cl | (rt[1] - '0');
  r->flags = F_REG_NONE;
  return REG;
}

static int parse_halfreg (Register *r, int cl, char *rt)
{
  r->regno = cl | (rt[1] - '0');

  switch (rt[3])
    {
      case 'b':
      case 'B':
	return BYTE_DREG;

      case 'l':
      case 'L':
	r->flags = F_REG_LOW;
	break;

      case 'h':
      case 'H':
	r->flags = F_REG_HIGH;
	break;
    }

  return HALF_REG;
}

/* Our start state is KEYWORD as we have
   command keywords such as PREFETCH.  */

void
set_start_state (void)
{
  BEGIN KEYWORD;
}


#ifndef yywrap
int
yywrap ()
{
  return 1;
}
#endif
Commit	Line	Data
07c1b327	1	/* bfin-lex.l ADI Blackfin lexer
62fb9fe1	2	Copyright 2005, 2006, 2007, 2008, 2010
07c1b327 CM	3	Free Software Foundation, Inc.
	4
	5	This file is part of GAS, the GNU Assembler.
	6
	7	GAS is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
ec2655a6	9	the Free Software Foundation; either version 3, or (at your option)
07c1b327 CM	10	any later version.
	11
	12	GAS is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GAS; see the file COPYING. If not, write to the Free
	19	Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
	20	02110-1301, USA. */
	21	%{
	22
ebd1c875	23	#include "as.h"
07c1b327	24	#include "bfin-defs.h"
9ba4c445	25	#include "bfin-parse.h"
07c1b327 CM	26
	27	static long parse_int (char **end);
	28	static int parse_halfreg (Register r, int cl, char hr);
	29	static int parse_reg (Register r, int type, char rt);
	30	int yylex (void);
	31
	32	#define _REG yylval.reg
	33
	34
	35	%}
	36
	37	/* Define Start States ... Actually we will use exclusion.
	38	If no start state is specified it should match any state
	39	and <INITIAL> would match some keyword rules only with
	40	initial. */
	41	%s KEYWORD
	42
	43	%%
	44	[sS][fF][tT][rR][eE][sS][eE][tT] _REG.regno = REG_sftreset; return REG;
	45	[oO][mM][oO][dD][eE] _REG.regno = REG_omode; return REG;
	46	[iI][dD][lL][eE]_[rR][eE][qQ] _REG.regno = REG_idle_req; return REG;
	47	[hH][wW][eE][rR][rR][cC][aA][uU][sS][eE] _REG.regno = REG_hwerrcause; return REG;
	48	[eE][xX][cC][aA][uU][sS][eE] _REG.regno = REG_excause; return REG;
	49	[eE][mM][uU][cC][aA][uU][sS][eE] _REG.regno = REG_emucause; return REG;
	50	[zZ] return Z;
	51	[xX] return X;
	52	[wW]32 yylval.value = M_W32; return MMOD;
	53	[wW] return W;
	54	[vV][iI][tT]_[mM][aA][xX] return VIT_MAX;
	55	[vV] return V; /* Special: V is a statflag and a modifier. */
	56	[uU][sS][pP] _REG.regno = REG_USP; return REG;
	57	[tT][lL] return TL;
	58	[tT][hH] return TH;
	59	[tT][fF][uU] yylval.value = M_TFU; return MMOD;
	60	[tT][eE][sS][tT][sS][eE][tT] return TESTSET;
	61	[tT] yylval.value = M_T; return MMOD;
	62	[sS] return S;
	63	[sS][yY][sS][cC][fF][gG] _REG.regno = REG_SYSCFG; return REG;
	64	[sS][tT][iI] return STI;
	65	[sS][sS][yY][nN][cC] return SSYNC;
f31bf2c6 JZ	66	[sS][pP]"."[lL] _REG.regno = REG_SP; _REG.flags = F_REG_LOW; return HALF_REG;
f31bf2c6 JZ	67	[sS][pP]"."[hH] _REG.regno = REG_SP; _REG.flags = F_REG_HIGH; return HALF_REG;
07c1b327 CM	68	[sS][pP] _REG.regno = REG_SP; return REG;
	69	[sS][iI][gG][nN][bB][iI][tT][sS] return SIGNBITS;
	70	[sS][iI][gG][nN] return SIGN;
	71	[sS][eE][qQ][sS][tT][aA][tT] _REG.regno = REG_SEQSTAT; return REG;
	72	[sS][eE][aA][rR][cC][hH] return SEARCH;
	73	[sS][hH][iI][fF][tT] return SHIFT;
	74	[sS][cC][oO] return SCO;
	75
	76	[sS][aA][aA] return SAA;
	77	[sS]2[rR][nN][dD] yylval.value = M_S2RND; return MMOD;
	78	[rR][tT][xX] return RTX;
	79	[rR][tT][sS] return RTS;
	80	[rR][tT][nN] return RTN;
	81	[rR][tT][iI] return RTI;
	82	[rR][tT][eE] return RTE;
	83	[rR][oO][tT] return ROT;
	84	[rR][nN][dD]20 return RND20;
	85	[rR][nN][dD]12 return RND12;
	86	[rR][nN][dD][lL] return RNDL;
	87	[rR][nN][dD][hH] return RNDH;
	88	[rR][nN][dD] return RND;
	89
	90	[rR][0-7]"."[lLhHbB] return parse_halfreg(&yylval.reg, T_REG_R, yytext);
	91
	92	[rR][eE][tT][sS] _REG.regno = REG_RETS; return REG;
	93	[rR][eE][tT][iI] _REG.regno = REG_RETI; return REG;
	94	[rR][eE][tT][xX] _REG.regno = REG_RETX; return REG;
	95	[rR][eE][tT][nN] _REG.regno = REG_RETN; return REG;
	96	[rR][eE][tT][eE] _REG.regno = REG_RETE; return REG;
	97	[eE][mM][uU][dD][aA][tT] _REG.regno = REG_EMUDAT; return REG;
	98	[rR][aA][iI][sS][eE] return RAISE;
	99
	100	[rR][0-7] return parse_reg (&yylval.reg, T_REG_R, yytext);
	101
	102	[rR] return R;
	103	[pP][rR][nN][tT] return PRNT;
	104	[pP][cC] return PC;
	105	[pP][aA][cC][kK] return PACK;
	106
	107	[pP][0-5]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_P, yytext);
	108	[pP][0-5] return parse_reg (&yylval.reg, T_REG_P, yytext);
	109
	110	[oO][uU][tT][cC] return OUTC;
	111	[oO][nN][eE][sS] return ONES;
	112
	113	[nN][oO][tT] return NOT;
	114	[nN][oO][pP] return NOP;
	115	[mM][nN][oO][pP] return MNOP;
	116	[nN][sS] return NS;
	117
	118
	119	[mM][iI][nN] return MIN;
	120	[mM][aA][xX] return MAX;
	121
	122	[mM][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_M, yytext);
	123	[mM][0-3] return parse_reg (&yylval.reg, T_REG_M, yytext);
	124
	125	[mM] return M;
	126	[lL][tT] return LT;
	127	[lL][sS][hH][iI][fF][tT] return LSHIFT;
	128	[lL][sS][eE][tT][uU][pP] return LSETUP;
	129	[lL][oO][oO][pP] return LOOP;
	130	[lL][oO][oO][pP]_[bB][eE][gG][iI][nN] return LOOP_BEGIN;
	131	[lL][oO][oO][pP]_[eE][nN][dD] return LOOP_END;
132
133	[lL][eE] return LE;
134	[lL][cC]0 _REG.regno = REG_LC0; return REG;
135	[lL][tT]0 _REG.regno = REG_LT0; return REG;
136	[lL][bB]0 _REG.regno = REG_LB0; return REG;
137	[lL][cC]1 _REG.regno = REG_LC1; return REG;
138	[lL][tT]1 _REG.regno = REG_LT1; return REG;
139	[lL][bB]1 _REG.regno = REG_LB1; return REG;
140
141	[lL][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_L, yytext);
142	[lL][0-3] return parse_reg (&yylval.reg, T_REG_L, yytext);
143	[lL][oO] return LO;
144	[jJ][uU][mM][pP]"."[sS] { BEGIN 0; return JUMP_DOT_S;}
145	[jJ][uU][mM][pP]"."[lL] { BEGIN 0; return JUMP_DOT_L;}
146	[jJ][uU][mM][pP] { BEGIN 0; return JUMP;}
147	[jJ][uU][mM][pP]"."[xX] { BEGIN 0; return JUMP_DOT_L; }
148	[iI][uU] yylval.value = M_IU; return MMOD;
149	[iI][sS][sS]2 yylval.value = M_ISS2; return MMOD;
150	[iI][sS] yylval.value = M_IS; return MMOD;
151	[iI][hH] yylval.value = M_IH; return MMOD;
152	[iI][fF] return IF;
153	[iI][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_I, yytext);
154	[iI][0-3] return parse_reg (&yylval.reg, T_REG_I, yytext);
155	[hH][lL][tT] return HLT;
156	[hH][iI] return HI;
157	[gG][tT] return GT;
158	[gG][eE] return GE;
159	[fF][uU] yylval.value = M_FU; return MMOD;
160	[fF][pP] _REG.regno = REG_FP; return REG;
f31bf2c6 JZ	161	[fF][pP]"."[lL] _REG.regno = REG_FP; _REG.flags = F_REG_LOW; return HALF_REG;
f31bf2c6 JZ	162	[fF][pP]"."[hH] _REG.regno = REG_FP; _REG.flags = F_REG_HIGH; return HALF_REG;
07c1b327 CM	163
	164	[eE][xX][tT][rR][aA][cC][tT] return EXTRACT;
	165	[eE][xX][pP][aA][dD][jJ] return EXPADJ;
	166	[eE][xX][cC][pP][tT] return EXCPT;
	167	[eE][mM][uU][eE][xX][cC][pP][tT] return EMUEXCPT;
	168	[dD][iI][vV][sS] return DIVS;
	169	[dD][iI][vV][qQ] return DIVQ;
	170	[dD][iI][sS][aA][lL][gG][nN][eE][xX][cC][pP][tT] return DISALGNEXCPT;
	171	[dD][eE][pP][oO][sS][iI][tT] return DEPOSIT;
	172	[dD][bB][gG][hH][aA][lL][tT] return DBGHALT;
	173	[dD][bB][gG][cC][mM][pP][lL][xX] return DBGCMPLX;
	174	[dD][bB][gG][aA][lL] return DBGAL;
	175	[dD][bB][gG][aA][hH] return DBGAH;
	176	[dD][bB][gG][aA] return DBGA;
	177	[dD][bB][gG] return DBG;
	178	[cC][yY][cC][lL][eE][sS]2 { _REG.regno = REG_CYCLES2; return REG; }
	179	[cC][yY][cC][lL][eE][sS] { _REG.regno = REG_CYCLES; return REG; }
	180	[cC][sS][yY][nN][cC] return CSYNC;
	181	[cC][oO] return CO;
	182	[cC][lL][iI] return CLI;
	183
	184	[cC][cC] _REG.regno = REG_CC; return CCREG;
	185	[cC][aA][lL][lL]"."[xX] { BEGIN 0; return CALL;}
	186	[cC][aA][lL][lL] { BEGIN 0; return CALL;}
	187	[bB][yY][tT][eE][uU][nN][pP][aA][cC][kK] return BYTEUNPACK;
	188	[bB][yY][tT][eE][pP][aA][cC][kK] return BYTEPACK;
	189	[bB][yY][tT][eE][oO][pP]16[mM] return BYTEOP16M;
	190	[bB][yY][tT][eE][oO][pP]16[pP] return BYTEOP16P;
	191	[bB][yY][tT][eE][oO][pP]3[pP] return BYTEOP3P;
	192	[bB][yY][tT][eE][oO][pP]2[mM] return BYTEOP2M;
	193	[bB][yY][tT][eE][oO][pP]2[pP] return BYTEOP2P;
	194	[bB][yY][tT][eE][oO][pP]1[pP] return BYTEOP1P;
	195	[bB][yY] return BY;
	196	[bB][xX][oO][rR][sS][hH][iI][fF][tT] return BXORSHIFT;
	197	[bB][xX][oO][rR] return BXOR;
	198
	199	[bB][rR][eE][vV] return BREV;
	200	[bB][pP] return BP;
	201	[bB][iI][tT][tT][sS][tT] return BITTST;
	202	[bB][iI][tT][tT][gG][lL] return BITTGL;
	203	[bB][iI][tT][sS][eE][tT] return BITSET;
	204	[bB][iI][tT][mM][uU][xX] return BITMUX;
	205	[bB][iI][tT][cC][lL][rR] return BITCLR;
	206	[bB][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_B, yytext);
	207	[bB][0-3] return parse_reg (&yylval.reg, T_REG_B, yytext);
	208	[bB] return B;
	209	[aA][zZ] _REG.regno = S_AZ; return STATUS_REG;
	210	[aA][nN] _REG.regno = S_AN; return STATUS_REG;
	211	[aA][qQ] _REG.regno = S_AQ; return STATUS_REG;
	212	[aA][cC]0 _REG.regno = S_AC0; return STATUS_REG;
	213	[aA][cC]1 _REG.regno = S_AC1; return STATUS_REG;
	214	[aA][vV]0 _REG.regno = S_AV0; return STATUS_REG;
	215	[aA][vV]0[sS] _REG.regno = S_AV0S; return STATUS_REG;
	216	[aA][vV]1 _REG.regno = S_AV1; return STATUS_REG;
	217	[aA][vV]1[sS] _REG.regno = S_AV1S; return STATUS_REG;
07c1b327 CM	218	[vV][sS] _REG.regno = S_VS; return STATUS_REG;
	219
	220
	221	[aA][sS][tT][aA][tT] _REG.regno = REG_ASTAT; return REG;
	222	[aA][sS][hH][iI][fF][tT] return ASHIFT;
	223	[aA][sS][lL] return ASL;
	224	[aA][sS][rR] return ASR;
	225	[aA][lL][iI][gG][nN]8 return ALIGN8;
	226	[aA][lL][iI][gG][nN]16 return ALIGN16;
	227	[aA][lL][iI][gG][nN]24 return ALIGN24;
	228	[aA]1"."[lL] return A_ONE_DOT_L;
	229	[aA]0"."[lL] return A_ZERO_DOT_L;
	230	[aA]1"."[hH] return A_ONE_DOT_H;
	231	[aA]0"."[hH] return A_ZERO_DOT_H;
	232	[aA][bB][sS] return ABS;
	233	abort return ABORT;
	234	[aA]1"."[xX] _REG.regno = REG_A1x; return REG;
	235	[aA]1"."[wW] _REG.regno = REG_A1w; return REG;
	236	[aA]1 _REG.regno = REG_A1; return REG_A_DOUBLE_ONE;
	237	[aA]0"."[xX] _REG.regno = REG_A0x; return REG;
	238	[aA]0"."[wW] _REG.regno = REG_A0w; return REG;
	239	[aA]0 _REG.regno = REG_A0; return REG_A_DOUBLE_ZERO;
	240	[Gg][Oo][Tt] return GOT;
1ac4baed BS	241	[Gg][Oo][Tt]"17"[Mm]"4" return GOT17M4;
1ac4baed BS	242	[Ff][Uu][Nn][Cc][Dd][Ee][Ss][Cc]"_"[Gg][Oo][Tt]"17"[Mm]"4" return FUNCDESC_GOT17M4;
07c1b327 CM	243	[Pp][Ll][Tt][Pp][Cc] return PLTPC;
	244
	245
	246	"~" return TILDA;
	247	"\|=" return _BAR_ASSIGN;
	248	"\|" return BAR;
	249	"^=" return _CARET_ASSIGN;
	250	"^" return CARET;
	251	"]" return RBRACK;
	252	"[" return LBRACK;
	253	">>>=" return _GREATER_GREATER_GREATER_THAN_ASSIGN;
	254	">>=" return _GREATER_GREATER_ASSIGN;
	255	">>>" return _GREATER_GREATER_GREATER;
	256	">>" return GREATER_GREATER;
	257	"==" return _ASSIGN_ASSIGN;
	258	"=" return ASSIGN;
	259	"<=" return _LESS_THAN_ASSIGN;
	260	"<<=" return _LESS_LESS_ASSIGN;
	261	"<<" return LESS_LESS;
	262	"<" return LESS_THAN;
	263	"(" return LPAREN;
	264	")" return RPAREN;
	265	":" return COLON;
	266	"/" return SLASH;
	267	"-=" return _MINUS_ASSIGN;
	268	"+\|+" return _PLUS_BAR_PLUS;
	269	"-\|+" return _MINUS_BAR_PLUS;
	270	"+\|-" return _PLUS_BAR_MINUS;
	271	"-\|-" return _MINUS_BAR_MINUS;
	272	"--" return _MINUS_MINUS;
	273	"-" return MINUS;
	274	"," return COMMA;
	275	"+=" return _PLUS_ASSIGN;
	276	"++" return _PLUS_PLUS;
	277	"+" return PLUS;
	278	"*=" return _STAR_ASSIGN;
	279	"*" return STAR;
	280	"&=" return _AMPERSAND_ASSIGN;
	281	"&" return AMPERSAND;
	282	"%" return PERCENT;
	283	"!" return BANG;
	284	";" return SEMICOLON;
	285	"=!" return _ASSIGN_BANG;
	286	"\|\|" return DOUBLE_BAR;
	287	"@" return AT;
	288	<KEYWORD>[pP][rR][eE][fF][eE][tT][cC][hH] return PREFETCH;
	289	<KEYWORD>[uU][nN][lL][iI][nN][kK] return UNLINK;
	290	<KEYWORD>[lL][iI][nN][kK] return LINK;
	291	<KEYWORD>[iI][dD][lL][eE] return IDLE;
	292	<KEYWORD>[iI][fF][lL][uU][sS][hH] return IFLUSH;
	293	<KEYWORD>[fF][lL][uU][sS][hH][iI][nN][vV] return FLUSHINV;
	294	<KEYWORD>[fF][lL][uU][sS][hH] return FLUSH;
fec82760	295	([0-9]+)\|(0[xX][0-9a-fA-F]+)\|([bhfodBHOFD]#[0-9a-fA-F]+)\|(0"."[0-9]+) {
07c1b327 CM	296	yylval.value = parse_int (&yytext);
	297	return NUMBER;
	298	}
ee9e7c78	299	[A-Za-z_$.][A-Za-z0-9_$.]* {
07c1b327 CM	300	yylval.symbol = symbol_find_or_make (yytext);
07c1b327 CM	301	symbol_mark_used (yylval.symbol);
ee9e7c78	302	return SYMBOL;
07c1b327 CM	303	}
	304	[0-9][bfBF] {
	305	char *name;
	306	char *ref = strdup (yytext);
	307	if (ref[1] == 'b' \|\| ref[1] == 'B')
	308	{
	309	name = fb_label_name ((int) (ref[0] - '0'), 0);
	310	yylval.symbol = symbol_find (name);
	311
	312	if ((yylval.symbol != NULL)
	313	&& (S_IS_DEFINED (yylval.symbol)))
	314	return SYMBOL;
ee9e7c78 MF	315	as_bad ("backward reference to unknown label %d:",
ee9e7c78 MF	316	(int) (ref[0] - '0'));
07c1b327 CM	317	}
	318	else if (ref[1] == 'f' \|\| ref[1] == 'F')
	319	{
	320	/* Forward reference. Expect symbol to be undefined or
	321	unknown. undefined: seen it before. unknown: never seen
	322	it before.
	323
	324	Construct a local label name, then an undefined symbol.
	325	Just return it as never seen before. */
	326
	327	name = fb_label_name ((int) (ref[0] - '0'), 1);
	328	yylval.symbol = symbol_find_or_make (name);
	329	/* We have no need to check symbol properties. */
	330	return SYMBOL;
ee9e7c78 MF	331	}
ee9e7c78 MF	332	}
07c1b327 CM	333	[ \t\n] ;
	334	"/"."*/" ;
	335	. return yytext[0];
	336	%%
	337	static long parse_int (char **end)
	338	{
	339	char fmt = '\0';
	340	int not_done = 1;
	341	int shiftvalue = 0;
	342	char * char_bag;
	343	long value = 0;
07c1b327 CM	344	char arg = end;
	345
	346	while (arg && arg == ' ')
	347	arg++;
	348
	349	switch (*arg)
	350	{
	351	case '1':
	352	case '2':
	353	case '3':
	354	case '4':
	355	case '5':
	356	case '6':
	357	case '7':
	358	case '8':
	359	case '9':
	360	fmt = 'd';
	361	break;
	362
	363	case '0': /* Accept different formated integers hex octal and binary. */
	364	{
62fb9fe1	365	char c = *++arg;
07c1b327 CM	366	arg++;
	367	if (c == 'x' \|\| c == 'X') /* Hex input. */
	368	fmt = 'h';
	369	else if (c == 'b' \|\| c == 'B')
	370	fmt = 'b';
	371	else if (c == '.')
	372	fmt = 'f';
	373	else
	374	{ /* Octal. */
	375	arg--;
	376	fmt = 'o';
	377	}
	378	break;
	379	}
	380
	381	case 'd':
	382	case 'D':
	383	case 'h':
	384	case 'H':
	385	case 'o':
	386	case 'O':
	387	case 'b':
	388	case 'B':
	389	case 'f':
	390	case 'F':
	391	{
	392	fmt = *arg++;
	393	if (*arg == '#')
	394	arg++;
	395	}
	396	}
	397
	398	switch (fmt)
	399	{
	400	case 'h':
	401	case 'H':
	402	shiftvalue = 4;
	403	char_bag = "0123456789ABCDEFabcdef";
	404	break;
	405
	406	case 'o':
	407	case 'O':
	408	shiftvalue = 3;
	409	char_bag = "01234567";
	410	break;
	411
	412	case 'b':
	413	case 'B':
	414	shiftvalue = 1;
	415	char_bag = "01";
	416	break;
	417
	418	/* The assembler allows for fractional constants to be created
ee9e7c78	419	by either the 0.xxxx or the f#xxxx format
07c1b327 CM	420
	421	i.e. 0.5 would result in 0x4000
	422
	423	note .5 would result in the identifier .5.
	424
	425	The assembler converts to fractional format 1.15 by the simple rule:
	426
	427	value = (short) (finput * (1 << 15)). */
	428
	429	case 'f':
	430	case 'F':
	431	{
	432	float fval = 0.0;
	433	float pos = 10.0;
	434	while (1)
	435	{
	436	int c;
	437	c = *arg++;
	438
	439	if (c >= '0' && c <= '9')
	440	{
	441	float digit = (c - '0') / pos;
	442	fval = fval + digit;
	443	pos = pos * 10.0;
	444	}
	445	else
	446	{
	447	*--arg = c;
	448	value = (short) (fval * (1 << 15));
	449	break;
	450	}
	451	}
	452	*end = arg+1;
	453	return value;
	454	}
	455
	456	case 'd':
	457	case 'D':
	458	default:
	459	{
	460	while (1)
	461	{
62fb9fe1	462	char c;
07c1b327 CM	463	c = *arg++;
	464	if (c >= '0' && c <= '9')
	465	value = (value * 10) + (c - '0');
	466	else
	467	{
	468	/* Constants that are suffixed with k\|K are multiplied by 1024
	469	This suffix is only allowed on decimal constants. */
	470	if (c == 'k' \|\| c == 'K')
	471	value *= 1024;
	472	else
	473	*--arg = c;
	474	break;
	475	}
	476	}
	477	*end = arg+1;
	478	return value;
	479	}
	480	}
	481
	482	while (not_done)
	483	{
	484	char c;
	485	c = *arg++;
048e5b80	486	if (c == 0 \|\| !strchr (char_bag, c))
07c1b327 CM	487	{
	488	not_done = 0;
	489	*--arg = c;
	490	}
	491	else
	492	{
	493	if (c >= 'a' && c <= 'z')
	494	c = c - ('a' - '9') + 1;
	495	else if (c >= 'A' && c <= 'Z')
	496	c = c - ('A' - '9') + 1;
	497
	498	c -= '0';
	499	value = (value << shiftvalue) + c;
	500	}
	501	}
	502	*end = arg+1;
	503	return value;
	504	}
	505
	506
	507	static int parse_reg (Register r, int cl, char rt)
	508	{
	509	r->regno = cl \| (rt[1] - '0');
f31bf2c6	510	r->flags = F_REG_NONE;
07c1b327 CM	511	return REG;
	512	}
	513
	514	static int parse_halfreg (Register r, int cl, char rt)
	515	{
	516	r->regno = cl \| (rt[1] - '0');
	517
	518	switch (rt[3])
	519	{
	520	case 'b':
	521	case 'B':
	522	return BYTE_DREG;
	523
	524	case 'l':
	525	case 'L':
f31bf2c6	526	r->flags = F_REG_LOW;
07c1b327 CM	527	break;
	528
	529	case 'h':
	530	case 'H':
f31bf2c6	531	r->flags = F_REG_HIGH;
07c1b327 CM	532	break;
	533	}
	534
	535	return HALF_REG;
	536	}
	537
	538	/* Our start state is KEYWORD as we have
	539	command keywords such as PREFETCH. */
	540
ee9e7c78	541	void
07c1b327 CM	542	set_start_state (void)
	543	{
	544	BEGIN KEYWORD;
	545	}
	546
	547
	548	#ifndef yywrap
	549	int
	550	yywrap ()
ee9e7c78	551	{
07c1b327 CM	552	return 1;
	553	}
	554	#endif