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

Subversion Repositories openrisc

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

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


/*  This file is part of the program psim.
 
    Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
 
    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 2 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, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    */
 
 
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
 
#include "build-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;
  int line_nr;
  int nr_fields;
  int nr_model_fields;
  char *file_name;
  open_table *parent;
  table *root;
};
struct _table {
  open_table *current;
};
 
void
table_push (table *root,
            table_include *includes,
            const char *file_name,
            int nr_fields,
            int nr_model_fields)
 
{
  int fd;
  struct stat stat_buf;
  open_table *file;
  table_include dummy;
  table_include *include = &dummy;
  int nr;
 
  /* dummy up a search of this directory */
  dummy.next = includes;
  dummy.dir = "";
 
  /* create a file descriptor */
  file = ZALLOC (open_table);
  ASSERT(file != NULL);
  file->nr_fields = nr_fields;
  file->nr_model_fields = nr_model_fields;
  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->file_name = dup_name;
      /* open the file */
      fd = open (dup_name, O_RDONLY, 0);
      if (fd >= 0)
        break;
      /* zfree (dup_name); */
      if (include->next == NULL)
        {
          error ("Problem opening file `%s'\n", file_name);
          perror (file_name);
          exit (1);
        }
      include = include->next;
  }
 
  /* determine the size */
  if (fstat(fd, &stat_buf) < 0) {
    perror("table_open.fstat");
    exit(1);
  }
  file->size = stat_buf.st_size;
 
  /* allocate this much memory */
  file->buffer = (char*)zalloc(file->size+1);
  if(file->buffer == NULL) {
    perror("table_open.calloc.file->size+1");
    exit(1);
  }
  file->pos = file->buffer;
 
  /* read it in */
#ifdef __CYGWIN32__
  if ((file->size) && ((nr = read(fd, file->buffer, file->size)) <= 0)) {
#else
  if ((nr = read(fd, file->buffer, file->size)) < file->size) {
#endif
    perror("table_open.read");
    exit(1);
  }
  file->size = nr;
  file->buffer[file->size] = '\0';
 
  /* done */
  close(fd);
}
 
extern table *
table_open(const char *file_name,
           int nr_fields,
           int nr_model_fields)
{
  table *root;
 
  /* create a file descriptor */
  root = ZALLOC (table);
  if (root == NULL)
    {
      perror (file_name);
      exit (1);
    }
 
  table_push (root, NULL, file_name, nr_fields, nr_model_fields);
  return root;
}
 
extern table_entry *
table_entry_read(table *root)
{
  open_table *file = root->current;
  int field;
  table_entry *entry;
 
  /* skip comments/blanks */
  while(1) {
    /* end-of-file? */
    while (*file->pos == '\0')
      {
        if (file->parent != NULL)
          {
            file = file->parent;
            root->current = file;
          }
        else
          return NULL;
      }
    /* leading white space */
    while (*file->pos != '\0'
           && *file->pos != '\n'
           && isspace(*file->pos))
      file->pos++;
    /* comment */
    if (*file->pos == '#') {
      do {
        file->pos++;
      } while (*file->pos != '\0' && *file->pos != '\n');
    }
    /* end of line? */
    if (*file->pos == '\n') {
      file->pos++;
      file->line_nr++;
    }
    else
      break;
  }
 
  /* create this new entry */
  entry = (table_entry*)zalloc(sizeof(table_entry)
                               + (file->nr_fields + 1) * sizeof(char*));
  ASSERT(entry != NULL);
  entry->file_name = file->file_name;
  entry->nr_fields = file->nr_fields;
 
  /* break the line into its colon delimitered fields */
  for (field = 0; field < file->nr_fields-1; field++) {
    entry->fields[field] = file->pos;
    while(*file->pos && *file->pos != ':' && *file->pos != '\n')
      file->pos++;
    if (*file->pos == ':') {
      *file->pos = '\0';
      file->pos++;
    }
  }
 
  /* any trailing stuff not the last field */
  ASSERT(field == file->nr_fields-1);
  entry->fields[field] = file->pos;
  while (*file->pos && *file->pos != '\n') {
    file->pos++;
  }
  if (*file->pos == '\n') {
    *file->pos = '\0';
    file->pos++;
  }
  file->line_nr++;
 
  /* if following lines begin with a star, add them to the model
     section.  */
  while ((file->nr_model_fields > 0) && (*file->pos == '*')) {
    table_model_entry *model = (table_model_entry*)zalloc(sizeof(table_model_entry)
                                                          + (file->nr_model_fields + 1) * sizeof(char*));
    if (entry->model_last)
      entry->model_last->next = model;
    else
      entry->model_first = model;
    entry->model_last = model;
 
    /* break the line into its colon delimitered fields */
    file->pos++;
    for (field = 0; field < file->nr_model_fields-1; field++) {
      model->fields[field] = file->pos;
      while(*file->pos && *file->pos != ':' && *file->pos != '\n')
        file->pos++;
      if (*file->pos == ':') {
        *file->pos = '\0';
        file->pos++;
      }
    }
 
    /* any trailing stuff not the last field */
    ASSERT(field == file->nr_model_fields-1);
    model->fields[field] = file->pos;
    while (*file->pos && *file->pos != '\n') {
      file->pos++;
    }
    if (*file->pos == '\n') {
      *file->pos = '\0';
      file->pos++;
    }
 
    file->line_nr++;
    model->line_nr = file->line_nr;
  }
 
  entry->line_nr = file->line_nr;
 
  /* if following lines are tab indented, put in the annex */
  if (*file->pos == '\t') {
    entry->annex = file->pos;
    do {
      do {
        file->pos++;
      } while (*file->pos != '\0' && *file->pos != '\n');
      if (*file->pos == '\n') {
        char *save_pos = ++file->pos;
        int extra_lines = 0;
        file->line_nr++;
        /* Allow tab indented to have blank lines */
        while (*save_pos == '\n') {
          save_pos++;
          extra_lines++;
        }
        if (*save_pos == '\t') {
          file->pos = save_pos;
          file->line_nr += extra_lines;
        }
      }
    } while (*file->pos != '\0' && *file->pos == '\t');
    if (file->pos[-1] == '\n')
      file->pos[-1] = '\0';
  }
  else
    entry->annex = NULL;
 
  /* return it */
  return entry;
 
}
 
 
extern void
dump_table_entry(table_entry *entry,
                 int indent)
{
  printf("(table_entry*)%p\n", entry);
 
  if (entry != NULL) {
    int field;
    char sep;
 
    sep = ' ';
    dumpf(indent, "(fields");
    for (field = 0; field < entry->nr_fields; field++) {
      printf("%c%s", sep, entry->fields[field]);
      sep = ':';
    }
    printf(")\n");
 
    dumpf(indent, "(line_nr %d)\n", entry->line_nr);
 
    dumpf(indent, "(file_name %s)\n", entry->file_name);
 
    dumpf(indent, "(annex\n%s\n", entry->annex);
    dumpf(indent, " )\n");
 
  }
}
 
 
extern void
table_entry_print_cpp_line_nr(lf *file,
                              table_entry *entry)
{
  lf_print__external_reference(file, entry->line_nr, entry->file_name);
}
 
 

Browse

Tools

Subversion Repositories openrisc

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

Line No.	Rev	Author	Line
1	330	jeremybenn	`/* This file is part of the program psim.`
2
3			`Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>`
4
5			`This program is free software; you can redistribute it and/or modify`
6			`it under the terms of the GNU General Public License as published by`
7			`the Free Software Foundation; either version 2 of the License, or`
8			`(at your option) any later version.`
9
10			`This program is distributed in the hope that it will be useful,`
11			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
12			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
13			`GNU General Public License for more details.`
14
15			`You should have received a copy of the GNU General Public License`
16			`along with this program; if not, write to the Free Software`
17			`Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.`
18
19			`*/`
20
21
22			`#include <sys/types.h>`
23			`#include <sys/stat.h>`
24			`#include <stdio.h>`
25			`#include <fcntl.h>`
26			`#include <ctype.h>`
27
28			`#include "build-config.h"`
29			`#include "misc.h"`
30			`#include "lf.h"`
31			`#include "table.h"`
32
33			`#ifdef HAVE_UNISTD_H`
34			`#include <unistd.h>`
35			`#endif`
36
37			`#ifdef HAVE_STDLIB_H`
38			`#include <stdlib.h>`
39			`#endif`
40
41			`typedef struct _open_table open_table;`
42			`struct _open_table {`
43			`size_t size;`
44			`char *buffer;`
45			`char *pos;`
46			`int line_nr;`
47			`int nr_fields;`
48			`int nr_model_fields;`
49			`char *file_name;`
50			`open_table *parent;`
51			`table *root;`
52			`};`
53			`struct _table {`
54			`open_table *current;`
55			`};`
56
57			`void`
58			`table_push (table *root,`
59			`table_include *includes,`
60			`const char *file_name,`
61			`int nr_fields,`
62			`int nr_model_fields)`
63
64			`{`
65			`int fd;`
66			`struct stat stat_buf;`
67			`open_table *file;`
68			`table_include dummy;`
69			`table_include *include = &dummy;`
70			`int nr;`
71
72			`/* dummy up a search of this directory */`
73			`dummy.next = includes;`
74			`dummy.dir = "";`
75
76			`/* create a file descriptor */`
77			`file = ZALLOC (open_table);`
78			`ASSERT(file != NULL);`
79			`file->nr_fields = nr_fields;`
80			`file->nr_model_fields = nr_model_fields;`
81			`file->root = root;`
82			`file->parent = root->current;`
83			`root->current = file;`
84
85			`while (1)`
86			`{`
87			`/* save the file name */`
88			`char *dup_name = NZALLOC (char, strlen (include->dir) + strlen (file_name) + 2);`
89			`if (dup_name == NULL)`
90			`{`
91			`perror (file_name);`
92			`exit (1);`
93			`}`
94			`if (include->dir[0] != '\0')`
95			`{`
96			`strcat (dup_name, include->dir);`
97			`strcat (dup_name, "/");`
98			`}`
99			`strcat (dup_name, file_name);`
100			`file->file_name = dup_name;`
101			`/* open the file */`
102			`fd = open (dup_name, O_RDONLY, 0);`
103			`if (fd >= 0)`
104			`break;`
105			`/* zfree (dup_name); */`
106			`if (include->next == NULL)`
107			`{`
108			error ("Problem opening file `%s'\n", file_name);
109			`perror (file_name);`
110			`exit (1);`
111			`}`
112			`include = include->next;`
113			`}`
114
115			`/* determine the size */`
116			`if (fstat(fd, &stat_buf) < 0) {`
117			`perror("table_open.fstat");`
118			`exit(1);`
119			`}`
120			`file->size = stat_buf.st_size;`
121
122			`/* allocate this much memory */`
123			`file->buffer = (char*)zalloc(file->size+1);`
124			`if(file->buffer == NULL) {`
125			`perror("table_open.calloc.file->size+1");`
126			`exit(1);`
127			`}`
128			`file->pos = file->buffer;`
129
130			`/* read it in */`
131			`#ifdef __CYGWIN32__`
132			`if ((file->size) && ((nr = read(fd, file->buffer, file->size)) <= 0)) {`
133			`#else`
134			`if ((nr = read(fd, file->buffer, file->size)) < file->size) {`
135			`#endif`
136			`perror("table_open.read");`
137			`exit(1);`
138			`}`
139			`file->size = nr;`
140			`file->buffer[file->size] = '\0';`
141
142			`/* done */`
143			`close(fd);`
144			`}`
145
146			`extern table *`
147			`table_open(const char *file_name,`
148			`int nr_fields,`
149			`int nr_model_fields)`
150			`{`
151			`table *root;`
152
153			`/* create a file descriptor */`
154			`root = ZALLOC (table);`
155			`if (root == NULL)`
156			`{`
157			`perror (file_name);`
158			`exit (1);`
159			`}`
160
161			`table_push (root, NULL, file_name, nr_fields, nr_model_fields);`
162			`return root;`
163			`}`
164
165			`extern table_entry *`
166			`table_entry_read(table *root)`
167			`{`
168			`open_table *file = root->current;`
169			`int field;`
170			`table_entry *entry;`
171
172			`/* skip comments/blanks */`
173			`while(1) {`
174			`/* end-of-file? */`
175			`while (*file->pos == '\0')`
176			`{`
177			`if (file->parent != NULL)`
178			`{`
179			`file = file->parent;`
180			`root->current = file;`
181			`}`
182			`else`
183			`return NULL;`
184			`}`
185			`/* leading white space */`
186			`while (*file->pos != '\0'`
187			`&& *file->pos != '\n'`
188			`&& isspace(*file->pos))`
189			`file->pos++;`
190			`/* comment */`
191			`if (*file->pos == '#') {`
192			`do {`
193			`file->pos++;`
194			`} while (file->pos != '\0' && file->pos != '\n');`
195			`}`
196			`/* end of line? */`
197			`if (*file->pos == '\n') {`
198			`file->pos++;`
199			`file->line_nr++;`
200			`}`
201			`else`
202			`break;`
203			`}`
204
205			`/* create this new entry */`
206			`entry = (table_entry*)zalloc(sizeof(table_entry)`
207			`+ (file->nr_fields + 1) * sizeof(char*));`
208			`ASSERT(entry != NULL);`
209			`entry->file_name = file->file_name;`
210			`entry->nr_fields = file->nr_fields;`
211
212			`/* break the line into its colon delimitered fields */`
213			`for (field = 0; field < file->nr_fields-1; field++) {`
214			`entry->fields[field] = file->pos;`
215			`while(file->pos && file->pos != ':' && *file->pos != '\n')`
216			`file->pos++;`
217			`if (*file->pos == ':') {`
218			`*file->pos = '\0';`
219			`file->pos++;`
220			`}`
221			`}`
222
223			`/* any trailing stuff not the last field */`
224			`ASSERT(field == file->nr_fields-1);`
225			`entry->fields[field] = file->pos;`
226			`while (file->pos && file->pos != '\n') {`
227			`file->pos++;`
228			`}`
229			`if (*file->pos == '\n') {`
230			`*file->pos = '\0';`
231			`file->pos++;`
232			`}`
233			`file->line_nr++;`
234
235			`/* if following lines begin with a star, add them to the model`
236			`section. */`
237			`while ((file->nr_model_fields > 0) && (file->pos == '')) {`
238			`table_model_entry model = (table_model_entry)zalloc(sizeof(table_model_entry)`
239			`+ (file->nr_model_fields + 1) * sizeof(char*));`
240			`if (entry->model_last)`
241			`entry->model_last->next = model;`
242			`else`
243			`entry->model_first = model;`
244			`entry->model_last = model;`
245
246			`/* break the line into its colon delimitered fields */`
247			`file->pos++;`
248			`for (field = 0; field < file->nr_model_fields-1; field++) {`
249			`model->fields[field] = file->pos;`
250			`while(file->pos && file->pos != ':' && *file->pos != '\n')`
251			`file->pos++;`
252			`if (*file->pos == ':') {`
253			`*file->pos = '\0';`
254			`file->pos++;`
255			`}`
256			`}`
257
258			`/* any trailing stuff not the last field */`
259			`ASSERT(field == file->nr_model_fields-1);`
260			`model->fields[field] = file->pos;`
261			`while (file->pos && file->pos != '\n') {`
262			`file->pos++;`
263			`}`
264			`if (*file->pos == '\n') {`
265			`*file->pos = '\0';`
266			`file->pos++;`
267			`}`
268
269			`file->line_nr++;`
270			`model->line_nr = file->line_nr;`
271			`}`
272
273			`entry->line_nr = file->line_nr;`
274
275			`/* if following lines are tab indented, put in the annex */`
276			`if (*file->pos == '\t') {`
277			`entry->annex = file->pos;`
278			`do {`
279			`do {`
280			`file->pos++;`
281			`} while (file->pos != '\0' && file->pos != '\n');`
282			`if (*file->pos == '\n') {`
283			`char *save_pos = ++file->pos;`
284			`int extra_lines = 0;`
285			`file->line_nr++;`
286			`/* Allow tab indented to have blank lines */`
287			`while (*save_pos == '\n') {`
288			`save_pos++;`
289			`extra_lines++;`
290			`}`
291			`if (*save_pos == '\t') {`
292			`file->pos = save_pos;`
293			`file->line_nr += extra_lines;`
294			`}`
295			`}`
296			`} while (file->pos != '\0' && file->pos == '\t');`
297			`if (file->pos[-1] == '\n')`
298			`file->pos[-1] = '\0';`
299			`}`
300			`else`
301			`entry->annex = NULL;`
302
303			`/* return it */`
304			`return entry;`
305
306			`}`
307
308
309			`extern void`
310			`dump_table_entry(table_entry *entry,`
311			`int indent)`
312			`{`
313			`printf("(table_entry*)%p\n", entry);`
314
315			`if (entry != NULL) {`
316			`int field;`
317			`char sep;`
318
319			`sep = ' ';`
320			`dumpf(indent, "(fields");`
321			`for (field = 0; field < entry->nr_fields; field++) {`
322			`printf("%c%s", sep, entry->fields[field]);`
323			`sep = ':';`
324			`}`
325			`printf(")\n");`
326
327			`dumpf(indent, "(line_nr %d)\n", entry->line_nr);`
328
329			`dumpf(indent, "(file_name %s)\n", entry->file_name);`
330
331			`dumpf(indent, "(annex\n%s\n", entry->annex);`
332			`dumpf(indent, " )\n");`
333
334			`}`
335			`}`
336
337
338			`extern void`
339			`table_entry_print_cpp_line_nr(lf *file,`
340			`table_entry *entry)`
341			`{`
342			`lf_print__external_reference(file, entry->line_nr, entry->file_name);`
343			`}`
344
345