Return to misc.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / jove

Annotation of 43BSD/contrib/jove/misc.c, revision 1.1

1.1     ! root        1: /*************************************************************************
        !             2:  * This program is copyright (C) 1985, 1986 by Jonathan Payne.  It is    *
        !             3:  * provided to you without charge for use only on a licensed Unix        *
        !             4:  * system.  You may copy JOVE provided that this notice is included with *
        !             5:  * the copy.  You may not sell copies of this program or versions        *
        !             6:  * modified for use on microcomputer systems, unless the copies are      *
        !             7:  * included with a Unix system distribution and the source is provided.  *
        !             8:  *************************************************************************/
        !             9: 
        !            10: #include "jove.h"
        !            11: #include "ctype.h"
        !            12: #include <signal.h>
        !            13: #ifdef ANSICODES
        !            14: #include "termcap.h"
        !            15: #endif
        !            16: 
        !            17: Digit()
        !            18: {
        !            19:        GetExp(LastKeyStruck);
        !            20: }
        !            21: 
        !            22: Digit0()
        !            23: {
        !            24:        GetExp('0');
        !            25: }
        !            26: 
        !            27: Digit1()
        !            28: {
        !            29:        GetExp('1');
        !            30: }
        !            31: 
        !            32: Digit2()
        !            33: {
        !            34:        GetExp('2');
        !            35: }
        !            36: 
        !            37: Digit3()
        !            38: {
        !            39:        GetExp('3');
        !            40: }
        !            41: 
        !            42: Digit4()
        !            43: {
        !            44:        GetExp('4');
        !            45: }
        !            46: 
        !            47: Digit5()
        !            48: {
        !            49:        GetExp('5');
        !            50: }
        !            51: 
        !            52: Digit6()
        !            53: {
        !            54:        GetExp('6');
        !            55: }
        !            56: 
        !            57: Digit7()
        !            58: {
        !            59:        GetExp('7');
        !            60: }
        !            61: 
        !            62: Digit8()
        !            63: {
        !            64:        GetExp('8');
        !            65: }
        !            66: 
        !            67: Digit9()
        !            68: {
        !            69:        GetExp('9');
        !            70: }
        !            71: 
        !            72: prCTIME()
        !            73: {
        !            74:        s_mess(": %f %s", get_time((long *) 0, (char *) 0, 0, -1));
        !            75: }
        !            76: 
        !            77: extern int     alarmed;
        !            78: 
        !            79: FourTime()
        !            80: {
        !            81:        int     oldc = LastKeyStruck,
        !            82:                newc;
        !            83:        int     nexp;
        !            84: 
        !            85:        alarmed = 0;
        !            86:        exp_p = 1;
        !            87:        this_cmd = ARG_CMD;
        !            88:        do {
        !            89:                if ((nexp = exp * 4) != 0)
        !            90:                        exp = nexp;
        !            91:                if (!alarmed)
        !            92:                        newc = waitchar();
        !            93:                else
        !            94:                        newc = getch();
        !            95:                if (alarmed)
        !            96:                        message(key_strokes);
        !            97:        } while (newc == oldc);
        !            98:        Ungetc(newc);
        !            99: }
        !           100: 
        !           101: int    exp_p,
        !           102:        exp;
        !           103: 
        !           104: GetExp(c)
        !           105: {
        !           106:        int     sign = 1,
        !           107:                i,
        !           108:                digited = 0;
        !           109: 
        !           110:        if (!isdigit(c) && c != '-')
        !           111:                complain((char *) 0);
        !           112:        if (exp_p)
        !           113:                i = exp;
        !           114:        else
        !           115:                i = 0;
        !           116:        if (c == '-') {
        !           117:                sign = -1;
        !           118:                goto goread;
        !           119:        }
        !           120:        for (;;) {
        !           121:                if (alarmed)
        !           122:                        message(key_strokes);
        !           123:                if (isdigit(c)) {
        !           124:                        i = i * 10 + (c - '0');
        !           125:                        digited++;
        !           126:                } else {
        !           127:                        if (digited)
        !           128:                                exp_p = 1;
        !           129:                        else
        !           130:                                i = 1;
        !           131:                        exp = i * sign;
        !           132:                        this_cmd = ARG_CMD;
        !           133:                        Ungetc(c);
        !           134:                        return;
        !           135:                }
        !           136: goread:                if (!alarmed)
        !           137:                        c = waitchar();
        !           138:                else {
        !           139:                        add_mess(NullStr);
        !           140:                        c = getch();
        !           141:                }
        !           142:        }
        !           143: }
        !           144: 
        !           145: ChrToOct()
        !           146: {
        !           147:        int     c;
        !           148: 
        !           149:        c = waitchar();
        !           150:        if (alarmed)
        !           151:                message(key_strokes);
        !           152:        ins_str(sprint("\\%03o", c), NO);
        !           153: }
        !           154: 
        !           155: StrLength()
        !           156: {
        !           157:        static char     inquotes[] = "Where are the quotes?";
        !           158:        char    *first = StrIndex(-1, linebuf, curchar, '"'),
        !           159:                *last = StrIndex(1, linebuf, curchar + 1, '"'),
        !           160:                c;
        !           161:        int     numchars = 0;
        !           162: 
        !           163:        if (first == 0 || last == 0)
        !           164:                complain(inquotes);
        !           165:        first++;
        !           166:        while (first < last) {
        !           167:                c = *first++;
        !           168:                if (c == '\\') {
        !           169:                        int     num;
        !           170: 
        !           171:                        if (!isdigit(*first))
        !           172:                                ++first;
        !           173:                        else {
        !           174:                                num = 3;
        !           175:                                while (num-- && isdigit(*first++) && first < last)
        !           176:                                        ;
        !           177:                        }
        !           178:                }
        !           179:                numchars++;
        !           180:        }
        !           181:        s_mess("%d characters", numchars);
        !           182: }
        !           183: 
        !           184: /* Transpos cur_char with cur_char - 1 */
        !           185: 
        !           186: TransChar()
        !           187: {
        !           188:        char    before;
        !           189: 
        !           190:        if (curchar == 0 || (eolp() && curchar == 1))
        !           191:                complain((char *) 0);   /* BEEP */
        !           192:        exp = 1;
        !           193:        if (eolp())
        !           194:                BackChar();
        !           195:        before = linebuf[curchar - 1];
        !           196:        DelPChar();
        !           197:        ForChar();
        !           198:        Insert(before);
        !           199: }
        !           200: 
        !           201: /* Switch current line with previous one */
        !           202: 
        !           203: TransLines()
        !           204: {
        !           205:        disk_line       old_prev;
        !           206: 
        !           207:        if (firstp(curline))
        !           208:                return;
        !           209:        exp = 1;
        !           210:        lsave();
        !           211:        old_prev = curline->l_prev->l_dline;
        !           212:        curline->l_prev->l_dline = curline->l_dline;
        !           213:        curline->l_dline = old_prev;
        !           214:        getDOT();
        !           215:        if (!lastp(curline))
        !           216:                line_move(FORWARD, NO);
        !           217:        modify();
        !           218: }
        !           219: 
        !           220: Leave()
        !           221: {
        !           222:        longjmp(mainjmp, QUIT);
        !           223: }
        !           224: 
        !           225: /* If argument is specified, kill that many lines down.  Otherwise,
        !           226:    if we "appear" to be at the end of a line, i.e. everything to the
        !           227:    right of the cursor is white space, we delete the line separator
        !           228:    as if we were at the end of the line. */
        !           229: 
        !           230: KillEOL()
        !           231: {
        !           232:        Line    *line2;
        !           233:        int     char2;
        !           234: 
        !           235:        if (exp_p) {
        !           236:                if (exp == 0) { /* Kill to beginning of line */
        !           237:                        line2 = curline;
        !           238:                        char2 = 0;
        !           239:                } else {
        !           240:                        line2 = next_line(curline, exp);
        !           241:                        if ((LineDist(curline, line2) < exp) || (line2 == curline))
        !           242:                                char2 = length(line2);
        !           243:                        else
        !           244:                                char2 = 0;
        !           245:                }
        !           246:        } else if (blnkp(&linebuf[curchar])) {
        !           247:                line2 = next_line(curline, 1);
        !           248:                if (line2 == curline)
        !           249:                        char2 = length(curline);
        !           250:                else
        !           251:                        char2 = 0;
        !           252:        } else {
        !           253:                line2 = curline;
        !           254:                char2 = length(curline);
        !           255:        }
        !           256:        reg_kill(line2, char2, 0);
        !           257: }
        !           258: 
        !           259: /* Kill to beginning of sentence */
        !           260: 
        !           261: KillBos()
        !           262: {
        !           263:        exp = -exp;
        !           264:        KillEos();
        !           265: }
        !           266: 
        !           267: /* Kill to end of sentence */
        !           268: 
        !           269: KillEos()
        !           270: {
        !           271:        Line    *line1;
        !           272:        int     char1;
        !           273: 
        !           274:        line1 = curline;
        !           275:        char1 = curchar;
        !           276:        Eos();
        !           277:        reg_kill(line1, char1, 1);
        !           278: }
        !           279: 
        !           280: KillExpr()
        !           281: {
        !           282:        Line    *line1;
        !           283:        int     char1;
        !           284: 
        !           285:        line1 = curline;
        !           286:        char1 = curchar;
        !           287:        FSexpr();
        !           288:        reg_kill(line1, char1, 1);
        !           289: }
        !           290: 
        !           291: EscPrefix()
        !           292: {
        !           293:        HandlePref(pref1map);
        !           294: }
        !           295: 
        !           296: CtlxPrefix()
        !           297: {
        !           298:        HandlePref(pref2map);
        !           299: }
        !           300: 
        !           301: MiscPrefix()
        !           302: {
        !           303:        HandlePref(miscmap);
        !           304: }
        !           305: 
        !           306: HandlePref(map)
        !           307: data_obj       **map;
        !           308: {
        !           309:        register data_obj       *cp;
        !           310:        register int    c;
        !           311: 
        !           312:        c = waitchar();
        !           313:        if (c == CTL(G)) {
        !           314:                message("[Aborted]");
        !           315:                rbell();
        !           316:                return;
        !           317:        }
        !           318: 
        !           319:        if (alarmed)
        !           320:                message(key_strokes);
        !           321: 
        !           322:        cp = map[c];
        !           323:        if (cp == 0) {
        !           324:                s_mess("[%sunbound]", key_strokes);
        !           325:                rbell();
        !           326:        } else
        !           327:                ExecCmd(cp);
        !           328: }
        !           329: 
        !           330: Yank()
        !           331: {
        !           332:        Line    *line,
        !           333:                *lp;
        !           334:        Bufpos  *dot;
        !           335: 
        !           336:        if (killbuf[killptr] == 0)
        !           337:                complain("[Nothing to yank!]");
        !           338:        lsave();
        !           339:        this_cmd = YANKCMD;
        !           340:        line = killbuf[killptr];
        !           341:        lp = lastline(line);
        !           342:        dot = DoYank(line, 0, lp, length(lp), curline, curchar, curbuf);
        !           343:        SetMark();
        !           344:        SetDot(dot);
        !           345: }
        !           346: 
        !           347: WtModBuf()
        !           348: {
        !           349:        if (!ModBufs(NO))
        !           350:                message("[No buffers need saving]");
        !           351:        else
        !           352:                put_bufs(exp_p);
        !           353: }
        !           354: 
        !           355: put_bufs(askp)
        !           356: {
        !           357:        register Buffer *oldb = curbuf, 
        !           358:                        *b;             
        !           359: 
        !           360:        for (b = world; b != 0; b = b->b_next) {
        !           361:                if (!IsModified(b) || b->b_type != B_FILE)
        !           362:                        continue;
        !           363:                SetBuf(b);      /* Make this current Buffer */
        !           364:                if (curbuf->b_fname == 0) {
        !           365:                        char    *newname;
        !           366: 
        !           367:                        newname = ask(NullStr, "Buffer \"%s\" needs a file name; type Return to skip: ", b->b_name);
        !           368:                        if (*newname == 0)
        !           369:                                continue;
        !           370:                        setfname(b, newname);
        !           371:                }
        !           372:                if (SaveBuf(askp))
        !           373:                        unmodify();
        !           374:        }
        !           375:        SetBuf(oldb);
        !           376: }
        !           377: 
        !           378: SaveBuf(askp)
        !           379: {
        !           380:        char    *yorn;
        !           381: 
        !           382:        if (askp) {
        !           383:                yorn = ask((char *) 0, "Write %s? ", curbuf->b_fname);
        !           384:                if (*yorn != 'Y' && *yorn != 'y')
        !           385:                        return 0;
        !           386:        }
        !           387:        file_write(curbuf->b_fname, 0);
        !           388:        return 1;
        !           389: }
        !           390: 
        !           391: DOTsave(buf)
        !           392: Bufpos *buf;
        !           393: {
        !           394:        buf->p_line = curline;
        !           395:        buf->p_char = curchar;
        !           396: }
        !           397: 
        !           398: ToIndent()
        !           399: {
        !           400:        register char   *cp,
        !           401:                        c;
        !           402: 
        !           403:        for (cp = linebuf; c = *cp; cp++)
        !           404:                if (c != ' ' && c != '\t')
        !           405:                        break;
        !           406:        curchar = cp - linebuf;
        !           407: }
        !           408: 
        !           409: GoLine()
        !           410: {
        !           411:        Line    *newline;
        !           412: 
        !           413: #ifndef ANSICODES
        !           414:        if (exp_p == 0)
        !           415:                return;
        !           416: #else
        !           417:        if (exp_p == 0 || exp <= 0) {
        !           418:                if (SP)
        !           419:                        putpad(SP, 1);  /* Ask for cursor position */
        !           420:                return;
        !           421:        }
        !           422: #endif
        !           423:        newline = next_line(curbuf->b_first, exp - 1);
        !           424:        PushPntp(newline);
        !           425:        SetLine(newline);
        !           426: }
        !           427: 
        !           428: #ifdef ANSICODES
        !           429: MoveToCursor(line, col)
        !           430: {
        !           431:        register struct scrimage *sp = &PhysScreen[line];
        !           432: 
        !           433:        while (sp->s_id == NULL)
        !           434:                sp = &PhysScreen[--line];
        !           435:        if (sp->s_flags & MODELINE)
        !           436:                complain((char *) 0);
        !           437:        if (curwind != sp->s_window)
        !           438:                SetWind(sp->s_window);
        !           439:        SetLine(sp->s_lp);
        !           440:        curchar = how_far(sp->s_lp, col);
        !           441: }
        !           442: 
        !           443: AnsiCodes()
        !           444: {
        !           445:        int     c;
        !           446:        int     num1 = 0;
        !           447:        int     num2;
        !           448:        static char *unsupported = "[Unsupported ANSI code received]";
        !           449: 
        !           450:        while (isdigit(c = getch()))
        !           451:                num1 = (num1*10) + (c - '0');
        !           452: 
        !           453:        switch (c) {
        !           454:        case ';':
        !           455:                num2 = 0;
        !           456:                while (isdigit(c = getch()))
        !           457:                        num2 = (num2*10) + (c - '0');
        !           458:                switch (c) {
        !           459:                case 'R':
        !           460:                        MoveToCursor(--num1, --num2);
        !           461:                        break;
        !           462:                case 'H':
        !           463:                        Eow(); Bol();
        !           464:                        break;
        !           465:                default:
        !           466:                        complain(unsupported);
        !           467:                }
        !           468:                break;
        !           469:        case 'A':
        !           470:                line_move(BACKWARD, NO);
        !           471:                break;
        !           472:        case 'B':
        !           473:                line_move(FORWARD, NO);
        !           474:                break;
        !           475:        case 'C':
        !           476:                ForChar();
        !           477:                break;
        !           478:        case 'D':
        !           479:                BackChar();
        !           480:                break;
        !           481:        case 'H':
        !           482:                Bow();
        !           483:                break;
        !           484:        case 'J':
        !           485:                if (num1 == 2) {
        !           486:                        ClAndRedraw();
        !           487:                        break;
        !           488:                }
        !           489:                /* FALL THROUGH */
        !           490:        default:
        !           491:                complain(unsupported);
        !           492:        }
        !           493: }
        !           494: #endif ANSICODES
        !           495: 
        !           496: NotModified()
        !           497: {
        !           498:        unmodify();
        !           499: }
        !           500: 
        !           501: SetLMargin()
        !           502: {
        !           503:        LMargin = calc_pos(linebuf, curchar);
        !           504: }
        !           505: 
        !           506: SetRMargin()
        !           507: {
        !           508:        RMargin = calc_pos(linebuf, curchar);
        !           509: }

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