![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ref.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 / vi|
Return to ref.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* ref2.c */
2:
3: /* This is a totally rewritten version of ref. This version looks for the
4: * desired function name in the "tags" file, and then reads the header out
5: * from the source file. There is no longer any need for a "refs" file.
6: *
7: * Usage: ref [-a] [-t] [-f file] [-c class] tag
8: * Options: -t output tag info, not the description
9: * -f file default filename for static functions
10: * -c class default class names for class functions
11: */
12: #ifdef __STDC__
13: # include <string.h>
14: # include <stdlib.h>
15: #endif
16:
17: #include <stdio.h>
18: #include "config.h"
19:
20: extern char *cktagdir P_((char *, char *));
21: extern int getline P_((char *, int, FILE *));
22: extern int lookup P_((char *, char *));
23: extern int find P_((char *));
24: extern void usage P_((void));
25: extern int countcolons P_((char *));
26: extern void main P_((int, char **));
27: extern char *getenv P_((char *));
28:
29:
30: /* This is the default path that is searched for tags */
31: #if OSK
32: # define DEFTAGPATH ".:/dd/defs:/dd/defs/sys:/dd/usr/src/lib:../lib:/dd/usr/lib"
33: #else
34: # if ANY_UNIX
35: # define DEFTAGPATH ".:/usr/include:/usr/include/sys:/usr/src/lib:../lib:/usr/local/lib"
36: # else
37: # if MSDOS || TOS
38: # define DEFTAGPATH ".;C:\\include;C:\\include\\sys;C:\\lib;..\\lib"
39: # define SEP ';'
40: # else
41: # if AMIGA
42: # define DEFTAGPATH ".;Include:;Include:sys"
43: # define SEP ';'
44: # else /* any other OS */
45: # define DEFTAGPATH "."
46: # endif
47: # endif
48: # endif
49: #endif
50:
51: #ifndef SEP
52: # define SEP ':'
53: #endif
54:
55:
56: /* These variables reflect the command-line options given by the user. */
57: int taginfo; /* boolean: give only the tag info? (not header?) */
58: char *def_file; /* default filename for static functions */
59: char *def_class; /* default classname for class members */
60: int colons; /* #colons in tag: 0=normal, 1=static, 2=member */
61:
62: /* This function checks for a tag in the "tags" file of given directory.
63: * If the tag is found, then it returns a pointer to a static buffer which
64: * contains the filename, a tab character, and a linespec for finding the
65: * the tag. If the tag is not found in the "tags" file, or if the "tags"
66: * file cannot be opened or doesn't exist, then this function returns NULL.
67: */
68: char *cktagdir(tag, dir)
69: char *tag; /* name of the tag to look for */
70: char *dir; /* name of the directory to check */
71: {
72: char buf[BLKSIZE];
73: static char found[BLKSIZE];
74: FILE *tfile;
75: int len;
76:
77: #if AMIGA
78: if (dir[strlen(dir) - 1] == COLON)
79: sprintf(buf, "%s%s", dir, TAGS); /* no slash after colon. */
80: else
81: #endif
82: /* construct the name of the "tags" file in this directory */
83: sprintf(buf, "%s%c%s", dir, SLASH, TAGS);
84:
85: /* Try to open the tags file. Return NULL if can't open */
86: #if AMIGA
87: if (buf[0] == '.' && buf[1] == SLASH)
88: tfile = fopen(&buf[2], "r");
89: else
90: #endif
91: tfile = fopen(buf, "r");
92: if (!tfile)
93: {
94: return (char *)0;
95: }
96:
97: /* compute the length of the tagname once */
98: len = strlen(tag);
99:
100: /* read lines until we get the one for this tag */
101: found[0] = '\0';
102: while (fgets(buf, sizeof buf, tfile))
103: {
104: /* is this the one we want? */
105: if (!strncmp(buf, tag, len) && buf[len] == '\t')
106: {
107: /* we've found a match -- remember it */
108: strcpy(found, buf);
109:
110: /* if there is no default file, or this match is in
111: * the default file, then we've definitely found the
112: * one we want. Break out of the loop now.
113: */
114: if (!def_file || !strncmp(&buf[len + 1], def_file, strlen(def_file)))
115: {
116: break;
117: }
118: }
119: }
120:
121: /* we're through reading */
122: fclose(tfile);
123:
124: /* if there's anything in found[], use it */
125: if (found[0])
126: {
127: return &found[len + 1];
128: }
129:
130: /* else we didn't find it */
131: return (char *)0;
132: }
133:
134: /* This function reads a single textline from a binary file. It returns
135: * the number of bytes read, or 0 at EOF.
136: */
137: int getline(buf, limit, fp)
138: char *buf; /* buffer to read into */
139: int limit; /* maximum characters to read */
140: FILE *fp; /* binary stream to read from */
141: {
142: int bytes; /* number of bytes read so far */
143: int ch; /* single character from file */
144:
145: for (bytes = 0, ch = 0; ch != '\n' && --limit > 0 && (ch = getc(fp)) != EOF; bytes++)
146: {
147: #if MSDOS || TOS
148: /* since this is a binary file, we'll need to manually strip CR's */
149: if (ch == '\r')
150: {
151: continue;
152: }
153: #endif
154: *buf++ = ch;
155: }
156: *buf = '\0';
157:
158: return bytes;
159: }
160:
161:
162: /* This function reads a source file, looking for a given tag. If it finds
163: * the tag, then it displays it and returns TRUE. Otherwise it returns FALSE.
164: * To display the tag, it attempts to output any introductory comment, the
165: * tag line itself, and any arguments. Arguments are assumed to immediately
166: * follow the tag line, and start with whitespace. Comments are assumed to
167: * start with lines that begin with "/*", "//", "(*", or "--", and end at the
168: * tag line or at a blank line.
169: */
170: int lookup(dir, entry)
171: char *dir; /* name of the directory that contains the source */
172: char *entry; /* source filename, <Tab>, linespec */
173: {
174: char buf[BLKSIZE]; /* pathname of sourcefile */
175: long lnum; /* line number */
176: long here; /* seek position where current line began */
177: long comment; /* seek position of introductory comment, or -1L */
178: FILE *sfile; /* used for reading the source file */
179: int len; /* length of string */
180: char *ptr;
181: #if COHERENT
182: char *modname;
183: #endif
184:
185: /* construct the pathname of the source file */
186: strcpy(buf, dir);
187: ptr = buf + strlen(buf);
188: #if AMIGA
189: if (ptr[-1] != COLON)
190: #endif
191: *ptr++ = SLASH;
192: #if COHERENT
193: modname = ptr;
194: #endif
195: while (*entry != '\t')
196: {
197: *ptr++ = *entry++;
198: }
199: *ptr = '\0';
200: #if COHERENT
201: printf("--%s--\n", modname);
202: #endif
203: entry++;
204:
205: /* searching for string or number? */
206: if (*entry >= '0' && *entry <= '9')
207: {
208: /* given a specific line number */
209: lnum = atol(entry);
210: entry = (char *)0;
211: }
212: else
213: {
214: /* given a string -- strip off "/^" and "$/\n" */
215: entry += 2;
216: len = strlen(entry) - 2;
217: if (entry[len - 1] == '$')
218: {
219: entry[len - 1] = '\n';
220: }
221: lnum = 0L;
222: }
223:
224: /* Open the file. Note that we open the file in binary mode even
225: * though we know it is a text file, because ftell() and fseek()
226: * don't work on text files.
227: */
228: #if MSDOS || TOS
229: sfile = fopen(buf, "rb");
230: #else
231: # if AMIGA
232: if (buf[0] == '.' && buf[1] == SLASH)
233: sfile = fopen(&buf[2], "r");
234: else
235: # endif
236: sfile = fopen(buf, "r");
237: #endif
238: if (!sfile)
239: {
240: /* can't open the real source file. Try "refs" instead */
241: #if AMIGA
242: if (dir[strlen(dir) - 1] == COLON)
243: sprintf(buf, "%srefs", dir);
244: else
245: #endif
246: sprintf(buf, "%s%crefs", dir, SLASH);
247: #if MSDOS || TOS
248: sfile = fopen(buf, "rb");
249: #else
250: # if AMIGA
251: if (buf[0] == '.' && buf[1] == SLASH)
252: sfile = fopen(&buf[2], "r");
253: else
254: # endif
255: sfile = fopen(buf, "r");
256: #endif
257: if (!sfile)
258: {
259: /* failed! */
260: return 0;
261: }
262: }
263:
264: /* search the file */
265: for (comment = -1L; here = ftell(sfile), getline(buf, BLKSIZE, sfile) > 0; )
266: {
267: /* Is this the start/end of a comment? */
268: if (comment == -1L)
269: {
270: /* starting a comment? */
271: if (buf[0] == '/' && buf[1] == '*'
272: || buf[0] == '/' && buf[1] == '/'
273: || buf[0] == '(' && buf[1] == '*'
274: || buf[0] == '-' && buf[1] == '-')
275: {
276: comment = here;
277: }
278: }
279: else
280: {
281: /* ending a comment? */
282: if (buf[0] == '\n' || buf[0] == '#')
283: {
284: comment = -1L;
285: }
286: }
287:
288: /* is this the tag line? */
289: if (--lnum == 0L || (entry && !strncmp(buf, entry, len)))
290: {
291: /* if there were introductory comments, show them */
292: if (comment != -1L)
293: {
294: fseek(sfile, comment, 0);
295: while (comment != here)
296: {
297: getline(buf, BLKSIZE, sfile);
298: fputs(buf, stdout);
299: comment = ftell(sfile);
300: }
301:
302: /* re-fetch the tag line */
303: fgets(buf, BLKSIZE, sfile);
304: }
305:
306: /* show the tag line */
307: fputs(buf, stdout);
308:
309: /* show any argument lines */
310: while (getline(buf, BLKSIZE, sfile) > 0
311: && buf[0] != '#'
312: && strchr(buf, '{') == (char *)0)
313: {
314: fputs(buf, stdout);
315: }
316:
317: /* Done! Close the file, and return TRUE */
318: fclose(sfile);
319: return 1;
320: }
321: }
322:
323: /* not found -- return FALSE */
324: return 0;
325: }
326:
327: /* This function searches through the entire search path for a given tag.
328: * If it finds the tag, then it displays the info and returns TRUE;
329: * otherwise it returns FALSE.
330: */
331: int find(tag)
332: char *tag; /* the tag to look up */
333: {
334: char *tagpath;
335: char dir[80];
336: char *ptr;
337: int len;
338:
339: if (colons == 1)
340: {
341: /* looking for static function -- only look in current dir */
342: tagpath = ".";
343: }
344: else
345: {
346: /* get the tagpath from the environment. Default to DEFTAGPATH */
347: tagpath = getenv("TAGPATH");
348: if (!tagpath)
349: {
350: tagpath = DEFTAGPATH;
351: }
352: }
353:
354: /* for each entry in the path... */
355: while (*tagpath)
356: {
357: /* Copy the entry into the dir[] buffer */
358: for (ptr = dir; *tagpath && *tagpath != SEP; tagpath++)
359: {
360: *ptr++ = *tagpath;
361: }
362: if (*tagpath == SEP)
363: {
364: tagpath++;
365: }
366:
367: /* if the entry ended with "/tags", then strip that off */
368: len = strlen(TAGS);
369: if (&dir[len] < ptr && ptr[-len - 1] == SLASH && !strncmp(&ptr[-len], TAGS, len))
370: {
371: ptr -= len + 1;
372: }
373:
374: /* if the entry is now an empty string, then assume "." */
375: if (ptr == dir)
376: {
377: *ptr++ = '.';
378: }
379: *ptr = '\0';
380:
381: /* look for the tag in this path. If found, then display it
382: * and exit.
383: */
384: ptr = cktagdir(tag, dir);
385: if (ptr)
386: {
387: /* just supposed to display tag info? */
388: if (taginfo)
389: {
390: /* then do only that! */
391: if (strcmp(dir, "."))
392: {
393: printf("%s%c%s", dir, SLASH, ptr);
394: }
395: else
396: {
397: /* avoid leading "./" if possible */
398: fputs(ptr, stdout);
399: }
400: return 1;
401: }
402: else
403: {
404: /* else look up the declaration of the thing */
405: return lookup(dir, ptr);
406: }
407: }
408: }
409:
410: /* if we get here, then the tag wasn't found anywhere */
411: return 0;
412: }
413:
414: void usage()
415: {
416: fputs("usage: ref [-a] [-t] [-c class] [-f file] tag\n", stderr);
417: fputs(" -a function's args may be flush against left margin\n", stderr);
418: fputs(" -t output tag info, instead of the function header\n", stderr);
419: fputs(" -f File tag might be a static function in File\n", stderr);
420: fputs(" -c Class tag might be a member of class Class\n", stderr);
421: exit(2);
422: }
423:
424:
425: int countcolons(str)
426: char *str;
427: {
428: while (*str != ':' && *str)
429: {
430: str++;
431: }
432: if (str[0] != ':')
433: {
434: return 0;
435: }
436: else if (str[1] != ':')
437: {
438: return 1;
439: }
440: return 2;
441: }
442:
443: void main(argc, argv)
444: int argc;
445: char **argv;
446: {
447: char def_tag[100]; /* used to build tag name with default file/class */
448: int i;
449:
450: /* parse flags */
451: for (i = 1; i < argc && argv[i][0] == '-'; i++)
452: {
453: switch (argv[i][1])
454: {
455: case 't':
456: taginfo = 1;
457: break;
458:
459: case 'f':
460: if (argv[i][2])
461: {
462: def_file = &argv[i][2];
463: }
464: else if (++i < argc)
465: {
466: def_file = argv[i];
467: }
468: else
469: {
470: usage();
471: }
472: break;
473:
474: case 'c':
475: if (argv[i][2])
476: {
477: def_class = &argv[i][2];
478: }
479: else if (++i < argc)
480: {
481: def_class = argv[i];
482: }
483: else
484: {
485: usage();
486: }
487: break;
488:
489: default:
490: usage();
491: }
492: }
493:
494: /* if no tag was given, complain */
495: if (i + 1 != argc)
496: {
497: usage();
498: }
499:
500: /* does the tag have an explicit class or file? */
501: colons = countcolons(argv[i]);
502:
503: /* if not, then maybe try some defaults */
504: if (colons == 0)
505: {
506: /* try a static function in the file first */
507: if (def_file)
508: {
509: sprintf(def_tag, "%s:%s", def_file, argv[i]);
510: colons = 1;
511: if (find(def_tag))
512: {
513: exit(0);
514: }
515: }
516:
517: /* try a member function for a class */
518: if (def_class)
519: {
520: sprintf(def_tag, "%s::%s", def_class, argv[i]);
521: colons = 2;
522: if (find(def_tag))
523: {
524: exit(0);
525: }
526: }
527:
528: /* oh, well */
529: colons = 0;
530: }
531:
532: /* find the tag */
533: if (find(argv[i]))
534: {
535: exit(0);
536: }
537:
538: exit(1);
539: /*NOTREACHED*/
540: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.