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

%option noyywrap

/* bfin-lex.l  ADI Blackfin lexer
   Copyright (C) 2005-2021 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 "config/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

/* Flex generates static functions "input" & "unput" which are not used.  */
#define YY_NO_INPUT
#define YY_NO_UNPUT

%}

/* 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
%s FLAGS

%%
[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;
<FLAGS>[zZ]                             return Z;
<FLAGS>[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;
<FLAGS>[tT]                             yylval.value = M_T; return MMOD;
<FLAGS>[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);

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