Return to icont.c CVS log

Up to [Research Unix] / researchv10dc / cmd / icon / src / icont

Annotation of researchv10dc/cmd/icon/src/icont/icont.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include "../h/config.h"
        !             3: #include "../h/paths.h"
        !             4: #define MaxArgs 30
        !             5: #define PathSize 100   /* maximum length of a fully qualified file name */
        !             6: #ifndef Itran
        !             7: #define Itran TranPath
        !             8: #endif
        !             9: #ifndef Ilink
        !            10: #define Ilink LinkPath
        !            11: #endif
        !            12: #ifndef Iconx
        !            13: #define Iconx IconxPath
        !            14: #endif Iconx
        !            15: 
        !            16: 
        !            17: char **rfiles;
        !            18: 
        !            19: 
        !            20: main(argc,argv,envp)
        !            21: int argc; char **argv, **envp;
        !            22:    {
        !            23:    char **tfiles;
        !            24:    char **lfiles;
        !            25:    char **execlist;
        !            26:    char *tflags[MaxArgs];
        !            27:    char *lflags[MaxArgs];
        !            28:    char **xargs;
        !            29:    int ntf, nlf, nrf, ntflags, nlflags, cflag, quiet;
        !            30:    char **arg;
        !            31:    char *base, *getbase();
        !            32:    char *u1, *u2, *xfile;
        !            33:    char *rindex(), *mkname();
        !            34:    char cmd[PathSize];
        !            35:    
        !            36:    ntf = nlf = nrf = ntflags = nlflags = cflag = quiet = 0;
        !            37:    xargs = NULL;
        !            38:    rfiles = (char **)calloc(2*(argc+10), sizeof(char **));
        !            39:    tfiles = (char **)calloc(argc+10, sizeof(char **));
        !            40:    lfiles = (char **)calloc(argc+10, sizeof(char **));
        !            41:    execlist = (char **)calloc(2*(argc+10), sizeof(char **));
        !            42: 
        !            43:    tflags[ntflags++] = "itran";
        !            44:    lflags[nlflags++] = "ilink";
        !            45:    lflags[nlflags++] = "-i";
        !            46:    lflags[nlflags++] = Iconx;
        !            47:    xfile = "";
        !            48:    
        !            49:    for (arg = &argv[1]; arg <= &argv[argc-1]; arg++) {
        !            50:       if ((*arg)[0] == '-') switch ((*arg)[1]) {
        !            51:          case '\0': /* "-" */
        !            52:             tfiles[ntf++] = *arg;
        !            53:             lfiles[nlf++] = rfiles[nrf++]
        !            54:               = "stdin.u1";
        !            55:             rfiles[nrf++] = "stdin.u2";
        !            56:             break;
        !            57:          case 's':
        !            58:             tflags[ntflags++] = "-s";
        !            59:             quiet++;
        !            60:             break;
        !            61:          case 'o':
        !            62:             lfiles[nlf++] = "-o";
        !            63:             xfile = lfiles[nlf++] = *++arg;
        !            64:             break;
        !            65:          case 'x':
        !            66:             xargs = arg++;
        !            67:             goto argsdone;
        !            68:          case 'c':
        !            69:             cflag++;
        !            70:             break;
        !            71:          default:
        !            72:             lflags[nlflags++] = tflags[ntflags++] = *arg;
        !            73:             break;
        !            74:             }
        !            75:       else if (suffix(*arg,".icn")) {
        !            76:          tfiles[ntf++] = *arg;
        !            77:          base = getbase(*arg,".icn");
        !            78:          u1 = mkname(base,".u1");
        !            79:          u2 = mkname(base,".u2");
        !            80:          lfiles[nlf++] = rfiles[nrf++] = u1;
        !            81:          rfiles[nrf++] = u2;
        !            82:          }
        !            83:       else if (suffix(*arg,".u1")) {
        !            84:          lfiles[nlf++] = *arg;
        !            85:          }
        !            86:       else {
        !            87:          fprintf(stderr,"icont: bad argument '%s'\n",*arg);
        !            88:          exit(ErrorExit);
        !            89:          }
        !            90:       }
        !            91: argsdone:
        !            92:    if (nlf == 0)
        !            93:       usage("icont");
        !            94:    if (!xfile[0])
        !            95:       xfile = getbase(lfiles[0],".u1");
        !            96:    
        !            97:    if (ntf != 0) {
        !            98:       tflags[ntflags] = NULL;
        !            99:       tfiles[ntf] = NULL;
        !           100:       lcat(execlist,tflags,tfiles);
        !           101:       runit(Itran,execlist,envp);
        !           102:       }
        !           103:    if (cflag) {
        !           104:       exit(NormalExit);
        !           105:       }
        !           106:    if (!quiet)
        !           107:       fprintf(stderr,"Linking:\n");
        !           108:    execlist[0] = 0;
        !           109:    lflags[nlflags] = NULL;
        !           110:    lfiles[nlf] = NULL;
        !           111:    lcat(execlist,lflags,lfiles);
        !           112:    runit(Ilink,execlist,envp);
        !           113:    rmfiles();
        !           114:    chmod(xfile,0755);
        !           115:    if (xargs) {
        !           116:       if (!quiet)
        !           117:          fprintf(stderr,"Executing:\n");
        !           118:       xargs[0] = xfile;
        !           119:       execlist[0] = "iconx";
        !           120:       execlist[1] = 0;
        !           121:       lcat(execlist,xargs,0);
        !           122:       execv(Iconx,execlist);
        !           123:       }
        !           124:    exit(NormalExit);
        !           125:    }
        !           126: 
        !           127: 
        !           128: runit(c,a,e)
        !           129: char *c; char **a, **e;
        !           130:    {
        !           131:    int rc;
        !           132:    if ((rc = docmd(c,a,e)) != 0) {
        !           133:       rmfiles();
        !           134:       exit(ErrorExit);
        !           135:       }
        !           136:    }
        !           137: 
        !           138: rmfiles()
        !           139:    {
        !           140:    char **p;
        !           141:    for (p = rfiles;  *p;  p++)
        !           142: #ifndef VMS
        !           143:       unlink(*p);
        !           144: #else
        !           145:       delete(*p);
        !           146: #endif
        !           147:    }
        !           148: 
        !           149: 
        !           150: suffix(name,suf)
        !           151: char *name,*suf;
        !           152:    {
        !           153:    char *rindex(), *x;
        !           154: 
        !           155:    if (x = rindex(name,'.'))
        !           156:       return !strcmp(suf,x);
        !           157:    else
        !           158:       return 0;
        !           159:    }
        !           160: 
        !           161: 
        !           162: char *
        !           163: mkname(name,suf)
        !           164: char *name,*suf;
        !           165:    {
        !           166:    char *p, *malloc();
        !           167:    
        !           168:    p = malloc(PathSize);
        !           169:    strcpy(p,name);
        !           170:    strcat(p,suf);
        !           171:    return p;
        !           172:    }
        !           173: 
        !           174: 
        !           175: char *
        !           176: getbase(name,suf)
        !           177: char *name,*suf;
        !           178:    {
        !           179:    char *f,*e, *rindex(), *p, *malloc();
        !           180:    
        !           181:    if (f = rindex(name,'/'))
        !           182:       f++;
        !           183: #ifdef VMS
        !           184:    else if ((f = rindex(name,']')) || (f = rindex(name,':')))
        !           185:       f++;
        !           186: #endif VMS
        !           187:    else
        !           188:       f = name;
        !           189:    e = rindex(f,'.');
        !           190:    p = malloc(PathSize);
        !           191:    strncpy(p,f,e-f);
        !           192:    return p;
        !           193:    }
        !           194: 
        !           195: 
        !           196: lcat(c,a,b)
        !           197: int c[],a[],b[];
        !           198:    {
        !           199:    int cp,p;
        !           200:    
        !           201:    cp = p = 0;
        !           202:    while (c[cp])
        !           203:       cp++;
        !           204:    while (c[cp] = a[p++])
        !           205:       cp++;
        !           206:    p = 0;
        !           207:    if (b)
        !           208:       while (c[cp++] = b[p++]);
        !           209:    }
        !           210: 
        !           211: 
        !           212: usage(p)
        !           213: char *p;
        !           214:    {
        !           215:    fprintf(stderr,"usage: %s [-c] [-m] [-t] [-u] file ... [-x args]\n",p);
        !           216:    exit(ErrorExit);
        !           217:    }
        !           218: 
        !           219: 
        !           220: docmd(cmd,argv,envp)
        !           221: char *cmd, **argv, **envp;
        !           222:    {
        !           223:    int rc, stat;
        !           224:    rc = Fork();
        !           225:    if (rc == -1) {
        !           226:       fprintf(stderr,"No more processes\n");
        !           227:       return 255;
        !           228:       }
        !           229:    if (rc == 0) {
        !           230:       execve(cmd,argv,envp);
        !           231:       fprintf(stderr,"exec failed on %s\n",cmd);
        !           232:       _exit(ErrorExit);
        !           233:       }
        !           234:    while (rc != wait(&stat));
        !           235: #ifndef VMS
        !           236:    return ((stat>>8) & 0xff);
        !           237: #else VMS
        !           238:    return (!(stat&1));
        !           239: #endif VMS
        !           240:    }
        !           241: 
        !           242: 
        !           243: plist(title,list)
        !           244: char *title, **list;
        !           245:    {
        !           246:    char **p;
        !           247:    printf("\n%s\n",title);
        !           248:    for (p = list; *p; p++)
        !           249:       printf("'%s'\n",*p);
        !           250:    }

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