/* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */

/* Assembler interface for targets using CGEN. -*- C -*-

   CGEN: Cpu tools GENerator

   THIS FILE IS MACHINE GENERATED WITH CGEN.

   - the resultant file is machine generated, cgen-asm.in isn't

   Copyright (C) 1996-2023 Free Software Foundation, Inc.

   This file is part of libopcodes.

   This library 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.

   It 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 this program; if not, write to the Free Software Foundation, Inc.,

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

/* ??? Eventually more and more of this stuff can go to cpu-independent files.

   Keep that in mind.  */

#include "sysdep.h"

#include <stdio.h>

#include "ansidecl.h"

#include "bfd.h"

#include "symcat.h"

#include "m32c-desc.h"

#include "m32c-opc.h"

#include "opintl.h"

#include "xregex.h"

#include "libiberty.h"

#include "safe-ctype.h"

#undef  min

#define min(a,b) ((a) < (b) ? (a) : (b))

#undef  max

#define max(a,b) ((a) > (b) ? (a) : (b))

static const char * parse_insn_normal

  (CGEN_CPU_DESC, const CGEN_INSN *, const char **, CGEN_FIELDS *);

/* -- assembler routines inserted here.  */

/* -- asm.c */

#include "safe-ctype.h"

#define MACH_M32C 5    /* Must match md_begin.  */

static int

m32c_cgen_isa_register (const char **strp)

 {

   int u;

   const char *s = *strp;

   static char * m32c_register_names [] =

     {

       "r0", "r1", "r2", "r3", "r0l", "r0h", "r1l", "r1h",

       "a0", "a1", "r2r0", "r3r1", "sp", "fb", "dct0", "dct1", "flg", "svf",

       "drc0", "drc1", "dmd0", "dmd1", "intb", "svp", "vct", "isp", "dma0",

       "dma1", "dra0", "dra1", "dsa0", "dsa1", 0

     };

   for (u = 0; m32c_register_names[u]; u++)

     {

       int len = strlen (m32c_register_names[u]);

       if (memcmp (m32c_register_names[u], s, len) == 0

     && (s[len] == 0 || ! ISALNUM (s[len])))

        return 1;

     }

   return 0;

}

#define PARSE_UNSIGNED              \

  do                  \

    {                 \

      /* Don't successfully parse literals beginning with '['.  */  \

      if (**strp == '[')           \

  return "Invalid literal"; /* Anything -- will not be seen.  */  \

                  \

      errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);\

      if (errmsg)             \

  return errmsg;             \

    }                 \

  while (0)

#define PARSE_SIGNED              \

  do                  \

    {                 \

      /* Don't successfully parse literals beginning with '['.  */  \

      if (**strp == '[')           \

  return "Invalid literal"; /* Anything -- will not be seen.  */  \

                  \

      errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);  \

      if (errmsg)             \

  return errmsg;             \

    }                 \

  while (0)

static const char *

parse_unsigned6 (CGEN_CPU_DESC cd, const char **strp,

     int opindex, unsigned long *valuep)

{

  const char *errmsg = 0;

  unsigned long value;

  PARSE_UNSIGNED;

  if (value > 0x3f)

    return _("imm:6 immediate is out of range");

  *valuep = value;

  return 0;

}

static const char *

parse_unsigned8 (CGEN_CPU_DESC cd, const char **strp,

     int opindex, unsigned long *valuep)

{

  const char *errmsg = 0;

  unsigned long value = 0;

  long have_zero = 0;

  if (strncasecmp (*strp, "%dsp8(", 6) == 0)

    {

      enum cgen_parse_operand_result result_type;

      bfd_vma val;

      *strp += 6;

      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_8,

           & result_type, & val);

      if (**strp != ')')

  return _("missing `)'");

      (*strp) ++;

      if (errmsg == NULL

      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)

  return _("%dsp8() takes a symbolic address, not a number");

      value = val;

      *valuep = value;

      return errmsg;

    }

  if (strncmp (*strp, "0x0", 3) == 0

      || (**strp == '0' && *(*strp + 1) != 'x'))

    have_zero = 1;

  PARSE_UNSIGNED;

  if (value > 0xff)

    return _("dsp:8 immediate is out of range");

  /* If this field may require a relocation then use larger dsp16.  */

  if (! have_zero && value == 0)

    return _("dsp:8 immediate is out of range");

  *valuep = value;

  return 0;

}

static const char *

parse_signed4 (CGEN_CPU_DESC cd, const char **strp,

         int opindex, signed long *valuep)

{

  const char *errmsg = 0;

  signed long value;

  long have_zero = 0;

  if (strncmp (*strp, "0x0", 3) == 0

      || (**strp == '0' && *(*strp + 1) != 'x'))

    have_zero = 1;

  PARSE_SIGNED;

  if (value < -8 || value > 7)

    return _("Immediate is out of range -8 to 7");

  /* If this field may require a relocation then use larger dsp16.  */

  if (! have_zero && value == 0)

    return _("Immediate is out of range -8 to 7");

  *valuep = value;

  return 0;

}

static const char *

parse_signed4n (CGEN_CPU_DESC cd, const char **strp,

    int opindex, signed long *valuep)

{

  const char *errmsg = 0;

  signed long value;

  long have_zero = 0;

  if (strncmp (*strp, "0x0", 3) == 0

      || (**strp == '0' && *(*strp + 1) != 'x'))

    have_zero = 1;

  PARSE_SIGNED;

  if (value < -7 || value > 8)

    return _("Immediate is out of range -7 to 8");

  /* If this field may require a relocation then use larger dsp16.  */

  if (! have_zero && value == 0)

    return _("Immediate is out of range -7 to 8");

  *valuep = -value;

  return 0;

}

static const char *

parse_signed8 (CGEN_CPU_DESC cd, const char **strp,

         int opindex, signed long *valuep)

{

  const char *errmsg = 0;

  signed long value = 0;

  if (strncasecmp (*strp, "%hi8(", 5) == 0)

    {

      enum cgen_parse_operand_result result_type;

      bfd_vma val;

      *strp += 5;

      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_M32C_HI8,

           & result_type, & val);

      if (**strp != ')')

  return _("missing `)'");

      (*strp) ++;

      if (errmsg == NULL

      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)

  val >>= 16;

      value = val;

      *valuep = value;

      return errmsg;

    }

  PARSE_SIGNED;

  if (value <= 255 && value > 127)

    value -= 0x100;

  if (value < -128 || value > 127)

    return _("dsp:8 immediate is out of range");

  *valuep = value;

  return 0;

}

static const char *

parse_unsigned16 (CGEN_CPU_DESC cd, const char **strp,

     int opindex, unsigned long *valuep)

{

  const char *errmsg = 0;

  unsigned long value = 0;

  long have_zero = 0;

  if (strncasecmp (*strp, "%dsp16(", 7) == 0)

    {

      enum cgen_parse_operand_result result_type;

      bfd_vma val;

      *strp += 7;

      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_16,

           & result_type, & val);

      if (**strp != ')')

  return _("missing `)'");

      (*strp) ++;

      if (errmsg == NULL

      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)

  return _("%dsp16() takes a symbolic address, not a number");

      value = val;

      *valuep = value;

      return errmsg;

    }

  /* Don't successfully parse literals beginning with '['.  */

  if (**strp == '[')

    return "Invalid literal"; /* Anything -- will not be seen.  */

  /* Don't successfully parse register names.  */

  if (m32c_cgen_isa_register (strp))

    return "Invalid literal"; /* Anything -- will not be seen.  */

  if (strncmp (*strp, "0x0", 3) == 0

      || (**strp == '0' && *(*strp + 1) != 'x'))

    have_zero = 1;

  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);

  if (errmsg)

    return errmsg;

  if (value > 0xffff)

    return _("dsp:16 immediate is out of range");

  /* If this field may require a relocation then use larger dsp24.  */

  if (cd->machs == MACH_M32C && ! have_zero && value == 0

      && (strncmp (*strp, "[a", 2) == 0

    || **strp == ','

    || **strp == 0))

    return _("dsp:16 immediate is out of range");

  *valuep = value;

  return 0;

}

static const char *

parse_signed16 (CGEN_CPU_DESC cd, const char **strp,

         int opindex, signed long *valuep)

{

  const char *errmsg = 0;

  signed long value = 0;

  if (strncasecmp (*strp, "%lo16(", 6) == 0)

    {

      enum cgen_parse_operand_result result_type;

      bfd_vma val;

      *strp += 6;

      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_LO16,

           & result_type, & val);

      if (**strp != ')')

  return _("missing `)'");

      (*strp) ++;

      if (errmsg == NULL

      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)

  val &= 0xffff;

      value = val;

      *valuep = value;

      return errmsg;

    }

  if (strncasecmp (*strp, "%hi16(", 6) == 0)

    {

      enum cgen_parse_operand_result result_type;

      bfd_vma val;

      *strp += 6;

      errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_HI16,

           & result_type, & val);

      if (**strp != ')')

  return _("missing `)'");

      (*strp) ++;

      if (errmsg == NULL

      && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)

  val >>= 16;

      value = val;

      *valuep = value;

      return errmsg;

    }

  PARSE_SIGNED;

  if (value <= 65535 && value > 32767)

    value -= 0x10000;

  if (value < -32768 || value > 32767)

    return _("dsp:16 immediate is out of range");

  *valuep = value;

  return 0;

}

static const char *

parse_unsigned20 (CGEN_CPU_DESC cd, const char **strp,

     int opindex, unsigned long *valuep)

{

  const char *errmsg = 0;

  unsigned long value;

  /* Don't successfully parse literals beginning with '['.  */

  if (**strp == '[')

    return "Invalid literal"; /* Anything -- will not be seen.  */

  /* Don't successfully parse register names.  */

  if (m32c_cgen_isa_register (strp))

    return "Invalid literal"; /* Anything -- will not be seen.  */

  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);

  if (errmsg)

    return errmsg;

  if (value > 0xfffff)

    return _("dsp:20 immediate is out of range");

  *valuep = value;

  return 0;

}

static const char *

parse_unsigned24 (CGEN_CPU_DESC cd, const char **strp,

     int opindex, unsigned long *valuep)

{

  const char *errmsg = 0;

  unsigned long value;

  /* Don't successfully parse literals beginning with '['.  */

  if (**strp == '[')

    return "Invalid literal"; /* Anything -- will not be seen.  */

  /* Don't successfully parse register names.  */

  if (m32c_cgen_isa_register (strp))

    return "Invalid literal"; /* Anything -- will not be seen.  */

  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);

  if (errmsg)

    return errmsg;

  if (value > 0xffffff)

    return _("dsp:24 immediate is out of range");

  *valuep = value;

  return 0;

}

/* This should only be used for #imm->reg.  */

static const char *

parse_signed24 (CGEN_CPU_DESC cd, const char **strp,

     int opindex, signed long *valuep)

{

  const char *errmsg = 0;

  signed long value;

  PARSE_SIGNED;

  if (value <= 0xffffff && value > 0x7fffff)

    value -= 0x1000000;

  if (value > 0xffffff)

    return _("dsp:24 immediate is out of range");

  *valuep = value;

  return 0;

}

static const char *

parse_signed32 (CGEN_CPU_DESC cd, const char **strp,

    int opindex, signed long *valuep)

{

  const char *errmsg = 0;

  signed long value;

  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);

  if (errmsg)

    return errmsg;

  *valuep = value;

  return 0;

}

static const char *

parse_imm1_S (CGEN_CPU_DESC cd, const char **strp,

       int opindex, signed long *valuep)

{

  const char *errmsg = 0;

  signed long value;

  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);

  if (errmsg)

    return errmsg;

  if (value < 1 || value > 2)

    return _("immediate is out of range 1-2");

  *valuep = value;

  return 0;

}

static const char *

parse_imm3_S (CGEN_CPU_DESC cd, const char **strp,

       int opindex, signed long *valuep)

{

  const char *errmsg = 0;

  signed long value;

  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);

  if (errmsg)

    return errmsg;

  if (value < 1 || value > 8)

    return _("immediate is out of range 1-8");

  *valuep = value;

  return 0;

}

static const char *

parse_bit3_S (CGEN_CPU_DESC cd, const char **strp,

       int opindex, signed long *valuep)

{

  const char *errmsg = 0;

  signed long value;

  errmsg = cgen_parse_signed_integer (cd, strp, opindex, & value);

  if (errmsg)

    return errmsg;

  if (value < 0 || value > 7)

    return _("immediate is out of range 0-7");

  *valuep = value;

  return 0;

}

static const char *

parse_lab_5_3 (CGEN_CPU_DESC cd,

         const char **strp,

         int opindex ATTRIBUTE_UNUSED,

         int opinfo,

         enum cgen_parse_operand_result *type_addr,

         bfd_vma *valuep)

{

  const char *errmsg = 0;

  bfd_vma value;

  enum cgen_parse_operand_result op_res;

  errmsg = cgen_parse_address (cd, strp, M32C_OPERAND_LAB_5_3,

             opinfo, & op_res, & value);

  if (type_addr)

    *type_addr = op_res;

  if (op_res == CGEN_PARSE_OPERAND_RESULT_QUEUED)

    {

      /* This is a hack; the field cannot handle near-zero signed

   offsets that CGEN wants to put in to indicate an "empty"

   operand at first.  */

      *valuep = 2;

      return 0;

    }

  if (errmsg)

    return errmsg;

  if (value < 2 || value > 9)

    return _("immediate is out of range 2-9");

  *valuep = value;

  return 0;

}

static const char *

parse_Bitno16R (CGEN_CPU_DESC cd, const char **strp,

    int opindex, unsigned long *valuep)

{

  const char *errmsg = 0;

  unsigned long value;

  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, & value);

  if (errmsg)

    return errmsg;

  if (value > 15)

    return _("Bit number for indexing general register is out of range 0-15");

  *valuep = value;

  return 0;

}

static const char *

parse_unsigned_bitbase (CGEN_CPU_DESC cd, const char **strp,

      int opindex, unsigned long *valuep,

      unsigned bits, int allow_syms)

{

  const char *errmsg = 0;

  unsigned long bit;

  unsigned long base;

  const char *newp = *strp;

  unsigned long long bitbase;

  long have_zero = 0;

  errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);

  if (errmsg)

    return errmsg;

  if (*newp != ',')

    return "Missing base for bit,base:8";

  ++newp;

  if (strncmp (newp, "0x0", 3) == 0

      || (newp[0] == '0' && newp[1] != 'x'))

    have_zero = 1;

  errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & base);

  if (errmsg)

    return errmsg;

  bitbase = (unsigned long long) bit + ((unsigned long long) base * 8);

  if (bitbase >= (1ull << bits))

    return _("bit,base is out of range");

  /* If this field may require a relocation then use larger displacement.  */

  if (! have_zero && base == 0)

    {

      switch (allow_syms) {

      case 0:

  return _("bit,base out of range for symbol");

      case 1:

  break;

      case 2:

  if (strncmp (newp, "[sb]", 4) != 0)

    return _("bit,base out of range for symbol");

  break;

      }

    }

  *valuep = bitbase;

  *strp = newp;

  return 0;

}

static const char *

parse_signed_bitbase (CGEN_CPU_DESC cd, const char **strp,

          int opindex, signed long *valuep,

          unsigned bits, int allow_syms)

{

  const char *errmsg = 0;

  unsigned long bit;

  signed long base;

  const char *newp = *strp;

  long long bitbase;

  long long limit;

  long have_zero = 0;

  errmsg = cgen_parse_unsigned_integer (cd, & newp, opindex, & bit);

  if (errmsg)

    return errmsg;

  if (*newp != ',')

    return "Missing base for bit,base:8";

  ++newp;

  if (strncmp (newp, "0x0", 3) == 0

      || (newp[0] == '0' && newp[1] != 'x'))

    have_zero = 1;

  errmsg = cgen_parse_signed_integer (cd, & newp, opindex, & base);

  if (errmsg)

    return errmsg;

  bitbase = (long long)bit + ((long long)base * 8);

  limit = 1ll << (bits - 1);

  if (bitbase < -limit || bitbase >= limit)

    return _("bit,base is out of range");

  /* If this field may require a relocation then use larger displacement.  */

  if (! have_zero && base == 0 && ! allow_syms)

    return _("bit,base out of range for symbol");

  *valuep = bitbase;

  *strp = newp;

  return 0;

}

static const char *

parse_unsigned_bitbase8 (CGEN_CPU_DESC cd, const char **strp,

       int opindex, unsigned long *valuep)

{

  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 8, 0);

}

static const char *

parse_unsigned_bitbase11 (CGEN_CPU_DESC cd, const char **strp,

       int opindex, unsigned long *valuep)

{

  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 11, 0);

}

static const char *

parse_unsigned_bitbase16 (CGEN_CPU_DESC cd, const char **strp,

        int opindex, unsigned long *valuep)

{

  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 16, 1);

}

static const char *

parse_unsigned_bitbase19 (CGEN_CPU_DESC cd, const char **strp,

       int opindex, unsigned long *valuep)

{

  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 19, 2);

}

static const char *

parse_unsigned_bitbase27 (CGEN_CPU_DESC cd, const char **strp,

       int opindex, unsigned long *valuep)

{

  return parse_unsigned_bitbase (cd, strp, opindex, valuep, 27, 1);

}

static const char *

parse_signed_bitbase8 (CGEN_CPU_DESC cd, const char **strp,

           int opindex, signed long *valuep)

{

  return parse_signed_bitbase (cd, strp, opindex, valuep, 8, 1);

}

static const char *

parse_signed_bitbase11 (CGEN_CPU_DESC cd, const char **strp,

           int opindex, signed long *valuep)

{

  return parse_signed_bitbase (cd, strp, opindex, valuep, 11, 0);

}

static const char *

parse_signed_bitbase19 (CGEN_CPU_DESC cd, const char **strp,

           int opindex, signed long *valuep)

{

  return parse_signed_bitbase (cd, strp, opindex, valuep, 19, 1);

}

/* Parse the suffix as :<char> or as nothing followed by a whitespace.  */

static const char *

parse_suffix (const char **strp, char suffix)

{

  const char *newp = *strp;

  if (**strp == ':' && TOLOWER (*(*strp + 1)) == suffix)

    newp = *strp + 2;

  if (ISSPACE (*newp))

    {

      *strp = newp;

      return 0;

    }

  return "Invalid suffix"; /* Anything -- will not be seen.  */

}

static const char *

parse_S (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,

   int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)

{

  return parse_suffix (strp, 's');

}

static const char *

parse_G (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,

   int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)

{

  return parse_suffix (strp, 'g');

}

static const char *

parse_Q (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,

   int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)

{

  return parse_suffix (strp, 'q');

}

static const char *

parse_Z (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,

   int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)

{

  return parse_suffix (strp, 'z');

}

/* Parse an empty suffix. Fail if the next char is ':'.  */

static const char *

parse_X (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,

   int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)

{

  if (**strp == ':')

    return "Unexpected suffix";

  return 0;

}

static const char *

parse_r0l_r0h (CGEN_CPU_DESC cd, const char **strp,

         int opindex ATTRIBUTE_UNUSED, signed long *valuep)

{

  const char *errmsg;

  signed long value;

  signed long junk;

  const char *newp = *strp;

  /* Parse r0[hl].  */

  errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l_r0h, & value);

  if (errmsg)

    return errmsg;

  if (*newp != ',')

    return _("not a valid r0l/r0h pair");

  ++newp;

  /* Parse the second register in the pair.  */

  if (value == 0) /* r0l */

    errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0h, & junk);

  else

    errmsg = cgen_parse_keyword (cd, & newp, & m32c_cgen_opval_h_r0l, & junk);

  if (errmsg)

    return errmsg;

  *strp = newp;

  *valuep = ! value;

  return 0;

}

/* Accept .b or .w in any case.  */

static const char *

parse_size (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, const char **strp,

      int opindex ATTRIBUTE_UNUSED, signed long *valuep ATTRIBUTE_UNUSED)

{

  if (**strp == '.'

      && (*(*strp + 1) == 'b' || *(*strp + 1) == 'B'

    || *(*strp + 1) == 'w' || *(*strp + 1) == 'W'))

    {

      *strp += 2;

      return NULL;

    }

  return _("Invalid size specifier");

}

/* Special check to ensure that instruction exists for given machine.  */

int

m32c_cgen_insn_supported (CGEN_CPU_DESC cd,

        const CGEN_INSN *insn)

{

  int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);

  CGEN_BITSET isas = CGEN_INSN_BITSET_ATTR_VALUE (insn, CGEN_INSN_ISA);

  /* If attributes are absent, assume no restriction.  */

  if (machs == 0)

    machs = ~0;

  return ((machs & cd->machs)

          && cgen_bitset_intersect_p (& isas, cd->isas));

}

/* Parse a set of registers, R0,R1,A0,A1,SB,FB.  */

static const char *

parse_regset (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,

        const char **strp,

        int opindex ATTRIBUTE_UNUSED,

        unsigned long *valuep,

        int push)

{

  const char *errmsg = 0;

  int regno = 0;

  *valuep = 0;

  while (**strp && **strp != ')')

    {

      if (**strp == 'r' || **strp == 'R')

  {

    ++*strp;

    regno = **strp - '0';

    if (regno > 4)

      errmsg = _("Register number is not valid");

  }

      else if (**strp == 'a' || **strp == 'A')

  {

    ++*strp;

    regno = **strp - '0';

    if (regno > 2)

      errmsg = _("Register number is not valid");

    regno = **strp - '0' + 4;

  }

      else if (strncasecmp (*strp, "sb", 2) == 0 || strncasecmp (*strp, "SB", 2) == 0)

  {

    regno = 6;

    ++*strp;

  }

      else if (strncasecmp (*strp, "fb", 2) == 0 || strncasecmp (*strp, "FB", 2) == 0)

  {

    regno = 7;

    ++*strp;

  }

      if (push) /* Mask is reversed for push.  */

  *valuep |= 0x80 >> regno;

      else

  *valuep |= 1 << regno;