![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to savenl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / src|
Return to savenl.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / src |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)savenl.c 5.2 (Berkeley) 1/9/89";
9: #endif not lint
10:
11: /*
12: * savenl - routines for saving namelist and line number information
13: *
14: * This module contains the routines that make pi dump a namelist
15: * at the end of the object file. We do this by first creating
16: * four temporary files in "startnlfile". One temp file contains
17: * the string table, one the symbol table, one the file name
18: * information and one the line number information.
19: *
20: * Prior to generation of the code for a statement the "lineno"
21: * routine is called to dump the line number and current object
22: * address. At the end of each block "savenl" is called to dump
23: * the strings and symbol structures.
24: *
25: * At the end of execution "copynlfile" is called and it copies
26: * the temp files onto the end of the obj file.
27: *
28: * In case of error, "removenlfile" is called to destroy the temp files.
29: *
30: * The only other changes to pi are in calling these routines from
31: *
32: * "main" (main.c)
33: * "yymain" (yymain.c)
34: * "funcend" (fend.c)
35: * "yyget" (yyget.c)
36: * "putline" (stat.c)
37: */
38:
39: #include "whoami.h"
40: #ifdef OBJ
41: /*
42: * and the rest of the file
43: */
44: #include "0.h"
45: #include "objfmt.h"
46:
47: #undef NIL
48:
49: /*
50: * pdx header files
51: */
52:
53: #include "../pdx/defs.h"
54: #include "../pdx/object.h"
55: #include "../pdx/object/objsym.rep"
56: #include "../pdx/mappings.h"
57: #include "../pdx/mappings/filetab.h"
58:
59: LOCAL char symname[] = "/tmp/obj.symXXXXXX";
60: LOCAL char strname[] = "/tmp/obj.strXXXXXX";
61: LOCAL char filesname[] = "/tmp/obj.filesXXXXXX";
62: LOCAL char linesname[] = "/tmp/obj.linesXXXXXX";
63:
64: LOCAL FILE *symfp;
65: LOCAL FILE *strfp;
66: LOCAL FILE *filesfp;
67: LOCAL FILE *linesfp;
68:
69: LOCAL long nlsize;
70:
71: extern FILE *fopen();
72:
73: LOCAL putblock();
74: LOCAL putstring();
75:
76: /*
77: * create temporary files for the namelist info
78: */
79:
80: startnlfile()
81: {
82: nlsize = 0;
83: (void) mktemp(symname);
84: (void) mktemp(strname);
85: (void) mktemp(filesname);
86: (void) mktemp(linesname);
87: symfp = fopen(symname, "w");
88: strfp = fopen(strname, "w");
89: filesfp = fopen(filesname, "w");
90: linesfp = fopen(linesname, "w");
91: if (symfp==NULL || strfp==NULL || filesfp==NULL || linesfp==NULL) {
92: fprintf(stderr, "can't create /tmp/obj");
93: pexit(NOSTART);
94: }
95: newfile(filename, 1);
96: }
97:
98: /*
99: * now copy the temp files back to obj; strings, symbols, file names, and lines
100: *
101: * There's some efficiency garbage here that uses straight system
102: * calls rather than standard I/O library calls.
103: */
104:
105: copynlfile()
106: {
107: register int n;
108: extern long lseek();
109: int symfd, strfd, filesfd, linesfd;
110: char buff[BUFSIZ];
111:
112: (void) fclose((FILE *) symfp);
113: (void) fclose((FILE *) strfp);
114: (void) fclose((FILE *) filesfp);
115: (void) fclose((FILE *) linesfp);
116: if (!opt('g')) {
117: removenlfile();
118: return;
119: }
120: symfd = open(symname, 0);
121: strfd = open(strname, 0);
122: filesfd = open(filesname, 0);
123: linesfd = open(linesname, 0);
124: if (symfd < 0 || strfd < 0 || filesfd < 0 || linesfd < 0) {
125: fprintf(stderr, "sync error on /tmp/obj");
126: pexit(ERRS);
127: }
128: (void) lseek(ofil, 0L, 2);
129: write(ofil, (char *) (&nlhdr), sizeof(nlhdr));
130: n = read(strfd, buff, BUFSIZ - sizeof(nlhdr));
131: write(ofil, buff, n);
132: cat(strfd);
133: cat(symfd);
134: cat(filesfd);
135: cat(linesfd);
136: removenlfile();
137: }
138:
139: cat(fd)
140: int fd;
141: {
142: register int n;
143: char buff[BUFSIZ];
144:
145: while ((n = read(fd, buff, BUFSIZ)) > 0) {
146: write(ofil, buff, n);
147: }
148: (void) close(fd);
149: }
150:
151: removenlfile()
152: {
153: unlink(symname);
154: unlink(strname);
155: unlink(filesname);
156: unlink(linesname);
157: }
158:
159: nlhdrsize()
160: {
161: int r;
162:
163: if (!opt('g')) {
164: r = 0;
165: } else {
166: r = nlsize + sizeof(nlhdr);
167: }
168: return r;
169: }
170:
171: #define isblock(s) (s->class == FUNC || s->class == PROC)
172: #define isbuiltin(s) ((s->nl_block&037) == 0 && isblock(s))
173: #define symno(p) (p==NULL ? 0 : nloff(p))
174:
175: struct nls {
176: struct nl *nls_low;
177: struct nl *nls_high;
178: };
179:
180: struct nl nl[], *nlp, ntab[], *nlact;
181:
182: /*VARARGS*/
183: savenl(to, rout)
184: struct nl *to;
185: {
186: register struct nl *p;
187: register OBJSYM *s;
188: OBJSYM tmpsym;
189: struct nls *nlsp;
190:
191: if (to != NIL) {
192: putblock((char *) rout);
193: } else {
194: putblock("main program");
195: }
196: nlsp = (struct nls *) nlact;
197: s = &tmpsym;
198: for (p = nlp; p != to;) {
199: if (p == nlsp->nls_low) {
200: if (nlsp == ((struct nls *) &ntab[0]))
201: break;
202: nlsp--;
203: p = nlsp->nls_high;
204: }
205: p--;
206: if (isbuiltin(p) || symno(p) == 0) {
207: continue;
208: }
209: nlhdr.nsyms++;
210: nlsize += sizeof(OBJSYM) + sizeof(int);
211: (void) putw(symno(p), symfp);
212: if (p->symbol != NULL) {
213: s->strindex = nlhdr.stringsize;
214: putstring(p->symbol);
215: } else {
216: s->strindex = 0;
217: }
218: s->oclass = p->class;
219: s->oblkno = (p->nl_block&037);
220: s->typno = symno(p->type);
221: s->chno = symno(p->chain);
222: s->osymvalue.orangev.lower = p->range[0];
223: s->osymvalue.orangev.upper = p->range[1];
224: if (isblock(p)) {
225: s->osymvalue.ofuncv.codeloc = p->value[NL_ENTLOC];
226: } else if (p->class == RECORD || p->class == VARNT) {
227: s->osymvalue.ovarnt.vtorecno = symno(p->ptr[2]);
228: s->osymvalue.ovarnt.vtagno = symno(p->ptr[3]);
229: }
230: fwrite((char *) s, sizeof(*s), 1, symfp);
231: }
232: }
233:
234: /*
235: * Dump a line number and the current object location counter.
236: *
237: * To save space the difference from the previous line number and offset
238: * (one byte each) is dumped.
239: */
240:
241: LOCAL int oline = 0;
242: LOCAL int olc = HEADER_BYTES;
243:
244: lineno(line)
245: int line;
246: {
247: OBJLINE info;
248:
249: if (line != oline) {
250: nlhdr.nlines++;
251: nlsize += sizeof(OBJLINE);
252: info.separate.lineincr = line - oline;
253: info.separate.addrincr = ((unsigned short) (lc - olc));
254: (void) putw((int) info.together, linesfp);
255: oline = line;
256: olc = (int) lc;
257: }
258: }
259:
260: /*
261: * put out a file name entry, including:
262: *
263: * the current line number for the new file
264: * the current location counter
265: * the string table address of the file name
266: * an index into the current line number information
267: */
268:
269: newfile(s, line)
270: char *s;
271: int line;
272: {
273: FILETAB ft;
274:
275: nlhdr.nfiles++;
276: nlsize += sizeof(FILETAB);
277: ft.line = line;
278: oline = line;
279: if (lc == 0) {
280: ft.addr = 0;
281: } else {
282: ft.addr = ((LINENO) lc - HEADER_BYTES );
283: }
284: ft.filename = (char *) nlhdr.stringsize;
285: putstring(s);
286: ft.lineindex = nlhdr.nlines;
287: fwrite((char *) (&ft), sizeof(ft), 1, filesfp);
288: }
289:
290: /*
291: * put out a dummy symbol at the beginning of a block
292: */
293:
294: LOCAL putblock(s)
295: char *s;
296: {
297: static OBJSYM zerosym;
298:
299: nlhdr.nsyms++;
300: nlsize += sizeof(OBJSYM) + sizeof(int);
301: (void) putw(0, symfp);
302: zerosym.strindex = nlhdr.stringsize;
303: putstring(s);
304: fwrite((char *) (&zerosym), sizeof(zerosym), 1, symfp);
305: }
306:
307: /*
308: * put out a string to the string table file
309: */
310:
311: LOCAL putstring(s)
312: char *s;
313: {
314: register char *p;
315:
316: for (p = s; *p != '\0'; p++) {
317: putc(*p, strfp);
318: }
319: nlhdr.stringsize += (p - s + 1);
320: nlsize += (p - s + 1);
321: putc('\0', strfp);
322: }
323: #endif OBJ
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.