Changeset 609 for branches/GNU/src/binutils/opcodes/cgen-asm.in

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/opcodes/cgen-asm.in (modified) (16 diffs, 1 prop)

branches/GNU/src/binutils/opcodes/cgen-asm.in

@@ -27 +27 @@
 
 #include "sysdep.h"
-#include <ctype.h>
 #include <stdio.h>
 #include "ansidecl.h"
@@ -35 +34 @@
 #include "@prefix@-opc.h"
 #include "opintl.h"
-
-#undef min
+#include "xregex.h"
+#include "libiberty.h"
+#include "safe-ctype.h"
+
+#undef  min
 #define min(a,b) ((a) < (b) ? (a) : (b))
-#undef max
+#undef  max
 #define max(a,b) ((a) > (b) ? (a) : (b))
 
@@ -45 +47 @@
 
 
-/* -- assembler routines inserted here */
+/* -- assembler routines inserted here.  */
+
+
+
+/* Regex construction routine.
+
+   This translates an opcode syntax string into a regex string,
+   by replacing any non-character syntax element (such as an
+   opcode) with the pattern '.*'
+
+   It then compiles the regex and stores it in the opcode, for
+   later use by @arch@_cgen_assemble_insn
+
+   Returns NULL for success, an error message for failure.  */
+
+char * 
+@arch@_cgen_build_insn_regex (insn)
+     CGEN_INSN *insn;
+{  
+  CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
+  const char *mnem = CGEN_INSN_MNEMONIC (insn);
+  char rxbuf[CGEN_MAX_RX_ELEMENTS];
+  char *rx = rxbuf;
+  const CGEN_SYNTAX_CHAR_TYPE *syn;
+  int reg_err;
+
+  syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
+
+  /* Mnemonics come first in the syntax string.  */
+  if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
+    return _("missing mnemonic in syntax string");
+  ++syn;
+
+  /* Generate a case sensitive regular expression that emulates case
+     insensitive matching in the "C" locale.  We cannot generate a case
+     insensitive regular expression because in Turkish locales, 'i' and 'I'
+     are not equal modulo case conversion.  */
+
+  /* Copy the literal mnemonic out of the insn.  */
+  for (; *mnem; mnem++)
+    {
+      char c = *mnem;
+
+      if (ISALPHA (c))
+        {
+          *rx++ = '[';
+          *rx++ = TOLOWER (c);
+          *rx++ = TOUPPER (c);
+          *rx++ = ']';
+        }
+      else
+        *rx++ = c;
+    }
+
+  /* Copy any remaining literals from the syntax string into the rx.  */
+  for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
+    {
+      if (CGEN_SYNTAX_CHAR_P (* syn)) 
+        {
+          char c = CGEN_SYNTAX_CHAR (* syn);
+
+          switch (c) 
+            {
+              /* Escape any regex metacharacters in the syntax.  */
+            case '.': case '[': case '\\': 
+            case '*': case '^': case '$': 
+
+#ifdef CGEN_ESCAPE_EXTENDED_REGEX
+            case '?': case '{': case '}': 
+            case '(': case ')': case '*':
+            case '|': case '+': case ']':
+#endif
+              *rx++ = '\\';
+              *rx++ = c;
+              break;
+
+            default:
+              if (ISALPHA (c))
+                {
+                  *rx++ = '[';
+                  *rx++ = TOLOWER (c);
+                  *rx++ = TOUPPER (c);
+                  *rx++ = ']';
+                }
+              else
+                *rx++ = c;
+              break;
+            }
+        }
+      else
+        {
+          /* Replace non-syntax fields with globs.  */
+          *rx++ = '.';
+          *rx++ = '*';
+        }
+    }
+
+  /* Trailing whitespace ok.  */
+  * rx++ = '['; 
+  * rx++ = ' '; 
+  * rx++ = '\t'; 
+  * rx++ = ']'; 
+  * rx++ = '*'; 
+
+  /* But anchor it after that.  */
+  * rx++ = '$'; 
+  * rx = '\0';
+
+  CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
+  reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
+
+  if (reg_err == 0) 
+    return NULL;
+  else
+    {
+      static char msg[80];
+
+      regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
+      regfree ((regex_t *) CGEN_INSN_RX (insn));
+      free (CGEN_INSN_RX (insn));
+      (CGEN_INSN_RX (insn)) = NULL;
+      return msg;
+    }
+}
+
 
 
@@ -59 +185 @@
    expensive in the case of the m68k.  Deal with later.
 
-   Returns NULL for success, an error message for failure.
-*/
+   Returns NULL for success, an error message for failure.  */
 
 static const char *
@@ -85 +210 @@
      not be called from GAS.  */
   p = CGEN_INSN_MNEMONIC (insn);
-  while (*p && tolower (*p) == tolower (*str))
+  while (*p && TOLOWER (*p) == TOLOWER (*str))
     ++p, ++str;
 
@@ -92 +217 @@
 
 #ifndef CGEN_MNEMONIC_OPERANDS
-  if (* str && !isspace (* str))
+  if (* str && ! ISSPACE (* str))
     return _("unrecognized instruction");
 #endif
@@ -121 +246 @@
           /* FIXME: We also take inappropriate advantage of the fact that
              GAS's input scrubber will remove extraneous blanks.  */
-          if (tolower (*str) == tolower (CGEN_SYNTAX_CHAR (* syn)))
+          if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
             {
 #ifdef CGEN_MNEMONIC_OPERANDS
@@ -134 +259 @@
               /* Syntax char didn't match.  Can't be this insn.  */
               static char msg [80];
+
               /* xgettext:c-format */
               sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
@@ -143 +269 @@
               /* Ran out of input.  */
               static char msg [80];
+
               /* xgettext:c-format */
               sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
@@ -152 +279 @@
 
       /* We have an operand of some sort.  */
-      errmsg = @arch@_cgen_parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
+      errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn),
                                           &str, fields);
       if (errmsg)
@@ -168 +295 @@
          the insn and it is assumed that longer versions of insns appear
          before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3).  */
-      while (isspace (* str))
+      while (ISSPACE (* str))
         ++ str;
 
@@ -215 +342 @@
   const char *parse_errmsg = NULL;
   const char *insert_errmsg = NULL;
+  int recognized_mnemonic = 0;
 
   /* Skip leading white space.  */
-  while (isspace (* str))
+  while (ISSPACE (* str))
     ++ str;
 
@@ -225 +353 @@
 
   /* Keep looking until we find a match.  */
-
   start = str;
   for ( ; ilist != NULL ; ilist = CGEN_ASM_NEXT_INSN (ilist))
     {
       const CGEN_INSN *insn = ilist->insn;
+      recognized_mnemonic = 1;
 
 #ifdef CGEN_VALIDATE_INSN_SUPPORTED 
-      /* not usually needed as unsupported opcodes shouldn't be in the hash lists */
+      /* Not usually needed as unsupported opcodes
+         shouldn't be in the hash lists.  */
       /* Is this insn supported by the selected cpu?  */
       if (! @arch@_cgen_insn_supported (cd, insn))
         continue;
 #endif
-
       /* If the RELAX attribute is set, this is an insn that shouldn't be
          chosen immediately.  Instead, it is used during assembler/linker
@@ -246 +374 @@
       str = start;
 
+      /* Skip this insn if str doesn't look right lexically.  */
+      if (CGEN_INSN_RX (insn) != NULL &&
+          regexec ((regex_t *) CGEN_INSN_RX (insn), str, 0, NULL, 0) == REG_NOMATCH)
+        continue;
+
       /* Allow parse/insert handlers to obtain length of insn.  */
       CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
@@ -253 +386 @@
         continue;
 
-      /* ??? 0 is passed for `pc' */
+      /* ??? 0 is passed for `pc'.  */
       insert_errmsg = CGEN_INSERT_FN (cd, insn) (cd, insn, fields, buf,
                                                  (bfd_vma) 0);
@@ -266 +399 @@
   {
     static char errbuf[150];
+#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
     const char *tmp_errmsg;
 
-#ifdef CGEN_VERBOSE_ASSEMBLER_ERRORS
     /* If requesting verbose error messages, use insert_errmsg.
-       Failing that, use parse_errmsg */
+       Failing that, use parse_errmsg.  */
     tmp_errmsg = (insert_errmsg ? insert_errmsg :
                   parse_errmsg ? parse_errmsg :
+                  recognized_mnemonic ?
+                  _("unrecognized form of instruction") :
                   _("unrecognized instruction"));