![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to source.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / dbx|
Return to source.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / dbx |
1.1 root 1: /*
2: * Copyright (c) 1983 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[] = "@(#)source.c 5.1 (Berkeley) 5/31/85";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: source.c,v 1.4 84/06/07 16:29:38 linton Exp $";
12:
13: /*
14: * Source file management.
15: */
16:
17: #include "defs.h"
18: #include "source.h"
19: #include "object.h"
20: #include "mappings.h"
21: #include "machine.h"
22: #include "keywords.h"
23: #include "tree.h"
24: #include "eval.h"
25: #include <sys/file.h>
26:
27: #ifndef public
28: typedef int Lineno;
29:
30: String cursource;
31: Lineno curline;
32: Lineno cursrcline;
33:
34: #define LASTLINE 0 /* recognized by printlines */
35:
36: #include "lists.h"
37:
38: List sourcepath;
39: #endif
40:
41: extern char *re_comp();
42:
43: private Lineno lastlinenum;
44: private String prevsource = nil;
45:
46: /*
47: * Data structure for indexing source seek addresses by line number.
48: *
49: * The constraints are:
50: *
51: * we want an array so indexing is fast and easy
52: * we don't want to waste space for small files
53: * we don't want an upper bound on # of lines in a file
54: * we don't know how many lines there are
55: *
56: * The solution is a "dirty" hash table. We have NSLOTS pointers to
57: * arrays of NLINESPERSLOT addresses. To find the source address of
58: * a particular line we find the slot, allocate space if necessary,
59: * and then find its location within the pointed to array.
60: */
61:
62: typedef long Seekaddr;
63:
64: #define NSLOTS 40
65: #define NLINESPERSLOT 500
66:
67: #define slotno(line) ((line) div NLINESPERSLOT)
68: #define index(line) ((line) mod NLINESPERSLOT)
69: #define slot_alloc() newarr(Seekaddr, NLINESPERSLOT)
70: #define srcaddr(line) seektab[slotno(line)][index(line)]
71:
72: private File srcfp;
73: private Seekaddr *seektab[NSLOTS];
74:
75: /*
76: * Determine if the current source file is available.
77: */
78:
79: public boolean canReadSource ()
80: {
81: boolean b;
82:
83: if (cursource == nil) {
84: b = false;
85: } else if (cursource != prevsource) {
86: skimsource();
87: b = (boolean) (lastlinenum != 0);
88: } else {
89: b = true;
90: }
91: return b;
92: }
93:
94: /*
95: * Print out the given lines from the source.
96: */
97:
98: public printlines(l1, l2)
99: Lineno l1, l2;
100: {
101: register int c;
102: register Lineno i, lb, ub;
103: register File f;
104:
105: if (cursource == nil) {
106: beginerrmsg();
107: fprintf(stderr, "no source file\n");
108: } else {
109: if (cursource != prevsource) {
110: skimsource();
111: }
112: if (lastlinenum == 0) {
113: beginerrmsg();
114: fprintf(stderr, "couldn't read \"%s\"\n", cursource);
115: } else {
116: lb = (l1 == LASTLINE) ? lastlinenum : l1;
117: ub = (l2 == LASTLINE) ? lastlinenum : l2;
118: if (lb < 1) {
119: beginerrmsg();
120: fprintf(stderr, "line number must be positive\n");
121: } else if (lb > lastlinenum) {
122: beginerrmsg();
123: if (lastlinenum == 1) {
124: fprintf(stderr, "\"%s\" has only 1 line\n", cursource);
125: } else {
126: fprintf(stderr, "\"%s\" has only %d lines\n",
127: cursource, lastlinenum);
128: }
129: } else if (ub < lb) {
130: beginerrmsg();
131: fprintf(stderr, "second number must be greater than first\n");
132: } else {
133: if (ub > lastlinenum) {
134: ub = lastlinenum;
135: }
136: f = srcfp;
137: fseek(f, srcaddr(lb), 0);
138: for (i = lb; i <= ub; i++) {
139: printf("%5d ", i);
140: while ((c = getc(f)) != '\n') {
141: putchar(c);
142: }
143: putchar('\n');
144: }
145: cursrcline = ub + 1;
146: }
147: }
148: }
149: }
150:
151: /*
152: * Search the sourcepath for a file.
153: */
154:
155: static char fileNameBuf[1024];
156:
157: public String findsource(filename)
158: String filename;
159: {
160: register String src, dir;
161:
162: if (filename[0] == '/') {
163: src = filename;
164: } else {
165: src = nil;
166: foreach (String, dir, sourcepath)
167: sprintf(fileNameBuf, "%s/%s", dir, filename);
168: if (access(fileNameBuf, R_OK) == 0) {
169: src = fileNameBuf;
170: break;
171: }
172: endfor
173: }
174: return src;
175: }
176:
177: /*
178: * Open a source file looking in the appropriate places.
179: */
180:
181: public File opensource(filename)
182: String filename;
183: {
184: String s;
185: File f;
186:
187: s = findsource(filename);
188: if (s == nil) {
189: f = nil;
190: } else {
191: f = fopen(s, "r");
192: }
193: return f;
194: }
195:
196: /*
197: * Set the current source file.
198: */
199:
200: public setsource(filename)
201: String filename;
202: {
203: if (filename != nil and filename != cursource) {
204: prevsource = cursource;
205: cursource = filename;
206: cursrcline = 1;
207: }
208: }
209:
210: /*
211: * Read the source file getting seek pointers for each line.
212: */
213:
214: private skimsource()
215: {
216: register int c;
217: register Seekaddr count;
218: register File f;
219: register Lineno linenum;
220: register Seekaddr lastaddr;
221: register int slot;
222:
223: f = opensource(cursource);
224: if (f == nil) {
225: lastlinenum = 0;
226: } else {
227: if (prevsource != nil) {
228: free_seektab();
229: if (srcfp != nil) {
230: fclose(srcfp);
231: }
232: }
233: prevsource = cursource;
234: linenum = 0;
235: count = 0;
236: lastaddr = 0;
237: while ((c = getc(f)) != EOF) {
238: ++count;
239: if (c == '\n') {
240: slot = slotno(++linenum);
241: if (slot >= NSLOTS) {
242: panic("skimsource: too many lines");
243: }
244: if (seektab[slot] == nil) {
245: seektab[slot] = slot_alloc();
246: }
247: seektab[slot][index(linenum)] = lastaddr;
248: lastaddr = count;
249: }
250: }
251: lastlinenum = linenum;
252: srcfp = f;
253: }
254: }
255:
256: /*
257: * Erase information and release space in the current seektab.
258: * This is in preparation for reading in seek pointers for a
259: * new file. It is possible that seek pointers for all files
260: * should be kept around, but the current concern is space.
261: */
262:
263: private free_seektab()
264: {
265: register int slot;
266:
267: for (slot = 0; slot < NSLOTS; slot++) {
268: if (seektab[slot] != nil) {
269: dispose(seektab[slot]);
270: }
271: }
272: }
273:
274: /*
275: * Figure out current source position.
276: */
277:
278: public getsrcpos()
279: {
280: String filename;
281:
282: curline = srcline(pc);
283: filename = srcfilename(pc);
284: setsource(filename);
285: if (curline != 0) {
286: cursrcline = curline;
287: }
288: }
289:
290: /*
291: * Print out the current source position.
292: */
293:
294: public printsrcpos()
295: {
296: printf("at line %d", curline);
297: if (nlhdr.nfiles > 1) {
298: printf(" in file \"%s\"", cursource);
299: }
300: }
301:
302: #define DEF_EDITOR "vi"
303:
304: /*
305: * Invoke an editor on the given file. Which editor to use might change
306: * installation to installation. For now, we use "vi". In any event,
307: * the environment variable "EDITOR" overrides any default.
308: */
309:
310: public edit(filename)
311: String filename;
312: {
313: extern String getenv();
314: String ed, src, s;
315: Symbol f;
316: Address addr;
317: char lineno[10];
318:
319: ed = getenv("EDITOR");
320: if (ed == nil) {
321: ed = DEF_EDITOR;
322: }
323: src = findsource((filename != nil) ? filename : cursource);
324: if (src == nil) {
325: f = which(identname(filename, true));
326: if (not isblock(f)) {
327: error("can't read \"%s\"", filename);
328: }
329: addr = firstline(f);
330: if (addr == NOADDR) {
331: error("no source for \"%s\"", filename);
332: }
333: src = srcfilename(addr);
334: s = findsource(src);
335: if (s != nil) {
336: src = s;
337: }
338: sprintf(lineno, "+%d", srcline(addr));
339: } else {
340: sprintf(lineno, "+1");
341: }
342: if (streq(ed, "vi") or streq(ed, "ex")) {
343: call(ed, stdin, stdout, lineno, src, nil);
344: } else {
345: call(ed, stdin, stdout, src, nil);
346: }
347: }
348:
349: /*
350: * Strip away portions of a given pattern not part of the regular expression.
351: */
352:
353: private String getpattern (pattern)
354: String pattern;
355: {
356: register char *p, *r;
357:
358: p = pattern;
359: while (*p == ' ' or *p == '\t') {
360: ++p;
361: }
362: r = p;
363: while (*p != '\0') {
364: ++p;
365: }
366: --p;
367: if (*p == '\n') {
368: *p = '\0';
369: --p;
370: }
371: if (*p == *r) {
372: *p = '\0';
373: --p;
374: }
375: return r + 1;
376: }
377:
378: /*
379: * Search the current file for a regular expression.
380: */
381:
382: public search (direction, pattern)
383: char direction;
384: String pattern;
385: {
386: register String p;
387: register File f;
388: String re, err;
389: Lineno line;
390: boolean matched;
391: char buf[512];
392:
393: if (cursource == nil) {
394: beginerrmsg();
395: fprintf(stderr, "no source file\n");
396: } else {
397: if (cursource != prevsource) {
398: skimsource();
399: }
400: if (lastlinenum == 0) {
401: beginerrmsg();
402: fprintf(stderr, "couldn't read \"%s\"\n", cursource);
403: } else {
404: re = getpattern(pattern);
405: /* circf = 0; */
406: if (re != nil and *re != '\0') {
407: err = re_comp(re);
408: if (err != nil) {
409: error(err);
410: }
411: }
412: matched = false;
413: f = srcfp;
414: line = cursrcline;
415: do {
416: if (direction == '/') {
417: ++line;
418: if (line > lastlinenum) {
419: line = 1;
420: }
421: } else {
422: --line;
423: if (line < 1) {
424: line = lastlinenum;
425: }
426: }
427: fseek(f, srcaddr(line), L_SET);
428: p = buf;
429: *p = getc(f);
430: while ((*p != '\n') and (*p != EOF)) {
431: ++p;
432: *p = getc(f);
433: }
434: *p = '\0';
435: matched = (boolean) re_exec(buf);
436: } while (not matched and line != cursrcline);
437: if (not matched) {
438: beginerrmsg();
439: fprintf(stderr, "no match\n");
440: } else {
441: printlines(line, line);
442: cursrcline = line;
443: }
444: }
445: }
446: }
447:
448: /*
449: * Compute a small window around the given line.
450: */
451:
452: public getsrcwindow (line, l1, l2)
453: Lineno line, *l1, *l2;
454: {
455: Node s;
456: integer size;
457:
458: s = findvar(identname("$listwindow", true));
459: if (s == nil) {
460: size = 10;
461: } else {
462: eval(s);
463: size = pop(integer);
464: }
465: *l1 = line - (size div 2);
466: if (*l1 < 1) {
467: *l1 = 1;
468: }
469: *l2 = *l1 + size;
470: if (lastlinenum != LASTLINE and *l2 > lastlinenum) {
471: *l2 = lastlinenum;
472: }
473: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.