Return to dosys.c CVS log

Up to [Research Unix] / researchv10no / cmd / usgmake

Annotation of researchv10no/cmd/usgmake/dosys.c, revision 1.1

1.1     ! root        1: /*      %W%     */
        !             2: /*      @(#)/usr/src/cmd/make/dosys.c   3.2     */
        !             3: /*      @(#)dosys.c     3.1     */
        !             4: 
        !             5: # include "defs"
        !             6: # include "sys/types.h"
        !             7: # include "sys/stat.h"
        !             8: 
        !             9: extern char Makecall;
        !            10: 
        !            11: 
        !            12: dosys(comstring, nohalt)
        !            13: register CHARSTAR comstring;
        !            14: int nohalt;
        !            15: {
        !            16:         register CHARSTAR p;
        !            17:         register int i;
        !            18:         int status;
        !            19: 
        !            20:         p = comstring;
        !            21:         while(  *p == BLANK ||
        !            22:                 *p == TAB ||
        !            23:                 *p == AT ||
        !            24:                 *p == MINUS ||
        !            25:                 *p == NULL) p++;
        !            26: 
        !            27:         if(IS_ON(NOEX) && Makecall == NO)
        !            28:                 return(0);
        !            29: 
        !            30:         if(metas(comstring))
        !            31:                 status = doshell(comstring,nohalt);
        !            32:         else
        !            33:                 status = doexec(comstring);
        !            34: 
        !            35:         return(status);
        !            36: }
        !            37: 
        !            38: 
        !            39: 
        !            40: metas(s)   /* Are there are any  Shell meta-characters? */
        !            41: register CHARSTAR s;
        !            42: {
        !            43:         while(*s)
        !            44:                 if( funny[*s++] & META)
        !            45:                         return(YES);
        !            46: 
        !            47:         return(NO);
        !            48: }
        !            49: 
        !            50: doshell(comstring,nohalt)
        !            51: register CHARSTAR comstring;
        !            52: register int nohalt;
        !            53: {
        !            54:         register CHARSTAR shell;
        !            55: 
        !            56:         if((waitpid = fork()) == 0)
        !            57:         {
        !            58:                 enbint(0);
        !            59:                 doclose();
        !            60: 
        !            61:                 setenv();
        !            62:                 shell = varptr("SHELL")->varval;
        !            63:                 if(shell == 0 || shell[0] == CNULL)
        !            64:                         shell = SHELLCOM;
        !            65:                 execl(shell, "sh", (nohalt ? "-c" : "-ce"), comstring, 0);
        !            66:                 fatal("Couldn't load Shell");
        !            67:         }
        !            68: 
        !            69:         return( await() );
        !            70: }
        !            71: 
        !            72: 
        !            73: 
        !            74: 
        !            75: await()
        !            76: {
        !            77:         int intrupt();
        !            78:         int status;
        !            79:         int pid;
        !            80: 
        !            81:         enbint(intrupt);
        !            82:         while( (pid = wait(&status)) != waitpid)
        !            83:                 if(pid == -1)
        !            84:                         fatal("bad wait code");
        !            85:         waitpid = 0;
        !            86:         return(status);
        !            87: }
        !            88: 
        !            89: 
        !            90: 
        !            91: 
        !            92: 
        !            93: 
        !            94: doclose()       /* Close open directory files before exec'ing */
        !            95: {
        !            96:         register OPENDIR od;
        !            97: 
        !            98:         for (od = firstod; od != 0; od = od->nextopendir)
        !            99:                 if (od->dirfc != NULL)
        !           100:                         fclose(od->dirfc);
        !           101: }
        !           102: 
        !           103: 
        !           104: 
        !           105: 
        !           106: 
        !           107: doexec(str)
        !           108: register CHARSTAR str;
        !           109: {
        !           110:         register CHARSTAR t;
        !           111:         register CHARSTAR *p;
        !           112:         CHARSTAR argv[200];
        !           113:         int status;
        !           114: 
        !           115:         while( *str==BLANK || *str==TAB )
        !           116:                 ++str;
        !           117:         if( *str == CNULL )
        !           118:                 return(-1);     /* no command */
        !           119: 
        !           120:         p = argv;
        !           121:         for(t = str ; *t ; )
        !           122:         {
        !           123:                 *p++ = t;
        !           124:                 while(*t!=BLANK && *t!=TAB && *t!=CNULL)
        !           125:                         ++t;
        !           126:                 if(*t)
        !           127:                         for( *t++ = CNULL ; *t==BLANK || *t==TAB  ; ++t);
        !           128:         }
        !           129: 
        !           130:         *p = NULL;
        !           131: 
        !           132:         if((waitpid = fork()) == 0)
        !           133:         {
        !           134:                 enbint(0);
        !           135:                 doclose();
        !           136:                 setenv();
        !           137:                 execvp(str, argv);
        !           138:                 fatal1("Cannot load %s",str);
        !           139:         }
        !           140: 
        !           141:         return( await() );
        !           142: }
        !           143: 
        !           144: touch(force, name)
        !           145: register int force;
        !           146: register char *name;
        !           147: {
        !           148:         struct stat stbuff;
        !           149:         char junk[1];
        !           150:         int fd;
        !           151: 
        !           152:         if( stat(name,&stbuff) < 0)
        !           153:                 if(force)
        !           154:                         goto create;
        !           155:                 else
        !           156:                 {
        !           157:                         fprintf(stderr,"touch: file %s does not exist.\n",name);
        !           158:                         return;
        !           159:                 }
        !           160:         if(stbuff.st_size == 0)
        !           161:                 goto create;
        !           162:         if( (fd = open(name, 2)) < 0)
        !           163:                 goto bad;
        !           164:         if( read(fd, junk, 1) < 1)
        !           165:         {
        !           166:                 close(fd);
        !           167:                 goto bad;
        !           168:         }
        !           169:         lseek(fd, 0L, 0);
        !           170:         if( write(fd, junk, 1) < 1 )
        !           171:         {
        !           172:                 close(fd);
        !           173:                 goto bad;
        !           174:         }
        !           175:         close(fd);
        !           176:         return;
        !           177: bad:
        !           178:         fprintf(stderr, "Cannot touch %s\n", name);
        !           179:         return;
        !           180: create:
        !           181:         if( (fd = creat(name, 0666)) < 0)
        !           182:                 goto bad;
        !           183:         close(fd);
        !           184: }

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