Return to icfile.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / efl

Annotation of 41BSD/cmd/efl/icfile.c, revision 1.1

1.1     ! root        1: #include "defs"
        !             2: 
        !             3: struct { char chars[ 10 ]; };
        !             4: 
        !             5: 
        !             6: crii() /* create names for intermediate files */
        !             7: {
        !             8: 
        !             9: #ifdef unix
        !            10: sprintf(icfile->filename, "eflc.%d", getpid());
        !            11: sprintf(idfile->filename, "efld.%d", getpid());
        !            12: sprintf(iefile->filename, "efle.%d", getpid());
        !            13: #endif
        !            14: 
        !            15: #ifdef gcos
        !            16: sprintf(icfile->filename, "code.efl");
        !            17: sprintf(idfile->filename, "data.efl");
        !            18: sprintf(iefile->filename, "equv.efl");
        !            19: #endif
        !            20: }
        !            21: 
        !            22: 
        !            23: 
        !            24: rmiis()
        !            25: {
        !            26: rmii(icfile);
        !            27: rmii(idfile);
        !            28: rmii(iefile);
        !            29: }
        !            30: 
        !            31: 
        !            32: 
        !            33: 
        !            34: rmii(p)                /* discard the intermediate file */
        !            35: struct fileblock *p;
        !            36: {
        !            37: #ifdef unix
        !            38: if(p)
        !            39:        {
        !            40:        fclose(p->fileptr);
        !            41:        unlink(p->filename);
        !            42:        }
        !            43: #endif
        !            44: 
        !            45: #ifdef gcos
        !            46: if(p)
        !            47:        fclose(p->fileptr, "d");
        !            48: #endif
        !            49: }
        !            50: 
        !            51: 
        !            52: opiis()
        !            53: {
        !            54: opii(icfile);
        !            55: opii(idfile);
        !            56: opii(iefile);
        !            57: }
        !            58: 
        !            59: 
        !            60: 
        !            61: 
        !            62: opii(p)        /* open the intermediate file for writing */
        !            63: struct fileblock *p;
        !            64: {
        !            65: 
        !            66: #ifdef unix
        !            67: if( (p->fileptr = fopen(p->filename, "w")) == NULL)
        !            68:        fatal("cannot open intermediate file");
        !            69: #endif
        !            70: 
        !            71: #ifdef gcos
        !            72: if( (p->fileptr = fopen(p->filename, "wi")) == NULL)
        !            73:        fatal("cannot open intermediate file");
        !            74: #endif
        !            75: 
        !            76: }
        !            77: 
        !            78: 
        !            79: 
        !            80: swii(p)
        !            81: struct fileblock *p;
        !            82: {
        !            83: iifilep = p;
        !            84: }
        !            85: 
        !            86: 
        !            87: 
        !            88: putii(w,n)
        !            89: int *w, n;
        !            90: {
        !            91: if( fwrite(w,sizeof(int),n, iifilep->fileptr) != n)
        !            92:        fatal("write error");
        !            93: }
        !            94: 
        !            95: 
        !            96: 
        !            97: getii(w, n)
        !            98: int *w, n;
        !            99: {
        !           100: if( fread(w,sizeof(int), n, iifilep->fileptr) != n)
        !           101:        fatal("read error");
        !           102: }
        !           103: 
        !           104: 
        !           105: 
        !           106: 
        !           107: cliis()
        !           108: {
        !           109: clii(icfile);
        !           110: clii(idfile);
        !           111: clii(iefile);
        !           112: }
        !           113: 
        !           114: 
        !           115: 
        !           116: 
        !           117: clii(p)        /* close the intermediate file */
        !           118: struct fileblock *p;
        !           119: {
        !           120: #ifdef unix
        !           121: fclose(p->fileptr);
        !           122: #endif
        !           123: 
        !           124: #ifdef gcos
        !           125: fclose(p->fileptr, "rl");
        !           126: #endif
        !           127: }
        !           128: 
        !           129: 
        !           130: 
        !           131: rewii(p)       /* close and rewind the intermediate file for reading */
        !           132: struct fileblock *p;
        !           133: {
        !           134: swii(p);
        !           135: putic(ICEOF,0);
        !           136: clii(p);
        !           137: 
        !           138: #ifdef unix
        !           139: if( (p->fileptr = fopen(p->filename, "r")) == NULL)
        !           140:        fatal("cannot open intermediate file");
        !           141: #endif
        !           142: 
        !           143: #ifdef gcos
        !           144: if( (p->fileptr = fopen(p->filename, "ri")) == NULL)
        !           145:        fatal("cannot open intermediate file");
        !           146: #endif
        !           147: }
        !           148: 
        !           149: 
        !           150: 
        !           151: putic(c,p)
        !           152: int c;
        !           153: int p;
        !           154: {
        !           155: int w[2];
        !           156: prevbg = (c==ICINDENT);
        !           157: w[0] = c;
        !           158: w[1] = p;
        !           159: putii(w,2);
        !           160: }
        !           161: 
        !           162: 
        !           163: getic(p)
        !           164: int *p;
        !           165: {
        !           166: int w[2];
        !           167: 
        !           168: getii(w,2);
        !           169: *p = w[1];
        !           170: return( w[0] );
        !           171: }
        !           172: 
        !           173: 
        !           174: 
        !           175: putsii(l, p)
        !           176: int l;
        !           177: char *p;
        !           178: {
        !           179: int word;
        !           180: register int i, m, n;
        !           181: 
        !           182: n = strlen(p);
        !           183: putic(l, n);
        !           184: m = (n/sizeof(int)) ;
        !           185: while(m-- > 0)
        !           186:        {
        !           187:        for(i=0 ; i<sizeof(int); ++i)
        !           188:                word.chars[i] = *p++;
        !           189:        putii(&word, 1);
        !           190:        }
        !           191: n -= (n/sizeof(int))*sizeof(int);
        !           192: if(n > 0)
        !           193:        {
        !           194:        for(i=0 ; i<n ; ++i)
        !           195:                word.chars[i] = *p++;
        !           196:        putii(&word,1);
        !           197:        }
        !           198: }
        !           199: 
        !           200: 
        !           201: 
        !           202: 
        !           203: ptr getsii(n)
        !           204: int n;
        !           205: {
        !           206: static int incomm[100];
        !           207: int m;
        !           208: register int *q, *qm;
        !           209: char *p;
        !           210: 
        !           211: m = (n + sizeof(int)-1 ) / sizeof(int);
        !           212: q = incomm;
        !           213: qm = q + m;
        !           214: 
        !           215: while(q < qm)
        !           216:        getii(q++, 1);
        !           217: p = incomm;
        !           218: p[n] = '\0';
        !           219: 
        !           220: return(incomm);
        !           221: }

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