Return to source.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / pdx / source

Annotation of 42BSD/ucb/pascal/pdx/source/source.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1982 Regents of the University of California */
                      2: 
                      3: static char sccsid[] = "@(#)source.c 1.4 3/24/83";
                      4: 
                      5: /*
                      6:  * Source file management.
                      7:  */
                      8: 
                      9: #include "defs.h"
                     10: #include "source.h"
                     11: 
                     12: /*
                     13:  * Seektab is the data structure used for indexing source
                     14:  * seek addresses by line number.
                     15:  *
                     16:  * The constraints are:
                     17:  *
                     18:  *  we want an array so indexing is fast and easy
                     19:  *  we don't want to waste space for small files
                     20:  *  we don't want an upper bound on # of lines in a file
                     21:  *  we don't know how many lines there are
                     22:  *
                     23:  * The solution is a sparse array. We have NSLOTS pointers to
                     24:  * arrays of NLINESPERSLOT addresses.  To find the source address of
                     25:  * a particular line we find the slot, allocate space if necessary,
                     26:  * and then find its location within the pointed to array.
                     27:  *
                     28:  * As a result, there is a limit of NSLOTS*NLINESPERSLOT lines per file
                     29:  * but this is plenty high and still fairly inexpensive.
                     30:  *
                     31:  * This implementation maintains only one source file at any given
                     32:  * so as to avoid consuming too much memory.  In an environment where
                     33:  * memory is less constrained and one expects to be changing between
                     34:  * files often enough, it would be reasonable to have multiple seek tables.
                     35:  */
                     36: 
                     37: typedef int SEEKADDR;
                     38: 
                     39: #define NSLOTS 40
                     40: #define NLINESPERSLOT 500
                     41: 
                     42: #define slotno(line)   ((line)/NLINESPERSLOT)
                     43: #define index(line)    ((line)%NLINESPERSLOT)
                     44: #define slot_alloc()   alloc(NLINESPERSLOT, SEEKADDR)
                     45: #define srcaddr(line)  seektab[(line)/NLINESPERSLOT][(line)%NLINESPERSLOT]
                     46: 
                     47: LOCAL SEEKADDR *seektab[NSLOTS];
                     48: 
                     49: LOCAL FILE *srcfp;
                     50: 
                     51: /*
                     52:  * check to make sure a source line number is valid
                     53:  */
                     54: 
                     55: chkline(linenum)
                     56: register LINENO linenum;
                     57: {
                     58:     if (linenum < 1) {
                     59:        error("line number must be positive");
                     60:     }
                     61:     if (linenum > lastlinenum) {
                     62:        error("not that many lines");
                     63:     }
                     64: }
                     65: 
                     66: /*
                     67:  * print out the given lines from the source
                     68:  */
                     69: 
                     70: printlines(l1, l2)
                     71: LINENO l1, l2;
                     72: {
                     73:     register int c;
                     74:     register LINENO i;
                     75:     register FILE *fp;
                     76: 
                     77:     chkline(l1);
                     78:     chkline(l2);
                     79:     if (l2 < l1) {
                     80:        error("second line number less than first");
                     81:     }
                     82:     fp = srcfp;
                     83:     fseek(fp, (long) srcaddr(l1), 0);
                     84:     for (i = l1; i <= l2; i++) {
                     85:        printf("%5d   ", i);
                     86:        while ((c = getc(fp)) != '\n') {
                     87:            putchar(c);
                     88:        }
                     89:        putchar('\n');
                     90:     }
                     91: }
                     92: 
                     93: /*
                     94:  * read the source file getting seek pointers for each line
                     95:  */
                     96: 
                     97: skimsource(file)
                     98: char *file;
                     99: {
                    100:     register int c;
                    101:     register SEEKADDR count;
                    102:     register FILE *fp;
                    103:     register LINENO linenum;
                    104:     register SEEKADDR lastaddr;
                    105:     register int slot;
                    106: 
                    107:     if (file == NIL || file == cursource) {
                    108:        return;
                    109:     }
                    110:     if ((fp = fopen(file, "r")) == NULL) {
                    111:        panic("can't open \"%s\"", file);
                    112:     }
                    113:     if (cursource != NIL) {
                    114:        free_seektab();
                    115:     }
                    116:     cursource = file;
                    117:     linenum = 0, count = 0, lastaddr = 0;
                    118:     while ((c = getc(fp)) != EOF) {
                    119:        count++;
                    120:        if (c == '\n') {
                    121:            slot = slotno(++linenum);
                    122:            if (slot >= NSLOTS) {
                    123:                panic("skimsource: too many lines");
                    124:            }
                    125:            if (seektab[slot] == NIL) {
                    126:                seektab[slot] = slot_alloc();
                    127:            }
                    128:            seektab[slot][index(linenum)] = lastaddr;
                    129:            lastaddr = count;
                    130:        }
                    131:     }
                    132:     lastlinenum = linenum;
                    133:     srcfp = fp;
                    134: }
                    135: 
                    136: /*
                    137:  * Erase information and release space in the current seektab.
                    138:  * This is in preparation for reading in seek pointers for a
                    139:  * new file.  It is possible that seek pointers for all files
                    140:  * should be kept around, but the current concern is space.
                    141:  */
                    142: 
                    143: LOCAL free_seektab()
                    144: {
                    145:     register int slot;
                    146: 
                    147:     for (slot = 0; slot < NSLOTS; slot++) {
                    148:        if (seektab[slot] != NIL) {
                    149:            free(seektab[slot]);
                    150:            seektab[slot] = NIL;
                    151:        }
                    152:     }
                    153: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.