Return to cmd.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / stand / vdfmt

Annotation of cci/sys/stand/vdfmt/cmd.c, revision 1.1

1.1     ! root        1: #include       "vdfmt.h"
        !             2: #include       "cmd.h"
        !             3: 
        !             4: #define TRUE   1
        !             5: #define FALSE  0
        !             6: 
        !             7: #define        HELP    1
        !             8: #define        STATUS  2
        !             9: #define        KILL    3
        !            10: #define        KQUIT   4
        !            11: 
        !            12: static cmd_text_element        primary[] = {
        !            13:        { STATUS,       "!",            "" },
        !            14:        { HELP,         "HElp",         "" },
        !            15:        { KILL,         "KILL",         "" },
        !            16:        { KQUIT,        "QUIT",         "" },
        !            17:        { STATUS,       "STATus",       "" },
        !            18:        { HELP,         "?",            "" },
        !            19:        { 0,            "",             "" }
        !            20: };
        !            21: 
        !            22: 
        !            23: /*
        !            24: */
        !            25: 
        !            26: boolean confirm(token)
        !            27: int    token;
        !            28: {
        !            29:        char    *action;
        !            30:        char    query[50];
        !            31: 
        !            32:        if(token == KILL)
        !            33:                action = "kill";
        !            34:        else
        !            35:                action = "quit";
        !            36:        sprintf(query, "Confirm %s operations", action);
        !            37:        return get_yes_no(query);
        !            38: }
        !            39: 
        !            40: 
        !            41: /*
        !            42: **
        !            43: */
        !            44: 
        !            45: get_text_cmd(table, tokens)
        !            46: cmd_text_element       *table;
        !            47: int                    *tokens;
        !            48: {
        !            49:        extern boolean  get_yes_no();
        !            50:        int             *t_ptr;
        !            51:        char            line[133];
        !            52: 
        !            53:        gets(line);
        !            54:        /* Check for help, status, or kill */
        !            55:        cmd_parse(primary, line, tokens);
        !            56:        t_ptr = tokens;
        !            57:        while(*t_ptr) {
        !            58:                switch (*t_ptr) {
        !            59:                        case STATUS :
        !            60:                                cmd_status();
        !            61:                                break;
        !            62:                        case KQUIT :
        !            63:                        case KILL :
        !            64:                                if(confirm(*t_ptr) == true) {
        !            65:                                        kill_processes = true;
        !            66:                                        return 0;
        !            67:                                }
        !            68:                                break;
        !            69:                        default:
        !            70:                                help_text(table);
        !            71:                                break;
        !            72:                }
        !            73:                t_ptr++;
        !            74:        }
        !            75:        /* Now parse all the operator's commands */
        !            76:        cmd_parse(table, line, tokens);
        !            77:        return strlen(line);
        !            78: }
        !            79: 
        !            80: 
        !            81: /*
        !            82: **
        !            83: */
        !            84: 
        !            85: cmd_intcmp(a, b)
        !            86: int    *a, *b;
        !            87: {
        !            88:        if(*a==*b)
        !            89:                return 0;
        !            90:        if(*a<*b)
        !            91:                return -1;
        !            92:        return 1;
        !            93: }
        !            94: 
        !            95: 
        !            96: /*
        !            97: **
        !            98: */
        !            99: 
        !           100: condition_list(tokens, sentinal)
        !           101: int    *tokens, sentinal;
        !           102: {
        !           103:        register int    *t_ptr = tokens;
        !           104:        register int    num_tok;
        !           105: 
        !           106:        for(num_tok=0; *t_ptr++ != sentinal; num_tok++)
        !           107:                ;       
        !           108:        qsort(tokens, num_tok, sizeof(int), cmd_intcmp);
        !           109:        /* compress out dups */
        !           110:        while(*tokens != sentinal) {
        !           111:                if(*tokens == *(tokens+1)) {
        !           112:                        for(t_ptr=tokens+1; *t_ptr != sentinal; t_ptr++) {
        !           113:                                *t_ptr = *(t_ptr+1);
        !           114:                        }
        !           115:                        continue;
        !           116:                }
        !           117:                tokens++;
        !           118:        }
        !           119: }
        !           120: 
        !           121: 
        !           122: /*
        !           123: **
        !           124: */
        !           125: 
        !           126: cmd_parse(table, line, tokens) 
        !           127: cmd_text_element       *table;
        !           128: char                   *line;
        !           129: int                    *tokens;
        !           130: {
        !           131:        char            *seperators = "\t ,.;:-~+/\\";
        !           132:        register char   *tok_start;
        !           133:        register int    *tok = tokens;
        !           134:        char            save_buf[133];
        !           135: 
        !           136:        strcpy(save_buf, line);
        !           137:        tok_start = (char *)strtok((char *)save_buf, seperators);
        !           138:        while(tok_start != NULL) {
        !           139:                if(strlen(tok_start)) {
        !           140:                        if(*tok = cmd_search(table, tok_start)) {
        !           141:                                tok++;
        !           142:                        }
        !           143:                }
        !           144:                tok_start = (char *)strtok((char *)NULL, seperators);
        !           145:        }
        !           146:        *tok = 0;
        !           147:        condition_list(tokens, 0);
        !           148: }
        !           149: 
        !           150: 
        !           151: /*
        !           152: **
        !           153: */
        !           154: 
        !           155: cmd_search(table, command)
        !           156: cmd_text_element       *table;
        !           157: char                   *command;
        !           158: {
        !           159:        register char   *tbl_ptr;
        !           160:        register char   *cmd_ptr;
        !           161: 
        !           162:        while(table->cmd_token != 0) {
        !           163:                cmd_ptr = command;
        !           164:                tbl_ptr = table->cmd_text;
        !           165:                while(ismustmatch(*tbl_ptr)) {
        !           166:                        if(toupper(*cmd_ptr) != *tbl_ptr)
        !           167:                                break;
        !           168:                        cmd_ptr++;
        !           169:                        tbl_ptr++;
        !           170:                }
        !           171:                if((*tbl_ptr == 0) || !ismustmatch(*tbl_ptr))
        !           172:                        return table->cmd_token;
        !           173:                table++;
        !           174:        }
        !           175:        return 0;
        !           176: }
        !           177: 
        !           178: 
        !           179: /*
        !           180: **
        !           181: */
        !           182: 
        !           183: is_in_digit_table(table, token)
        !           184: int    *table, token;
        !           185: {
        !           186:        while(*table != -1) {
        !           187:                if(token == *table)
        !           188:                        return TRUE;
        !           189:                table++;
        !           190:        }
        !           191:        return FALSE;
        !           192: }
        !           193: 
        !           194: 
        !           195: /*
        !           196: **
        !           197: */
        !           198: 
        !           199: int *fill_in(tokens, table, start, end)
        !           200: int    *tokens, *table, start, end;
        !           201: {
        !           202: 
        !           203:        if(start > end) {
        !           204:                register int temp = end;
        !           205: 
        !           206:                end = start;
        !           207:                start = temp;
        !           208:        }
        !           209:        while((*table != -1) && (*table < start))
        !           210:                table++;
        !           211:        while((*table != -1) && (*table <= end)) {
        !           212:                *tokens++ = *table++;
        !           213:        }
        !           214:        return tokens;
        !           215: }
        !           216: 
        !           217: /*
        !           218: **
        !           219: */
        !           220: 
        !           221: get_digit_list(tokens, table, help)
        !           222: int    *tokens, *table, (*help)();
        !           223: {
        !           224:        int             *tok_ptr;
        !           225:        char            *ptr, line[133];
        !           226: 
        !           227:        condition_list(table, -1);
        !           228:        gets(line);
        !           229:        if(!line[0]) {
        !           230:                *tokens = -1;
        !           231:                return;
        !           232:        }
        !           233:        /* Check for help, status, or kill */
        !           234:        cmd_parse(primary, line, tokens);
        !           235:        tok_ptr = tokens;
        !           236:        while(*tok_ptr) {
        !           237:                switch (*tok_ptr) {
        !           238:                        case STATUS :
        !           239:                                cmd_status();
        !           240:                                break;
        !           241:                        case KQUIT :
        !           242:                        case KILL :
        !           243:                                if(confirm(*tok_ptr)) {
        !           244:                                        kill_processes = true;
        !           245:                                        return;
        !           246:                                }
        !           247:                                break;
        !           248:                        default:
        !           249:                                (help)();
        !           250:                                break;
        !           251:                }
        !           252:                tok_ptr++;
        !           253:        }
        !           254:        tok_ptr = tokens;
        !           255:        ptr = line;
        !           256:        while(*ptr) {
        !           257:                finddigit(ptr);
        !           258:                if(sscanf(ptr, "%d", tok_ptr) > 0) {
        !           259:                        skipdigits(ptr);
        !           260:                        skip_junk(ptr);
        !           261:                        if((*ptr == '~') || (*ptr == '-')) {
        !           262:                                register int    start = *tok_ptr;
        !           263: 
        !           264:                                finddigit(ptr);
        !           265:                                if(sscanf(ptr, "%d", tok_ptr) > 0) {
        !           266:                                        skipdigits(ptr);
        !           267:                                        tok_ptr = fill_in(tok_ptr,
        !           268:                                            table, start, *tok_ptr);
        !           269:                                        continue;
        !           270:                                }
        !           271:                                else
        !           272:                                        *tok_ptr = start;
        !           273:                        }
        !           274:                        if(is_in_digit_table(table, *tok_ptr))
        !           275:                                tok_ptr++;
        !           276:                }
        !           277:        }
        !           278:        *tok_ptr = -1;
        !           279:        condition_list(tokens, -1);
        !           280: }
        !           281: 
        !           282: 
        !           283: 
        !           284: /*
        !           285: **
        !           286: */
        !           287: 
        !           288: get_digit_cmd(help)
        !           289: int    (*help)();
        !           290: {
        !           291:        int     tokens[20], *t_ptr;
        !           292:        char    line[80];
        !           293:        int     results;
        !           294: 
        !           295:        gets(line);
        !           296:        if(!*line)
        !           297:                return -1;
        !           298:        /* Check for help, status, or kill */
        !           299:        cmd_parse(primary, line, tokens);
        !           300:        t_ptr = tokens;
        !           301:        while(*t_ptr) {
        !           302:                switch (*t_ptr) {
        !           303:                        case STATUS :
        !           304:                                cmd_status();
        !           305:                                break;
        !           306:                        case KQUIT :
        !           307:                        case KILL :
        !           308:                                if(confirm(*t_ptr)) {
        !           309:                                        kill_processes = true;
        !           310:                                        return -1;
        !           311:                                }
        !           312:                                break;
        !           313:                        default:
        !           314:                                (*help)();
        !           315:                                break;
        !           316:                }
        !           317:                t_ptr++;
        !           318:        }
        !           319:        if(sscanf(line, "%d", &results) > 0)
        !           320:                return results;
        !           321:        return -1;
        !           322: }
        !           323: 
        !           324: 
        !           325: /*
        !           326: **
        !           327: */
        !           328: 
        !           329: get_string_cmd(line, help)
        !           330: char   *line;
        !           331: int    (*help)();
        !           332: {
        !           333:        int     tokens[20], *t_ptr;
        !           334: 
        !           335:        gets(line);
        !           336:        if(!*line)
        !           337:                return;
        !           338:        /* Check for help, status, or kill */
        !           339:        cmd_parse(primary, line, tokens);
        !           340:        t_ptr = tokens;
        !           341:        while(*t_ptr) {
        !           342:                switch (*t_ptr) {
        !           343:                        case STATUS :
        !           344:                                cmd_status();
        !           345:                                break;
        !           346:                        case KQUIT :
        !           347:                        case KILL :
        !           348:                                if(confirm(*t_ptr)) {
        !           349:                                        kill_processes = true;
        !           350:                                        return;
        !           351:                                }
        !           352:                                break;
        !           353:                        default:
        !           354:                                (*help)();
        !           355:                                break;
        !           356:                }
        !           357:                t_ptr++;
        !           358:        }
        !           359:        while(*line) {
        !           360:                *line = tolower(*line);
        !           361:                line++;
        !           362:        }
        !           363:        return;
        !           364: }
        !           365: 
        !           366: 
        !           367: /*
        !           368: **
        !           369: */
        !           370: 
        !           371: cmd_status()
        !           372: {
        !           373:        indent();
        !           374:        switch (cur.state) {
        !           375:                case cmd :
        !           376:                        print("Waiting for operator input.\n\n");
        !           377:                        break;
        !           378:                default :
        !           379:                        status();
        !           380:                        break;
        !           381:        }
        !           382:        exdent(1);
        !           383: }
        !           384: 
        !           385: 
        !           386: /*
        !           387: **     Vdget_yes_no is used to ask simple yes or no questions.  The question
        !           388: ** prompt is supplied by the caller,  The question mark, possible responses,
        !           389: ** and the default response is printed at the end of the prompt.  The routine
        !           390: ** then reads the answer and returns a 1 if a 'y' is typed or no response was
        !           391: ** given, otherwise, a zero is returned.
        !           392: */
        !           393: 
        !           394: boolean get_yes_no(str)
        !           395: register char  *str;
        !           396: {
        !           397:        extern int      wait_for_char;
        !           398:        char            answer[80];
        !           399:        boolean         retval;
        !           400:        int             old_wait_status = wait_for_char;
        !           401: 
        !           402:        wait_for_char = 1;
        !           403:        for(;;) {
        !           404:                if(*str)
        !           405:                        print("%s", str);
        !           406:                printf("? [Yes/No] ");
        !           407:                gets(answer);
        !           408:                if((answer[0] == 'Y') || (answer[0] == 'y')) {
        !           409:                        retval = true;
        !           410:                        break;
        !           411:                }
        !           412:                if((answer[0] == 'N') || (answer[0] == 'n')) {
        !           413:                        retval = false;
        !           414:                        break;
        !           415:                }
        !           416:                print("\n");
        !           417:                print("A 'Yes' or 'No' must be entered!\n\n");
        !           418:        }
        !           419:        wait_for_char = old_wait_status;
        !           420:        return retval;
        !           421: }
        !           422: 
        !           423: 
        !           424: /*
        !           425: **
        !           426: */
        !           427: 
        !           428: get_next_digit(ptr)
        !           429: char   *ptr;
        !           430: {
        !           431:        int     results;
        !           432: 
        !           433:        finddigit(ptr);
        !           434:        if(sscanf(ptr, "%d", &results) <= 0)
        !           435:                return -1;
        !           436:        return results;
        !           437: }

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