Return to 1.form.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.bin / struct

Annotation of 43BSD/usr.bin/struct/1.form.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)1.form.c   4.1     (Berkeley)      2/11/83";
        !             3: #endif not lint
        !             4: 
        !             5: #include <stdio.h>
        !             6: #include "1.defs.h"
        !             7: #include "def.h"
        !             8: extern int linechar, errflag, debug;
        !             9: extern int (*input)(), (*unput)();
        !            10: 
        !            11: 
        !            12: 
        !            13: uptolow(c)             /*translates upper to lower case */
        !            14: int c;
        !            15:        {
        !            16:        if ('A' <= c && c <= 'Z')
        !            17:                return(c+'a'-'A');
        !            18:        else
        !            19:                return(c);
        !            20:        }
        !            21: 
        !            22: rdfree(func)
        !            23: int (*func)();
        !            24:        {
        !            25:        int c;
        !            26:        while ( (c = (*input)()) != '\n')
        !            27:                {
        !            28:                (*func)(c);
        !            29:                }
        !            30:        }
        !            31: 
        !            32: rdstand(func)
        !            33: int (*func)();
        !            34:        {
        !            35:        int c;
        !            36:        while ( (c=(*input)()) != '\n')
        !            37:                {
        !            38:                (*func)(c);
        !            39:                }
        !            40:        }
        !            41: 
        !            42: labfree(func)                  /* labels in freeform input */
        !            43: int (*func)();
        !            44:        {
        !            45:        int c;
        !            46:        int temp[6];
        !            47:        int j;
        !            48:        for (j = 0; j < 5; ++j)
        !            49:                {
        !            50:                while ( (c = (*input)()) == ' ' || c == '\t' );
        !            51:                if (c == '\n')
        !            52:                        {
        !            53:                        if (j != 0)
        !            54:                                {
        !            55:                                temp[j] = '\0';
        !            56:                                error("label without code - ignored:","","");
        !            57:                                }
        !            58:                        }
        !            59:                if (c < '0' || c > '9')
        !            60:                        {
        !            61:                        (*unput)(c);
        !            62:                        break;
        !            63:                        }
        !            64:                else
        !            65:                        {
        !            66:                        temp[j] = c;
        !            67:                        (*func)(c);
        !            68:                        }
        !            69:                }
        !            70:        for ( ; j < 5; ++j)
        !            71:                (*func)(' ');
        !            72:        }
        !            73: 
        !            74: labstand(func)                 /* labels in standard form input */
        !            75: int (*func)();
        !            76:        {
        !            77:        int c;
        !            78:        int j;
        !            79: 
        !            80:        for (j = 0; j < 5; ++j)
        !            81:                {
        !            82:                c = (*input)();
        !            83:                if (c == '\n')
        !            84:                        {
        !            85:                        error("line shorter than 5 characters","","");
        !            86:                        errflag = 1;
        !            87:                        (*unput)('\n');
        !            88:                        }
        !            89:                if (c == '\t' || c == '\n')
        !            90:                        {
        !            91:                        for ( ;j<5; ++j)
        !            92:                                (*func)(' ');
        !            93:                        return;
        !            94:                        }
        !            95:                (*func)(c);
        !            96:                }
        !            97:        (*input)();                     /* throw away continuation char */
        !            98:        }
        !            99: 
        !           100: 
        !           101: 
        !           102: contfree()                     /* identify continuation lines in free-form input */
        !           103:        {
        !           104:        return(nonblchar(_diglet,0));   /* any non-alpha non-digit */
        !           105:        }
        !           106: 
        !           107: 
        !           108: nonblchar(class,yesno)
        !           109: int class,yesno;
        !           110:        {
        !           111: #define CARDSIZE       121
        !           112:        int temp[CARDSIZE];
        !           113:        int j;
        !           114:        for (j=0; (temp[j]=(*input)()) == ' ' || temp[j] == '\t'; ++j)
        !           115:                if (j>=CARDSIZE-1)
        !           116:                        {
        !           117:                        temp[CARDSIZE-1] = '\0';
        !           118:                         error ("line unexpectedly long","","");
        !           119:                        break;
        !           120:                        }
        !           121:        if (temp[j]!=EOF && classmatch(temp[j],class)==yesno)
        !           122:                return(1);
        !           123:        else
        !           124:                {
        !           125:                for ( ; j >= 0; --j)
        !           126:                        (*unput)(temp[j]);
        !           127:                return(0);
        !           128:                }
        !           129:        }
        !           130: 
        !           131: 
        !           132: contstand()                    /* continuation lines in standard form input */
        !           133:        {
        !           134:        int temp[6];
        !           135:        int i;
        !           136: 
        !           137:        for (i = 0; i < 6; ++i)
        !           138:                {
        !           139:                temp[i] = (*input)();
        !           140:                if (temp[i] == '\t' || temp[i] == '\n' || temp[i] == '\0' || temp[i] == EOF)
        !           141:                        {
        !           142:                        for ( ;i >= 0; --i)
        !           143:                                (*unput)(temp[i]);
        !           144:                        return(0);
        !           145:                        }
        !           146:                }
        !           147:        if (temp[5] != '0' && temp[5] != ' ')
        !           148:                return(1);
        !           149:        else
        !           150:                {
        !           151:                for ( i = 5 ; i >= 0; --i)
        !           152:                        (*unput)(temp[i]);
        !           153:                return(0);
        !           154:                }
        !           155:        }
        !           156: 
        !           157: 
        !           158: 
        !           159: comstand(posafter)                     /* standard form comments */
        !           160: int posafter;
        !           161:        {
        !           162:        int c;
        !           163:        c = (*input)();
        !           164:        if (!posafter)
        !           165:                (*unput)(c);
        !           166:        if (c == 'c' || c == '*' || c== '#')
        !           167:                return(1);
        !           168:        else
        !           169:                return(0);
        !           170:        }
        !           171: 
        !           172: 
        !           173: comfree(posafter)
        !           174: int posafter;
        !           175:        {
        !           176:        return(comstand(posafter));
        !           177:        }
        !           178: int (*rline[])()               = {rdfree,rdstand};
        !           179: int (*comment[])()             = {comfree,comstand};
        !           180: int (*getlabel[])()            = {labfree, labstand};
        !           181: int (*chkcont[])()             = {contfree,contstand};
        !           182: 
        !           183: blankline()
        !           184:        {
        !           185:        if ( nonblchar(_nl,1) )         /* first non-blank is nl */
        !           186:                {
        !           187:                (*unput) ('\n');
        !           188:                return(1);
        !           189:                }
        !           190:        else return(0);
        !           191:        }
        !           192: 
        !           193: #define maxunbp        80
        !           194: char unbuf[maxunbp+1];
        !           195: int unbp;
        !           196: 
        !           197: empseek(linebeg)
        !           198: int linebeg;
        !           199:        {
        !           200:        unbp = 0;
        !           201:        if (fseek(infd,(long)(linebeg+rtnbeg),0) == -1)
        !           202:                faterr("in disk seek","","");
        !           203:        }
        !           204: 
        !           205: inchar()
        !           206:        {
        !           207:        if (unbp > 0)
        !           208:                return( unbuf[--unbp] );
        !           209:        else
        !           210:                {
        !           211:                return( uptolow(getc(infd)) );
        !           212:                }
        !           213:        }
        !           214: 
        !           215: 
        !           216: unchar(c)
        !           217: int c;
        !           218:        {
        !           219:        if (unbp >= maxunbp)
        !           220:                faterr("dec.rat: unbuf size exceeded","","");
        !           221:        if(c!=EOF)unbuf[unbp++] = c;
        !           222:        }

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