URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [sim/] [m32c/] [opc2c.c] - Blame information for rev 26

Details | Compare with Previous | View Log


/* opc2c.c --- generate C simulator code from from .opc file
 
Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
 
This file is part of the GNU simulators.
 
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 "safe-fgets.h"
 
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;
  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 = 0;
#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++)
        {
          int found = 0;
          int i;
          int ob;
 
          if (byte != op->vary[vn].byte)
            continue;
          Vary *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, 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      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, "");
    }
  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);
  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, *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++)
    {
      if (ind[i].type == T_unused)
        continue;
 
      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, "-\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;
 
  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 = argv[1];
  in = fopen (argv[1], "r");
  if (!in)
    {
      fprintf (stderr, "Unable to open file %s for reading\n", argv[1]);
      perror ("The error was");
      exit (1);
    }
 
  n_opcodes = 0;
  opcodes = (opcode **) malloc (sizeof (opcode *));
  op = &prefix_text;
  op->lineno = 1;
  while ((line = safe_fgets (in)) != 0)
    {
      lineno++;
      if (strncmp (line, "  /** ", 6) == 0
          && (isdigit (line[6]) || memcmp (line + 6, "VARY", 4) == 0))
        line += 2;
      if (line[0] == '/' && line[1] == '*' && line[2] == '*')
        {
          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'))
                    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 (*lp == '1')
                        op->b[byte].decodable_bits |= 1 << bit;
 
                      op->nbytes = byte + 1;
                      op->id[i++] = *lp;
                    }
                }
            }
        }
      else
        {
          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 scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [sim/] [m32c/] [opc2c.c] - Blame information for rev 26

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