URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [opcodes/] [opc2c.c] - Blame information for rev 533

Go to most recent revision | Details | Compare with Previous | View Log


/* opc2c.c --- generate C opcode decoder code from from .opc file
 
   Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
   Contributed by Red Hat, Inc.
 
   This file is part of the GNU opcode library.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <errno.h>
#include "libiberty.h"
 
static char * line_buf = NULL;
static int line_buf_size = 0;
 
#define LBUFINCR 100
 
char *
safe_fgets (FILE * f)
{
  char * line_ptr;
 
  if (line_buf == NULL)
    {
      line_buf = (char *) malloc (LBUFINCR);
      line_buf_size = LBUFINCR;
    }
 
  /* Points to last byte.  */
  line_ptr = line_buf + line_buf_size - 1;
 
  /* So we can see if fgets put a 0 there.  */
  *line_ptr = 1;
  if (fgets (line_buf, line_buf_size, f) == 0)
    return NULL;
 
  /* We filled the buffer?  */
  while (line_ptr[0] == 0 && line_ptr[-1] != '\n')
    {
      /* Make the buffer bigger and read more of the line.  */
      line_buf_size += LBUFINCR;
      line_buf = (char *) realloc (line_buf, line_buf_size);
 
      /* Points to last byte again.  */
      line_ptr = line_buf + line_buf_size - 1;
      /* So we can see if fgets put a 0 there.  */
      *line_ptr = 1;
 
      if (fgets (line_buf + line_buf_size - LBUFINCR - 1, LBUFINCR + 1, f) == 0)
        return NULL;
    }
 
  return line_buf;
}
 
 
static int errors = 0;
 
#define MAX_BYTES 10
 
typedef struct
{
  int varyno:16;
  int byte:8;
  int shift:8;
} VaryRef;
 
typedef struct
{
  char nbytes;
  char dbytes;
  char id[MAX_BYTES * 8 + 1];
  unsigned char var_start[MAX_BYTES * 8 + 1];
  struct
  {
    unsigned char decodable_mask;
    unsigned char decodable_bits;
  } b[MAX_BYTES];
  char * comment;
  char * syntax;
  int lineno;
  int nlines;
  char ** lines;
  struct Indirect * last_ind;
  int semantics_label;
  int nvaries;
  VaryRef * vary;
} opcode;
 
int n_opcodes;
opcode ** opcodes;
opcode * op;
 
typedef struct
{
  char * name;
  int nlen;
  unsigned char mask;
  int n_patterns;
  unsigned char * patterns;
} Vary;
 
Vary ** vary = 0;
int n_varies = 0;
 
unsigned char cur_bits[MAX_BYTES + 1];
 
char * orig_filename;
 
FILE * sim_log = NULL;
#define lprintf if (sim_log) fprintf
 
opcode prefix_text, suffix_text;
 
typedef enum
{
  T_unused,
  T_op,
  T_indirect,
  T_done
} OpType;
 
typedef struct Indirect
{
  OpType type;
  union
  {
    struct Indirect * ind;
    opcode * op;
  } u;
} Indirect;
 
Indirect indirect[256];
 
static int
next_varybits (int bits, opcode * op, int byte)
{
  int mask = op->b[byte].decodable_mask;
  int i;
 
  for (i = 0; i < 8; i++)
    if (!(mask & (1 << i)))
      {
        if (bits & (1 << i))
          {
            bits &= ~(1 << i);
          }
        else
          {
            bits |= (1 << i);
            return bits;
          }
      }
  return 0;
}
 
static int
valid_varybits (int bits, opcode * op, int byte)
{
  if (op->nvaries)
    {
      int vn;
 
      for (vn = 0; vn < op->nvaries; vn++)
        {
          Vary * v;
          int found = 0;
          int i;
          int ob;
 
          if (byte != op->vary[vn].byte)
            continue;
          v = vary[op->vary[vn].varyno];
          ob = (bits >> op->vary[vn].shift) & v->mask;
          lprintf (sim_log, "varybits: vary %s ob %x\n", v->name, ob);
 
          for (i = 0; i < v->n_patterns; i++)
            if (ob == v->patterns[i])
              {
                lprintf (sim_log, "  found at %d\n", i);
                found = 1;
                break;
              }
          if (!found)
            return 0;
        }
    }
  return 1;
}
 
char *
prmb (int mask, int bits)
{
  static char buf[8][30];
  static int bn = 0;
  char * bp;
 
  bn = (bn + 1) % 8;
  bp = buf[bn];
  int i;
  for (i = 0; i < 8; i++)
    {
      int bit = 0x80 >> i;
 
      if (!(mask & bit))
        *bp++ = '-';
      else if (bits & bit)
        *bp++ = '1';
      else
        *bp++ = '0';
      if (i % 4 == 3)
        *bp++ = ' ';
    }
  *--bp = 0;
  return buf[bn];
}
 
static int
op_cmp (const void *va, const void *vb)
{
  const opcode * a = *(const opcode **) va;
  const opcode * b = *(const opcode **) vb;
 
  if (a->nbytes != b->nbytes)
    return a->nbytes - b->nbytes;
 
  return strcmp (a->id, b->id);
}
 
void
dump_lines (opcode * op, int level, Indirect * ind)
{
  char * varnames[40];
  int i, vn = 0;
 
  if (op->semantics_label)
    {
      printf ("%*sgoto op_semantics_%d;\n", level, "", op->semantics_label);
      return;
    }
 
  if (ind != op->last_ind)
    {
      static int labelno = 0;
      labelno++;
      printf ("%*sop_semantics_%d:\n", level, "", labelno);
      op->semantics_label = labelno;
    }
 
  if (op->comment)
    {
      level += 2;
      printf ("%*s{\n", level, "");
      printf ("%*s  %s\n", level, "", op->comment);
    }
 
  for (i = 0; i < op->nbytes * 8;)
    {
      if (isalpha (op->id[i]))
        {
          int byte = i >> 3;
          int mask = 0;
          int shift = 0;
          char name[33];
          char * np = name;
 
          while (op->id[i] && isalpha (op->id[i]))
            {
              mask = (mask << 1) | 1;
              shift = 7 - (i & 7);
              *np++ = op->id[i++];
              if (op->var_start[i])
                break;
            }
          *np = 0;
          varnames[vn++] = strdup (name);
          printf ("#line %d \"%s\"\n", op->lineno + 1, orig_filename);
          if (mask & ~0xff)
            {
              fprintf (stderr, "Error: variable %s spans bytes: %s\n",
                       name, op->comment);
              errors++;
            }
          else if (shift && (mask != 0xff))
            printf ("%*s  int %s AU = (op[%d] >> %d) & 0x%02x;\n",
                    level, "", name, byte, shift, mask);
          else if (mask != 0xff)
            printf ("%*s  int %s AU = op[%d] & 0x%02x;\n",
                    level, "", name, byte, mask);
          else
            printf ("%*s  int %s AU = op[%d];\n", level, "", name, byte);
        }
      else
        i++;
    }
 
  if (op->comment)
    {
      printf ("%*s  if (trace)\n", level, "");
      printf ("%*s    {\n", level, "");
      printf ("%*s      printf (\"\\033[33m%%s\\033[0m ", level, "");
      for (i = 0; i < op->nbytes; i++)
        printf (" %%02x");
      printf ("\\n\"");
      printf (",\n%*s             \"%s\"", level, "", op->comment);
      for (i = 0; i < op->nbytes; i++)
        {
          if (i == 0)
            printf (",\n%*s             op[%d]", level, "", i);
          else
            printf (", op[%d]", i);
        }
      printf (");\n");
      for (i = 0; i < vn; i++)
        printf ("%*s      printf (\"  %s = 0x%%x%s\", %s);\n", level, "",
                varnames[i], (i < vn - 1) ? "," : "\\n", varnames[i]);
      printf ("%*s    }\n", level, "");
    }
 
  if (op->syntax)
    printf ("%*s  SYNTAX(\"%s\");\n", level, "", op->syntax);
 
  printf ("#line %d \"%s\"\n", op->lineno + 1, orig_filename);
 
  for (i = 0; i < op->nlines; i++)
    printf ("%*s%s", level, "", op->lines[i]);
 
  if (op->comment)
    printf ("%*s}\n", level, "");
}
 
void
store_opcode_bits (opcode * op, int byte, Indirect * ind)
{
  int bits = op->b[byte].decodable_bits;
 
  do
    {
      if (!valid_varybits (bits, op, byte))
        continue;
 
      switch (ind[bits].type)
        {
        case T_unused:
          if (byte == op->dbytes - 1)
            {
              ind[bits].type = T_op;
              ind[bits].u.op = op;
              op->last_ind = ind;
              break;
            }
          else
            {
              int i2;
 
              ind[bits].type = T_indirect;
              ind[bits].u.ind = (Indirect *) malloc (256 * sizeof (Indirect));
              for (i2 = 0; i2 < 256; i2++)
                ind[bits].u.ind[i2].type = T_unused;
              store_opcode_bits (op, byte + 1, ind[bits].u.ind);
            }
          break;
 
        case T_indirect:
          if (byte < op->dbytes - 1)
            store_opcode_bits (op, byte + 1, ind[bits].u.ind);
          break;
 
        case T_op:
          break;
 
        case T_done:
          break;
        }
    }
  while ((bits = next_varybits (bits, op, byte)) != 0);
}
 
void
emit_indirect (Indirect * ind, int byte)
{
  int unsup = 0;
  int j, n, mask;
 
  mask = 0;
  for (j = 0; j < 256; j++)
    {
      switch (ind[j].type)
        {
        case T_indirect:
          mask = 0xff;
          break;
        case T_op:
          mask |= ind[j].u.op->b[byte].decodable_mask;
          break;
        case T_done:
        case T_unused:
          break;
        }
    }
 
  printf ("%*s  GETBYTE ();\n", byte * 6, "");
  printf ("%*s  switch (op[%d] & 0x%02x)\n", byte * 6, "", byte, mask);
  printf ("%*s  {\n", byte * 6, "");
 
  for (j = 0; j < 256; j++)
    if ((j & ~mask) == 0)
      {
        switch (ind[j].type)
          {
          case T_done:
            break;
          case T_unused:
            unsup = 1;
            break;
          case T_op:
            for (n = j; n < 256; n++)
              if ((n & ~mask) == 0
                  && ind[n].type == T_op && ind[n].u.op == ind[j].u.op)
                {
                  ind[n].type = T_done;
                  printf ("%*s    case 0x%02x:\n", byte * 6, "", n);
                }
            for (n = byte; n < ind[j].u.op->nbytes - 1; n++)
              printf ("%*s      GETBYTE();\n", byte * 6, "");
            dump_lines (ind[j].u.op, byte * 6 + 6, ind);
            printf ("%*s      break;\n", byte * 6, "");
            break;
          case T_indirect:
            printf ("%*s    case 0x%02x:\n", byte * 6, "", j);
            emit_indirect (ind[j].u.ind, byte + 1);
            printf ("%*s      break;\n", byte * 6, "");
            break;
          }
      }
  if (unsup)
    printf ("%*s    default: UNSUPPORTED(); break;\n", byte * 6, "");
  printf ("%*s  }\n", byte * 6, "");
}
 
static char *
pv_dup (char * p, char * ep)
{
  int n = ep - p;
  char *rv = (char *) malloc (n + 1);
 
  memcpy (rv, p, n);
  rv[n] = 0;
  return rv;
}
 
static unsigned char
str2mask (char * str, char * ep)
{
  unsigned char rv = 0;
 
  while (str < ep)
    {
      rv *= 2;
      if (*str == '1')
        rv += 1;
      str++;
    }
  return rv;
}
 
static void
process_vary (char * line)
{
  char * cp;
  char * ep;
  Vary * v = (Vary *) malloc (sizeof (Vary));
 
  n_varies++;
  if (vary)
    vary = (Vary **) realloc (vary, n_varies * sizeof (Vary *));
  else
    vary = (Vary **) malloc (n_varies * sizeof (Vary *));
  vary[n_varies - 1] = v;
 
  cp = line;
 
  for (cp = line; isspace (*cp); cp++);
  for (ep = cp; *ep && !isspace (*ep); ep++);
 
  v->name = pv_dup (cp, ep);
  v->nlen = strlen (v->name);
  v->mask = (1 << v->nlen) - 1;
 
  v->n_patterns = 0;
  v->patterns = (unsigned char *) malloc (1);
  while (1)
    {
      for (cp = ep; isspace (*cp); cp++);
      if (!isdigit (*cp))
        break;
      for (ep = cp; *ep && !isspace (*ep); ep++);
      v->n_patterns++;
      v->patterns = (unsigned char *) realloc (v->patterns, v->n_patterns);
      v->patterns[v->n_patterns - 1] = str2mask (cp, ep);
    }
}
 
static int
fieldcmp (opcode * op, int bit, char *name)
{
  int n = strlen (name);
 
  if (memcmp (op->id + bit, name, n) == 0
      && (!isalpha (op->id[bit + n]) || op->var_start[bit + n]))
    return 1;
  return 0;
}
 
static void
log_indirect (Indirect * ind, int byte)
{
  int i, j;
  char * last_c = 0;
 
  for (i = 0; i < 256; i++)
    {
 
      for (j = 0; j < byte; j++)
        fprintf (sim_log, "%s ", prmb (255, cur_bits[j]));
      fprintf (sim_log, "%s ", prmb (255, i));
 
      switch (ind[i].type)
        {
        case T_op:
        case T_done:
          if (last_c && (ind[i].u.op->comment == last_c))
            fprintf (sim_log, "''\n");
          else
            fprintf (sim_log, "%s\n", ind[i].u.op->comment);
          last_c = ind[i].u.op->comment;
          break;
        case T_unused:
          fprintf (sim_log, "unused\n");
          break;
        case T_indirect:
          fprintf (sim_log, "indirect\n");
          cur_bits[byte] = i;
          log_indirect (ind[i].u.ind, byte + 1);
          last_c = 0;
          break;
        }
    }
}
 
int
main (int argc, char ** argv)
{
  char * line;
  FILE * in;
  int lineno = 0;
  int i;
  VaryRef * vlist;
  int skipping_section = 0;
 
  if (argc > 2 && strcmp (argv[1], "-l") == 0)
    {
      sim_log = fopen (argv[2], "w");
      fprintf (stderr, "sim_log: %s\n", argv[2]);
      argc -= 2;
      argv += 2;
    }
 
  if (argc < 2)
    {
      fprintf (stderr, "usage: opc2c infile.opc > outfile.opc\n");
      exit (1);
    }
 
  orig_filename = lbasename (argv[1]);
  in = fopen (argv[1], "r");
  if (!in)
    {
      fprintf (stderr, "Unable to open file %s for reading: %s\n", argv[1],
               xstrerror (errno));
      exit (1);
    }
 
  n_opcodes = 0;
  opcodes = (opcode **) malloc (sizeof (opcode *));
  op = &prefix_text;
  op->lineno = 0;
  while ((line = safe_fgets (in)) != 0)
    {
      lineno++;
      if (strncmp (line, "/*?* ", 5) == 0)
        {
          skipping_section = 1;
          continue;
        }
      if (strncmp (line, "  /** ", 6) == 0
          && (isdigit (line[6]) || memcmp (line + 6, "VARY", 4) == 0))
        line += 2;
      if (line[0] == '/' && line[1] == '*' && line[2] == '*')
        {
          skipping_section = 0;
          if (strncmp (line, "/** */", 6) == 0)
            {
              op = &suffix_text;
              op->lineno = lineno;
            }
          else if (strncmp (line, "/** VARY ", 9) == 0)
            process_vary (line + 9);
          else
            {
              char * lp;
              int i, bit, byte;
              int var_start = 1;
 
              n_opcodes++;
              opcodes =
                (opcode **) realloc (opcodes, n_opcodes * sizeof (opcode *));
              op = (opcode *) malloc (sizeof (opcode));
              opcodes[n_opcodes - 1] = op;
 
              op->nbytes = op->dbytes = 0;
              memset (op->id, 0, sizeof (op->id));
              memset (op->var_start, 0, sizeof (op->var_start));
              for (i = 0; i < MAX_BYTES; i++)
                {
                  op->b[i].decodable_mask = 0;
                  op->b[i].decodable_bits = 0;
                }
              op->comment = strdup (line);
              op->comment[strlen (op->comment) - 1] = 0;
              while (op->comment[0] && isspace (op->comment[0]))
                op->comment++;
              op->lineno = lineno;
              op->nlines = 0;
              op->lines = 0;
              op->last_ind = 0;
              op->semantics_label = 0;
              op->nvaries = 0;
              op->vary = 0;
 
              i = 0;
              for (lp = line + 4; *lp; lp++)
                {
                  bit = 7 - (i & 7);
                  byte = i >> 3;
 
                  if (strncmp (lp, "*/", 2) == 0)
                    break;
                  else if ((lp[0] == ' ' && lp[1] == ' ') || (lp[0] == '\t'))
                    {
                      while (*lp == ' ' || *lp == '\t')
                        lp ++;
                      op->syntax = strdup (lp);
                      lp = strstr (op->syntax, "*/");
                      if (lp)
                        {
                          *lp-- = 0;
                          while ((*lp == ' ' || *lp == '\t')
                                 && lp > op->syntax)
                            *lp-- = 0;
                        }
                      break;
                    }
                  else if (*lp == ' ')
                    var_start = 1;
                  else
                    {
                      if (*lp == '0' || *lp == '1')
                        {
                          op->b[byte].decodable_mask |= 1 << bit;
                          var_start = 1;
                          if (op->dbytes < byte + 1)
                            op->dbytes = byte + 1;
                        }
                      else if (var_start)
                        {
                          op->var_start[i] = 1;
                          var_start = 0;
                          if (op->dbytes < byte + 1)
                            op->dbytes = byte + 1;
                        }
                      if (*lp == '1')
                        op->b[byte].decodable_bits |= 1 << bit;
 
                      op->nbytes = byte + 1;
                      op->id[i++] = *lp;
                    }
                }
            }
        }
      else if (!skipping_section)
        {
          op->nlines++;
          if (op->lines)
            op->lines =
              (char **) realloc (op->lines, op->nlines * sizeof (char *));
          else
            op->lines = (char **) malloc (op->nlines * sizeof (char *));
          op->lines[op->nlines - 1] = strdup (line);
        }
    }
 
  {
    int i, j;
    for (i = 0; i < n_varies; i++)
      {
        Vary *v = vary[i];
        lprintf (sim_log, "V[%s] %d\n", v->name, v->nlen);
        for (j = 0; j < v->n_patterns; j++)
          lprintf (sim_log, "  P %02x\n", v->patterns[j]);
      }
  }
 
  for (i = n_opcodes - 2; i >= 0; i--)
    {
      if (opcodes[i]->nlines == 0)
        {
          opcodes[i]->nlines = opcodes[i + 1]->nlines;
          opcodes[i]->lines = opcodes[i + 1]->lines;
        }
    }
 
  for (i = 0; i < 256; i++)
    indirect[i].type = T_unused;
 
  qsort (opcodes, n_opcodes, sizeof (opcodes[0]), op_cmp);
 
  vlist = (VaryRef *) malloc (n_varies * sizeof (VaryRef));
 
  for (i = 0; i < n_opcodes; i++)
    {
      int j, b, v;
 
      for (j = 0; j < opcodes[i]->nbytes; j++)
        lprintf (sim_log, "%s ",
                 prmb (opcodes[i]->b[j].decodable_mask,
                       opcodes[i]->b[j].decodable_bits));
      lprintf (sim_log, " %s\n", opcodes[i]->comment);
 
      for (j = 0; j < opcodes[i]->nbytes; j++)
        {
          for (b = 0; b < 8; b++)
            if (isalpha (opcodes[i]->id[j * 8 + b]))
              for (v = 0; v < n_varies; v++)
                if (fieldcmp (opcodes[i], j * 8 + b, vary[v]->name))
                  {
                    int nv = opcodes[i]->nvaries++;
                    if (nv)
                      opcodes[i]->vary =
                        (VaryRef *) realloc (opcodes[i]->vary,
                                             (nv + 1) * sizeof (VaryRef));
                    else
                      opcodes[i]->vary =
                        (VaryRef *) malloc ((nv + 1) * sizeof (VaryRef));
 
                    opcodes[i]->vary[nv].varyno = v;
                    opcodes[i]->vary[nv].byte = j;
                    opcodes[i]->vary[nv].shift = 8 - b - vary[v]->nlen;
                    lprintf (sim_log, "[vary %s shift %d]\n",
                             vary[v]->name, opcodes[i]->vary[nv].shift);
                  }
 
        }
    }
 
  for (i = 0; i < n_opcodes; i++)
    {
      int i2;
      int bytes = opcodes[i]->dbytes;
 
      lprintf (sim_log, "\nmask:");
      for (i2 = 0; i2 < opcodes[i]->nbytes; i2++)
        lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_mask);
      lprintf (sim_log, "%*s%s\n", 13 - 3 * opcodes[i]->nbytes, "",
               opcodes[i]->comment);
 
      lprintf (sim_log, "bits:");
      for (i2 = 0; i2 < opcodes[i]->nbytes; i2++)
        lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_bits);
      lprintf (sim_log, "%*s(%s) %d byte%s\n", 13 - 3 * opcodes[i]->nbytes,
               "", opcodes[i]->id, bytes, bytes == 1 ? "" : "s");
 
      store_opcode_bits (opcodes[i], 0, indirect);
    }
 
  dump_lines (&prefix_text, 0, 0);
 
  emit_indirect (indirect, 0);
 
  dump_lines (&suffix_text, 0, 0);
 
  if (sim_log)
    log_indirect (indirect, 0);
 
  return errors;
}

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [opcodes/] [opc2c.c] - Blame information for rev 533

Line No.	Rev	Author	Line
1	330	jeremybenn	`/* opc2c.c --- generate C opcode decoder code from from .opc file`
2
3			`Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc.`
4			`Contributed by Red Hat, Inc.`
5
6			`This file is part of the GNU opcode library.`
7
8			`This program is free software; you can redistribute it and/or modify`
9			`it under the terms of the GNU General Public License as published by`
10			`the Free Software Foundation; either version 3 of the License, or`
11			`(at your option) any later version.`
12
13			`This program is distributed in the hope that it will be useful,`
14			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
15			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
16			`GNU General Public License for more details.`
17
18			`You should have received a copy of the GNU General Public License`
19			`along with this program. If not, see <http://www.gnu.org/licenses/>. */`
20
21
22			`#include <stdio.h>`
23			`#include <string.h>`
24			`#include <ctype.h>`
25			`#include <stdlib.h>`
26			`#include <errno.h>`
27			`#include "libiberty.h"`
28
29			`static char * line_buf = NULL;`
30			`static int line_buf_size = 0;`
31
32			`#define LBUFINCR 100`
33
34			`char *`
35			`safe_fgets (FILE * f)`
36			`{`
37			`char * line_ptr;`
38
39			`if (line_buf == NULL)`
40			`{`
41			`line_buf = (char *) malloc (LBUFINCR);`
42			`line_buf_size = LBUFINCR;`
43			`}`
44
45			`/* Points to last byte. */`
46			`line_ptr = line_buf + line_buf_size - 1;`
47
48			`/* So we can see if fgets put a 0 there. */`
49			`*line_ptr = 1;`
50			`if (fgets (line_buf, line_buf_size, f) == 0)`
51			`return NULL;`
52
53			`/* We filled the buffer? */`
54			`while (line_ptr[0] == 0 && line_ptr[-1] != '\n')`
55			`{`
56			`/* Make the buffer bigger and read more of the line. */`
57			`line_buf_size += LBUFINCR;`
58			`line_buf = (char *) realloc (line_buf, line_buf_size);`
59
60			`/* Points to last byte again. */`
61			`line_ptr = line_buf + line_buf_size - 1;`
62			`/* So we can see if fgets put a 0 there. */`
63			`*line_ptr = 1;`
64
65			`if (fgets (line_buf + line_buf_size - LBUFINCR - 1, LBUFINCR + 1, f) == 0)`
66			`return NULL;`
67			`}`
68
69			`return line_buf;`
70			`}`
71
72
73			`static int errors = 0;`
74
75			`#define MAX_BYTES 10`
76
77			`typedef struct`
78			`{`
79			`int varyno:16;`
80			`int byte:8;`
81			`int shift:8;`
82			`} VaryRef;`
83
84			`typedef struct`
85			`{`
86			`char nbytes;`
87			`char dbytes;`
88			`char id[MAX_BYTES * 8 + 1];`
89			`unsigned char var_start[MAX_BYTES * 8 + 1];`
90			`struct`
91			`{`
92			`unsigned char decodable_mask;`
93			`unsigned char decodable_bits;`
94			`} b[MAX_BYTES];`
95			`char * comment;`
96			`char * syntax;`
97			`int lineno;`
98			`int nlines;`
99			`char ** lines;`
100			`struct Indirect * last_ind;`
101			`int semantics_label;`
102			`int nvaries;`
103			`VaryRef * vary;`
104			`} opcode;`
105
106			`int n_opcodes;`
107			`opcode ** opcodes;`
108			`opcode * op;`
109
110			`typedef struct`
111			`{`
112			`char * name;`
113			`int nlen;`
114			`unsigned char mask;`
115			`int n_patterns;`
116			`unsigned char * patterns;`
117			`} Vary;`
118
119			`Vary ** vary = 0;`
120			`int n_varies = 0;`
121
122			`unsigned char cur_bits[MAX_BYTES + 1];`
123
124			`char * orig_filename;`
125
126			`FILE * sim_log = NULL;`
127			`#define lprintf if (sim_log) fprintf`
128
129			`opcode prefix_text, suffix_text;`
130
131			`typedef enum`
132			`{`
133			`T_unused,`
134			`T_op,`
135			`T_indirect,`
136			`T_done`
137			`} OpType;`
138
139			`typedef struct Indirect`
140			`{`
141			`OpType type;`
142			`union`
143			`{`
144			`struct Indirect * ind;`
145			`opcode * op;`
146			`} u;`
147			`} Indirect;`
148
149			`Indirect indirect[256];`
150
151			`static int`
152			`next_varybits (int bits, opcode * op, int byte)`
153			`{`
154			`int mask = op->b[byte].decodable_mask;`
155			`int i;`
156
157			`for (i = 0; i < 8; i++)`
158			`if (!(mask & (1 << i)))`
159			`{`
160			`if (bits & (1 << i))`
161			`{`
162			`bits &= ~(1 << i);`
163			`}`
164			`else`
165			`{`
166			`bits \|= (1 << i);`
167			`return bits;`
168			`}`
169			`}`
170			`return 0;`
171			`}`
172
173			`static int`
174			`valid_varybits (int bits, opcode * op, int byte)`
175			`{`
176			`if (op->nvaries)`
177			`{`
178			`int vn;`
179
180			`for (vn = 0; vn < op->nvaries; vn++)`
181			`{`
182			`Vary * v;`
183			`int found = 0;`
184			`int i;`
185			`int ob;`
186
187			`if (byte != op->vary[vn].byte)`
188			`continue;`
189			`v = vary[op->vary[vn].varyno];`
190			`ob = (bits >> op->vary[vn].shift) & v->mask;`
191			`lprintf (sim_log, "varybits: vary %s ob %x\n", v->name, ob);`
192
193			`for (i = 0; i < v->n_patterns; i++)`
194			`if (ob == v->patterns[i])`
195			`{`
196			`lprintf (sim_log, " found at %d\n", i);`
197			`found = 1;`
198			`break;`
199			`}`
200			`if (!found)`
201			`return 0;`
202			`}`
203			`}`
204			`return 1;`
205			`}`
206
207			`char *`
208			`prmb (int mask, int bits)`
209			`{`
210			`static char buf[8][30];`
211			`static int bn = 0;`
212			`char * bp;`
213
214			`bn = (bn + 1) % 8;`
215			`bp = buf[bn];`
216			`int i;`
217			`for (i = 0; i < 8; i++)`
218			`{`
219			`int bit = 0x80 >> i;`
220
221			`if (!(mask & bit))`
222			`*bp++ = '-';`
223			`else if (bits & bit)`
224			`*bp++ = '1';`
225			`else`
226			`*bp++ = '0';`
227			`if (i % 4 == 3)`
228			`*bp++ = ' ';`
229			`}`
230			`*--bp = 0;`
231			`return buf[bn];`
232			`}`
233
234			`static int`
235			`op_cmp (const void va, const void vb)`
236			`{`
237			`const opcode * a = (const opcode *) va;`
238			`const opcode * b = (const opcode *) vb;`
239
240			`if (a->nbytes != b->nbytes)`
241			`return a->nbytes - b->nbytes;`
242
243			`return strcmp (a->id, b->id);`
244			`}`
245
246			`void`
247			`dump_lines (opcode * op, int level, Indirect * ind)`
248			`{`
249			`char * varnames[40];`
250			`int i, vn = 0;`
251
252			`if (op->semantics_label)`
253			`{`
254			`printf ("%*sgoto op_semantics_%d;\n", level, "", op->semantics_label);`
255			`return;`
256			`}`
257
258			`if (ind != op->last_ind)`
259			`{`
260			`static int labelno = 0;`
261			`labelno++;`
262			`printf ("%*sop_semantics_%d:\n", level, "", labelno);`
263			`op->semantics_label = labelno;`
264			`}`
265
266			`if (op->comment)`
267			`{`
268			`level += 2;`
269			`printf ("%*s{\n", level, "");`
270			`printf ("%*s %s\n", level, "", op->comment);`
271			`}`
272
273			`for (i = 0; i < op->nbytes * 8;)`
274			`{`
275			`if (isalpha (op->id[i]))`
276			`{`
277			`int byte = i >> 3;`
278			`int mask = 0;`
279			`int shift = 0;`
280			`char name[33];`
281			`char * np = name;`
282
283			`while (op->id[i] && isalpha (op->id[i]))`
284			`{`
285			`mask = (mask << 1) \| 1;`
286			`shift = 7 - (i & 7);`
287			`*np++ = op->id[i++];`
288			`if (op->var_start[i])`
289			`break;`
290			`}`
291			`*np = 0;`
292			`varnames[vn++] = strdup (name);`
293			`printf ("#line %d \"%s\"\n", op->lineno + 1, orig_filename);`
294			`if (mask & ~0xff)`
295			`{`
296			`fprintf (stderr, "Error: variable %s spans bytes: %s\n",`
297			`name, op->comment);`
298			`errors++;`
299			`}`
300			`else if (shift && (mask != 0xff))`
301			`printf ("%*s int %s AU = (op[%d] >> %d) & 0x%02x;\n",`
302			`level, "", name, byte, shift, mask);`
303			`else if (mask != 0xff)`
304			`printf ("%*s int %s AU = op[%d] & 0x%02x;\n",`
305			`level, "", name, byte, mask);`
306			`else`
307			`printf ("%*s int %s AU = op[%d];\n", level, "", name, byte);`
308			`}`
309			`else`
310			`i++;`
311			`}`
312
313			`if (op->comment)`
314			`{`
315			`printf ("%*s if (trace)\n", level, "");`
316			`printf ("%*s {\n", level, "");`
317			`printf ("%*s printf (\"\\033[33m%%s\\033[0m ", level, "");`
318			`for (i = 0; i < op->nbytes; i++)`
319			`printf (" %%02x");`
320			`printf ("\\n\"");`
321			`printf (",\n%*s \"%s\"", level, "", op->comment);`
322			`for (i = 0; i < op->nbytes; i++)`
323			`{`
324			`if (i == 0)`
325			`printf (",\n%*s op[%d]", level, "", i);`
326			`else`
327			`printf (", op[%d]", i);`
328			`}`
329			`printf (");\n");`
330			`for (i = 0; i < vn; i++)`
331			`printf ("%*s printf (\" %s = 0x%%x%s\", %s);\n", level, "",`
332			`varnames[i], (i < vn - 1) ? "," : "\\n", varnames[i]);`
333			`printf ("%*s }\n", level, "");`
334			`}`
335
336			`if (op->syntax)`
337			`printf ("%*s SYNTAX(\"%s\");\n", level, "", op->syntax);`
338
339			`printf ("#line %d \"%s\"\n", op->lineno + 1, orig_filename);`
340
341			`for (i = 0; i < op->nlines; i++)`
342			`printf ("%*s%s", level, "", op->lines[i]);`
343
344			`if (op->comment)`
345			`printf ("%*s}\n", level, "");`
346			`}`
347
348			`void`
349			`store_opcode_bits (opcode * op, int byte, Indirect * ind)`
350			`{`
351			`int bits = op->b[byte].decodable_bits;`
352
353			`do`
354			`{`
355			`if (!valid_varybits (bits, op, byte))`
356			`continue;`
357
358			`switch (ind[bits].type)`
359			`{`
360			`case T_unused:`
361			`if (byte == op->dbytes - 1)`
362			`{`
363			`ind[bits].type = T_op;`
364			`ind[bits].u.op = op;`
365			`op->last_ind = ind;`
366			`break;`
367			`}`
368			`else`
369			`{`
370			`int i2;`
371
372			`ind[bits].type = T_indirect;`
373			`ind[bits].u.ind = (Indirect ) malloc (256 sizeof (Indirect));`
374			`for (i2 = 0; i2 < 256; i2++)`
375			`ind[bits].u.ind[i2].type = T_unused;`
376			`store_opcode_bits (op, byte + 1, ind[bits].u.ind);`
377			`}`
378			`break;`
379
380			`case T_indirect:`
381			`if (byte < op->dbytes - 1)`
382			`store_opcode_bits (op, byte + 1, ind[bits].u.ind);`
383			`break;`
384
385			`case T_op:`
386			`break;`
387
388			`case T_done:`
389			`break;`
390			`}`
391			`}`
392			`while ((bits = next_varybits (bits, op, byte)) != 0);`
393			`}`
394
395			`void`
396			`emit_indirect (Indirect * ind, int byte)`
397			`{`
398			`int unsup = 0;`
399			`int j, n, mask;`
400
401			`mask = 0;`
402			`for (j = 0; j < 256; j++)`
403			`{`
404			`switch (ind[j].type)`
405			`{`
406			`case T_indirect:`
407			`mask = 0xff;`
408			`break;`
409			`case T_op:`
410			`mask \|= ind[j].u.op->b[byte].decodable_mask;`
411			`break;`
412			`case T_done:`
413			`case T_unused:`
414			`break;`
415			`}`
416			`}`
417
418			`printf ("%s GETBYTE ();\n", byte 6, "");`
419			`printf ("%s switch (op[%d] & 0x%02x)\n", byte 6, "", byte, mask);`
420			`printf ("%s {\n", byte 6, "");`
421
422			`for (j = 0; j < 256; j++)`
423			`if ((j & ~mask) == 0)`
424			`{`
425			`switch (ind[j].type)`
426			`{`
427			`case T_done:`
428			`break;`
429			`case T_unused:`
430			`unsup = 1;`
431			`break;`
432			`case T_op:`
433			`for (n = j; n < 256; n++)`
434			`if ((n & ~mask) == 0`
435			`&& ind[n].type == T_op && ind[n].u.op == ind[j].u.op)`
436			`{`
437			`ind[n].type = T_done;`
438			`printf ("%s case 0x%02x:\n", byte 6, "", n);`
439			`}`
440			`for (n = byte; n < ind[j].u.op->nbytes - 1; n++)`
441			`printf ("%s GETBYTE();\n", byte 6, "");`
442			`dump_lines (ind[j].u.op, byte * 6 + 6, ind);`
443			`printf ("%s break;\n", byte 6, "");`
444			`break;`
445			`case T_indirect:`
446			`printf ("%s case 0x%02x:\n", byte 6, "", j);`
447			`emit_indirect (ind[j].u.ind, byte + 1);`
448			`printf ("%s break;\n", byte 6, "");`
449			`break;`
450			`}`
451			`}`
452			`if (unsup)`
453			`printf ("%s default: UNSUPPORTED(); break;\n", byte 6, "");`
454			`printf ("%s }\n", byte 6, "");`
455			`}`
456
457			`static char *`
458			`pv_dup (char * p, char * ep)`
459			`{`
460			`int n = ep - p;`
461			`char rv = (char ) malloc (n + 1);`
462
463			`memcpy (rv, p, n);`
464			`rv[n] = 0;`
465			`return rv;`
466			`}`
467
468			`static unsigned char`
469			`str2mask (char * str, char * ep)`
470			`{`
471			`unsigned char rv = 0;`
472
473			`while (str < ep)`
474			`{`
475			`rv *= 2;`
476			`if (*str == '1')`
477			`rv += 1;`
478			`str++;`
479			`}`
480			`return rv;`
481			`}`
482
483			`static void`
484			`process_vary (char * line)`
485			`{`
486			`char * cp;`
487			`char * ep;`
488			`Vary * v = (Vary *) malloc (sizeof (Vary));`
489
490			`n_varies++;`
491			`if (vary)`
492			`vary = (Vary *) realloc (vary, n_varies sizeof (Vary *));`
493			`else`
494			`vary = (Vary *) malloc (n_varies sizeof (Vary *));`
495			`vary[n_varies - 1] = v;`
496
497			`cp = line;`
498
499			`for (cp = line; isspace (*cp); cp++);`
500			`for (ep = cp; ep && !isspace (ep); ep++);`
501
502			`v->name = pv_dup (cp, ep);`
503			`v->nlen = strlen (v->name);`
504			`v->mask = (1 << v->nlen) - 1;`
505
506			`v->n_patterns = 0;`
507			`v->patterns = (unsigned char *) malloc (1);`
508			`while (1)`
509			`{`
510			`for (cp = ep; isspace (*cp); cp++);`
511			`if (!isdigit (*cp))`
512			`break;`
513			`for (ep = cp; ep && !isspace (ep); ep++);`
514			`v->n_patterns++;`
515			`v->patterns = (unsigned char *) realloc (v->patterns, v->n_patterns);`
516			`v->patterns[v->n_patterns - 1] = str2mask (cp, ep);`
517			`}`
518			`}`
519
520			`static int`
521			`fieldcmp (opcode * op, int bit, char *name)`
522			`{`
523			`int n = strlen (name);`
524
525			`if (memcmp (op->id + bit, name, n) == 0`
526			`&& (!isalpha (op->id[bit + n]) \|\| op->var_start[bit + n]))`
527			`return 1;`
528			`return 0;`
529			`}`
530
531			`static void`
532			`log_indirect (Indirect * ind, int byte)`
533			`{`
534			`int i, j;`
535			`char * last_c = 0;`
536
537			`for (i = 0; i < 256; i++)`
538			`{`
539
540			`for (j = 0; j < byte; j++)`
541			`fprintf (sim_log, "%s ", prmb (255, cur_bits[j]));`
542			`fprintf (sim_log, "%s ", prmb (255, i));`
543
544			`switch (ind[i].type)`
545			`{`
546			`case T_op:`
547			`case T_done:`
548			`if (last_c && (ind[i].u.op->comment == last_c))`
549			`fprintf (sim_log, "''\n");`
550			`else`
551			`fprintf (sim_log, "%s\n", ind[i].u.op->comment);`
552			`last_c = ind[i].u.op->comment;`
553			`break;`
554			`case T_unused:`
555			`fprintf (sim_log, "unused\n");`
556			`break;`
557			`case T_indirect:`
558			`fprintf (sim_log, "indirect\n");`
559			`cur_bits[byte] = i;`
560			`log_indirect (ind[i].u.ind, byte + 1);`
561			`last_c = 0;`
562			`break;`
563			`}`
564			`}`
565			`}`
566
567			`int`
568			`main (int argc, char ** argv)`
569			`{`
570			`char * line;`
571			`FILE * in;`
572			`int lineno = 0;`
573			`int i;`
574			`VaryRef * vlist;`
575			`int skipping_section = 0;`
576
577			`if (argc > 2 && strcmp (argv[1], "-l") == 0)`
578			`{`
579			`sim_log = fopen (argv[2], "w");`
580			`fprintf (stderr, "sim_log: %s\n", argv[2]);`
581			`argc -= 2;`
582			`argv += 2;`
583			`}`
584
585			`if (argc < 2)`
586			`{`
587			`fprintf (stderr, "usage: opc2c infile.opc > outfile.opc\n");`
588			`exit (1);`
589			`}`
590
591			`orig_filename = lbasename (argv[1]);`
592			`in = fopen (argv[1], "r");`
593			`if (!in)`
594			`{`
595			`fprintf (stderr, "Unable to open file %s for reading: %s\n", argv[1],`
596			`xstrerror (errno));`
597			`exit (1);`
598			`}`
599
600			`n_opcodes = 0;`
601			`opcodes = (opcode *) malloc (sizeof (opcode ));`
602			`op = &prefix_text;`
603			`op->lineno = 0;`
604			`while ((line = safe_fgets (in)) != 0)`
605			`{`
606			`lineno++;`
607			`if (strncmp (line, "/? ", 5) == 0)`
608			`{`
609			`skipping_section = 1;`
610			`continue;`
611			`}`
612			`if (strncmp (line, " /** ", 6) == 0`
613			`&& (isdigit (line[6]) \|\| memcmp (line + 6, "VARY", 4) == 0))`
614			`line += 2;`
615			`if (line[0] == '/' && line[1] == '' && line[2] == '')`
616			`{`
617			`skipping_section = 0;`
618			`if (strncmp (line, "/** */", 6) == 0)`
619			`{`
620			`op = &suffix_text;`
621			`op->lineno = lineno;`
622			`}`
623			`else if (strncmp (line, "/** VARY ", 9) == 0)`
624			`process_vary (line + 9);`
625			`else`
626			`{`
627			`char * lp;`
628			`int i, bit, byte;`
629			`int var_start = 1;`
630
631			`n_opcodes++;`
632			`opcodes =`
633			`(opcode *) realloc (opcodes, n_opcodes sizeof (opcode *));`
634			`op = (opcode *) malloc (sizeof (opcode));`
635			`opcodes[n_opcodes - 1] = op;`
636
637			`op->nbytes = op->dbytes = 0;`
638			`memset (op->id, 0, sizeof (op->id));`
639			`memset (op->var_start, 0, sizeof (op->var_start));`
640			`for (i = 0; i < MAX_BYTES; i++)`
641			`{`
642			`op->b[i].decodable_mask = 0;`
643			`op->b[i].decodable_bits = 0;`
644			`}`
645			`op->comment = strdup (line);`
646			`op->comment[strlen (op->comment) - 1] = 0;`
647			`while (op->comment[0] && isspace (op->comment[0]))`
648			`op->comment++;`
649			`op->lineno = lineno;`
650			`op->nlines = 0;`
651			`op->lines = 0;`
652			`op->last_ind = 0;`
653			`op->semantics_label = 0;`
654			`op->nvaries = 0;`
655			`op->vary = 0;`
656
657			`i = 0;`
658			`for (lp = line + 4; *lp; lp++)`
659			`{`
660			`bit = 7 - (i & 7);`
661			`byte = i >> 3;`
662
663			`if (strncmp (lp, "*/", 2) == 0)`
664			`break;`
665			`else if ((lp[0] == ' ' && lp[1] == ' ') \|\| (lp[0] == '\t'))`
666			`{`
667			`while (lp == ' ' \|\| lp == '\t')`
668			`lp ++;`
669			`op->syntax = strdup (lp);`
670			`lp = strstr (op->syntax, "*/");`
671			`if (lp)`
672			`{`
673			`*lp-- = 0;`
674			`while ((lp == ' ' \|\| lp == '\t')`
675			`&& lp > op->syntax)`
676			`*lp-- = 0;`
677			`}`
678			`break;`
679			`}`
680			`else if (*lp == ' ')`
681			`var_start = 1;`
682			`else`
683			`{`
684			`if (lp == '0' \|\| lp == '1')`
685			`{`
686			`op->b[byte].decodable_mask \|= 1 << bit;`
687			`var_start = 1;`
688			`if (op->dbytes < byte + 1)`
689			`op->dbytes = byte + 1;`
690			`}`
691			`else if (var_start)`
692			`{`
693			`op->var_start[i] = 1;`
694			`var_start = 0;`
695			`if (op->dbytes < byte + 1)`
696			`op->dbytes = byte + 1;`
697			`}`
698			`if (*lp == '1')`
699			`op->b[byte].decodable_bits \|= 1 << bit;`
700
701			`op->nbytes = byte + 1;`
702			`op->id[i++] = *lp;`
703			`}`
704			`}`
705			`}`
706			`}`
707			`else if (!skipping_section)`
708			`{`
709			`op->nlines++;`
710			`if (op->lines)`
711			`op->lines =`
712			`(char *) realloc (op->lines, op->nlines sizeof (char *));`
713			`else`
714			`op->lines = (char *) malloc (op->nlines sizeof (char *));`
715			`op->lines[op->nlines - 1] = strdup (line);`
716			`}`
717			`}`
718
719			`{`
720			`int i, j;`
721			`for (i = 0; i < n_varies; i++)`
722			`{`
723			`Vary *v = vary[i];`
724			`lprintf (sim_log, "V[%s] %d\n", v->name, v->nlen);`
725			`for (j = 0; j < v->n_patterns; j++)`
726			`lprintf (sim_log, " P %02x\n", v->patterns[j]);`
727			`}`
728			`}`
729
730			`for (i = n_opcodes - 2; i >= 0; i--)`
731			`{`
732			`if (opcodes[i]->nlines == 0)`
733			`{`
734			`opcodes[i]->nlines = opcodes[i + 1]->nlines;`
735			`opcodes[i]->lines = opcodes[i + 1]->lines;`
736			`}`
737			`}`
738
739			`for (i = 0; i < 256; i++)`
740			`indirect[i].type = T_unused;`
741
742			`qsort (opcodes, n_opcodes, sizeof (opcodes[0]), op_cmp);`
743
744			`vlist = (VaryRef ) malloc (n_varies sizeof (VaryRef));`
745
746			`for (i = 0; i < n_opcodes; i++)`
747			`{`
748			`int j, b, v;`
749
750			`for (j = 0; j < opcodes[i]->nbytes; j++)`
751			`lprintf (sim_log, "%s ",`
752			`prmb (opcodes[i]->b[j].decodable_mask,`
753			`opcodes[i]->b[j].decodable_bits));`
754			`lprintf (sim_log, " %s\n", opcodes[i]->comment);`
755
756			`for (j = 0; j < opcodes[i]->nbytes; j++)`
757			`{`
758			`for (b = 0; b < 8; b++)`
759			`if (isalpha (opcodes[i]->id[j * 8 + b]))`
760			`for (v = 0; v < n_varies; v++)`
761			`if (fieldcmp (opcodes[i], j * 8 + b, vary[v]->name))`
762			`{`
763			`int nv = opcodes[i]->nvaries++;`
764			`if (nv)`
765			`opcodes[i]->vary =`
766			`(VaryRef *) realloc (opcodes[i]->vary,`
767			`(nv + 1) * sizeof (VaryRef));`
768			`else`
769			`opcodes[i]->vary =`
770			`(VaryRef ) malloc ((nv + 1) sizeof (VaryRef));`
771
772			`opcodes[i]->vary[nv].varyno = v;`
773			`opcodes[i]->vary[nv].byte = j;`
774			`opcodes[i]->vary[nv].shift = 8 - b - vary[v]->nlen;`
775			`lprintf (sim_log, "[vary %s shift %d]\n",`
776			`vary[v]->name, opcodes[i]->vary[nv].shift);`
777			`}`
778
779			`}`
780			`}`
781
782			`for (i = 0; i < n_opcodes; i++)`
783			`{`
784			`int i2;`
785			`int bytes = opcodes[i]->dbytes;`
786
787			`lprintf (sim_log, "\nmask:");`
788			`for (i2 = 0; i2 < opcodes[i]->nbytes; i2++)`
789			`lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_mask);`
790			`lprintf (sim_log, "%s%s\n", 13 - 3 opcodes[i]->nbytes, "",`
791			`opcodes[i]->comment);`
792
793			`lprintf (sim_log, "bits:");`
794			`for (i2 = 0; i2 < opcodes[i]->nbytes; i2++)`
795			`lprintf (sim_log, " %02x", opcodes[i]->b[i2].decodable_bits);`
796			`lprintf (sim_log, "%s(%s) %d byte%s\n", 13 - 3 opcodes[i]->nbytes,`
797			`"", opcodes[i]->id, bytes, bytes == 1 ? "" : "s");`
798
799			`store_opcode_bits (opcodes[i], 0, indirect);`
800			`}`
801
802			`dump_lines (&prefix_text, 0, 0);`
803
804			`emit_indirect (indirect, 0);`
805
806			`dump_lines (&suffix_text, 0, 0);`
807
808			`if (sim_log)`
809			`log_indirect (indirect, 0);`
810
811			`return errors;`
812			`}`