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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [sim/] [igen/] [table.c] - Blame information for rev 866

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


/* The IGEN simulator generator for GDB, the GNU Debugger.
 
   Copyright 2002, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 
   Contributed by Andrew Cagney.
 
   This file is part of GDB.
 
   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 <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
 
#include "config.h"
#include "misc.h"
#include "lf.h"
#include "table.h"
 
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
 
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
 
typedef struct _open_table open_table;
struct _open_table
{
  size_t size;
  char *buffer;
  char *pos;
  line_ref pseudo_line;
  line_ref real_line;
  open_table *parent;
  table *root;
};
struct _table
{
  open_table *current;
};
 
 
static line_ref *
current_line (open_table * file)
{
  line_ref *entry = ZALLOC (line_ref);
  *entry = file->pseudo_line;
  return entry;
}
 
static table_entry *
new_table_entry (open_table * file, table_entry_type type)
{
  table_entry *entry;
  entry = ZALLOC (table_entry);
  entry->file = file->root;
  entry->line = current_line (file);
  entry->type = type;
  return entry;
}
 
static void
set_nr_table_entry_fields (table_entry *entry, int nr_fields)
{
  entry->field = NZALLOC (char *, nr_fields + 1);
  entry->nr_fields = nr_fields;
}
 
 
void
table_push (table *root,
            line_ref *line, table_include *includes, const char *file_name)
{
  FILE *ff;
  open_table *file;
  table_include dummy;
  table_include *include = &dummy;
 
  /* dummy up a search of this directory */
  dummy.next = includes;
  dummy.dir = "";
 
  /* create a file descriptor */
  file = ZALLOC (open_table);
  if (file == NULL)
    {
      perror (file_name);
      exit (1);
    }
  file->root = root;
  file->parent = root->current;
  root->current = file;
 
  while (1)
    {
      /* save the file name */
      char *dup_name =
        NZALLOC (char, strlen (include->dir) + strlen (file_name) + 2);
      if (dup_name == NULL)
        {
          perror (file_name);
          exit (1);
        }
      if (include->dir[0] != '\0')
        {
          strcat (dup_name, include->dir);
          strcat (dup_name, "/");
        }
      strcat (dup_name, file_name);
      file->real_line.file_name = dup_name;
      file->pseudo_line.file_name = dup_name;
      /* open the file */
 
      ff = fopen (dup_name, "rb");
      if (ff)
        break;
      /* zfree (dup_name); */
      if (include->next == NULL)
        {
          if (line != NULL)
            error (line, "Problem opening file `%s'\n", file_name);
          perror (file_name);
          exit (1);
        }
      include = include->next;
    }
 
 
  /* determine the size */
  fseek (ff, 0, SEEK_END);
  file->size = ftell (ff);
  fseek (ff, 0, SEEK_SET);
 
  /* allocate this much memory */
  file->buffer = (char *) zalloc (file->size + 1);
  if (file->buffer == NULL)
    {
      perror (file_name);
      exit (1);
    }
  file->pos = file->buffer;
 
  /* read it all in */
  if (fread (file->buffer, 1, file->size, ff) < file->size)
    {
      perror (file_name);
      exit (1);
    }
  file->buffer[file->size] = '\0';
 
  /* set the initial line numbering */
  file->real_line.line_nr = 1;  /* specifies current line */
  file->pseudo_line.line_nr = 1;        /* specifies current line */
 
  /* done */
  fclose (ff);
}
 
table *
table_open (const char *file_name)
{
  table *root;
 
  /* create a file descriptor */
  root = ZALLOC (table);
  if (root == NULL)
    {
      perror (file_name);
      exit (1);
    }
 
  table_push (root, NULL, NULL, file_name);
  return root;
}
 
char *
skip_spaces (char *chp)
{
  while (1)
    {
      if (*chp == '\0' || *chp == '\n' || !isspace (*chp))
        return chp;
      chp++;
    }
}
 
 
char *
back_spaces (char *start, char *chp)
{
  while (1)
    {
      if (chp <= start || !isspace (chp[-1]))
        return chp;
      chp--;
    }
}
 
char *
skip_digits (char *chp)
{
  while (1)
    {
      if (*chp == '\0' || *chp == '\n' || !isdigit (*chp))
        return chp;
      chp++;
    }
}
 
char *
skip_to_separator (char *chp, char *separators)
{
  while (1)
    {
      char *sep = separators;
      while (1)
        {
          if (*chp == *sep)
            return chp;
          if (*sep == '\0')
            break;
          sep++;
        }
      chp++;
    }
}
 
static char *
skip_to_null (char *chp)
{
  return skip_to_separator (chp, "");
}
 
 
static char *
skip_to_nl (char *chp)
{
  return skip_to_separator (chp, "\n");
}
 
 
static void
next_line (open_table * file)
{
  file->pos = skip_to_nl (file->pos);
  if (*file->pos == '0')
    error (&file->pseudo_line, "Missing <nl> at end of line\n");
  *file->pos = '\0';
  file->pos += 1;
  file->real_line.line_nr += 1;
  file->pseudo_line.line_nr += 1;
}
 
 
extern table_entry *
table_read (table *root)
{
  open_table *file = root->current;
  table_entry *entry = NULL;
  while (1)
    {
 
      /* end-of-file? */
      while (*file->pos == '\0')
        {
          if (file->parent != NULL)
            {
              file = file->parent;
              root->current = file;
            }
          else
            return NULL;
        }
 
      /* code_block? */
      if (*file->pos == '{')
        {
          char *chp;
          next_line (file);     /* discard leading brace */
          entry = new_table_entry (file, table_code_entry);
          chp = file->pos;
          /* determine how many lines are involved - look for <nl> "}" */
          {
            int nr_lines = 0;
            while (*file->pos != '}')
              {
                next_line (file);
                nr_lines++;
              }
            set_nr_table_entry_fields (entry, nr_lines);
          }
          /* now enter each line */
          {
            int line_nr;
            for (line_nr = 0; line_nr < entry->nr_fields; line_nr++)
              {
                if (strncmp (chp, "  ", 2) == 0)
                  entry->field[line_nr] = chp + 2;
                else
                  entry->field[line_nr] = chp;
                chp = skip_to_null (chp) + 1;
              }
            /* skip trailing brace */
            ASSERT (*file->pos == '}');
            next_line (file);
          }
          break;
        }
 
      /* tab block? */
      if (*file->pos == '\t')
        {
          char *chp = file->pos;
          entry = new_table_entry (file, table_code_entry);
          /* determine how many lines are involved - look for <nl> !<tab> */
          {
            int nr_lines = 0;
            int nr_blank_lines = 0;
            while (1)
              {
                if (*file->pos == '\t')
                  {
                    nr_lines = nr_lines + nr_blank_lines + 1;
                    nr_blank_lines = 0;
                    next_line (file);
                  }
                else
                  {
                    file->pos = skip_spaces (file->pos);
                    if (*file->pos != '\n')
                      break;
                    nr_blank_lines++;
                    next_line (file);
                  }
              }
            set_nr_table_entry_fields (entry, nr_lines);
          }
          /* now enter each line */
          {
            int line_nr;
            for (line_nr = 0; line_nr < entry->nr_fields; line_nr++)
              {
                if (*chp == '\t')
                  entry->field[line_nr] = chp + 1;
                else
                  entry->field[line_nr] = "";   /* blank */
                chp = skip_to_null (chp) + 1;
              }
          }
          break;
        }
 
      /* cpp directive? */
      if (file->pos[0] == '#')
        {
          char *chp = skip_spaces (file->pos + 1);
 
          /* cpp line-nr directive - # <line-nr> "<file>" */
          if (isdigit (*chp)
              && *skip_digits (chp) == ' '
              && *skip_spaces (skip_digits (chp)) == '"')
            {
              int line_nr;
              char *file_name;
              file->pos = chp;
              /* parse the number */
              line_nr = atoi (file->pos) - 1;
              /* skip to the file name */
              while (file->pos[0] != '0'
                     && file->pos[0] != '"' && file->pos[0] != '\0')
                file->pos++;
              if (file->pos[0] != '"')
                error (&file->real_line,
                       "Missing opening quote in cpp directive\n");
              /* parse the file name */
              file->pos++;
              file_name = file->pos;
              while (file->pos[0] != '"' && file->pos[0] != '\0')
                file->pos++;
              if (file->pos[0] != '"')
                error (&file->real_line,
                       "Missing closing quote in cpp directive\n");
              file->pos[0] = '\0';
              file->pos++;
              file->pos = skip_to_nl (file->pos);
              if (file->pos[0] != '\n')
                error (&file->real_line,
                       "Missing newline in cpp directive\n");
              file->pseudo_line.file_name = file_name;
              file->pseudo_line.line_nr = line_nr;
              next_line (file);
              continue;
            }
 
          /* #define and #undef - not implemented yet */
 
          /* Old style # comment */
          next_line (file);
          continue;
        }
 
      /* blank line or end-of-file? */
      file->pos = skip_spaces (file->pos);
      if (*file->pos == '\0')
        error (&file->pseudo_line, "Missing <nl> at end of file\n");
      if (*file->pos == '\n')
        {
          next_line (file);
          continue;
        }
 
      /* comment - leading // or # - skip */
      if ((file->pos[0] == '/' && file->pos[1] == '/')
          || (file->pos[0] == '#'))
        {
          next_line (file);
          continue;
        }
 
      /* colon field */
      {
        char *chp = file->pos;
        entry = new_table_entry (file, table_colon_entry);
        next_line (file);
        /* figure out how many fields */
        {
          int nr_fields = 1;
          char *tmpch = chp;
          while (1)
            {
              tmpch = skip_to_separator (tmpch, "\\:");
              if (*tmpch == '\\')
                {
                  /* eat the escaped character */
                  char *cp = tmpch;
                  while (cp[1] != '\0')
                    {
                      cp[0] = cp[1];
                      cp++;
                    }
                  cp[0] = '\0';
                  tmpch++;
                }
              else if (*tmpch != ':')
                break;
              else
                {
                  *tmpch = '\0';
                  tmpch++;
                  nr_fields++;
                }
            }
          set_nr_table_entry_fields (entry, nr_fields);
        }
        /* now parse them */
        {
          int field_nr;
          for (field_nr = 0; field_nr < entry->nr_fields; field_nr++)
            {
              chp = skip_spaces (chp);
              entry->field[field_nr] = chp;
              chp = skip_to_null (chp);
              *back_spaces (entry->field[field_nr], chp) = '\0';
              chp++;
            }
        }
        break;
      }
 
    }
 
  ASSERT (entry == NULL || entry->field[entry->nr_fields] == NULL);
  return entry;
}
 
extern void
table_print_code (lf *file, table_entry *entry)
{
  int field_nr;
  int nr = 0;
  for (field_nr = 0; field_nr < entry->nr_fields; field_nr++)
    {
      char *chp = entry->field[field_nr];
      int in_bit_field = 0;
      if (*chp == '#')
        lf_indent_suppress (file);
      while (*chp != '\0')
        {
          if (chp[0] == '{' && !isspace (chp[1]) && chp[1] != '\0')
            {
              in_bit_field = 1;
              nr += lf_putchr (file, '_');
            }
          else if (in_bit_field && chp[0] == ':')
            {
              nr += lf_putchr (file, '_');
            }
          else if (in_bit_field && *chp == '}')
            {
              nr += lf_putchr (file, '_');
              in_bit_field = 0;
            }
          else
            {
              nr += lf_putchr (file, *chp);
            }
          chp++;
        }
      if (in_bit_field)
        {
          line_ref line = *entry->line;
          line.line_nr += field_nr;
          error (&line, "Bit field brace miss match\n");
        }
      nr += lf_putchr (file, '\n');
    }
}
 
 
 
void
dump_line_ref (lf *file, char *prefix, const line_ref *line, char *suffix)
{
  lf_printf (file, "%s(line_ref*) 0x%lx", prefix, (long) line);
  if (line != NULL)
    {
      lf_indent (file, +1);
      lf_printf (file, "\n(line_nr %d)", line->line_nr);
      lf_printf (file, "\n(file_name %s)", line->file_name);
      lf_indent (file, -1);
    }
  lf_printf (file, "%s", suffix);
}
 
 
static const char *
table_entry_type_to_str (table_entry_type type)
{
  switch (type)
    {
    case table_code_entry:
      return "code-entry";
    case table_colon_entry:
      return "colon-entry";
    }
  return "*invalid*";
}
 
void
dump_table_entry (lf *file,
                  char *prefix, const table_entry *entry, char *suffix)
{
  lf_printf (file, "%s(table_entry*) 0x%lx", prefix, (long) entry);
  if (entry != NULL)
    {
      int field;
      lf_indent (file, +1);
      dump_line_ref (file, "\n(line ", entry->line, ")");
      lf_printf (file, "\n(type %s)", table_entry_type_to_str (entry->type));
      lf_printf (file, "\n(nr_fields %d)", entry->nr_fields);
      lf_printf (file, "\n(fields");
      lf_indent (file, +1);
      for (field = 0; field < entry->nr_fields; field++)
        lf_printf (file, "\n\"%s\"", entry->field[field]);
      lf_indent (file, -1);
      lf_printf (file, ")");
      lf_indent (file, -1);
    }
  lf_printf (file, "%s", suffix);
}
 
 
#ifdef MAIN
int
main (int argc, char **argv)
{
  table *t;
  table_entry *entry;
  lf *l;
  int line_nr;
 
  if (argc != 2)
    {
      printf ("Usage: table <file>\n");
      exit (1);
    }
 
  t = table_open (argv[1]);
  l = lf_open ("-", "stdout", lf_omit_references, lf_is_text, "tmp-table");
 
  line_nr = 0;
  do
    {
      char line[10];
      entry = table_read (t);
      line_nr++;
      sprintf (line, "(%d ", line_nr);
      dump_table_entry (l, line, entry, ")\n");
    }
  while (entry != NULL);
 
  return 0;
}
#endif

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [sim/] [igen/] [table.c] - Blame information for rev 866

Line No.	Rev	Author	Line
1	330	jeremybenn	`/* The IGEN simulator generator for GDB, the GNU Debugger.`
2
3			`Copyright 2002, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.`
4
5			`Contributed by Andrew Cagney.`
6
7			`This file is part of GDB.`
8
9			`This program is free software; you can redistribute it and/or modify`
10			`it under the terms of the GNU General Public License as published by`
11			`the Free Software Foundation; either version 3 of the License, or`
12			`(at your option) any later version.`
13
14			`This program is distributed in the hope that it will be useful,`
15			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
16			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
17			`GNU General Public License for more details.`
18
19			`You should have received a copy of the GNU General Public License`
20			`along with this program. If not, see <http://www.gnu.org/licenses/>. */`
21
22
23
24			`#include <sys/types.h>`
25			`#include <sys/stat.h>`
26			`#include <stdio.h>`
27			`#include <fcntl.h>`
28			`#include <ctype.h>`
29
30			`#include "config.h"`
31			`#include "misc.h"`
32			`#include "lf.h"`
33			`#include "table.h"`
34
35			`#ifdef HAVE_UNISTD_H`
36			`#include <unistd.h>`
37			`#endif`
38
39			`#ifdef HAVE_STDLIB_H`
40			`#include <stdlib.h>`
41			`#endif`
42
43			`typedef struct _open_table open_table;`
44			`struct _open_table`
45			`{`
46			`size_t size;`
47			`char *buffer;`
48			`char *pos;`
49			`line_ref pseudo_line;`
50			`line_ref real_line;`
51			`open_table *parent;`
52			`table *root;`
53			`};`
54			`struct _table`
55			`{`
56			`open_table *current;`
57			`};`
58
59
60			`static line_ref *`
61			`current_line (open_table * file)`
62			`{`
63			`line_ref *entry = ZALLOC (line_ref);`
64			`*entry = file->pseudo_line;`
65			`return entry;`
66			`}`
67
68			`static table_entry *`
69			`new_table_entry (open_table * file, table_entry_type type)`
70			`{`
71			`table_entry *entry;`
72			`entry = ZALLOC (table_entry);`
73			`entry->file = file->root;`
74			`entry->line = current_line (file);`
75			`entry->type = type;`
76			`return entry;`
77			`}`
78
79			`static void`
80			`set_nr_table_entry_fields (table_entry *entry, int nr_fields)`
81			`{`
82			`entry->field = NZALLOC (char *, nr_fields + 1);`
83			`entry->nr_fields = nr_fields;`
84			`}`
85
86
87			`void`
88			`table_push (table *root,`
89			`line_ref line, table_include includes, const char *file_name)`
90			`{`
91			`FILE *ff;`
92			`open_table *file;`
93			`table_include dummy;`
94			`table_include *include = &dummy;`
95
96			`/* dummy up a search of this directory */`
97			`dummy.next = includes;`
98			`dummy.dir = "";`
99
100			`/* create a file descriptor */`
101			`file = ZALLOC (open_table);`
102			`if (file == NULL)`
103			`{`
104			`perror (file_name);`
105			`exit (1);`
106			`}`
107			`file->root = root;`
108			`file->parent = root->current;`
109			`root->current = file;`
110
111			`while (1)`
112			`{`
113			`/* save the file name */`
114			`char *dup_name =`
115			`NZALLOC (char, strlen (include->dir) + strlen (file_name) + 2);`
116			`if (dup_name == NULL)`
117			`{`
118			`perror (file_name);`
119			`exit (1);`
120			`}`
121			`if (include->dir[0] != '\0')`
122			`{`
123			`strcat (dup_name, include->dir);`
124			`strcat (dup_name, "/");`
125			`}`
126			`strcat (dup_name, file_name);`
127			`file->real_line.file_name = dup_name;`
128			`file->pseudo_line.file_name = dup_name;`
129			`/* open the file */`
130
131			`ff = fopen (dup_name, "rb");`
132			`if (ff)`
133			`break;`
134			`/* zfree (dup_name); */`
135			`if (include->next == NULL)`
136			`{`
137			`if (line != NULL)`
138			error (line, "Problem opening file `%s'\n", file_name);
139			`perror (file_name);`
140			`exit (1);`
141			`}`
142			`include = include->next;`
143			`}`
144
145
146			`/* determine the size */`
147			`fseek (ff, 0, SEEK_END);`
148			`file->size = ftell (ff);`
149			`fseek (ff, 0, SEEK_SET);`
150
151			`/* allocate this much memory */`
152			`file->buffer = (char *) zalloc (file->size + 1);`
153			`if (file->buffer == NULL)`
154			`{`
155			`perror (file_name);`
156			`exit (1);`
157			`}`
158			`file->pos = file->buffer;`
159
160			`/* read it all in */`
161			`if (fread (file->buffer, 1, file->size, ff) < file->size)`
162			`{`
163			`perror (file_name);`
164			`exit (1);`
165			`}`
166			`file->buffer[file->size] = '\0';`
167
168			`/* set the initial line numbering */`
169			`file->real_line.line_nr = 1; /* specifies current line */`
170			`file->pseudo_line.line_nr = 1; /* specifies current line */`
171
172			`/* done */`
173			`fclose (ff);`
174			`}`
175
176			`table *`
177			`table_open (const char *file_name)`
178			`{`
179			`table *root;`
180
181			`/* create a file descriptor */`
182			`root = ZALLOC (table);`
183			`if (root == NULL)`
184			`{`
185			`perror (file_name);`
186			`exit (1);`
187			`}`
188
189			`table_push (root, NULL, NULL, file_name);`
190			`return root;`
191			`}`
192
193			`char *`
194			`skip_spaces (char *chp)`
195			`{`
196			`while (1)`
197			`{`
198			`if (chp == '\0' \|\| chp == '\n' \|\| !isspace (*chp))`
199			`return chp;`
200			`chp++;`
201			`}`
202			`}`
203
204
205			`char *`
206			`back_spaces (char start, char chp)`
207			`{`
208			`while (1)`
209			`{`
210			`if (chp <= start \|\| !isspace (chp[-1]))`
211			`return chp;`
212			`chp--;`
213			`}`
214			`}`
215
216			`char *`
217			`skip_digits (char *chp)`
218			`{`
219			`while (1)`
220			`{`
221			`if (chp == '\0' \|\| chp == '\n' \|\| !isdigit (*chp))`
222			`return chp;`
223			`chp++;`
224			`}`
225			`}`
226
227			`char *`
228			`skip_to_separator (char chp, char separators)`
229			`{`
230			`while (1)`
231			`{`
232			`char *sep = separators;`
233			`while (1)`
234			`{`
235			`if (chp == sep)`
236			`return chp;`
237			`if (*sep == '\0')`
238			`break;`
239			`sep++;`
240			`}`
241			`chp++;`
242			`}`
243			`}`
244
245			`static char *`
246			`skip_to_null (char *chp)`
247			`{`
248			`return skip_to_separator (chp, "");`
249			`}`
250
251
252			`static char *`
253			`skip_to_nl (char *chp)`
254			`{`
255			`return skip_to_separator (chp, "\n");`
256			`}`
257
258
259			`static void`
260			`next_line (open_table * file)`
261			`{`
262			`file->pos = skip_to_nl (file->pos);`
263			`if (*file->pos == '0')`
264			`error (&file->pseudo_line, "Missing <nl> at end of line\n");`
265			`*file->pos = '\0';`
266			`file->pos += 1;`
267			`file->real_line.line_nr += 1;`
268			`file->pseudo_line.line_nr += 1;`
269			`}`
270
271
272			`extern table_entry *`
273			`table_read (table *root)`
274			`{`
275			`open_table *file = root->current;`
276			`table_entry *entry = NULL;`
277			`while (1)`
278			`{`
279
280			`/* end-of-file? */`
281			`while (*file->pos == '\0')`
282			`{`
283			`if (file->parent != NULL)`
284			`{`
285			`file = file->parent;`
286			`root->current = file;`
287			`}`
288			`else`
289			`return NULL;`
290			`}`
291
292			`/* code_block? */`
293			`if (*file->pos == '{')`
294			`{`
295			`char *chp;`
296			`next_line (file); /* discard leading brace */`
297			`entry = new_table_entry (file, table_code_entry);`
298			`chp = file->pos;`
299			`/* determine how many lines are involved - look for <nl> "}" */`
300			`{`
301			`int nr_lines = 0;`
302			`while (*file->pos != '}')`
303			`{`
304			`next_line (file);`
305			`nr_lines++;`
306			`}`
307			`set_nr_table_entry_fields (entry, nr_lines);`
308			`}`
309			`/* now enter each line */`
310			`{`
311			`int line_nr;`
312			`for (line_nr = 0; line_nr < entry->nr_fields; line_nr++)`
313			`{`
314			`if (strncmp (chp, " ", 2) == 0)`
315			`entry->field[line_nr] = chp + 2;`
316			`else`
317			`entry->field[line_nr] = chp;`
318			`chp = skip_to_null (chp) + 1;`
319			`}`
320			`/* skip trailing brace */`
321			`ASSERT (*file->pos == '}');`
322			`next_line (file);`
323			`}`
324			`break;`
325			`}`
326
327			`/* tab block? */`
328			`if (*file->pos == '\t')`
329			`{`
330			`char *chp = file->pos;`
331			`entry = new_table_entry (file, table_code_entry);`
332			`/* determine how many lines are involved - look for <nl> !<tab> */`
333			`{`
334			`int nr_lines = 0;`
335			`int nr_blank_lines = 0;`
336			`while (1)`
337			`{`
338			`if (*file->pos == '\t')`
339			`{`
340			`nr_lines = nr_lines + nr_blank_lines + 1;`
341			`nr_blank_lines = 0;`
342			`next_line (file);`
343			`}`
344			`else`
345			`{`
346			`file->pos = skip_spaces (file->pos);`
347			`if (*file->pos != '\n')`
348			`break;`
349			`nr_blank_lines++;`
350			`next_line (file);`
351			`}`
352			`}`
353			`set_nr_table_entry_fields (entry, nr_lines);`
354			`}`
355			`/* now enter each line */`
356			`{`
357			`int line_nr;`
358			`for (line_nr = 0; line_nr < entry->nr_fields; line_nr++)`
359			`{`
360			`if (*chp == '\t')`
361			`entry->field[line_nr] = chp + 1;`
362			`else`
363			`entry->field[line_nr] = ""; /* blank */`
364			`chp = skip_to_null (chp) + 1;`
365			`}`
366			`}`
367			`break;`
368			`}`
369
370			`/* cpp directive? */`
371			`if (file->pos[0] == '#')`
372			`{`
373			`char *chp = skip_spaces (file->pos + 1);`
374
375			`/* cpp line-nr directive - # <line-nr> "<file>" */`
376			`if (isdigit (*chp)`
377			`&& *skip_digits (chp) == ' '`
378			`&& *skip_spaces (skip_digits (chp)) == '"')`
379			`{`
380			`int line_nr;`
381			`char *file_name;`
382			`file->pos = chp;`
383			`/* parse the number */`
384			`line_nr = atoi (file->pos) - 1;`
385			`/* skip to the file name */`
386			`while (file->pos[0] != '0'`
387			`&& file->pos[0] != '"' && file->pos[0] != '\0')`
388			`file->pos++;`
389			`if (file->pos[0] != '"')`
390			`error (&file->real_line,`
391			`"Missing opening quote in cpp directive\n");`
392			`/* parse the file name */`
393			`file->pos++;`
394			`file_name = file->pos;`
395			`while (file->pos[0] != '"' && file->pos[0] != '\0')`
396			`file->pos++;`
397			`if (file->pos[0] != '"')`
398			`error (&file->real_line,`
399			`"Missing closing quote in cpp directive\n");`
400			`file->pos[0] = '\0';`
401			`file->pos++;`
402			`file->pos = skip_to_nl (file->pos);`
403			`if (file->pos[0] != '\n')`
404			`error (&file->real_line,`
405			`"Missing newline in cpp directive\n");`
406			`file->pseudo_line.file_name = file_name;`
407			`file->pseudo_line.line_nr = line_nr;`
408			`next_line (file);`
409			`continue;`
410			`}`
411
412			`/* #define and #undef - not implemented yet */`
413
414			`/* Old style # comment */`
415			`next_line (file);`
416			`continue;`
417			`}`
418
419			`/* blank line or end-of-file? */`
420			`file->pos = skip_spaces (file->pos);`
421			`if (*file->pos == '\0')`
422			`error (&file->pseudo_line, "Missing <nl> at end of file\n");`
423			`if (*file->pos == '\n')`
424			`{`
425			`next_line (file);`
426			`continue;`
427			`}`
428
429			`/* comment - leading // or # - skip */`
430			`if ((file->pos[0] == '/' && file->pos[1] == '/')`
431			`\|\| (file->pos[0] == '#'))`
432			`{`
433			`next_line (file);`
434			`continue;`
435			`}`
436
437			`/* colon field */`
438			`{`
439			`char *chp = file->pos;`
440			`entry = new_table_entry (file, table_colon_entry);`
441			`next_line (file);`
442			`/* figure out how many fields */`
443			`{`
444			`int nr_fields = 1;`
445			`char *tmpch = chp;`
446			`while (1)`
447			`{`
448			`tmpch = skip_to_separator (tmpch, "\\:");`
449			`if (*tmpch == '\\')`
450			`{`
451			`/* eat the escaped character */`
452			`char *cp = tmpch;`
453			`while (cp[1] != '\0')`
454			`{`
455			`cp[0] = cp[1];`
456			`cp++;`
457			`}`
458			`cp[0] = '\0';`
459			`tmpch++;`
460			`}`
461			`else if (*tmpch != ':')`
462			`break;`
463			`else`
464			`{`
465			`*tmpch = '\0';`
466			`tmpch++;`
467			`nr_fields++;`
468			`}`
469			`}`
470			`set_nr_table_entry_fields (entry, nr_fields);`
471			`}`
472			`/* now parse them */`
473			`{`
474			`int field_nr;`
475			`for (field_nr = 0; field_nr < entry->nr_fields; field_nr++)`
476			`{`
477			`chp = skip_spaces (chp);`
478			`entry->field[field_nr] = chp;`
479			`chp = skip_to_null (chp);`
480			`*back_spaces (entry->field[field_nr], chp) = '\0';`
481			`chp++;`
482			`}`
483			`}`
484			`break;`
485			`}`
486
487			`}`
488
489			`ASSERT (entry == NULL \|\| entry->field[entry->nr_fields] == NULL);`
490			`return entry;`
491			`}`
492
493			`extern void`
494			`table_print_code (lf file, table_entry entry)`
495			`{`
496			`int field_nr;`
497			`int nr = 0;`
498			`for (field_nr = 0; field_nr < entry->nr_fields; field_nr++)`
499			`{`
500			`char *chp = entry->field[field_nr];`
501			`int in_bit_field = 0;`
502			`if (*chp == '#')`
503			`lf_indent_suppress (file);`
504			`while (*chp != '\0')`
505			`{`
506			`if (chp[0] == '{' && !isspace (chp[1]) && chp[1] != '\0')`
507			`{`
508			`in_bit_field = 1;`
509			`nr += lf_putchr (file, '_');`
510			`}`
511			`else if (in_bit_field && chp[0] == ':')`
512			`{`
513			`nr += lf_putchr (file, '_');`
514			`}`
515			`else if (in_bit_field && *chp == '}')`
516			`{`
517			`nr += lf_putchr (file, '_');`
518			`in_bit_field = 0;`
519			`}`
520			`else`
521			`{`
522			`nr += lf_putchr (file, *chp);`
523			`}`
524			`chp++;`
525			`}`
526			`if (in_bit_field)`
527			`{`
528			`line_ref line = *entry->line;`
529			`line.line_nr += field_nr;`
530			`error (&line, "Bit field brace miss match\n");`
531			`}`
532			`nr += lf_putchr (file, '\n');`
533			`}`
534			`}`
535
536
537
538			`void`
539			`dump_line_ref (lf file, char prefix, const line_ref line, char suffix)`
540			`{`
541			`lf_printf (file, "%s(line_ref*) 0x%lx", prefix, (long) line);`
542			`if (line != NULL)`
543			`{`
544			`lf_indent (file, +1);`
545			`lf_printf (file, "\n(line_nr %d)", line->line_nr);`
546			`lf_printf (file, "\n(file_name %s)", line->file_name);`
547			`lf_indent (file, -1);`
548			`}`
549			`lf_printf (file, "%s", suffix);`
550			`}`
551
552
553			`static const char *`
554			`table_entry_type_to_str (table_entry_type type)`
555			`{`
556			`switch (type)`
557			`{`
558			`case table_code_entry:`
559			`return "code-entry";`
560			`case table_colon_entry:`
561			`return "colon-entry";`
562			`}`
563			`return "invalid";`
564			`}`
565
566			`void`
567			`dump_table_entry (lf *file,`
568			`char prefix, const table_entry entry, char *suffix)`
569			`{`
570			`lf_printf (file, "%s(table_entry*) 0x%lx", prefix, (long) entry);`
571			`if (entry != NULL)`
572			`{`
573			`int field;`
574			`lf_indent (file, +1);`
575			`dump_line_ref (file, "\n(line ", entry->line, ")");`
576			`lf_printf (file, "\n(type %s)", table_entry_type_to_str (entry->type));`
577			`lf_printf (file, "\n(nr_fields %d)", entry->nr_fields);`
578			`lf_printf (file, "\n(fields");`
579			`lf_indent (file, +1);`
580			`for (field = 0; field < entry->nr_fields; field++)`
581			`lf_printf (file, "\n\"%s\"", entry->field[field]);`
582			`lf_indent (file, -1);`
583			`lf_printf (file, ")");`
584			`lf_indent (file, -1);`
585			`}`
586			`lf_printf (file, "%s", suffix);`
587			`}`
588
589
590			`#ifdef MAIN`
591			`int`
592			`main (int argc, char **argv)`
593			`{`
594			`table *t;`
595			`table_entry *entry;`
596			`lf *l;`
597			`int line_nr;`
598
599			`if (argc != 2)`
600			`{`
601			`printf ("Usage: table <file>\n");`
602			`exit (1);`
603			`}`
604
605			`t = table_open (argv[1]);`
606			`l = lf_open ("-", "stdout", lf_omit_references, lf_is_text, "tmp-table");`
607
608			`line_nr = 0;`
609			`do`
610			`{`
611			`char line[10];`
612			`entry = table_read (t);`
613			`line_nr++;`
614			`sprintf (line, "(%d ", line_nr);`
615			`dump_table_entry (l, line, entry, ")\n");`
616			`}`
617			`while (entry != NULL);`
618
619			`return 0;`
620			`}`
621			`#endif`