![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to comp_parse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / tic|
Return to comp_parse.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / tic |
1.1 root 1: /*********************************************************************
2: * COPYRIGHT NOTICE *
3: **********************************************************************
4: * This software is copyright (C) 1982 by Pavel Curtis *
5: * *
6: * Permission is granted to reproduce and distribute *
7: * this file by any means so long as no fee is charged *
8: * above a nominal handling fee and so long as this *
9: * notice is always included in the copies. *
10: * *
11: * Other rights are reserved except as explicitly granted *
12: * by written permission of the author. *
13: * Pavel Curtis *
14: * Computer Science Dept. *
15: * 405 Upson Hall *
16: * Cornell University *
17: * Ithaca, NY 14853 *
18: * *
19: * Ph- (607) 256-4934 *
20: * *
21: * Pavel.Cornell@Udel-Relay (ARPAnet) *
22: * decvax!cornell!pavel (UUCPnet) *
23: *********************************************************************/
24:
25: /*
26: * comp_parse.c -- The high-level (ha!) parts of the compiler,
27: * that is, the routines which drive the scanner,
28: * etc.
29: *
30: * $Log: comp_parse.c,v $
31: * Revision 1.1 92/03/13 10:45:43 bin
32: * Initial revision
33: *
34: * Revision 3.2 91/07/28 13:59:10 munk
35: * Made all the large arrays static
36: *
37: * Revision 3.1 84/12/13 11:19:32 john
38: * Revisions by Mark Horton
39: *
40: * Revision 2.1 82/10/25 14:45:43 pavel
41: * Added Copyright Notice
42: *
43: * Revision 2.0 82/10/24 15:16:39 pavel
44: * Beta-one Test Release
45: *
46: * Revision 1.3 82/08/23 22:29:39 pavel
47: * The REAL Alpha-one Release Version
48: *
49: * Revision 1.2 82/08/19 19:09:53 pavel
50: * Alpha Test Release One
51: *
52: * Revision 1.1 82/08/12 18:37:12 pavel
53: * Initial revision
54: *
55: *
56: */
57:
58: #ifndef COHERENT
59: static char RCSid[] =
60: "$Header: /src386/usr/bin/tic/RCS/comp_parse.c,v 1.1 92/03/13 10:45:43 bin Exp $";
61: #endif
62:
63: #include <sys/types.h>
64: #include <sys/stat.h>
65: #include <stdio.h>
66: #include <ctype.h>
67: #include "compiler.h"
68: #include "term.h"
69: #include "object.h"
70:
71:
72: char *string_table;
73: int next_free; /* next free character in string_table */
74: int table_size = 0; /* current string_table size */
75: short term_names; /* string table offset - current terminal */
76: int part2 = 0; /* set to allow old compiled defns to be used */
77: int complete = 0; /* 1 if entry done with no forward uses */
78:
79: struct use_item
80: {
81: long offset;
82: struct use_item *fptr, *bptr;
83: };
84:
85: struct use_header
86: {
87: struct use_item *head, *tail;
88: };
89:
90: struct use_header use_list = {NULL, NULL};
91: int use_count = 0;
92:
93: /*
94: * The use_list is a doubly-linked list with NULLs terminating the lists:
95: *
96: * use_item use_item use_item
97: * --------- --------- ---------
98: * | | | | | | offset
99: * |-------| |-------| |-------|
100: * | ----+-->| ----+-->| NULL | fptr
101: * |-------| |-------| |-------|
102: * | NULL |<--+---- |<--+---- | bptr
103: * --------- --------- ---------
104: * ^ ^
105: * | ------------------ |
106: * | | | | |
107: * +--+---- | ----+---+
108: * | | |
109: * ------------------
110: * head tail
111: * use_list
112: *
113: */
114:
115:
116: /*
117: * compile()
118: *
119: * Main loop of the compiler.
120: *
121: * get_token()
122: * if curr_token != NAMES
123: * err_abort()
124: * while (not at end of file)
125: * do an entry
126: *
127: */
128:
129: compile()
130: {
131: static char line[1024];
132: int token_type;
133: struct use_item *ptr;
134: int old_use_count;
135:
136: token_type = get_token();
137:
138: if (token_type != NAMES)
139: err_abort("File does not start with terminal names in column one");
140:
141: while (token_type != EOF)
142: token_type = do_entry(NULL);
143:
144: DEBUG(2, "Starting handling of forward USE's\n", "");
145:
146: for (part2=0; part2<2; part2++) {
147: old_use_count = -1;
148: DEBUG(2, "\n\nPART %d\n\n", part2);
149: while (use_list.head != NULL && old_use_count != use_count)
150: {
151: old_use_count = use_count;
152: for (ptr = use_list.tail; ptr != NULL; ptr = ptr->bptr)
153: {
154: fseek(stdin, ptr->offset, 0);
155: reset_input();
156: if ((token_type = get_token()) != NAMES)
157: syserr_abort("Token after a seek not NAMES");
158: (void) do_entry(ptr);
159: if (complete)
160: dequeue(ptr);
161: }
162:
163: for (ptr = use_list.head; ptr != NULL; ptr = ptr->fptr)
164: {
165: fseek(stdin, ptr->offset, 0);
166: reset_input();
167: if ((token_type = get_token()) != NAMES)
168: syserr_abort("Token after a seek not NAMES");
169: (void) do_entry(ptr);
170: if (complete)
171: dequeue(ptr);
172: }
173:
174: DEBUG(2, "Finished a pass through enqueued forward USE's\n", "");
175: }
176: }
177:
178: if (use_list.head != NULL)
179: {
180: fprintf(stderr, "\nError in following up use-links. Either there is\n");
181: fprintf(stderr, "a loop in the links or they reference non-existant\n");
182: fprintf(stderr, "terminals. The following is a list of the entries\n");
183: fprintf(stderr, "involved:\n\n");
184:
185: for (ptr = use_list.head; ptr != NULL; ptr = ptr->fptr)
186: {
187: fseek(stdin, ptr->offset, 0);
188: fgets(line, 1024, stdin);
189: fprintf(stderr, "%s", line);
190: }
191:
192: exit(1);
193: }
194: }
195:
196: dump_list(str)
197: char *str;
198: {
199: struct use_item *ptr;
200: static char line[512];
201:
202: fprintf(stderr, "dump_list %s\n", str);
203: for (ptr = use_list.head; ptr != NULL; ptr = ptr->fptr)
204: {
205: fseek(stdin, ptr->offset, 0);
206: fgets(line, 1024, stdin);
207: fprintf(stderr, "ptr %x off %d bptr %x fptr %x str %s",
208: ptr, ptr->offset, ptr->bptr, ptr->fptr, line);
209: }
210: fprintf(stderr, "\n");
211: }
212:
213:
214:
215: /*
216: * int
217: * do_entry(item_ptr)
218: *
219: * Compile one entry. During the first pass, item_ptr is NULL. In pass
220: * two, item_ptr points to the current entry in the use_list.
221: *
222: * found-forward-use = FALSE
223: * re-initialise internal arrays
224: * save names in string_table
225: * get_token()
226: * while (not EOF and not NAMES)
227: * if found-forward-use
228: * do nothing
229: * else if 'use'
230: * if handle_use() < 0
231: * found-forward-use = TRUE
232: * else
233: * check for existance and type-correctness
234: * enter cap into structure
235: * if STRING
236: * save string in string_table
237: * get_token()
238: * if ! found-forward-use
239: * clear CANCELS out of the structure
240: * dump compiled entry into filesystem
241: *
242: */
243:
244: int
245: do_entry(item_ptr)
246: struct use_item *item_ptr;
247: {
248: long entry_offset;
249: int i;
250: register int token_type;
251: register struct name_table_entry *entry_ptr;
252: int found_forward_use = FALSE;
253: static char Booleans[BOOLCOUNT];
254: static short Numbers[NUMCOUNT],
255: Strings[STRCOUNT];
256:
257: init_structure(Booleans, Numbers, Strings);
258: complete = 0;
259: term_names = save_str(curr_token.tk_name);
260: DEBUG(2, "Starting '%s'\n", curr_token.tk_name);
261: entry_offset = curr_file_pos;
262:
263: for (token_type = get_token();
264: token_type != EOF && token_type != NAMES;
265: token_type = get_token())
266: {
267: if (found_forward_use)
268: /* do nothing */ ;
269: else if (strcmp(curr_token.tk_name, "use") == 0)
270: {
271: if (handle_use(item_ptr, entry_offset,
272: Booleans, Numbers, Strings) < 0)
273: found_forward_use = TRUE;
274: }
275: else
276: {
277: entry_ptr = find_entry(curr_token.tk_name);
278:
279: if (entry_ptr == NOTFOUND) {
280: warning("Unknown Capability - '%s'",
281: curr_token.tk_name);
282: continue;
283: }
284:
285:
286: if (token_type != CANCEL
287: && entry_ptr->nte_type != token_type)
288: warning("Wrong type used for capability '%s'",
289: curr_token.tk_name);
290: switch (token_type)
291: {
292: case CANCEL:
293: switch (entry_ptr->nte_type)
294: {
295: case BOOLEAN:
296: Booleans[entry_ptr->nte_index] = -2;
297: break;
298:
299: case NUMBER:
300: Numbers[entry_ptr->nte_index] = -2;
301: break;
302:
303: case STRING:
304: Strings[entry_ptr->nte_index] = -2;
305: break;
306: }
307: break;
308:
309: case BOOLEAN:
310: Booleans[entry_ptr->nte_index] = TRUE;
311: break;
312:
313: case NUMBER:
314: Numbers[entry_ptr->nte_index] =
315: curr_token.tk_valnumber;
316: break;
317:
318: case STRING:
319: Strings[entry_ptr->nte_index] =
320: save_str(curr_token.tk_valstring);
321: break;
322:
323: default:
324: warning("Unknown token type");
325: panic_mode(',');
326: continue;
327: }
328: } /* end else cur_token.name != "use" */
329:
330: } /* endwhile (not EOF and not NAMES) */
331:
332: if (found_forward_use)
333: return(token_type);
334:
335: for (i=0; i < BOOLCOUNT; i++)
336: {
337: if (Booleans[i] == -2)
338: Booleans[i] = FALSE;
339: }
340:
341: for (i=0; i < NUMCOUNT; i++)
342: {
343: if (Numbers[i] == -2)
344: Numbers[i] = -1;
345: }
346:
347: for (i=0; i < STRCOUNT; i++)
348: {
349: if (Strings[i] == -2)
350: Strings[i] = -1;
351: }
352:
353: dump_structure(term_names, Booleans, Numbers, Strings);
354:
355: complete = 1;
356: return(token_type);
357: }
358:
359:
360:
361:
362: /*
363: * enqueue(offset)
364: *
365: * Put a record of the given offset onto the use-list.
366: *
367: */
368:
369: enqueue(offset)
370: long offset;
371: {
372: struct use_item *item;
373: char *malloc();
374:
375: item = (struct use_item *) malloc(sizeof(struct use_item));
376:
377: if (item == NULL)
378: syserr_abort("Not enough memory for use_list element");
379:
380: item->offset = offset;
381:
382: if (use_list.head != NULL)
383: {
384: item->bptr = use_list.tail;
385: use_list.tail->fptr = item;
386: item->fptr = NULL;
387: use_list.tail = item;
388: }
389: else
390: {
391: use_list.tail = use_list.head = item;
392: item->fptr = item->bptr = NULL;
393: }
394:
395: use_count ++;
396: }
397:
398:
399:
400:
401: /*
402: * dequeue(ptr)
403: *
404: * remove the pointed-to item from the use_list
405: *
406: */
407:
408: dequeue(ptr)
409: struct use_item *ptr;
410: {
411: if (ptr->fptr == NULL)
412: use_list.tail = ptr->bptr;
413: else
414: (ptr->fptr)->bptr = ptr->bptr;
415:
416: if (ptr->bptr == NULL)
417: use_list.head = ptr->fptr;
418: else
419: (ptr->bptr)->fptr = ptr->fptr;
420:
421: use_count --;
422: }
423:
424:
425:
426: /*
427: * dump_structure()
428: *
429: * Save the compiled version of a description in the filesystem.
430: *
431: * make a copy of the name-list
432: * break it up into first-name and all-but-last-name
433: * creat(first-name)
434: * write object information to first-name
435: * close(first-name)
436: * for each name in all-but-last-name
437: * link to first-name
438: *
439: */
440:
441: dump_structure(term_names, Booleans, Numbers, Strings)
442: short term_names;
443: char Booleans[];
444: short Numbers[];
445: short Strings[];
446: {
447: struct stat statbuf;
448: FILE *fp;
449: static char name_list[1024];
450: register char *first_name, *other_names;
451: register char *ptr;
452: static char filename[50];
453: static char linkname[50];
454: extern char check_only;
455:
456: strcpy(name_list, term_names + string_table);
457: DEBUG(7, "Name list = '%s'\n", name_list);
458:
459: first_name = name_list;
460:
461: ptr = &name_list[strlen(name_list) - 1];
462: other_names = ptr + 1;
463:
464: while (ptr > name_list && *ptr != '|')
465: ptr--;
466:
467: if (ptr != name_list)
468: {
469: *ptr = '\0';
470:
471: for (ptr = name_list; *ptr != '\0' && *ptr != '|'; ptr++)
472: ;
473:
474: if (*ptr == '\0')
475: other_names = ptr;
476: else
477: {
478: *ptr = '\0';
479: other_names = ptr + 1;
480: }
481: }
482:
483: if (check_only) {
484: DEBUG(1, "Checked %s\n", first_name);
485: return;
486: }
487:
488: DEBUG(7, "First name = '%s'\n", first_name);
489: DEBUG(7, "Other names = '%s'\n", other_names);
490:
491: if (strlen(first_name) > 100)
492: warning("'%s': terminal name too long.", first_name);
493:
494: check_name(first_name);
495:
496: sprintf(filename, "%c/%s", first_name[0], first_name);
497:
498: if (stat(filename, &statbuf) >= 0 && statbuf.st_mtime >= start_time)
499: {
500: warning("'%s' defined in more than one entry.", first_name);
501: fprintf(stderr, "Entry being used is '%s'.\n",
502: (unsigned) term_names + string_table);
503: }
504:
505: unlink(filename);
506: fp = fopen(filename, "w");
507: if (fp == NULL)
508: {
509: perror(filename);
510: syserr_abort("Can't open %s/%s\n", destination, filename);
511: }
512: DEBUG(1, "Created %s\n", filename);
513:
514: if (write_object(fp, term_names, Booleans, Numbers, Strings) < 0)
515: {
516: syserr_abort("Error in writing %s/%s", destination, filename);
517: }
518: fclose(fp);
519:
520: while (*other_names != '\0')
521: {
522: ptr = other_names++;
523: while (*other_names != '|' && *other_names != '\0')
524: other_names++;
525:
526: if (*other_names != '\0')
527: *(other_names++) = '\0';
528:
529: if (strlen(ptr) > 100)
530: {
531: warning("'%s': terminal name too long.", ptr);
532: continue;
533: }
534:
535: sprintf(linkname, "%c/%s", ptr[0], ptr);
536:
537: if (strcmp(filename, linkname) == 0)
538: {
539: warning("Terminal name '%s' synonym for itself", first_name);
540: }
541: else if (stat(linkname, &statbuf) >= 0 &&
542: statbuf.st_mtime >= start_time)
543: {
544: warning("'%s' defined in more than one entry.", ptr);
545: fprintf(stderr, "Entry being used is '%s'.\n",
546: (unsigned) term_names + string_table);
547: }
548: else
549: {
550: unlink(linkname);
551: if (link(filename, linkname) < 0)
552: syserr_abort("Can't link %s to %s", filename, linkname);
553: DEBUG(1, "Linked %s\n", linkname);
554: }
555: }
556: }
557:
558:
559:
560:
561: /*
562: * int
563: * write_object(fp, term_names, Booleans, Numbers, Strings)
564: *
565: * Write out the compiled entry to the given file.
566: * Return 0 if OK or -1 if not.
567: *
568: */
569:
570: #define swap(x) (((x >> 8) & 0377) + 256 * (x & 0377))
571:
572: #define might_swap(x) (must_swap() ? swap(x) : (x))
573:
574:
575: int
576: write_object(fp, term_names, Booleans, Numbers, Strings)
577: FILE *fp;
578: short term_names;
579: char Booleans[];
580: short Numbers[];
581: short Strings[];
582: {
583: struct header header;
584: char *namelist;
585: short namelen;
586: char zero = '\0';
587: int i;
588:
589: namelist = term_names + string_table;
590: namelen = strlen(namelist) + 1;
591:
592: if (must_swap())
593: {
594: header.magic = swap(MAGIC);
595: header.name_size = swap(namelen);
596: header.bool_count = swap(BOOLCOUNT);
597: header.num_count = swap(NUMCOUNT);
598: header.str_count = swap(STRCOUNT);
599: header.str_size = swap(next_free);
600: }
601: else
602: {
603: header.magic = MAGIC;
604: header.name_size = namelen;
605: header.bool_count = BOOLCOUNT;
606: header.num_count = NUMCOUNT;
607: header.str_count = STRCOUNT;
608: header.str_size = next_free;
609: }
610:
611: if (fwrite(&header, sizeof(header), 1, fp) != 1
612: || fwrite(namelist, sizeof(char), namelen, fp) != namelen
613: || fwrite(Booleans, sizeof(char), BOOLCOUNT, fp) != BOOLCOUNT)
614: return(-1);
615:
616: if ((namelen+BOOLCOUNT) % 2 != 0 && fwrite(&zero, sizeof(char), 1, fp) != 1)
617: return(-1);
618:
619: if (must_swap())
620: {
621: for (i=0; i < NUMCOUNT; i++)
622: Numbers[i] = swap(Numbers[i]);
623: for (i=0; i < STRCOUNT; i++)
624: Strings[i] = swap(Strings[i]);
625: }
626:
627: if (fwrite(Numbers, sizeof(short), NUMCOUNT, fp) != NUMCOUNT
628: || fwrite(Strings, sizeof(short), STRCOUNT, fp) != STRCOUNT
629: || fwrite(string_table, sizeof(char), next_free, fp)
630: != next_free)
631: return(-1);
632:
633: }
634:
635:
636:
637: /*
638: * check_name(name)
639: *
640: * Generate an error message if given name does not begin with a
641: * digit or letter (should be lower-case letter, but SV likes capital)
642: * Vlad 3-11-92
643: */
644:
645: check_name(name)
646: char *name;
647: {
648: if (!isalnum(name[0]))
649: {
650: fprintf(stderr, "tic: Line %d: Illegal terminal name - '%s'\n",
651: curr_line, name);
652: fprintf(stderr,
653: "Terminal names must start with letter or digit\n");
654: exit(1);
655: }
656: }
657:
658:
659:
660: /*
661: * int
662: * save_str(string)
663: *
664: * copy string into next free part of string_table, doing a realloc()
665: * if necessary. return offset of beginning of string from start of
666: * string_table.
667: *
668: */
669:
670: int
671: save_str(string)
672: char *string;
673: {
674: char *malloc(), *realloc();
675: int old_next_free = next_free;
676:
677: if (table_size == 0)
678: {
679: if ((string_table = malloc(1024)) == NULL)
680: syserr_abort("Out of memory");
681: table_size = 1024;
682: DEBUG(5, "Made initial string table allocation. Size is %d\n",
683: table_size);
684: }
685:
686: while (table_size < next_free + strlen(string))
687: {
688: if ((string_table = realloc(string_table, table_size + 1024))
689: == NULL)
690: syserr_abort("Out of memory");
691: table_size += 1024;
692: DEBUG(5, "Extended string table. Size now %d\n", table_size);
693: }
694:
695: strcpy(&string_table[next_free], string);
696: DEBUG(7, "Saved string '%s' ", string);
697: DEBUG(7, "at location %d\n", next_free);
698: next_free += strlen(string) + 1;
699:
700: return(old_next_free);
701: }
702:
703:
704:
705: /*
706: * init_structure(Booleans, Numbers, Strings)
707: *
708: * Initialise the given arrays
709: * Reset the next_free counter to zero.
710: *
711: */
712:
713: init_structure(Booleans, Numbers, Strings)
714: char Booleans[];
715: short Numbers[], Strings[];
716: {
717: int i;
718:
719: for (i=0; i < BOOLCOUNT; i++)
720: Booleans[i] = FALSE;
721:
722: for (i=0; i < NUMCOUNT; i++)
723: Numbers[i] = -1;
724:
725: for (i=0; i < STRCOUNT; i++)
726: Strings[i] = -1;
727:
728: next_free = 0;
729: }
730:
731:
732:
733: /*
734: ** int
735: ** handle_use(item_ptr, entry_offset, Booleans, Numbers, Strings)
736: **
737: ** Merge the compiled file whose name is in cur_token.valstring
738: ** with the current entry.
739: **
740: ** if it's a forward use-link
741: ** if item_ptr == NULL
742: ** queue it up for later handling
743: ** else
744: ** ignore it (we're already going through the queue)
745: ** else it's a backward use-link
746: ** read in the object file for that terminal
747: ** merge contents with current structure
748: **
749: ** Returned value is 0 if it was a backward link and we
750: ** successfully read it in, -1 if a forward link.
751: */
752:
753: int
754: handle_use(item_ptr, entry_offset, Booleans, Numbers, Strings)
755: long entry_offset;
756: struct use_item *item_ptr;
757: char Booleans[];
758: short Numbers[];
759: short Strings[];
760: {
761: struct term use_term;
762: struct stat statbuf;
763: static char filename[50];
764: int i;
765:
766: check_name(curr_token.tk_valstring);
767:
768: sprintf(filename, "%c/%s", curr_token.tk_valstring[0],
769: curr_token.tk_valstring);
770:
771: if (stat(filename, &statbuf) < 0 || part2==0 && statbuf.st_mtime < start_time)
772: {
773: DEBUG(2, "Forward USE to %s", curr_token.tk_valstring);
774:
775: if (item_ptr == NULL)
776: {
777: DEBUG(2, " (enqueued)\n", "");
778: enqueue(entry_offset);
779: }
780: else
781: DEBUG(2, " (skipped)\n", "");
782:
783: return(-1);
784: }
785: else
786: {
787: DEBUG(2, "Backward USE to %s\n", curr_token.tk_valstring);
788: if (read_entry(filename, &use_term) < 0)
789: syserr_abort("Error in re-reading compiled file %s", filename);
790:
791: for (i=0; i < BOOLCOUNT; i++)
792: {
793: if (Booleans[i] == FALSE && use_term.Booleans[i] == TRUE)
794: Booleans[i] = TRUE;
795: }
796:
797: for (i=0; i < NUMCOUNT; i++)
798: {
799: if (Numbers[i] == -1 && use_term.Numbers[i] != -1)
800: Numbers[i] = use_term.Numbers[i];
801: }
802:
803: for (i=0; i < STRCOUNT; i++)
804: {
805: if (Strings[i] == -1 && use_term.Strings[i] != (char *) 0)
806: Strings[i] = save_str(use_term.Strings[i]);
807: }
808:
809: }
810: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.