Return to cmd.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoestand / vdformat

Annotation of 43BSDReno/sys/tahoestand/vdformat/cmd.c, revision 1.1

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

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