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