Locale changes from Bruno Haible <haible@clisp.cons.org>.
[deliverable/binutils-gdb.git] / gas / gasp.c
index 5ea70b682b012ca95bd1276ee0f336fb557b1b90..4022408e51cc16d889b8d57addf40f7ff19b27e0 100644 (file)
@@ -1,5 +1,6 @@
 /* gasp.c - Gnu assembler preprocessor main program.
 /* gasp.c - Gnu assembler preprocessor main program.
-   Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+   Free Software Foundation, Inc.
 
    Written by Steve and Judy Chamberlain of Cygnus Support,
       sac@cygnus.com
 
    Written by Steve and Judy Chamberlain of Cygnus Support,
       sac@cygnus.com
    You should have received a copy of the GNU General Public License
    along with GASP; see the file COPYING.  If not, write to the Free
    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    You should have received a copy of the GNU General Public License
    along with GASP; see the file COPYING.  If not, write to the Free
    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA. */
+   02111-1307, USA.  */
 
 /*
 
 /*
-
 This program translates the input macros and stuff into a form
 suitable for gas to consume.
 
 This program translates the input macros and stuff into a form
 suitable for gas to consume.
 
-
   gasp [-sdhau] [-c char] [-o <outfile>] <infile>*
 
   -s copy source to output
   gasp [-sdhau] [-c char] [-o <outfile>] <infile>*
 
   -s copy source to output
@@ -42,18 +41,16 @@ suitable for gas to consume.
     Macro arg parameters subsituted by name, don't need the &.
      String can start with ' too.
      Strings can be surrounded by <..>
     Macro arg parameters subsituted by name, don't need the &.
      String can start with ' too.
      Strings can be surrounded by <..>
-     A %<exp> in a string evaluates the expression 
+     A %<exp> in a string evaluates the expression
      Literal char in a string with !
      Literal char in a string with !
-
-
 */
 
 #include "config.h"
 */
 
 #include "config.h"
+#include "bin-bugs.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <getopt.h>
 
 #include <stdio.h>
 #include <string.h>
 #include <getopt.h>
-#include <ctype.h>
 
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
@@ -65,34 +62,45 @@ extern char *malloc ();
 
 #include "ansidecl.h"
 #include "libiberty.h"
 
 #include "ansidecl.h"
 #include "libiberty.h"
+#include "safe-ctype.h"
 #include "sb.h"
 #include "macro.h"
 #include "sb.h"
 #include "macro.h"
+#include "asintl.h"
 
 char *program_version = "1.2";
 
 
 char *program_version = "1.2";
 
-#define MAX_INCLUDES 30                /* Maximum include depth */
-#define MAX_REASONABLE 1000    /* Maximum number of expansions */
-
-int unreasonable;              /* -u on command line */
-int stats;                     /* -d on command line */
-int print_line_number;         /* -p flag on command line */
-int copysource;                        /* -c flag on command line */
-int warnings;                  /* Number of WARNINGs generated so far. */
-int errors;                    /* Number of ERRORs generated so far. */
-int fatals;                    /* Number of fatal ERRORs generated so far (either 0 or 1). */
-int alternate = 0;              /* -a on command line */
-int mri = 0;                   /* -M on command line */
+/* This is normally declared in as.h, but we don't include that.  We
+   need the function because other files linked with gasp.c might call
+   it.  */
+extern void as_abort PARAMS ((const char *, int, const char *));
+
+/* The default obstack chunk size.  If we set this to zero, the
+   obstack code will use whatever will fit in a 4096 byte block.  This
+   is used by the hash table code used by macro.c.  */
+int chunksize = 0;
+
+#define MAX_INCLUDES 30                /* Maximum include depth.  */
+#define MAX_REASONABLE 1000    /* Maximum number of expansions.  */
+
+int unreasonable;              /* -u on command line.  */
+int stats;                     /* -d on command line.  */
+int print_line_number;         /* -p flag on command line.  */
+int copysource;                        /* -c flag on command line.  */
+int warnings;                  /* Number of WARNINGs generated so far.  */
+int errors;                    /* Number of ERRORs generated so far.  */
+int fatals;                    /* Number of fatal ERRORs generated so far (either 0 or 1).  */
+int alternate = 0;              /* -a on command line.  */
+int mri = 0;                   /* -M on command line.  */
 char comment_char = '!';
 char comment_char = '!';
-int radix = 10;                        /* Default radix */
+int radix = 10;                        /* Default radix */
 
 
-int had_end; /* Seen .END */
+int had_end; /* Seen .END */
 
 
-/* The output stream */
+/* The output stream */
 FILE *outfile;
 
 FILE *outfile;
 
-/* the attributes of each character are stored as a bit pattern
-   chartype, which gives us quick tests. */
-
+/* The attributes of each character are stored as a bit pattern
+   chartype, which gives us quick tests.  */
 
 #define FIRSTBIT 1
 #define NEXTBIT  2
 
 #define FIRSTBIT 1
 #define NEXTBIT  2
@@ -100,15 +108,14 @@ FILE *outfile;
 #define WHITEBIT 8
 #define COMMENTBIT 16
 #define BASEBIT  32
 #define WHITEBIT 8
 #define COMMENTBIT 16
 #define BASEBIT  32
-#define ISCOMMENTCHAR(x) (chartype[(unsigned)(x)] & COMMENTBIT)
-#define ISFIRSTCHAR(x)  (chartype[(unsigned)(x)] & FIRSTBIT)
-#define ISNEXTCHAR(x)   (chartype[(unsigned)(x)] & NEXTBIT)
-#define ISSEP(x)        (chartype[(unsigned)(x)] & SEPBIT)
-#define ISWHITE(x)      (chartype[(unsigned)(x)] & WHITEBIT)
-#define ISBASE(x)       (chartype[(unsigned)(x)] & BASEBIT)
+#define ISCOMMENTCHAR(x) (chartype[(unsigned char)(x)] & COMMENTBIT)
+#define ISFIRSTCHAR(x)  (chartype[(unsigned char)(x)] & FIRSTBIT)
+#define ISNEXTCHAR(x)   (chartype[(unsigned char)(x)] & NEXTBIT)
+#define ISSEP(x)        (chartype[(unsigned char)(x)] & SEPBIT)
+#define ISWHITE(x)      (chartype[(unsigned char)(x)] & WHITEBIT)
+#define ISBASE(x)       (chartype[(unsigned char)(x)] & BASEBIT)
 static char chartype[256];
 
 static char chartype[256];
 
-
 /* Conditional assembly uses the `ifstack'.  Each aif pushes another
    entry onto the stack, and sets the on flag if it should.  The aelse
    sets hadelse, and toggles on.  An aend pops a level.  We limit to
 /* Conditional assembly uses the `ifstack'.  Each aif pushes another
    entry onto the stack, and sets the on flag if it should.  The aelse
    sets hadelse, and toggles on.  An aend pops a level.  We limit to
@@ -117,149 +124,101 @@ static char chartype[256];
    a bug in the user's macro structure.  */
 
 #define IFNESTING 100
    a bug in the user's macro structure.  */
 
 #define IFNESTING 100
-struct
-  {
-    int on;                    /* is the level being output */
-    int hadelse;               /* has an aelse been seen */
-  }
-ifstack[IFNESTING];
+struct {
+  int on;                      /* Is the level being output.  */
+  int hadelse;                 /* Has an aelse been seen.  */
+} ifstack[IFNESTING];
+
 int ifi;
 
 /* The final and intermediate results of expression evaluation are kept in
    exp_t's.  Note that a symbol is not an sb, but a pointer into the input
 int ifi;
 
 /* The final and intermediate results of expression evaluation are kept in
    exp_t's.  Note that a symbol is not an sb, but a pointer into the input
-   line.  It must be coped somewhere safe before the next line is read in. */
-
-typedef struct
-  {
-    char *name;
-    int len;
-  }
-symbol;
+   line.  It must be coped somewhere safe before the next line is read in.  */
 
 
-typedef struct
-  {
-    int value;                 /* constant part */
-    symbol add_symbol;         /* name part */
-    symbol sub_symbol;         /* name part */
-  }
-exp_t;
+typedef struct {
+  char *name;
+  int len;
+} symbol;
 
 
+typedef struct {
+  int value;                   /* Constant part.  */
+  symbol add_symbol;           /* Name part.  */
+  symbol sub_symbol;           /* Name part.  */
+} exp_t;
 
 /* Hashing is done in a pretty standard way.  A hash_table has a
    pointer to a vector of pointers to hash_entrys, and the size of the
    vector.  A hash_entry contains a union of all the info we like to
    store in hash table.  If there is a hash collision, hash_entries
 
 /* Hashing is done in a pretty standard way.  A hash_table has a
    pointer to a vector of pointers to hash_entrys, and the size of the
    vector.  A hash_entry contains a union of all the info we like to
    store in hash table.  If there is a hash collision, hash_entries
-   with the same hash are kept in a chain. */
-
-/* What the data in a hash_entry means */
-typedef enum
-  {
-    hash_integer,              /* name->integer mapping */
-    hash_string,               /* name->string mapping */
-    hash_macro,                        /* name is a macro */
-    hash_formal                        /* name is a formal argument */
-  } hash_type;
-
-typedef struct hs
-  {
-    sb key;                    /* symbol name */
-    hash_type type;            /* symbol meaning */
-    union
-      {
-       sb s;
-       int i;
-       struct macro_struct *m;
-       struct formal_struct *f;
-      } value;
-    struct hs *next;           /* next hash_entry with same hash key */
-  } hash_entry;
-
-typedef struct
-  {
-    hash_entry **table;
-    int size;
-  } hash_table;
-
-
-/* Structures used to store macros. 
-
-   Each macro knows its name and included text.  It gets built with a
-   list of formal arguments, and also keeps a hash table which points
-   into the list to speed up formal search.  Each formal knows its
-   name and its default value.  Each time the macro is expanded, the
-   formals get the actual values attatched to them. */
-
-/* describe the formal arguments to a macro */
-
-typedef struct formal_struct
-  {
-    struct formal_struct *next;        /* next formal in list */
-    sb name;                   /* name of the formal */
-    sb def;                    /* the default value */
-    sb actual;                 /* the actual argument (changed on each expansion) */
-    int index;                 /* the index of the formal 0..formal_count-1 */
-  }
-formal_entry;
-
-/* describe the macro. */
-
-typedef struct macro_struct
-  {
-    sb sub;                    /* substitution text. */
-    int formal_count;          /* number of formal args. */
-    formal_entry *formals;     /* pointer to list of formal_structs */
-    hash_table formal_hash;    /* hash table of formals. */
-  }
-macro_entry;
-
-/* how we nest files and expand macros etc.
-
-   we keep a stack of of include_stack structs.  each include file
-   pushes a new level onto the stack.  we keep an sb with a pushback
+   with the same hash are kept in a chain.  */
+
+/* What the data in a hash_entry means.  */
+typedef enum {
+  hash_integer,                        /* Name->integer mapping.  */
+  hash_string,                 /* Name->string mapping.  */
+  hash_macro,                  /* Name is a macro.  */
+  hash_formal                  /* Name is a formal argument.  */
+} hash_type;
+
+typedef struct hs {
+  sb key;                      /* Symbol name.  */
+  hash_type type;              /* Symbol meaning.  */
+  union {
+    sb s;
+    int i;
+    struct macro_struct *m;
+    struct formal_struct *f;
+  } value;
+  struct hs *next;             /* Next hash_entry with same hash key.  */
+} hash_entry;
+
+typedef struct {
+  hash_entry **table;
+  int size;
+} hash_table;
+
+/* How we nest files and expand macros etc.
+
+   We keep a stack of of include_stack structs.  Each include file
+   pushes a new level onto the stack.  We keep an sb with a pushback
    too.  unget chars are pushed onto the pushback sb, getchars first
    checks the pushback sb before reading from the input stream.
 
    too.  unget chars are pushed onto the pushback sb, getchars first
    checks the pushback sb before reading from the input stream.
 
-   small things are expanded by adding the text of the item onto the
-   pushback sb.  larger items are grown by pushing a new level and
-   allocating the entire pushback buf for the item.  each time
-   something like a macro is expanded, the stack index is changed. we
+   Small things are expanded by adding the text of the item onto the
+   pushback sb.  Larger items are grown by pushing a new level and
+   allocating the entire pushback buf for the item.  Each time
+   something like a macro is expanded, the stack index is changed.  We
    can then perform an exitm by popping all entries off the stack with
    can then perform an exitm by popping all entries off the stack with
-   the same stack index.  if we're being reasonable, we can detect
-   recusive expansion by checking the index is reasonably small.
- */
-
-typedef enum
-  {
-    include_file, include_repeat, include_while, include_macro
-  } include_type;
-
-struct include_stack
-  {
-    sb pushback;               /* current pushback stream */
-    int pushback_index;                /* next char to read from stream */
-    FILE *handle;              /* open file */
-    sb name;                   /* name of file */
-    int linecount;             /* number of lines read so far */
-    include_type type;
-    int index;                 /* index of this layer */
-  }
-include_stack[MAX_INCLUDES];
+   the same stack index.  If we're being reasonable, we can detect
+   recusive expansion by checking the index is reasonably small.  */
+
+typedef enum {
+  include_file, include_repeat, include_while, include_macro
+} include_type;
+
+struct include_stack {
+  sb pushback;                 /* Current pushback stream.  */
+  int pushback_index;          /* Next char to read from stream.  */
+  FILE *handle;                        /* Open file.  */
+  sb name;                     /* Name of file.  */
+  int linecount;               /* Number of lines read so far.  */
+  include_type type;
+  int index;                   /* Index of this layer.  */
+} include_stack[MAX_INCLUDES];
 
 struct include_stack *sp;
 #define isp (sp - include_stack)
 
 
 struct include_stack *sp;
 #define isp (sp - include_stack)
 
-/* Include file list */
+/* Include file list */
 
 
-typedef struct include_path 
-{
+typedef struct include_path {
   struct include_path *next;
   sb path;
   struct include_path *next;
   sb path;
-}  include_path;
+} include_path;
 
 include_path *paths_head;
 include_path *paths_tail;
 
 
 include_path *paths_head;
 include_path *paths_tail;
 
-
 static void quit PARAMS ((void));
 static void hash_new_table PARAMS ((int, hash_table *));
 static int hash PARAMS ((sb *));
 static void quit PARAMS ((void));
 static void hash_new_table PARAMS ((int, hash_table *));
 static int hash PARAMS ((sb *));
@@ -352,16 +311,36 @@ static void do_define PARAMS ((const char *));
 static void show_usage PARAMS ((FILE *, int));
 static void show_help PARAMS ((void));
 
 static void show_usage PARAMS ((FILE *, int));
 static void show_help PARAMS ((void));
 
-#define FATAL(x) \
-  do { include_print_where_line (stderr); fprintf x ; fatals++; quit(); } while(0) 
-#define ERROR(x) \
-  do { include_print_where_line (stderr); fprintf x; errors++; } while(0)
-#define WARNING(x) \
-  do { include_print_where_line (stderr); fprintf x; warnings++;} while(0) 
-
-
+#define FATAL(x)                               \
+  do                                           \
+    {                                          \
+      include_print_where_line (stderr);       \
+      fprintf x;                               \
+      fatals++;                                        \
+      quit ();                                 \
+    }                                          \
+  while (0)
+
+#define ERROR(x)                               \
+  do                                           \
+    {                                          \
+      include_print_where_line (stderr);       \
+      fprintf x;                               \
+      errors++;                                        \
+    }                                          \
+  while (0)
+
+#define WARNING(x)                             \
+  do                                           \
+    {                                          \
+      include_print_where_line (stderr);       \
+      fprintf x;                               \
+      warnings++;                              \
+    }                                          \
+  while (0)
+
+/* Exit the program and return the right ERROR code.  */
 
 
-/* exit the program and return the right ERROR code. */
 static void
 quit ()
 {
 static void
 quit ()
 {
@@ -371,20 +350,22 @@ quit ()
   else
     exitcode = 0;
 
   else
     exitcode = 0;
 
-  if (stats) 
+  if (stats)
     {
       int i;
     {
       int i;
-      for (i = 0; i < sb_max_power_two; i++) 
+      for (i = 0; i < sb_max_power_two; i++)
        {
        {
-         fprintf (stderr, "strings size %8d : %d\n", 1<<i, string_count[i]);
+         fprintf (stderr, "strings size %8d : %d\n",
+                  1 << i, string_count[i]);
        }
     }
   exit (exitcode);
 }
 
        }
     }
   exit (exitcode);
 }
 
-/* hash table maintenance. */
+/* Hash table maintenance.  */
 
 
-/* build a new hash table with size buckets, and fill in the info at ptr. */
+/* Build a new hash table with size buckets
+   and fill in the info at ptr.  */
 
 static void
 hash_new_table (size, ptr)
 
 static void
 hash_new_table (size, ptr)
@@ -399,7 +380,7 @@ hash_new_table (size, ptr)
     ptr->table[i] = 0;
 }
 
     ptr->table[i] = 0;
 }
 
-/* calculate and return the hash value of the sb at key. */
+/* Calculate and return the hash value of the sb at key.  */
 
 static int
 hash (key)
 
 static int
 hash (key)
@@ -416,11 +397,10 @@ hash (key)
   return k & 0xf0fff;
 }
 
   return k & 0xf0fff;
 }
 
-/* lookup key in hash_table tab, if present, then return it, otherwise
-   build a new one and fill it with hash_integer. */
+/* Look up key in hash_table tab.  If present, then return it,
+   otherwise build a new one and fill it with hash_integer.  */
 
 
-static
-hash_entry *
+static hash_entry *
 hash_create (tab, key)
      hash_table *tab;
      sb *key;
 hash_create (tab, key)
      hash_table *tab;
      sb *key;
@@ -451,11 +431,10 @@ hash_create (tab, key)
     }
 }
 
     }
 }
 
-/* add sb name with key into hash_table tab.  if replacing old value
-   and again, then ERROR. */
+/* Add sb name with key into hash_table tab.
+   If replacing old value and again, then ERROR.  */
 
 
-static
-void
+static void
 hash_add_to_string_table (tab, key, name, again)
      hash_table *tab;
      sb *key;
 hash_add_to_string_table (tab, key, name, again)
      hash_table *tab;
      sb *key;
@@ -470,19 +449,18 @@ hash_add_to_string_table (tab, key, name, again)
   if (ptr->value.s.len)
     {
       if (!again)
   if (ptr->value.s.len)
     {
       if (!again)
-       ERROR ((stderr, "redefintion not allowed"));
+       ERROR ((stderr, _("redefinition not allowed\n")));
     }
 
   ptr->type = hash_string;
   sb_reset (&ptr->value.s);
     }
 
   ptr->type = hash_string;
   sb_reset (&ptr->value.s);
-  
+
   sb_add_sb (&ptr->value.s, name);
 }
 
   sb_add_sb (&ptr->value.s, name);
 }
 
-/* add integer name to hash_table tab with sb key. */
+/* Add integer name to hash_table tab with sb key.  */
 
 
-static
-void
+static void
 hash_add_to_int_table (tab, key, name)
      hash_table *tab;
      sb *key;
 hash_add_to_int_table (tab, key, name)
      hash_table *tab;
      sb *key;
@@ -492,11 +470,10 @@ hash_add_to_int_table (tab, key, name)
   ptr->value.i = name;
 }
 
   ptr->value.i = name;
 }
 
-/* lookup sb key in hash_table tab.  if found return hash_entry result,
-   else 0. */
-   
-static
-hash_entry *
+/* Look up sb key in hash_table tab.
+   If found, return hash_entry result, else 0.  */
+
+static hash_entry *
 hash_lookup (tab, key)
      hash_table *tab;
      sb *key;
 hash_lookup (tab, key)
      hash_table *tab;
      sb *key;
@@ -514,7 +491,6 @@ hash_lookup (tab, key)
   return 0;
 }
 
   return 0;
 }
 
-
 /* expressions
 
    are handled in a really simple recursive decent way. each bit of
 /* expressions
 
    are handled in a really simple recursive decent way. each bit of
@@ -529,14 +505,12 @@ hash_lookup (tab, key)
   + -
   &
   | ~
   + -
   &
   | ~
-
 */
 
 */
 
+/* Make sure that the exp_t at term is constant.
+   If not the give the op ERROR.  */
 
 
-/* make sure that the exp_t at term is constant, if not the give the op ERROR. */
-
-static
-void
+static void
 checkconst (op, term)
      int op;
      exp_t *term;
 checkconst (op, term)
      int op;
      exp_t *term;
@@ -544,16 +518,14 @@ checkconst (op, term)
   if (term->add_symbol.len
       || term->sub_symbol.len)
     {
   if (term->add_symbol.len
       || term->sub_symbol.len)
     {
-      ERROR ((stderr, "the %c operator cannot take non-absolute arguments.\n", op));
+      ERROR ((stderr, _("the %c operator cannot take non-absolute arguments.\n"), op));
     }
 }
 
     }
 }
 
-/* turn the number in string at idx into a number of base,
-   fill in ptr and return the index of the first character not in the
-   number. */
+/* Turn the number in string at idx into a number of base, fill in
+   ptr, and return the index of the first character not in the number.  */
 
 
-static
-int
+static int
 sb_strtol (idx, string, base, ptr)
      int idx;
      sb *string;
 sb_strtol (idx, string, base, ptr)
      int idx;
      sb *string;
@@ -567,7 +539,7 @@ sb_strtol (idx, string, base, ptr)
     {
       int ch = string->ptr[idx];
       int dig = 0;
     {
       int ch = string->ptr[idx];
       int dig = 0;
-      if (isdigit (ch))
+      if (ISDIGIT (ch))
        dig = ch - '0';
       else if (ch >= 'a' && ch <= 'f')
        dig = ch - 'a' + 10;
        dig = ch - '0';
       else if (ch >= 'a' && ch <= 'f')
        dig = ch - 'a' + 10;
@@ -602,7 +574,7 @@ level_0 (idx, string, lhs)
 
   lhs->value = 0;
 
 
   lhs->value = 0;
 
-  if (isdigit (string->ptr[idx]))
+  if (ISDIGIT (string->ptr[idx]))
     {
       idx = sb_strtol (idx, string, 10, &lhs->value);
     }
     {
       idx = sb_strtol (idx, string, 10, &lhs->value);
     }
@@ -621,20 +593,18 @@ level_0 (idx, string, lhs)
     {
       sb acc;
       sb_new (&acc);
     {
       sb acc;
       sb_new (&acc);
-      ERROR ((stderr, "string where expression expected.\n"));
+      ERROR ((stderr, _("string where expression expected.\n")));
       idx = getstring (idx, string, &acc);
       sb_kill (&acc);
     }
   else
     {
       idx = getstring (idx, string, &acc);
       sb_kill (&acc);
     }
   else
     {
-      ERROR ((stderr, "can't find primary in expression.\n"));
+      ERROR ((stderr, _("can't find primary in expression.\n")));
       idx++;
     }
   return sb_skip_white (idx, string);
 }
 
       idx++;
     }
   return sb_skip_white (idx, string);
 }
 
-
-
 static int
 level_1 (idx, string, lhs)
      int idx;
 static int
 level_1 (idx, string, lhs)
      int idx;
@@ -667,7 +637,7 @@ level_1 (idx, string, lhs)
       idx++;
       idx = level_5 (sb_skip_white (idx, string), string, lhs);
       if (string->ptr[idx] != ')')
       idx++;
       idx = level_5 (sb_skip_white (idx, string), string, lhs);
       if (string->ptr[idx] != ')')
-       ERROR ((stderr, "misplaced closing parens.\n"));
+       ERROR ((stderr, _("misplaced closing parens.\n")));
       else
        idx++;
       break;
       else
        idx++;
       break;
@@ -704,7 +674,7 @@ level_2 (idx, string, lhs)
          checkconst ('/', lhs);
          checkconst ('/', &rhs);
          if (rhs.value == 0)
          checkconst ('/', lhs);
          checkconst ('/', &rhs);
          if (rhs.value == 0)
-           ERROR ((stderr, "attempt to divide by zero.\n"));
+           ERROR ((stderr, _("attempt to divide by zero.\n")));
          else
            lhs->value /= rhs.value;
          break;
          else
            lhs->value /= rhs.value;
          break;
@@ -713,7 +683,6 @@ level_2 (idx, string, lhs)
   return sb_skip_white (idx, string);
 }
 
   return sb_skip_white (idx, string);
 }
 
-
 static int
 level_3 (idx, string, lhs)
      int idx;
 static int
 level_3 (idx, string, lhs)
      int idx;
@@ -736,9 +705,9 @@ level_3 (idx, string, lhs)
          lhs->value += rhs.value;
          if (lhs->add_symbol.name && rhs.add_symbol.name)
            {
          lhs->value += rhs.value;
          if (lhs->add_symbol.name && rhs.add_symbol.name)
            {
-             ERROR ((stderr, "can't add two relocatable expressions\n"));
+             ERROR ((stderr, _("can't add two relocatable expressions\n")));
            }
            }
-         /* change nn+symbol to symbol + nn */
+         /* Change nn+symbol to symbol + nn.  */
          if (rhs.add_symbol.name)
            {
              lhs->add_symbol = rhs.add_symbol;
          if (rhs.add_symbol.name)
            {
              lhs->add_symbol = rhs.add_symbol;
@@ -812,10 +781,9 @@ level_5 (idx, string, lhs)
   return sb_skip_white (idx, string);
 }
 
   return sb_skip_white (idx, string);
 }
 
-
-/* parse the expression at offset idx into string, fill up res with
-   the result. return the index of the first char past the expression.
-   */
+/* Parse the expression at offset idx into string, fill up res with
+   the result.  Return the index of the first char past the
+   expression.  */
 
 static int
 exp_parse (idx, string, res)
 
 static int
 exp_parse (idx, string, res)
@@ -826,9 +794,8 @@ exp_parse (idx, string, res)
   return level_5 (sb_skip_white (idx, string), string, res);
 }
 
   return level_5 (sb_skip_white (idx, string), string, res);
 }
 
-
-/* turn the expression at exp into text and glue it onto the end of
-   string. */
+/* Turn the expression at exp into text and glue it onto the end of
+   string.  */
 
 static void
 exp_string (exp, string)
 
 static void
 exp_string (exp, string)
@@ -867,10 +834,9 @@ exp_string (exp, string)
     sb_add_char (string, '0');
 }
 
     sb_add_char (string, '0');
 }
 
-
-/* parse the expression at offset idx into sb in, return the value in val.  
-   if the expression is not constant, give ERROR emsg.  returns the index
-   of the first character past the end of the expression. */
+/* Parse the expression at offset idx into sb in.  Return the value in
+   val.  If the expression is not constant, give ERROR emsg.  Return
+   the index of the first character past the end of the expression.  */
 
 static int
 exp_get_abs (emsg, idx, in, val)
 
 static int
 exp_get_abs (emsg, idx, in, val)
@@ -882,16 +848,22 @@ exp_get_abs (emsg, idx, in, val)
   exp_t res;
   idx = exp_parse (idx, in, &res);
   if (res.add_symbol.len || res.sub_symbol.len)
   exp_t res;
   idx = exp_parse (idx, in, &res);
   if (res.add_symbol.len || res.sub_symbol.len)
-    ERROR ((stderr, emsg));
+    ERROR ((stderr, "%s", emsg));
   *val = res.value;
   return idx;
 }
 
   *val = res.value;
   return idx;
 }
 
+/* Current label parsed from line.  */
+sb label;
+
+/* Hash table for all assigned variables.  */
+hash_table assign_hash_table;
+
+/* Hash table for keyword.  */
+hash_table keyword_hash_table;
 
 
-sb label; /* current label parsed from line */
-hash_table assign_hash_table;   /* hash table for all assigned variables */
-hash_table keyword_hash_table;  /* hash table for keyword */
-hash_table vars;  /* hash table for  eq variables */
+/* Hash table for eq variables.  */
+hash_table vars;
 
 #define in_comment ';'
 
 
 #define in_comment ';'
 
@@ -904,7 +876,7 @@ strip_comments (out)
   int i = 0;
   for (i = 0; i < out->len; i++)
     {
   int i = 0;
   for (i = 0; i < out->len; i++)
     {
-      if (ISCOMMENTCHAR(s[i]))
+      if (ISCOMMENTCHAR (s[i]))
        {
          out->len = i;
          return;
        {
          out->len = i;
          return;
@@ -913,7 +885,7 @@ strip_comments (out)
 }
 #endif
 
 }
 #endif
 
-/* push back character ch so that it can be read again. */
+/* Push back character ch so that it can be read again.  */
 
 static void
 unget (ch)
 
 static void
 unget (ch)
@@ -929,10 +901,10 @@ unget (ch)
     sb_add_char (&sp->pushback, ch);
 }
 
     sb_add_char (&sp->pushback, ch);
 }
 
-/* push the sb ptr onto the include stack, with the given name, type and index. */
+/* Push the sb ptr onto the include stack, with the given name, type
+   and index.  */
 
 
-static
-void
+static void
 include_buf (name, ptr, type, index)
      sb *name;
      sb *ptr;
 include_buf (name, ptr, type, index)
      sb *name;
      sb *ptr;
@@ -941,7 +913,7 @@ include_buf (name, ptr, type, index)
 {
   sp++;
   if (sp - include_stack >= MAX_INCLUDES)
 {
   sp++;
   if (sp - include_stack >= MAX_INCLUDES)
-    FATAL ((stderr, "unreasonable nesting.\n"));
+    FATAL ((stderr, _("unreasonable nesting.\n")));
   sb_new (&sp->name);
   sb_add_sb (&sp->name, name);
   sp->handle = 0;
   sb_new (&sp->name);
   sb_add_sb (&sp->name, name);
   sp->handle = 0;
@@ -953,10 +925,10 @@ include_buf (name, ptr, type, index)
   sb_add_sb (&sp->pushback, ptr);
 }
 
   sb_add_sb (&sp->pushback, ptr);
 }
 
+/* Used in ERROR messages, print info on where the include stack is
+   onto file.  */
 
 
-/* used in ERROR messages, print info on where the include stack is onto file. */
-static 
-void
+static void
 include_print_where_line (file)
      FILE *file;
 {
 include_print_where_line (file)
      FILE *file;
 {
@@ -969,7 +941,8 @@ include_print_where_line (file)
     }
 }
 
     }
 }
 
-/* used in listings, print the line number onto file. */
+/* Used in listings, print the line number onto file.  */
+
 static void
 include_print_line (file)
      FILE *file;
 static void
 include_print_line (file)
      FILE *file;
@@ -991,8 +964,7 @@ include_print_line (file)
     }
 }
 
     }
 }
 
-
-/* read a line from the top of the include stack into sb in. */
+/* Read a line from the top of the include stack into sb in.  */
 
 static int
 get_line (in)
 
 static int
 get_line (in)
@@ -1019,7 +991,7 @@ get_line (in)
        {
          if (online)
            {
        {
          if (online)
            {
-             WARNING ((stderr, "End of file not at start of line.\n"));
+             WARNING ((stderr, _("End of file not at start of line.\n")));
              if (copysource)
                putc ('\n', outfile);
              ch = '\n';
              if (copysource)
                putc ('\n', outfile);
              ch = '\n';
@@ -1040,7 +1012,7 @@ get_line (in)
          online = 0;
          if (ch == '+')
            {
          online = 0;
          if (ch == '+')
            {
-             /* continued line */
+             /* Continued line.  */
              if (copysource)
                {
                  putc (comment_char, outfile);
              if (copysource)
                {
                  putc (comment_char, outfile);
@@ -1065,7 +1037,7 @@ get_line (in)
   return more;
 }
 
   return more;
 }
 
-/* find a label from sb in and put it in out. */
+/* Find a label from sb in and put it in out.  */
 
 static int
 grab_label (in, out)
 
 static int
 grab_label (in, out)
@@ -1074,13 +1046,13 @@ grab_label (in, out)
 {
   int i = 0;
   sb_reset (out);
 {
   int i = 0;
   sb_reset (out);
-  if (ISFIRSTCHAR (in->ptr[i]))
+  if (ISFIRSTCHAR (in->ptr[i]) || in->ptr[i] == '\\')
     {
       sb_add_char (out, in->ptr[i]);
       i++;
     {
       sb_add_char (out, in->ptr[i]);
       i++;
-      while ((ISNEXTCHAR (in->ptr[i]) 
+      while ((ISNEXTCHAR (in->ptr[i])
              || in->ptr[i] == '\\'
              || in->ptr[i] == '\\'
-             || in->ptr[i] == '&') 
+             || in->ptr[i] == '&')
             && i < in->len)
        {
          sb_add_char (out, in->ptr[i]);
             && i < in->len)
        {
          sb_add_char (out, in->ptr[i]);
@@ -1090,8 +1062,8 @@ grab_label (in, out)
   return i;
 }
 
   return i;
 }
 
-/* find all strange base stuff and turn into decimal. also
-   find all the other numbers and convert them from the default radix */
+/* Find all strange base stuff and turn into decimal.  Also
+   find all the other numbers and convert them from the default radix */
 
 static void
 change_base (idx, in, out)
 
 static void
 change_base (idx, in, out)
@@ -1103,7 +1075,21 @@ change_base (idx, in, out)
 
   while (idx < in->len)
     {
 
   while (idx < in->len)
     {
-      if (idx < in->len - 1 && in->ptr[idx + 1] == '\'' && ! mri)
+      if (in->ptr[idx] == '\\'
+         && idx + 1 < in->len
+         && in->ptr[idx + 1] == '(')
+       {
+         idx += 2;
+         while (idx < in->len
+                && in->ptr[idx] != ')')
+           {
+             sb_add_char (out, in->ptr[idx]);
+             idx++;
+           }
+         if (idx < in->len)
+           idx++;
+       }
+      else if (idx < in->len - 1 && in->ptr[idx + 1] == '\'' && ! mri)
        {
          int base;
          int value;
        {
          int base;
          int value;
@@ -1126,7 +1112,7 @@ change_base (idx, in, out)
              base = 10;
              break;
            default:
              base = 10;
              break;
            default:
-             ERROR ((stderr, "Illegal base character %c.\n", in->ptr[idx]));
+             ERROR ((stderr, _("Illegal base character %c.\n"), in->ptr[idx]));
              base = 10;
              break;
            }
              base = 10;
              break;
            }
@@ -1137,7 +1123,7 @@ change_base (idx, in, out)
        }
       else if (ISFIRSTCHAR (in->ptr[idx]))
        {
        }
       else if (ISFIRSTCHAR (in->ptr[idx]))
        {
-         /* copy entire names through quickly */
+         /* Copy entire names through quickly.  */
          sb_add_char (out, in->ptr[idx]);
          idx++;
          while (idx < in->len && ISNEXTCHAR (in->ptr[idx]))
          sb_add_char (out, in->ptr[idx]);
          idx++;
          while (idx < in->len && ISNEXTCHAR (in->ptr[idx]))
@@ -1146,16 +1132,16 @@ change_base (idx, in, out)
              idx++;
            }
        }
              idx++;
            }
        }
-      else if (isdigit (in->ptr[idx]))
+      else if (ISDIGIT (in->ptr[idx]))
        {
          int value;
        {
          int value;
-         /* all numbers must start with a digit, let's chew it and
-            spit out decimal */
+         /* All numbers must start with a digit, let's chew it and
+            spit out decimal */
          idx = sb_strtol (idx, in, radix, &value);
          sprintf (buffer, "%d", value);
          sb_add_string (out, buffer);
 
          idx = sb_strtol (idx, in, radix, &value);
          sprintf (buffer, "%d", value);
          sb_add_string (out, buffer);
 
-         /* skip all undigsested letters */
+         /* Skip all undigsested letters.  */
          while (idx < in->len && ISNEXTCHAR (in->ptr[idx]))
            {
              sb_add_char (out, in->ptr[idx]);
          while (idx < in->len && ISNEXTCHAR (in->ptr[idx]))
            {
              sb_add_char (out, in->ptr[idx]);
@@ -1165,7 +1151,7 @@ change_base (idx, in, out)
       else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'')
        {
          char tchar = in->ptr[idx];
       else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'')
        {
          char tchar = in->ptr[idx];
-         /* copy entire names through quickly */
+         /* Copy entire names through quickly.  */
          sb_add_char (out, in->ptr[idx]);
          idx++;
          while (idx < in->len && in->ptr[idx] != tchar)
          sb_add_char (out, in->ptr[idx]);
          idx++;
          while (idx < in->len && in->ptr[idx] != tchar)
@@ -1176,7 +1162,7 @@ change_base (idx, in, out)
        }
       else
        {
        }
       else
        {
-         /* nothing special, just pass it through */
+         /* Nothing special, just pass it through.  */
          sb_add_char (out, in->ptr[idx]);
          idx++;
        }
          sb_add_char (out, in->ptr[idx]);
          idx++;
        }
@@ -1184,7 +1170,8 @@ change_base (idx, in, out)
 
 }
 
 
 }
 
-/* .end */
+/* .end  */
+
 static void
 do_end (in)
      sb *in;
 static void
 do_end (in)
      sb *in;
@@ -1194,7 +1181,7 @@ do_end (in)
     fprintf (outfile, "%s\n", sb_name (in));
 }
 
     fprintf (outfile, "%s\n", sb_name (in));
 }
 
-/* .assign */
+/* .assign  */
 
 static void
 do_assign (again, idx, in)
 
 static void
 do_assign (again, idx, in)
@@ -1202,7 +1189,7 @@ do_assign (again, idx, in)
      int idx;
      sb *in;
 {
      int idx;
      sb *in;
 {
-  /* stick label in symbol table with following value */
+  /* Stick label in symbol table with following value.  */
   exp_t e;
   sb acc;
 
   exp_t e;
   sb acc;
 
@@ -1213,11 +1200,9 @@ do_assign (again, idx, in)
   sb_kill (&acc);
 }
 
   sb_kill (&acc);
 }
 
+/* .radix [b|q|d|h]  */
 
 
-/* .radix [b|q|d|h] */
-
-static
-void
+static void
 do_radix (ptr)
      sb *ptr;
 {
 do_radix (ptr)
      sb *ptr;
 {
@@ -1241,12 +1226,11 @@ do_radix (ptr)
       radix = 16;
       break;
     default:
       radix = 16;
       break;
     default:
-      ERROR ((stderr, "radix is %c must be one of b, q, d or h", radix));
+      ERROR ((stderr, _("radix is %c must be one of b, q, d or h"), radix));
     }
 }
 
     }
 }
 
-
-/* Parse off a .b, .w or .l */
+/* Parse off a .b, .w or .l.  */
 
 static int
 get_opsize (idx, in, size)
 
 static int
 get_opsize (idx, in, size)
@@ -1277,7 +1261,7 @@ get_opsize (idx, in, size)
     case '\t':
       break;
     default:
     case '\t':
       break;
     default:
-      ERROR ((stderr, "size must be one of b, w or l, is %c.\n", in->ptr[idx]));
+      ERROR ((stderr, _("size must be one of b, w or l, is %c.\n"), in->ptr[idx]));
       break;
     }
   idx++;
       break;
     }
   idx++;
@@ -1285,13 +1269,13 @@ get_opsize (idx, in, size)
   return idx;
 }
 
   return idx;
 }
 
-static 
-int eol(idx, line)
+static int
+eol (idx, line)
      int idx;
      sb *line;
 {
   idx = sb_skip_white (idx, line);
      int idx;
      sb *line;
 {
   idx = sb_skip_white (idx, line);
-  if (idx < line->len 
+  if (idx < line->len
       && ISCOMMENTCHAR(line->ptr[idx]))
     return 1;
   if (idx >= line->len)
       && ISCOMMENTCHAR(line->ptr[idx]))
     return 1;
   if (idx >= line->len)
@@ -1299,8 +1283,8 @@ int eol(idx, line)
   return 0;
 }
 
   return 0;
 }
 
-/* .data [.b|.w|.l] <data>* 
-    or d[bwl] <data>* */
+/* .data [.b|.w|.l] <data>*
+    or d[bwl] <data>*  */
 
 static void
 do_data (idx, in, size)
 
 static void
 do_data (idx, in, size)
@@ -1313,13 +1297,14 @@ do_data (idx, in, size)
   sb acc;
   sb_new (&acc);
 
   sb acc;
   sb_new (&acc);
 
-  if (!size) 
+  if (!size)
     {
       idx = get_opsize (idx, in, &opsize);
     }
     {
       idx = get_opsize (idx, in, &opsize);
     }
-  else {
-    opsize = size;
-  }
+  else
+    {
+      opsize = size;
+    }
   switch (opsize)
     {
     case 4:
   switch (opsize)
     {
     case 4:
@@ -1333,13 +1318,12 @@ do_data (idx, in, size)
       break;
     }
 
       break;
     }
 
-
   fprintf (outfile, "%s\t", opname);
 
   fprintf (outfile, "%s\t", opname);
 
-  idx =   sb_skip_white (idx, in);
+  idx = sb_skip_white (idx, in);
 
 
-  if (alternate 
-      && idx < in->len 
+  if (alternate
+      && idx < in->len
       && in->ptr[idx] == '"')
     {
       int i;
       && in->ptr[idx] == '"')
     {
       int i;
@@ -1347,11 +1331,11 @@ do_data (idx, in, size)
       for (i = 0; i < acc.len; i++)
        {
          if (i)
       for (i = 0; i < acc.len; i++)
        {
          if (i)
-           fprintf(outfile,",");
+           fprintf (outfile, ",");
          fprintf (outfile, "%d", acc.ptr[i]);
        }
     }
          fprintf (outfile, "%d", acc.ptr[i]);
        }
     }
-  else 
+  else
     {
       while (!eol (idx, in))
        {
     {
       while (!eol (idx, in))
        {
@@ -1359,7 +1343,7 @@ do_data (idx, in, size)
          idx = exp_parse (idx, in, &e);
          exp_string (&e, &acc);
          sb_add_char (&acc, 0);
          idx = exp_parse (idx, in, &e);
          exp_string (&e, &acc);
          sb_add_char (&acc, 0);
-         fprintf (outfile, acc.ptr);
+         fprintf (outfile, "%s", acc.ptr);
          if (idx < in->len && in->ptr[idx] == ',')
            {
              fprintf (outfile, ",");
          if (idx < in->len && in->ptr[idx] == ',')
            {
              fprintf (outfile, ",");
@@ -1372,7 +1356,7 @@ do_data (idx, in, size)
   fprintf (outfile, "\n");
 }
 
   fprintf (outfile, "\n");
 }
 
-/* .datab [.b|.w|.l] <repeat>,<fill> */
+/* .datab [.b|.w|.l] <repeat>,<fill>  */
 
 static void
 do_datab (idx, in)
 
 static void
 do_datab (idx, in)
@@ -1385,32 +1369,41 @@ do_datab (idx, in)
 
   idx = get_opsize (idx, in, &opsize);
 
 
   idx = get_opsize (idx, in, &opsize);
 
-  idx = exp_get_abs ("datab repeat must be constant.\n", idx, in, &repeat);
+  idx = exp_get_abs (_("datab repeat must be constant.\n"), idx, in, &repeat);
   idx = sb_skip_comma (idx, in);
   idx = sb_skip_comma (idx, in);
-  idx = exp_get_abs ("datab data must be absolute.\n", idx, in, &fill);
+  idx = exp_get_abs (_("datab data must be absolute.\n"), idx, in, &fill);
 
   fprintf (outfile, ".fill\t%d,%d,%d\n", repeat, opsize, fill);
 }
 
 
   fprintf (outfile, ".fill\t%d,%d,%d\n", repeat, opsize, fill);
 }
 
-/* .align <size> */
+/* .align <size>  */
 
 static void
 do_align (idx, in)
      int idx;
      sb *in;
 {
 
 static void
 do_align (idx, in)
      int idx;
      sb *in;
 {
-  int al;
-  idx = exp_get_abs ("align needs absolute expression.\n", idx, in, &al);
+  int al, have_fill, fill;
 
 
-  if (al != 1
-      && al != 2
-      && al != 4)
-    WARNING ((stderr, "alignment must be one of 1, 2 or 4.\n"));
+  idx = exp_get_abs (_("align needs absolute expression.\n"), idx, in, &al);
+  idx = sb_skip_white (idx, in);
+  have_fill = 0;
+  fill = 0;
+  if (! eol (idx, in))
+    {
+      idx = sb_skip_comma (idx, in);
+      idx = exp_get_abs (_(".align needs absolute fill value.\n"), idx, in,
+                        &fill);
+      have_fill = 1;
+    }
 
 
-  fprintf (outfile, ".align    %d\n", al);
+  fprintf (outfile, ".align    %d", al);
+  if (have_fill)
+    fprintf (outfile, ",%d", fill);
+  fprintf (outfile, "\n");
 }
 
 }
 
-/* .res[.b|.w|.l] <size> */
+/* .res[.b|.w|.l] <size>  */
 
 static void
 do_res (idx, in, type)
 
 static void
 do_res (idx, in, type)
@@ -1422,12 +1415,12 @@ do_res (idx, in, type)
   int count = 0;
 
   idx = get_opsize (idx, in, &size);
   int count = 0;
 
   idx = get_opsize (idx, in, &size);
-  while (!eol(idx, in))
+  while (!eol (idx, in))
     {
       idx = sb_skip_white (idx, in);
       if (in->ptr[idx] == ',')
        idx++;
     {
       idx = sb_skip_white (idx, in);
       if (in->ptr[idx] == ',')
        idx++;
-      idx = exp_get_abs ("res needs absolute expression for fill count.\n", idx, in, &count);
+      idx = exp_get_abs (_("res needs absolute expression for fill count.\n"), idx, in, &count);
 
       if (type == 'c' || type == 'z')
        count++;
 
       if (type == 'c' || type == 'z')
        count++;
@@ -1436,8 +1429,7 @@ do_res (idx, in, type)
     }
 }
 
     }
 }
 
-
-/* .export */
+/* .export  */
 
 static void
 do_export (in)
 
 static void
 do_export (in)
@@ -1446,7 +1438,7 @@ do_export (in)
   fprintf (outfile, ".global   %s\n", sb_name (in));
 }
 
   fprintf (outfile, ".global   %s\n", sb_name (in));
 }
 
-/* .print [list] [nolist] */
+/* .print [list] [nolist]  */
 
 static void
 do_print (idx, in)
 
 static void
 do_print (idx, in)
@@ -1470,7 +1462,8 @@ do_print (idx, in)
     }
 }
 
     }
 }
 
-/* .head */
+/* .head  */
+
 static void
 do_heading (idx, in)
      int idx;
 static void
 do_heading (idx, in)
      int idx;
@@ -1483,7 +1476,7 @@ do_heading (idx, in)
   sb_kill (&head);
 }
 
   sb_kill (&head);
 }
 
-/* .page */
+/* .page  */
 
 static void
 do_page ()
 
 static void
 do_page ()
@@ -1491,7 +1484,8 @@ do_page ()
   fprintf (outfile, ".eject\n");
 }
 
   fprintf (outfile, ".eject\n");
 }
 
-/* .form [lin=<value>] [col=<value>] */
+/* .form [lin=<value>] [col=<value>]  */
+
 static void
 do_form (idx, in)
      int idx;
 static void
 do_form (idx, in)
      int idx;
@@ -1507,13 +1501,13 @@ do_form (idx, in)
       if (strncasecmp (in->ptr + idx, "LIN=", 4) == 0)
        {
          idx += 4;
       if (strncasecmp (in->ptr + idx, "LIN=", 4) == 0)
        {
          idx += 4;
-         idx = exp_get_abs ("form LIN= needs absolute expresssion.\n", idx, in, &lines);
+         idx = exp_get_abs (_("form LIN= needs absolute expresssion.\n"), idx, in, &lines);
        }
 
        }
 
-      if (strncasecmp (in->ptr + idx, "COL=", 4) == 0)
+      if (strncasecmp (in->ptr + idx, _("COL="), 4) == 0)
        {
          idx += 4;
        {
          idx += 4;
-         idx = exp_get_abs ("form COL= needs absolute expresssion.\n", idx, in, &columns);
+         idx = exp_get_abs (_("form COL= needs absolute expresssion.\n"), idx, in, &columns);
        }
 
       idx++;
        }
 
       idx++;
@@ -1522,7 +1516,6 @@ do_form (idx, in)
 
 }
 
 
 }
 
-
 /* Fetch string from the input stream,
    rules:
     'Bxyx<whitespace>          -> return 'Bxyza
 /* Fetch string from the input stream,
    rules:
     'Bxyx<whitespace>          -> return 'Bxyza
@@ -1530,6 +1523,7 @@ do_form (idx, in)
     "<string>"         -> return string
     xyx<whitespace>     -> return xyz
 */
     "<string>"         -> return string
     xyx<whitespace>     -> return xyz
 */
+
 static int
 get_any_string (idx, in, out, expand, pretend_quoted)
      int idx;
 static int
 get_any_string (idx, in, out, expand, pretend_quoted)
      int idx;
@@ -1543,7 +1537,7 @@ get_any_string (idx, in, out, expand, pretend_quoted)
 
   if (idx < in->len)
     {
 
   if (idx < in->len)
     {
-      if (in->len > 2 && in->ptr[idx+1] == '\'' && ISBASE (in->ptr[idx]))
+      if (in->len > 2 && in->ptr[idx + 1] == '\'' && ISBASE (in->ptr[idx]))
        {
          while (!ISSEP (in->ptr[idx]))
            sb_add_char (out, in->ptr[idx++]);
        {
          while (!ISSEP (in->ptr[idx]))
            sb_add_char (out, in->ptr[idx++]);
@@ -1554,12 +1548,12 @@ get_any_string (idx, in, out, expand, pretend_quoted)
        {
          int val;
          char buf[20];
        {
          int val;
          char buf[20];
-         /* Turns the next expression into a string */
-         idx = exp_get_abs ("% operator needs absolute expression",
+         /* Turns the next expression into a string */
+         idx = exp_get_abs (_("% operator needs absolute expression"),
                             idx + 1,
                             in,
                             &val);
                             idx + 1,
                             in,
                             &val);
-         sprintf(buf, "%d", val);
+         sprintf (buf, "%d", val);
          sb_add_string (out, buf);
        }
       else if (in->ptr[idx] == '"'
          sb_add_string (out, buf);
        }
       else if (in->ptr[idx] == '"'
@@ -1568,35 +1562,36 @@ get_any_string (idx, in, out, expand, pretend_quoted)
        {
          if (alternate && expand)
            {
        {
          if (alternate && expand)
            {
-             /* Keep the quotes */
-             sb_add_char (out,  '\"');
-                   
-             idx =  getstring (idx, in, out);
-             sb_add_char (out,  '\"');
+             /* Keep the quotes */
+             sb_add_char (out, '\"');
+
+             idx = getstring (idx, in, out);
+             sb_add_char (out, '\"');
 
            }
 
            }
-         else {
-           idx = getstring (idx, in, out);
-         }
+         else
+           {
+             idx = getstring (idx, in, out);
+           }
        }
        }
-      else 
+      else
        {
        {
-         while (idx < in->len 
+         while (idx < in->len
                 && (in->ptr[idx] == '"'
                     || in->ptr[idx] == '\''
                 && (in->ptr[idx] == '"'
                     || in->ptr[idx] == '\''
-                    || pretend_quoted 
+                    || pretend_quoted
                     || !ISSEP (in->ptr[idx])))
            {
                     || !ISSEP (in->ptr[idx])))
            {
-             if (in->ptr[idx] == '"' 
+             if (in->ptr[idx] == '"'
                  || in->ptr[idx] == '\'')
                {
                  char tchar = in->ptr[idx];
                  sb_add_char (out, in->ptr[idx++]);
                  while (idx < in->len
                         && in->ptr[idx] != tchar)
                  || in->ptr[idx] == '\'')
                {
                  char tchar = in->ptr[idx];
                  sb_add_char (out, in->ptr[idx++]);
                  while (idx < in->len
                         && in->ptr[idx] != tchar)
-                   sb_add_char (out, in->ptr[idx++]);              
+                   sb_add_char (out, in->ptr[idx++]);
                  if (idx == in->len)
                  if (idx == in->len)
-                   return idx;       
+                   return idx;
                }
              sb_add_char (out, in->ptr[idx++]);
            }
                }
              sb_add_char (out, in->ptr[idx++]);
            }
@@ -1606,9 +1601,8 @@ get_any_string (idx, in, out, expand, pretend_quoted)
   return idx;
 }
 
   return idx;
 }
 
-
-/* skip along sb in starting at idx, suck off whitespace a ( and more
-   whitespace.  return the idx of the next char */
+/* Skip along sb in starting at idx, suck off whitespace a ( and more
+   whitespace.  Return the idx of the next char.  */
 
 static int
 skip_openp (idx, in)
 
 static int
 skip_openp (idx, in)
@@ -1617,13 +1611,13 @@ skip_openp (idx, in)
 {
   idx = sb_skip_white (idx, in);
   if (in->ptr[idx] != '(')
 {
   idx = sb_skip_white (idx, in);
   if (in->ptr[idx] != '(')
-    ERROR ((stderr, "misplaced ( .\n"));
+    ERROR ((stderr, _("misplaced ( .\n")));
   idx = sb_skip_white (idx + 1, in);
   return idx;
 }
 
   idx = sb_skip_white (idx + 1, in);
   return idx;
 }
 
-/* skip along sb in starting at idx, suck off whitespace a ) and more
-   whitespace.  return the idx of the next char */
+/* Skip along sb in starting at idx, suck off whitespace a ) and more
+   whitespace.  Return the idx of the next char.  */
 
 static int
 skip_closep (idx, in)
 
 static int
 skip_closep (idx, in)
@@ -1632,12 +1626,12 @@ skip_closep (idx, in)
 {
   idx = sb_skip_white (idx, in);
   if (in->ptr[idx] != ')')
 {
   idx = sb_skip_white (idx, in);
   if (in->ptr[idx] != ')')
-    ERROR ((stderr, "misplaced ).\n"));
+    ERROR ((stderr, _("misplaced ).\n")));
   idx = sb_skip_white (idx + 1, in);
   return idx;
 }
 
   idx = sb_skip_white (idx + 1, in);
   return idx;
 }
 
-/* .len */
+/* .len  */
 
 static int
 dolen (idx, in, out)
 
 static int
 dolen (idx, in, out)
@@ -1660,11 +1654,9 @@ dolen (idx, in, out)
   return idx;
 }
 
   return idx;
 }
 
+/* .instr  */
 
 
-/* .instr */
-
-static
-int
+static int
 doinstr (idx, in, out)
      int idx;
      sb *in;
 doinstr (idx, in, out)
      int idx;
      sb *in;
@@ -1684,9 +1676,9 @@ doinstr (idx, in, out)
   idx = sb_skip_comma (idx, in);
   idx = get_and_process (idx, in, &search);
   idx = sb_skip_comma (idx, in);
   idx = sb_skip_comma (idx, in);
   idx = get_and_process (idx, in, &search);
   idx = sb_skip_comma (idx, in);
-  if (isdigit (in->ptr[idx]))
+  if (ISDIGIT (in->ptr[idx]))
     {
     {
-      idx = exp_get_abs (".instr needs absolute expresson.\n", idx, in, &start);
+      idx = exp_get_abs (_(".instr needs absolute expresson.\n"), idx, in, &start);
     }
   else
     {
     }
   else
     {
@@ -1709,7 +1701,6 @@ doinstr (idx, in, out)
   return idx;
 }
 
   return idx;
 }
 
-
 static int
 dosubstr (idx, in, out)
      int idx;
 static int
 dosubstr (idx, in, out)
      int idx;
@@ -1724,19 +1715,18 @@ dosubstr (idx, in, out)
   idx = skip_openp (idx, in);
   idx = get_and_process (idx, in, &string);
   idx = sb_skip_comma (idx, in);
   idx = skip_openp (idx, in);
   idx = get_and_process (idx, in, &string);
   idx = sb_skip_comma (idx, in);
-  idx = exp_get_abs ("need absolute position.\n", idx, in, &pos);
+  idx = exp_get_abs (_("need absolute position.\n"), idx, in, &pos);
   idx = sb_skip_comma (idx, in);
   idx = sb_skip_comma (idx, in);
-  idx = exp_get_abs ("need absolute length.\n", idx, in, &len);
+  idx = exp_get_abs (_("need absolute length.\n"), idx, in, &len);
   idx = skip_closep (idx, in);
 
   idx = skip_closep (idx, in);
 
-
   if (len < 0 || pos < 0 ||
       pos > string.len
       || pos + len > string.len)
     {
       sb_add_string (out, " ");
     }
   if (len < 0 || pos < 0 ||
       pos > string.len
       || pos + len > string.len)
     {
       sb_add_string (out, " ");
     }
-  else 
+  else
     {
       sb_add_char (out, '"');
       while (len > 0)
     {
       sb_add_char (out, '"');
       while (len > 0)
@@ -1746,11 +1736,12 @@ dosubstr (idx, in, out)
        }
       sb_add_char (out, '"');
     }
        }
       sb_add_char (out, '"');
     }
-  sb_kill(&string);
+  sb_kill (&string);
   return idx;
 }
 
   return idx;
 }
 
-/* scan line, change tokens in the hash table to their replacements */
+/* Scan line, change tokens in the hash table to their replacements.  */
+
 static void
 process_assigns (idx, in, buf)
      int idx;
 static void
 process_assigns (idx, in, buf)
      int idx;
@@ -1761,41 +1752,54 @@ process_assigns (idx, in, buf)
     {
       hash_entry *ptr;
       if (in->ptr[idx] == '\\'
     {
       hash_entry *ptr;
       if (in->ptr[idx] == '\\'
+         && idx + 1 < in->len
+         && in->ptr[idx + 1] == '(')
+       {
+         do
+           {
+             sb_add_char (buf, in->ptr[idx]);
+             idx++;
+           }
+         while (idx < in->len && in->ptr[idx - 1] != ')');
+       }
+      else if (in->ptr[idx] == '\\'
+         && idx + 1 < in->len
          && in->ptr[idx + 1] == '&')
        {
          idx = condass_lookup_name (in, idx + 2, buf, 1);
        }
       else if (in->ptr[idx] == '\\'
          && in->ptr[idx + 1] == '&')
        {
          idx = condass_lookup_name (in, idx + 2, buf, 1);
        }
       else if (in->ptr[idx] == '\\'
+              && idx + 1 < in->len
               && in->ptr[idx + 1] == '$')
        {
          idx = condass_lookup_name (in, idx + 2, buf, 0);
        }
       else if (idx + 3 < in->len
               && in->ptr[idx] == '.'
               && in->ptr[idx + 1] == '$')
        {
          idx = condass_lookup_name (in, idx + 2, buf, 0);
        }
       else if (idx + 3 < in->len
               && in->ptr[idx] == '.'
-              && toupper ((unsigned char) in->ptr[idx + 1]) == 'L'
-              && toupper ((unsigned char) in->ptr[idx + 2]) == 'E'
-              && toupper ((unsigned char) in->ptr[idx + 3]) == 'N')
+              && TOUPPER (in->ptr[idx + 1]) == 'L'
+              && TOUPPER (in->ptr[idx + 2]) == 'E'
+              && TOUPPER (in->ptr[idx + 3]) == 'N')
        idx = dolen (idx + 4, in, buf);
       else if (idx + 6 < in->len
               && in->ptr[idx] == '.'
        idx = dolen (idx + 4, in, buf);
       else if (idx + 6 < in->len
               && in->ptr[idx] == '.'
-              && toupper ((unsigned char) in->ptr[idx + 1]) == 'I'
-              && toupper ((unsigned char) in->ptr[idx + 2]) == 'N'
-              && toupper ((unsigned char) in->ptr[idx + 3]) == 'S'
-              && toupper ((unsigned char) in->ptr[idx + 4]) == 'T'
-              && toupper ((unsigned char) in->ptr[idx + 5]) == 'R')
+              && TOUPPER (in->ptr[idx + 1]) == 'I'
+              && TOUPPER (in->ptr[idx + 2]) == 'N'
+              && TOUPPER (in->ptr[idx + 3]) == 'S'
+              && TOUPPER (in->ptr[idx + 4]) == 'T'
+              && TOUPPER (in->ptr[idx + 5]) == 'R')
        idx = doinstr (idx + 6, in, buf);
       else if (idx + 7 < in->len
               && in->ptr[idx] == '.'
        idx = doinstr (idx + 6, in, buf);
       else if (idx + 7 < in->len
               && in->ptr[idx] == '.'
-              && toupper ((unsigned char) in->ptr[idx + 1]) == 'S'
-              && toupper ((unsigned char) in->ptr[idx + 2]) == 'U'
-              && toupper ((unsigned char) in->ptr[idx + 3]) == 'B'
-              && toupper ((unsigned char) in->ptr[idx + 4]) == 'S'
-              && toupper ((unsigned char) in->ptr[idx + 5]) == 'T'
-              && toupper ((unsigned char) in->ptr[idx + 6]) == 'R')
+              && TOUPPER (in->ptr[idx + 1]) == 'S'
+              && TOUPPER (in->ptr[idx + 2]) == 'U'
+              && TOUPPER (in->ptr[idx + 3]) == 'B'
+              && TOUPPER (in->ptr[idx + 4]) == 'S'
+              && TOUPPER (in->ptr[idx + 5]) == 'T'
+              && TOUPPER (in->ptr[idx + 6]) == 'R')
        idx = dosubstr (idx + 7, in, buf);
       else if (ISFIRSTCHAR (in->ptr[idx]))
        {
        idx = dosubstr (idx + 7, in, buf);
       else if (ISFIRSTCHAR (in->ptr[idx]))
        {
-         /* may be a simple name subsitution, see if we have a word */
+         /* May be a simple name subsitution, see if we have a word.  */
          sb acc;
          int cur = idx + 1;
          while (cur < in->len
          sb acc;
          int cur = idx + 1;
          while (cur < in->len
@@ -1807,12 +1811,12 @@ process_assigns (idx, in, buf)
          ptr = hash_lookup (&assign_hash_table, &acc);
          if (ptr)
            {
          ptr = hash_lookup (&assign_hash_table, &acc);
          if (ptr)
            {
-             /* Found a definition for it */
+             /* Found a definition for it */
              sb_add_sb (buf, &ptr->value.s);
            }
          else
            {
              sb_add_sb (buf, &ptr->value.s);
            }
          else
            {
-             /* No definition, just copy the word */
+             /* No definition, just copy the word */
              sb_add_sb (buf, &acc);
            }
          sb_kill (&acc);
              sb_add_sb (buf, &acc);
            }
          sb_kill (&acc);
@@ -1839,8 +1843,7 @@ get_and_process (idx, in, out)
   return idx;
 }
 
   return idx;
 }
 
-static
-void
+static void
 process_file ()
 {
   sb line;
 process_file ()
 {
   sb line;
@@ -1852,13 +1855,13 @@ process_file ()
   sb_new (&line);
   sb_new (&t1);
   sb_new (&t2);
   sb_new (&line);
   sb_new (&t1);
   sb_new (&t2);
-  sb_new(&acc);
+  sb_new (&acc);
   sb_new (&label_in);
   sb_reset (&line);
   more = get_line (&line);
   while (more)
     {
   sb_new (&label_in);
   sb_reset (&line);
   more = get_line (&line);
   while (more)
     {
-      /* Find any label and pseudo op that we're intested in */
+      /* Find any label and pseudo op that we're intested in */
       int l;
       if (line.len == 0)
        {
       int l;
       if (line.len == 0)
        {
@@ -1870,31 +1873,53 @@ process_file ()
                   || line.ptr[0] == '!'))
        {
          /* MRI line comment.  */
                   || line.ptr[0] == '!'))
        {
          /* MRI line comment.  */
-         fprintf (outfile, sb_name (&line));
+         fprintf (outfile, "%s", sb_name (&line));
        }
       else
        {
          l = grab_label (&line, &label_in);
        }
       else
        {
          l = grab_label (&line, &label_in);
-         sb_reset (&label);              
-         if (label_in.len)
-           {
-             /* Munge any label */
-
-             
-             process_assigns (0, &label_in, &label);
-           }
+         sb_reset (&label);
 
          if (line.ptr[l] == ':')
            l++;
          while (ISWHITE (line.ptr[l]) && l < line.len)
            l++;
 
 
          if (line.ptr[l] == ':')
            l++;
          while (ISWHITE (line.ptr[l]) && l < line.len)
            l++;
 
-         if (l < line.len)
+         if (label_in.len)
            {
            {
-             if (process_pseudo_op (l, &line, &acc))
+             int do_assigns;
+
+             /* Munge the label, unless this is EQU or ASSIGN.  */
+             do_assigns = 1;
+             if (l < line.len
+                 && (line.ptr[l] == '.' || alternate || mri))
                {
                {
+                 int lx = l;
+
+                 if (line.ptr[lx] == '.')
+                   ++lx;
+                 if (lx + 3 <= line.len
+                     && strncasecmp ("EQU", line.ptr + lx, 3) == 0
+                     && (lx + 3 == line.len
+                         || ! ISFIRSTCHAR (line.ptr[lx + 3])))
+                   do_assigns = 0;
+                 else if (lx + 6 <= line.len
+                          && strncasecmp ("ASSIGN", line.ptr + lx, 6) == 0
+                          && (lx + 6 == line.len
+                              || ! ISFIRSTCHAR (line.ptr[lx + 6])))
+                   do_assigns = 0;
+               }
 
 
+             if (do_assigns)
+               process_assigns (0, &label_in, &label);
+             else
+               sb_add_sb (&label, &label_in);
+           }
 
 
+         if (l < line.len)
+           {
+             if (process_pseudo_op (l, &line, &acc))
+               {
 
                }
              else if (condass_on ())
 
                }
              else if (condass_on ())
@@ -1902,7 +1927,6 @@ process_file ()
                  if (macro_op (l, &line))
                    {
 
                  if (macro_op (l, &line))
                    {
 
-
                    }
                  else
                    {
                    }
                  else
                    {
@@ -1913,7 +1937,7 @@ process_file ()
                          }
                        else
                          fprintf (outfile, "\t");
                          }
                        else
                          fprintf (outfile, "\t");
-                       sb_reset(&t1);
+                       sb_reset (&t1);
                        process_assigns (l, &line, &t1);
                        sb_reset (&t2);
                        change_base (0, &t1, &t2);
                        process_assigns (l, &line, &t1);
                        sb_reset (&t2);
                        change_base (0, &t1, &t2);
@@ -1922,13 +1946,14 @@ process_file ()
                    }
                }
            }
                    }
                }
            }
-         else {
-           /* Only a label on this line */
-           if (label.len && condass_on())
-             {
-               fprintf (outfile, "%s:\n", sb_name (&label));
-             }
-         }
+         else
+           {
+             /* Only a label on this line.  */
+             if (label.len && condass_on ())
+               {
+                 fprintf (outfile, "%s:\n", sb_name (&label));
+               }
+           }
        }
 
       if (had_end)
        }
 
       if (had_end)
@@ -1938,13 +1963,9 @@ process_file ()
     }
 
   if (!had_end && !mri)
     }
 
   if (!had_end && !mri)
-    WARNING ((stderr, "END missing from end of file.\n"));
+    WARNING ((stderr, _("END missing from end of file.\n")));
 }
 
 }
 
-
-
-
-
 static void
 free_old_entry (ptr)
      hash_entry *ptr;
 static void
 free_old_entry (ptr)
      hash_entry *ptr;
@@ -1952,11 +1973,11 @@ free_old_entry (ptr)
   if (ptr)
     {
       if (ptr->type == hash_string)
   if (ptr)
     {
       if (ptr->type == hash_string)
-       sb_kill(&ptr->value.s);
+       sb_kill (&ptr->value.s);
     }
 }
 
     }
 }
 
-/* name: .ASSIGNA <value> */
+/* name: .ASSIGNA <value>  */
 
 static void
 do_assigna (idx, in)
 
 static void
 do_assigna (idx, in)
@@ -1968,11 +1989,11 @@ do_assigna (idx, in)
   sb_new (&tmp);
 
   process_assigns (idx, in, &tmp);
   sb_new (&tmp);
 
   process_assigns (idx, in, &tmp);
-  idx = exp_get_abs (".ASSIGNA needs constant expression argument.\n", 0, &tmp, &val);
+  idx = exp_get_abs (_(".ASSIGNA needs constant expression argument.\n"), 0, &tmp, &val);
 
   if (!label.len)
     {
 
   if (!label.len)
     {
-      ERROR ((stderr, ".ASSIGNA without label.\n"));
+      ERROR ((stderr, _(".ASSIGNA without label.\n")));
     }
   else
     {
     }
   else
     {
@@ -1984,7 +2005,7 @@ do_assigna (idx, in)
   sb_kill (&tmp);
 }
 
   sb_kill (&tmp);
 }
 
-/* name: .ASSIGNC <string> */
+/* name: .ASSIGNC <string>  */
 
 static void
 do_assignc (idx, in)
 
 static void
 do_assignc (idx, in)
@@ -1997,7 +2018,7 @@ do_assignc (idx, in)
 
   if (!label.len)
     {
 
   if (!label.len)
     {
-      ERROR ((stderr, ".ASSIGNS without label.\n"));
+      ERROR ((stderr, _(".ASSIGNS without label.\n")));
     }
   else
     {
     }
   else
     {
@@ -2010,15 +2031,14 @@ do_assignc (idx, in)
   sb_kill (&acc);
 }
 
   sb_kill (&acc);
 }
 
-
-/* name: .REG (reg) */
+/* name: .REG (reg)  */
 
 static void
 do_reg (idx, in)
      int idx;
      sb *in;
 {
 
 static void
 do_reg (idx, in)
      int idx;
      sb *in;
 {
-  /* remove reg stuff from inside parens */
+  /* Remove reg stuff from inside parens.  */
   sb what;
   if (!mri)
     idx = skip_openp (idx, in);
   sb what;
   if (!mri)
     idx = skip_openp (idx, in);
@@ -2037,7 +2057,6 @@ do_reg (idx, in)
   sb_kill (&what);
 }
 
   sb_kill (&what);
 }
 
-
 static int
 condass_lookup_name (inbuf, idx, out, warn)
      sb *inbuf;
 static int
 condass_lookup_name (inbuf, idx, out, warn)
      sb *inbuf;
@@ -2059,14 +2078,13 @@ condass_lookup_name (inbuf, idx, out, warn)
     idx++;
   ptr = hash_lookup (&vars, &condass_acc);
 
     idx++;
   ptr = hash_lookup (&vars, &condass_acc);
 
-
   if (!ptr)
     {
   if (!ptr)
     {
-      if (warn) 
+      if (warn)
        {
        {
-         WARNING ((stderr, "Can't find preprocessor variable %s.\n", sb_name (&condass_acc)));
+         WARNING ((stderr, _("Can't find preprocessor variable %s.\n"), sb_name (&condass_acc)));
        }
        }
-      else 
+      else
        {
          sb_add_string (out, "0");
        }
        {
          sb_add_string (out, "0");
        }
@@ -2112,8 +2130,8 @@ whatcond (idx, in, val)
       char a, b;
 
       p = in->ptr + idx;
       char a, b;
 
       p = in->ptr + idx;
-      a = toupper ((unsigned char) p[0]);
-      b = toupper ((unsigned char) p[1]);
+      a = TOUPPER (p[0]);
+      b = TOUPPER (p[1]);
       if (a == 'E' && b == 'Q')
        cond = EQ;
       else if (a == 'N' && b == 'E')
       if (a == 'E' && b == 'Q')
        cond = EQ;
       else if (a == 'N' && b == 'E')
@@ -2129,7 +2147,7 @@ whatcond (idx, in, val)
     }
   if (cond == NEVER)
     {
     }
   if (cond == NEVER)
     {
-      ERROR ((stderr, "Comparison operator must be one of EQ, NE, LT, LE, GT or GE.\n"));
+      ERROR ((stderr, _("Comparison operator must be one of EQ, NE, LT, LE, GT or GE.\n")));
       cond = NEVER;
     }
   idx = sb_skip_white (idx + 2, in);
       cond = NEVER;
     }
   idx = sb_skip_white (idx + 2, in);
@@ -2155,37 +2173,38 @@ istrue (idx, in)
     {
       int cond;
       int same;
     {
       int cond;
       int same;
-      /* This is a string comparision */
+      /* This is a string comparision */
       idx = getstring (idx, in, &acc_a);
       idx = whatcond (idx, in, &cond);
       idx = getstring (idx, in, &acc_b);
       idx = getstring (idx, in, &acc_a);
       idx = whatcond (idx, in, &cond);
       idx = getstring (idx, in, &acc_b);
-      same = acc_a.len == acc_b.len && (strncmp (acc_a.ptr, acc_b.ptr, acc_a.len) == 0);
+      same = acc_a.len == acc_b.len
+       && (strncmp (acc_a.ptr, acc_b.ptr, acc_a.len) == 0);
 
       if (cond != EQ && cond != NE)
        {
 
       if (cond != EQ && cond != NE)
        {
-         ERROR ((stderr, "Comparison operator for strings must be EQ or NE\n"));
+         ERROR ((stderr, _("Comparison operator for strings must be EQ or NE\n")));
          res = 0;
        }
       else
        res = (cond != EQ) ^ same;
     }
   else
          res = 0;
        }
       else
        res = (cond != EQ) ^ same;
     }
   else
-    /* This is a numeric expression */
+    /* This is a numeric expression */
     {
       int vala;
       int valb;
       int cond;
     {
       int vala;
       int valb;
       int cond;
-      idx = exp_get_abs ("Conditional operator must have absolute operands.\n", idx, in, &vala);
+      idx = exp_get_abs (_("Conditional operator must have absolute operands.\n"), idx, in, &vala);
       idx = whatcond (idx, in, &cond);
       idx = sb_skip_white (idx, in);
       if (in->ptr[idx] == '"')
        {
       idx = whatcond (idx, in, &cond);
       idx = sb_skip_white (idx, in);
       if (in->ptr[idx] == '"')
        {
-         WARNING ((stderr, "String compared against expression.\n"));
+         WARNING ((stderr, _("String compared against expression.\n")));
          res = 0;
        }
       else
        {
          res = 0;
        }
       else
        {
-         idx = exp_get_abs ("Conditional operator must have absolute operands.\n", idx, in, &valb);
+         idx = exp_get_abs (_("Conditional operator must have absolute operands.\n"), idx, in, &valb);
          switch (cond)
            {
            default:
          switch (cond)
            {
            default:
@@ -2222,7 +2241,8 @@ istrue (idx, in)
   return res;
 }
 
   return res;
 }
 
-/* .AIF */
+/* .AIF  */
+
 static void
 do_aif (idx, in)
      int idx;
 static void
 do_aif (idx, in)
      int idx;
@@ -2230,28 +2250,28 @@ do_aif (idx, in)
 {
   if (ifi >= IFNESTING)
     {
 {
   if (ifi >= IFNESTING)
     {
-      FATAL ((stderr, "AIF nesting unreasonable.\n"));
+      FATAL ((stderr, _("AIF nesting unreasonable.\n")));
     }
   ifi++;
     }
   ifi++;
-  ifstack[ifi].on = ifstack[ifi-1].on ? istrue (idx, in) : 0;
+  ifstack[ifi].on = ifstack[ifi - 1].on ? istrue (idx, in) : 0;
   ifstack[ifi].hadelse = 0;
 }
 
   ifstack[ifi].hadelse = 0;
 }
 
+/* .AELSE  */
 
 
-/* .AELSE */
 static void
 do_aelse ()
 {
 static void
 do_aelse ()
 {
-  ifstack[ifi].on = ifstack[ifi-1].on ? !ifstack[ifi].on : 0;
+  ifstack[ifi].on = ifstack[ifi - 1].on ? !ifstack[ifi].on : 0;
   if (ifstack[ifi].hadelse)
     {
   if (ifstack[ifi].hadelse)
     {
-      ERROR ((stderr, "Multiple AELSEs in AIF.\n"));
+      ERROR ((stderr, _("Multiple AELSEs in AIF.\n")));
     }
   ifstack[ifi].hadelse = 1;
 }
 
     }
   ifstack[ifi].hadelse = 1;
 }
 
+/* .AENDI  */
 
 
-/* .AENDI */
 static void
 do_aendi ()
 {
 static void
 do_aendi ()
 {
@@ -2261,7 +2281,7 @@ do_aendi ()
     }
   else
     {
     }
   else
     {
-      ERROR ((stderr, "AENDI without AIF.\n"));
+      ERROR ((stderr, _("AENDI without AIF.\n")));
     }
 }
 
     }
 }
 
@@ -2284,10 +2304,10 @@ do_if (idx, in, cond)
 
   if (ifi >= IFNESTING)
     {
 
   if (ifi >= IFNESTING)
     {
-      FATAL ((stderr, "IF nesting unreasonable.\n"));
+      FATAL ((stderr, _("IF nesting unreasonable.\n")));
     }
 
     }
 
-  idx = exp_get_abs ("Conditional operator must have absolute operands.\n",
+  idx = exp_get_abs (_("Conditional operator must have absolute operands.\n"),
                     idx, in, &val);
   switch (cond)
     {
                     idx, in, &val);
   switch (cond)
     {
@@ -2301,7 +2321,7 @@ do_if (idx, in, cond)
     }
 
   ifi++;
     }
 
   ifi++;
-  ifstack[ifi].on = ifstack[ifi-1].on ? res: 0;
+  ifstack[ifi].on = ifstack[ifi - 1].on ? res : 0;
   ifstack[ifi].hadelse = 0;
 }
 
   ifstack[ifi].hadelse = 0;
 }
 
@@ -2352,7 +2372,7 @@ get_mri_string (idx, in, val, terminator)
   return idx;
 }
 
   return idx;
 }
 
-/* MRI IFC, IFNC.  */
+/* MRI IFC, IFNC  */
 
 static void
 do_ifc (idx, in, ifnc)
 
 static void
 do_ifc (idx, in, ifnc)
@@ -2366,7 +2386,7 @@ do_ifc (idx, in, ifnc)
 
   if (ifi >= IFNESTING)
     {
 
   if (ifi >= IFNESTING)
     {
-      FATAL ((stderr, "IF nesting unreasonable.\n"));
+      FATAL ((stderr, _("IF nesting unreasonable.\n")));
     }
 
   sb_new (&first);
     }
 
   sb_new (&first);
@@ -2376,7 +2396,7 @@ do_ifc (idx, in, ifnc)
 
   if (idx >= in->len || in->ptr[idx] != ',')
     {
 
   if (idx >= in->len || in->ptr[idx] != ',')
     {
-      ERROR ((stderr, "Bad format for IF or IFNC.\n"));
+      ERROR ((stderr, _("Bad format for IF or IFNC.\n")));
       return;
     }
 
       return;
     }
 
@@ -2387,24 +2407,24 @@ do_ifc (idx, in, ifnc)
   res ^= ifnc;
 
   ifi++;
   res ^= ifnc;
 
   ifi++;
-  ifstack[ifi].on = ifstack[ifi-1].on ? res : 0;
+  ifstack[ifi].on = ifstack[ifi - 1].on ? res : 0;
   ifstack[ifi].hadelse = 0;
 }
 
   ifstack[ifi].hadelse = 0;
 }
 
-/* .ENDR */
+/* .ENDR  */
+
 static void
 do_aendr ()
 {
   if (!mri)
 static void
 do_aendr ()
 {
   if (!mri)
-    ERROR ((stderr, "AENDR without a AREPEAT.\n"));
+    ERROR ((stderr, _("AENDR without a AREPEAT.\n")));
   else
   else
-    ERROR ((stderr, "ENDR without a REPT.\n"));
+    ERROR ((stderr, _("ENDR without a REPT.\n")));
 }
 
 }
 
-/* .AWHILE */
+/* .AWHILE  */
 
 
-static
-void
+static void
 do_awhile (idx, in)
      int idx;
      sb *in;
 do_awhile (idx, in)
      int idx;
      sb *in;
@@ -2421,7 +2441,7 @@ do_awhile (idx, in)
   doit = istrue (0, &exp);
 
   if (! buffer_and_nest ("AWHILE", "AENDW", &sub, get_line))
   doit = istrue (0, &exp);
 
   if (! buffer_and_nest ("AWHILE", "AENDW", &sub, get_line))
-    FATAL ((stderr, "AWHILE without a AENDW at %d.\n", line - 1));
+    FATAL ((stderr, _("AWHILE without a AENDW at %d.\n"), line - 1));
 
   /* Turn
        .AWHILE exp
 
   /* Turn
        .AWHILE exp
@@ -2432,7 +2452,7 @@ do_awhile (idx, in)
        .AWHILE exp
        foo
        .ENDW
        .AWHILE exp
        foo
        .ENDW
-   */
+  */
 
   if (doit)
     {
 
   if (doit)
     {
@@ -2445,7 +2465,7 @@ do_awhile (idx, in)
       sb_add_string (&copy, "\n");
       sb_add_sb (&copy, &sub);
       sb_add_string (&copy, "\t.AENDW\n");
       sb_add_string (&copy, "\n");
       sb_add_sb (&copy, &sub);
       sb_add_string (&copy, "\t.AENDW\n");
-      /* Push another WHILE */
+      /* Push another WHILE */
       include_buf (&exp, &copy, include_while, index);
       sb_kill (&copy);
     }
       include_buf (&exp, &copy, include_while, index);
       sb_kill (&copy);
     }
@@ -2453,19 +2473,17 @@ do_awhile (idx, in)
   sb_kill (&sub);
 }
 
   sb_kill (&sub);
 }
 
-
-/* .AENDW */
+/* .AENDW  */
 
 static void
 do_aendw ()
 {
 
 static void
 do_aendw ()
 {
-  ERROR ((stderr, "AENDW without a AENDW.\n"));
+  ERROR ((stderr, _("AENDW without a AENDW.\n")));
 }
 
 }
 
-
 /* .EXITM
 /* .EXITM
-   
-   Pop things off the include stack until the type and index changes */
+
+   Pop things off the include stack until the type and index changes */
 
 static void
 do_exitm ()
 
 static void
 do_exitm ()
@@ -2485,7 +2503,7 @@ do_exitm ()
     }
 }
 
     }
 }
 
-/* .AREPEAT */
+/* .AREPEAT  */
 
 static void
 do_arepeat (idx, in)
 
 static void
 do_arepeat (idx, in)
@@ -2493,9 +2511,9 @@ do_arepeat (idx, in)
      sb *in;
 {
   int line = linecount ();
      sb *in;
 {
   int line = linecount ();
-  sb exp;                      /* buffer with expression in it */
-  sb copy;                     /* expanded repeat block */
-  sb sub;                      /* contents of AREPEAT */
+  sb exp;                      /* Buffer with expression in it.  */
+  sb copy;                     /* Expanded repeat block.  */
+  sb sub;                      /* Contents of AREPEAT.  */
   int rc;
   int ret;
   char buffer[30];
   int rc;
   int ret;
   char buffer[30];
@@ -2504,13 +2522,13 @@ do_arepeat (idx, in)
   sb_new (&copy);
   sb_new (&sub);
   process_assigns (idx, in, &exp);
   sb_new (&copy);
   sb_new (&sub);
   process_assigns (idx, in, &exp);
-  idx = exp_get_abs ("AREPEAT must have absolute operand.\n", 0, &exp, &rc);
+  idx = exp_get_abs (_("AREPEAT must have absolute operand.\n"), 0, &exp, &rc);
   if (!mri)
     ret = buffer_and_nest ("AREPEAT", "AENDR", &sub, get_line);
   else
     ret = buffer_and_nest ("REPT", "ENDR", &sub, get_line);
   if (! ret)
   if (!mri)
     ret = buffer_and_nest ("AREPEAT", "AENDR", &sub, get_line);
   else
     ret = buffer_and_nest ("REPT", "ENDR", &sub, get_line);
   if (! ret)
-    FATAL ((stderr, "AREPEAT without a AENDR at %d.\n", line - 1));
+    FATAL ((stderr, _("AREPEAT without a AENDR at %d.\n"), line - 1));
   if (rc > 0)
     {
       /* Push back the text following the repeat, and another repeat block
   if (rc > 0)
     {
       /* Push back the text following the repeat, and another repeat block
@@ -2523,7 +2541,7 @@ do_arepeat (idx, in)
         .AREPEAT 19
         foo
         .AENDR
         .AREPEAT 19
         foo
         .AENDR
-        */
+      */
       int index = include_next_index ();
       sb_add_sb (&copy, &sub);
       if (rc > 1)
       int index = include_next_index ();
       sb_add_sb (&copy, &sub);
       if (rc > 1)
@@ -2547,12 +2565,12 @@ do_arepeat (idx, in)
   sb_kill (&copy);
 }
 
   sb_kill (&copy);
 }
 
-/* .ENDM */
+/* .ENDM  */
 
 static void
 do_endm ()
 {
 
 static void
 do_endm ()
 {
-  ERROR ((stderr, ".ENDM without a matching .MACRO.\n"));
+  ERROR ((stderr, _(".ENDM without a matching .MACRO.\n")));
 }
 
 /* MRI IRP pseudo-op.  */
 }
 
 /* MRI IRP pseudo-op.  */
@@ -2577,16 +2595,16 @@ do_irp (idx, in, irpc)
   sb_kill (&out);
 }
 
   sb_kill (&out);
 }
 
-/* MACRO PROCESSING */
+/* Macro processing.  */
+
+/* Parse off LOCAL n1, n2,... Invent a label name for it.  */
 
 
-/* Parse off LOCAL n1, n2,... Invent a label name for it */
-static
-void 
+static void
 do_local (idx, line)
 do_local (idx, line)
-     int idx;
-     sb *line;
+     int idx ATTRIBUTE_UNUSED;
+     sb *line ATTRIBUTE_UNUSED;
 {
 {
-  ERROR ((stderr, "LOCAL outside of MACRO"));
+  ERROR ((stderr, _("LOCAL outside of MACRO")));
 }
 
 static void
 }
 
 static void
@@ -2597,9 +2615,9 @@ do_macro (idx, in)
   const char *err;
   int line = linecount ();
 
   const char *err;
   int line = linecount ();
 
-  err = define_macro (idx, in, &label, get_line);
+  err = define_macro (idx, in, &label, get_line, (const char **) NULL);
   if (err != NULL)
   if (err != NULL)
-    ERROR ((stderr, "macro at line %d: %s\n", line - 1, err));
+    ERROR ((stderr, _("macro at line %d: %s\n"), line - 1, err));
 }
 
 static int
 }
 
 static int
@@ -2615,14 +2633,14 @@ macro_op (idx, in)
     return 0;
 
   sb_terminate (in);
     return 0;
 
   sb_terminate (in);
-  if (! check_macro (in->ptr + idx, &out, comment_char, &err))
+  if (! check_macro (in->ptr + idx, &out, comment_char, &err, NULL))
     return 0;
 
   if (err != NULL)
     ERROR ((stderr, "%s\n", err));
 
   sb_new (&name);
     return 0;
 
   if (err != NULL)
     ERROR ((stderr, "%s\n", err));
 
   sb_new (&name);
-  sb_add_string (&name, "macro expansion");
+  sb_add_string (&name, _("macro expansion"));
 
   include_buf (&name, &out, include_macro, include_next_index ());
 
 
   include_buf (&name, &out, include_macro, include_next_index ());
 
@@ -2632,7 +2650,7 @@ macro_op (idx, in)
   return 1;
 }
 
   return 1;
 }
 
-/* STRING HANDLING */
+/* String handling.  */
 
 static int
 getstring (idx, in, acc)
 
 static int
 getstring (idx, in, acc)
@@ -2643,8 +2661,8 @@ getstring (idx, in, acc)
   idx = sb_skip_white (idx, in);
 
   while (idx < in->len
   idx = sb_skip_white (idx, in);
 
   while (idx < in->len
-        && (in->ptr[idx] == '"' 
-            || in->ptr[idx] == '<' 
+        && (in->ptr[idx] == '"'
+            || in->ptr[idx] == '<'
             || (in->ptr[idx] == '\'' && alternate)))
     {
       if (in->ptr[idx] == '<')
             || (in->ptr[idx] == '\'' && alternate)))
     {
       if (in->ptr[idx] == '<')
@@ -2658,30 +2676,32 @@ getstring (idx, in, acc)
                {
                  if (in->ptr[idx] == '!')
                    {
                {
                  if (in->ptr[idx] == '!')
                    {
-                     idx++  ;
+                     idx++;
+                     sb_add_char (acc, in->ptr[idx++]);
+                   }
+                 else
+                   {
+                     if (in->ptr[idx] == '>')
+                       nest--;
+                     if (in->ptr[idx] == '<')
+                       nest++;
                      sb_add_char (acc, in->ptr[idx++]);
                    }
                      sb_add_char (acc, in->ptr[idx++]);
                    }
-                 else {
-                   if (in->ptr[idx] == '>')
-                     nest--;
-                   if (in->ptr[idx] == '<')
-                     nest++;
-                   sb_add_char (acc, in->ptr[idx++]);
-                 }
                }
              idx++;
            }
                }
              idx++;
            }
-         else {
-           int code;
-           idx++;
-           idx = exp_get_abs ("Character code in string must be absolute expression.\n",
-                              idx, in, &code);
-           sb_add_char (acc, code);
+         else
+           {
+             int code;
+             idx++;
+             idx = exp_get_abs (_("Character code in string must be absolute expression.\n"),
+                                idx, in, &code);
+             sb_add_char (acc, code);
 
 
-           if (in->ptr[idx] != '>')
-             ERROR ((stderr, "Missing > for character code.\n"));
-           idx++;
-         }
+             if (in->ptr[idx] != '>')
+               ERROR ((stderr, _("Missing > for character code.\n")));
+             idx++;
+           }
        }
       else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'')
        {
        }
       else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'')
        {
@@ -2691,30 +2711,30 @@ getstring (idx, in, acc)
            {
              if (alternate && in->ptr[idx] == '!')
                {
            {
              if (alternate && in->ptr[idx] == '!')
                {
-                 idx++  ;
+                 idx++;
                  sb_add_char (acc, in->ptr[idx++]);
                }
                  sb_add_char (acc, in->ptr[idx++]);
                }
-             else {
-               if (in->ptr[idx] == tchar)
-                 {
-                   idx++;
-                   if (idx >= in->len || in->ptr[idx] != tchar)
-                     break;
-                 }
-               sb_add_char (acc, in->ptr[idx]);
-               idx++;
-             }
+             else
+               {
+                 if (in->ptr[idx] == tchar)
+                   {
+                     idx++;
+                     if (idx >= in->len || in->ptr[idx] != tchar)
+                       break;
+                   }
+                 sb_add_char (acc, in->ptr[idx]);
+                 idx++;
+               }
            }
        }
     }
            }
        }
     }
-  
+
   return idx;
 }
 
   return idx;
 }
 
-/* .SDATA[C|Z] <string> */
+/* .SDATA[C|Z] <string>  */
 
 
-static
-void
+static void
 do_sdata (idx, in, type)
      int idx;
      sb *in;
 do_sdata (idx, in, type)
      int idx;
      sb *in;
@@ -2738,7 +2758,7 @@ do_sdata (idx, in, type)
            {
              if (acc.len > 255)
                {
            {
              if (acc.len > 255)
                {
-                 ERROR ((stderr, "string for SDATAC longer than 255 characters (%d).\n", acc.len));
+                 ERROR ((stderr, _("string for SDATAC longer than 255 characters (%d).\n"), acc.len));
                }
              fprintf (outfile, "%d", acc.len);
              nc = 1;
                }
              fprintf (outfile, "%d", acc.len);
              nc = 1;
@@ -2761,12 +2781,14 @@ do_sdata (idx, in, type)
              fprintf (outfile, "0");
            }
          idx = sb_skip_comma (idx, in);
              fprintf (outfile, "0");
            }
          idx = sb_skip_comma (idx, in);
-         if (idx == pidx) break;
+         if (idx == pidx)
+           break;
        }
       if (!alternate && in->ptr[idx] != ',' && idx != in->len)
        {
          fprintf (outfile, "\n");
        }
       if (!alternate && in->ptr[idx] != ',' && idx != in->len)
        {
          fprintf (outfile, "\n");
-         ERROR ((stderr, "illegal character in SDATA line (0x%x).\n", in->ptr[idx]));
+         ERROR ((stderr, _("illegal character in SDATA line (0x%x).\n"),
+                 in->ptr[idx]));
          break;
        }
       idx++;
          break;
        }
       idx++;
@@ -2775,7 +2797,7 @@ do_sdata (idx, in, type)
   fprintf (outfile, "\n");
 }
 
   fprintf (outfile, "\n");
 }
 
-/* .SDATAB <count> <string> */
+/* .SDATAB <count> <string>  */
 
 static void
 do_sdatab (idx, in)
 
 static void
 do_sdatab (idx, in)
@@ -2787,10 +2809,10 @@ do_sdatab (idx, in)
   sb acc;
   sb_new (&acc);
 
   sb acc;
   sb_new (&acc);
 
-  idx = exp_get_abs ("Must have absolute SDATAB repeat count.\n", idx, in, &repeat);
+  idx = exp_get_abs (_("Must have absolute SDATAB repeat count.\n"), idx, in, &repeat);
   if (repeat <= 0)
     {
   if (repeat <= 0)
     {
-      ERROR ((stderr, "Must have positive SDATAB repeat count (%d).\n", repeat));
+      ERROR ((stderr, _("Must have positive SDATAB repeat count (%d).\n"), repeat));
       repeat = 1;
     }
 
       repeat = 1;
     }
 
@@ -2818,7 +2840,7 @@ new_file (name)
     return 0;
 
   if (isp == MAX_INCLUDES)
     return 0;
 
   if (isp == MAX_INCLUDES)
-    FATAL ((stderr, "Unreasonable include depth (%ld).\n", (long) isp));
+    FATAL ((stderr, _("Unreasonable include depth (%ld).\n"), (long) isp));
 
   sp++;
   sp->handle = newone;
 
   sp++;
   sp->handle = newone;
@@ -2872,7 +2894,7 @@ do_include (idx, in)
   if (!includes)
     {
       if (! new_file (sb_name (&t)))
   if (!includes)
     {
       if (! new_file (sb_name (&t)))
-       FATAL ((stderr, "Can't open include file `%s'.\n", sb_name (&t)));
+       FATAL ((stderr, _("Can't open include file `%s'.\n"), sb_name (&t)));
     }
   sb_kill (&cat);
   sb_kill (&t);
     }
   sb_kill (&cat);
   sb_kill (&t);
@@ -2891,7 +2913,7 @@ include_pop ()
 
 /* Get the next character from the include stack.  If there's anything
    in the pushback buffer, take that first.  If we're at eof, pop from
 
 /* Get the next character from the include stack.  If there's anything
    in the pushback buffer, take that first.  If we're at eof, pop from
-   the stack and try again.  Keep the linecount up to date. */
+   the stack and try again.  Keep the linecount up to date.  */
 
 static int
 get ()
 
 static int
 get ()
@@ -2901,7 +2923,7 @@ get ()
   if (sp->pushback.len != sp->pushback_index)
     {
       r = (char) (sp->pushback.ptr[sp->pushback_index++]);
   if (sp->pushback.len != sp->pushback_index)
     {
       r = (char) (sp->pushback.ptr[sp->pushback_index++]);
-      /* When they've all gone, reset the pointer */
+      /* When they've all gone, reset the pointer */
       if (sp->pushback_index == sp->pushback.len)
        {
          sp->pushback.len = 0;
       if (sp->pushback_index == sp->pushback.len)
        {
          sp->pushback.len = 0;
@@ -2946,12 +2968,11 @@ include_next_index ()
   static int index;
   if (!unreasonable
       && index > MAX_REASONABLE)
   static int index;
   if (!unreasonable
       && index > MAX_REASONABLE)
-    FATAL ((stderr, "Unreasonable expansion (-u turns off check).\n"));
+    FATAL ((stderr, _("Unreasonable expansion (-u turns off check).\n")));
   return ++index;
 }
 
   return ++index;
 }
 
-
-/* Initialize the chartype vector. */
+/* Initialize the chartype vector.  */
 
 static void
 chartype_init ()
 
 static void
 chartype_init ()
@@ -2959,13 +2980,13 @@ chartype_init ()
   int x;
   for (x = 0; x < 256; x++)
     {
   int x;
   for (x = 0; x < 256; x++)
     {
-      if (isalpha (x) || x == '_' || x == '$')
+      if (ISALPHA (x) || x == '_' || x == '$')
        chartype[x] |= FIRSTBIT;
 
       if (mri && x == '.')
        chartype[x] |= FIRSTBIT;
 
        chartype[x] |= FIRSTBIT;
 
       if (mri && x == '.')
        chartype[x] |= FIRSTBIT;
 
-      if (isdigit (x) || isalpha (x) || x == '_' || x == '$')
+      if (ISDIGIT (x) || ISALPHA (x) || x == '_' || x == '$')
        chartype[x] |= NEXTBIT;
 
       if (x == ' ' || x == '\t' || x == ',' || x == '"' || x == ';'
        chartype[x] |= NEXTBIT;
 
       if (x == ' ' || x == '\t' || x == ',' || x == '"' || x == ';'
@@ -2977,7 +2998,7 @@ chartype_init ()
          || x == 'h' || x == 'H'
          || x == 'd' || x == 'D')
        chartype [x] |= BASEBIT;
          || x == 'h' || x == 'H'
          || x == 'd' || x == 'D')
        chartype [x] |= BASEBIT;
-         
+
       if (x == ' ' || x == '\t')
        chartype[x] |= WHITEBIT;
 
       if (x == ' ' || x == '\t')
        chartype[x] |= WHITEBIT;
 
@@ -2986,11 +3007,9 @@ chartype_init ()
     }
 }
 
     }
 }
 
-
-
-/* What to do with all the keywords */
-#define PROCESS        0x1000  /* Run substitution over the line */
-#define LAB            0x2000  /* Spit out the label */
+/* What to do with all the keywords.  */
+#define PROCESS        0x1000  /* Run substitution over the line.  */
+#define LAB            0x2000  /* Spit out the label.  */
 
 #define K_EQU          (PROCESS|1)
 #define K_ASSIGN       (PROCESS|2)
 
 #define K_EQU          (PROCESS|1)
 #define K_ASSIGN       (PROCESS|2)
@@ -3047,16 +3066,13 @@ chartype_init ()
 #define K_IRP          (PROCESS|54)
 #define K_IRPC         (PROCESS|55)
 
 #define K_IRP          (PROCESS|54)
 #define K_IRPC         (PROCESS|55)
 
-
-struct keyword
-{
+struct keyword {
   char *name;
   int code;
   int extra;
 };
 
   char *name;
   int code;
   int extra;
 };
 
-static struct keyword kinfo[] =
-{
+static struct keyword kinfo[] = {
   { "EQU", K_EQU, 0 },
   { "ALTERNATE", K_ALTERNATE, 0 },
   { "ASSIGN", K_ASSIGN, 0 },
   { "EQU", K_EQU, 0 },
   { "ALTERNATE", K_ALTERNATE, 0 },
   { "ASSIGN", K_ASSIGN, 0 },
@@ -3107,8 +3123,7 @@ static struct keyword kinfo[] =
    handle them here as well, in case they are used in a recursive
    macro to end the recursion.  */
 
    handle them here as well, in case they are used in a recursive
    macro to end the recursion.  */
 
-static struct keyword mrikinfo[] =
-{
+static struct keyword mrikinfo[] = {
   { "IFEQ", K_IFEQ, 0 },
   { "IFNE", K_IFNE, 0 },
   { "IFLT", K_IFLT, 0 },
   { "IFEQ", K_IFEQ, 0 },
   { "IFNE", K_IFNE, 0 },
   { "IFLT", K_IFLT, 0 },
@@ -3128,7 +3143,7 @@ static struct keyword mrikinfo[] =
 };
 
 /* Look for a pseudo op on the line. If one's there then call
 };
 
 /* Look for a pseudo op on the line. If one's there then call
-   its handler. */
+   its handler.  */
 
 static int
 process_pseudo_op (idx, line, acc)
 
 static int
 process_pseudo_op (idx, line, acc)
@@ -3140,7 +3155,7 @@ process_pseudo_op (idx, line, acc)
 
   if (line->ptr[idx] == '.' || alternate || mri)
     {
 
   if (line->ptr[idx] == '.' || alternate || mri)
     {
-      /* Scan forward and find pseudo name */
+      /* Scan forward and find pseudo name */
       char *in;
       hash_entry *ptr;
 
       char *in;
       hash_entry *ptr;
 
@@ -3166,13 +3181,15 @@ process_pseudo_op (idx, line, acc)
        {
 #if 0
          /* This one causes lots of pain when trying to preprocess
        {
 #if 0
          /* This one causes lots of pain when trying to preprocess
-            ordinary code */
-         WARNING ((stderr, "Unrecognised pseudo op `%s'.\n", sb_name (acc)));
+            ordinary code.  */
+         WARNING ((stderr, _("Unrecognised pseudo op `%s'.\n"),
+                   sb_name (acc)));
 #endif
          return 0;
        }
       if (ptr->value.i & LAB)
 #endif
          return 0;
        }
       if (ptr->value.i & LAB)
-       {                       /* output the label */
+       {
+         /* Output the label.  */
          if (label.len)
            {
              fprintf (outfile, "%s:\t", sb_name (&label));
          if (label.len)
            {
              fprintf (outfile, "%s:\t", sb_name (&label));
@@ -3193,13 +3210,13 @@ process_pseudo_op (idx, line, acc)
 
       if (ptr->value.i & PROCESS)
        {
 
       if (ptr->value.i & PROCESS)
        {
-         /* Polish the rest of the line before handling the pseudo op */
+         /* Polish the rest of the line before handling the pseudo op */
 #if 0
 #if 0
-         strip_comments(line);
+         strip_comments (line);
 #endif
          sb_reset (acc);
          process_assigns (idx, line, acc);
 #endif
          sb_reset (acc);
          process_assigns (idx, line, acc);
-         sb_reset(line);
+         sb_reset (line);
          change_base (0, acc, line);
          idx = 0;
        }
          change_base (0, acc, line);
          idx = 0;
        }
@@ -3225,7 +3242,7 @@ process_pseudo_op (idx, line, acc)
            {
            case K_ALTERNATE:
              alternate = 1;
            {
            case K_ALTERNATE:
              alternate = 1;
-             macro_init (1, mri, exp_get_abs);
+             macro_init (1, mri, 0, exp_get_abs);
              return 1;
            case K_AELSE:
              do_aelse ();
              return 1;
            case K_AELSE:
              do_aelse ();
@@ -3234,7 +3251,7 @@ process_pseudo_op (idx, line, acc)
              do_aendi ();
              return 1;
            case K_ORG:
              do_aendi ();
              return 1;
            case K_ORG:
-             ERROR ((stderr, "ORG command not allowed.\n"));
+             ERROR ((stderr, _("ORG command not allowed.\n")));
              break;
            case K_RADIX:
              do_radix (line);
              break;
            case K_RADIX:
              do_radix (line);
@@ -3267,7 +3284,7 @@ process_pseudo_op (idx, line, acc)
              do_sdata (idx, line, 'z');
              return 1;
            case K_ASSIGN:
              do_sdata (idx, line, 'z');
              return 1;
            case K_ASSIGN:
-             do_assign (1, 0, line);
+             do_assign (0, 0, line);
              return 1;
            case K_AIF:
              do_aif (idx, line);
              return 1;
            case K_AIF:
              do_aif (idx, line);
@@ -3285,7 +3302,7 @@ process_pseudo_op (idx, line, acc)
              do_aendr ();
              return 1;
            case K_EQU:
              do_aendr ();
              return 1;
            case K_EQU:
-             do_assign (0, idx, line);
+             do_assign (1, idx, line);
              return 1;
            case K_ALIGN:
              do_align (idx, line);
              return 1;
            case K_ALIGN:
              do_align (idx, line);
@@ -3385,8 +3402,6 @@ process_pseudo_op (idx, line, acc)
   return 0;
 }
 
   return 0;
 }
 
-
-
 /* Add a keyword to the hash table.  */
 
 static void
 /* Add a keyword to the hash table.  */
 
 static void
@@ -3408,10 +3423,10 @@ add_keyword (name, code)
   hash_add_to_int_table (&keyword_hash_table, &label, code);
 
   sb_kill (&label);
   hash_add_to_int_table (&keyword_hash_table, &label, code);
 
   sb_kill (&label);
-}  
+}
 
 /* Build the keyword hash table - put each keyword in the table twice,
 
 /* Build the keyword hash table - put each keyword in the table twice,
-   once upper and once lower case.*/
+   once upper and once lower case.  */
 
 static void
 process_init ()
 
 static void
 process_init ()
@@ -3428,7 +3443,6 @@ process_init ()
     }
 }
 
     }
 }
 
-
 static void
 do_define (string)
      const char *string;
 static void
 do_define (string)
      const char *string;
@@ -3438,10 +3452,9 @@ do_define (string)
   hash_entry *ptr;
   sb_new (&label);
 
   hash_entry *ptr;
   sb_new (&label);
 
-
   while (*string)
     {
   while (*string)
     {
-      if (*string == '=') 
+      if (*string == '=')
        {
          sb value;
          sb_new (&value);
        {
          sb value;
          sb_new (&value);
@@ -3451,13 +3464,14 @@ do_define (string)
              sb_add_char (&value, *string);
              string++;
            }
              sb_add_char (&value, *string);
              string++;
            }
-         exp_get_abs ("Invalid expression on command line.\n", 0, &value, &res);
+         exp_get_abs (_("Invalid expression on command line.\n"),
+                      0, &value, &res);
          sb_kill (&value);
          break;
        }
       sb_add_char (&label, *string);
 
          sb_kill (&value);
          break;
        }
       sb_add_char (&label, *string);
 
-      string ++;
+      string++;
     }
 
   ptr = hash_create (&vars, &label);
     }
 
   ptr = hash_create (&vars, &label);
@@ -3466,6 +3480,7 @@ do_define (string)
   ptr->value.i = res;
   sb_kill (&label);
 }
   ptr->value.i = res;
   sb_kill (&label);
 }
+
 char *program_name;
 
 /* The list of long options.  */
 char *program_name;
 
 /* The list of long options.  */
@@ -3492,7 +3507,7 @@ show_usage (file, status)
      FILE *file;
      int status;
 {
      FILE *file;
      int status;
 {
-  fprintf (file, "\
+  fprintf (file, _("\
 Usage: %s \n\
   [-a]      [--alternate]         enter alternate macro mode\n\
   [-c char] [--commentchar char]  change the comment character from !\n\
 Usage: %s \n\
   [-a]      [--alternate]         enter alternate macro mode\n\
   [-c char] [--commentchar char]  change the comment character from !\n\
@@ -3500,23 +3515,25 @@ Usage: %s \n\
   [-h]      [--help]              print this message\n\
   [-M]      [--mri]               enter MRI compatibility mode\n\
   [-o out]  [--output out]        set the output file\n\
   [-h]      [--help]              print this message\n\
   [-M]      [--mri]               enter MRI compatibility mode\n\
   [-o out]  [--output out]        set the output file\n\
-  [-p]      [--print]             print line numbers\n", program_name);
-  fprintf (file, "\
+  [-p]      [--print]             print line numbers\n"), program_name);
+  fprintf (file, _("\
   [-s]      [--copysource]        copy source through as comments \n\
   [-u]      [--unreasonable]      allow unreasonable nesting\n\
   [-v]      [--version]           print the program version\n\
   [-Dname=value]                  create preprocessor variable called name, with value\n\
   [-Ipath]                        add to include path list\n\
   [-s]      [--copysource]        copy source through as comments \n\
   [-u]      [--unreasonable]      allow unreasonable nesting\n\
   [-v]      [--version]           print the program version\n\
   [-Dname=value]                  create preprocessor variable called name, with value\n\
   [-Ipath]                        add to include path list\n\
-  [in-file]\n");
+  [in-file]\n"));
+  if (status == 0)
+    printf (_("Report bugs to %s\n"), REPORT_BUGS_TO);
   exit (status);
 }
 
 /* Display a help message and exit.  */
   exit (status);
 }
 
 /* Display a help message and exit.  */
+
 static void
 show_help ()
 {
 static void
 show_help ()
 {
-  printf ("%s: Gnu Assembler Macro Preprocessor\n",
-         program_name);
+  printf (_("%s: Gnu Assembler Macro Preprocessor\n"), program_name);
   show_usage (stdout, 0);
 }
 
   show_usage (stdout, 0);
 }
 
@@ -3532,7 +3549,14 @@ main (argc, argv)
   ifstack[0].on = 1;
   ifi = 0;
 
   ifstack[0].on = 1;
   ifi = 0;
 
-
+#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
+  setlocale (LC_MESSAGES, "");
+#endif
+#if defined (HAVE_SETLOCALE)
+  setlocale (LC_CTYPE, "");
+#endif
+  bindtextdomain (PACKAGE, LOCALEDIR);
+  textdomain (PACKAGE);
 
   program_name = argv[0];
   xmalloc_set_program_name (program_name);
 
   program_name = argv[0];
   xmalloc_set_program_name (program_name);
@@ -3558,6 +3582,7 @@ main (argc, argv)
        case 'I':
          {
            include_path *p = (include_path *) xmalloc (sizeof (include_path));
        case 'I':
          {
            include_path *p = (include_path *) xmalloc (sizeof (include_path));
+           p->next = NULL;
            sb_new (&p->path);
            sb_add_string (&p->path, optarg);
            if (paths_tail)
            sb_new (&p->path);
            sb_add_string (&p->path, optarg);
            if (paths_tail)
@@ -3591,41 +3616,48 @@ main (argc, argv)
          break;
        case 'h':
          show_help ();
          break;
        case 'h':
          show_help ();
-         /*NOTREACHED*/
+         /* NOTREACHED  */
        case 'v':
        case 'v':
-         printf ("GNU %s version %s\n", program_name, program_version);
+         /* This output is intended to follow the GNU standards document.  */
+         printf (_("GNU assembler pre-processor %s\n"), program_version);
+         printf (_("Copyright 1996 Free Software Foundation, Inc.\n"));
+         printf (_("\
+This program is free software; you may redistribute it under the terms of\n\
+the GNU General Public License.  This program has absolutely no warranty.\n"));
          exit (0);
          exit (0);
-         /*NOTREACHED*/
+         /* NOTREACHED  */
        case 0:
          break;
        default:
          show_usage (stderr, 1);
        case 0:
          break;
        default:
          show_usage (stderr, 1);
-         /*NOTREACHED*/
+         /* NOTREACHED  */
        }
     }
 
   process_init ();
 
        }
     }
 
   process_init ();
 
-  macro_init (alternate, mri, exp_get_abs);
+  macro_init (alternate, mri, 0, exp_get_abs);
 
 
-  if (out_name) {
-    outfile = fopen (out_name, "w");
-    if (!outfile)
-      {
-       fprintf (stderr, "%s: Can't open output file `%s'.\n",
-                program_name, out_name);
-       exit (1);
-      }
-  }
-  else  {
-    outfile = stdout;
-  }
+  if (out_name)
+    {
+      outfile = fopen (out_name, "w");
+      if (!outfile)
+       {
+         fprintf (stderr, _("%s: Can't open output file `%s'.\n"),
+                  program_name, out_name);
+         exit (1);
+       }
+    }
+  else
+    {
+      outfile = stdout;
+    }
 
   chartype_init ();
   if (!outfile)
     outfile = stdout;
 
 
   chartype_init ();
   if (!outfile)
     outfile = stdout;
 
-  /* Process all the input files */
+  /* Process all the input files */
 
   while (optind < argc)
     {
 
   while (optind < argc)
     {
@@ -3635,7 +3667,7 @@ main (argc, argv)
        }
       else
        {
        }
       else
        {
-         fprintf (stderr, "%s: Can't open input file `%s'.\n",
+         fprintf (stderr, _("%s: Can't open input file `%s'.\n"),
                   program_name, argv[optind]);
          exit (1);
        }
                   program_name, argv[optind]);
          exit (1);
        }
@@ -3654,9 +3686,9 @@ as_abort (file, line, fn)
      const char *file, *fn;
      int line;
 {
      const char *file, *fn;
      int line;
 {
-  fprintf (stderr, "Internal error, aborting at %s line %d", file, line);
+  fprintf (stderr, _("Internal error, aborting at %s line %d"), file, line);
   if (fn)
     fprintf (stderr, " in %s", fn);
   if (fn)
     fprintf (stderr, " in %s", fn);
-  fprintf (stderr, "\nPlease report this bug.\n");
+  fprintf (stderr, _("\nPlease report this bug.\n"));
   exit (1);
 }
   exit (1);
 }
This page took 0.064923 seconds and 4 git commands to generate.