Return to prim.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / miscellany / less

Annotation of 43BSDReno/contrib/mh/miscellany/less/prim.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Primitives for displaying the file on the screen.
        !             3:  */
        !             4: 
        !             5: #include "less.h"
        !             6: #include "position.h"
        !             7: 
        !             8: public int hit_eof;    /* Keeps track of how many times we hit end of file */
        !             9: 
        !            10: extern int quiet;
        !            11: extern int top_search;
        !            12: extern int top_scroll;
        !            13: extern int back_scroll;
        !            14: extern int sc_width, sc_height;
        !            15: extern int sigs;
        !            16: extern char *line;
        !            17: extern char *first_cmd;
        !            18: 
        !            19: /*
        !            20:  * Sound the bell to indicate he is trying to move past end of file.
        !            21:  */
        !            22:        static void
        !            23: eof_bell()
        !            24: {
        !            25:        if (quiet == NOT_QUIET)
        !            26:                bell();
        !            27:        else
        !            28:                vbell();
        !            29: }
        !            30: 
        !            31: /*
        !            32:  * Check to see if the end of file is currently "displayed".
        !            33:  */
        !            34:        static void
        !            35: eof_check()
        !            36: {
        !            37:        POSITION pos;
        !            38: 
        !            39:        /*
        !            40:         * If the bottom line is empty, we are at EOF.
        !            41:         * If the bottom line ends at the file length,
        !            42:         * we must be just at EOF.
        !            43:         */
        !            44:        pos = position(BOTTOM_PLUS_ONE);
        !            45:        if (pos == NULL_POSITION || pos == ch_length())
        !            46:                hit_eof++;
        !            47: }
        !            48: 
        !            49: /*
        !            50:  * Display n lines, scrolling forward, 
        !            51:  * starting at position pos in the input file.
        !            52:  * "force" means display the n lines even if we hit end of file.
        !            53:  * "only_last" means display only the last screenful if n > screen size.
        !            54:  */
        !            55:        static void
        !            56: forw(n, pos, force, only_last)
        !            57:        register int n;
        !            58:        POSITION pos;
        !            59:        int force;
        !            60:        int only_last;
        !            61: {
        !            62:        int eof = 0;
        !            63:        int nlines = 0;
        !            64:        int repaint_flag;
        !            65: 
        !            66:        /*
        !            67:         * repaint_flag tells us not to display anything till the end, 
        !            68:         * then just repaint the entire screen.
        !            69:         */
        !            70:        repaint_flag = (only_last && n > sc_height-1);
        !            71: 
        !            72:        if (!repaint_flag)
        !            73:        {
        !            74:                if (top_scroll && n >= sc_height - 1)
        !            75:                {
        !            76:                        /*
        !            77:                         * Start a new screen.
        !            78:                         * {{ This is not really desirable if we happen
        !            79:                         *    to hit eof in the middle of this screen,
        !            80:                         *    but we don't know if that will happen now. }}
        !            81:                         */
        !            82:                        clear();
        !            83:                        home();
        !            84:                        force = 1;
        !            85:                } else
        !            86:                {
        !            87:                        lower_left();
        !            88:                        clear_eol();
        !            89:                }
        !            90: 
        !            91:                if (pos != position(BOTTOM_PLUS_ONE))
        !            92:                {
        !            93:                        /*
        !            94:                         * This is not contiguous with what is
        !            95:                         * currently displayed.  Clear the screen image 
        !            96:                         * (position table) and start a new screen.
        !            97:                         */
        !            98:                        pos_clear();
        !            99:                        add_forw_pos(pos);
        !           100:                        force = 1;
        !           101:                        if (top_scroll)
        !           102:                        {
        !           103:                                clear();
        !           104:                                home();
        !           105:                        } else
        !           106:                        {
        !           107:                                puts("...skipping...\n");
        !           108:                        }
        !           109:                }
        !           110:        }
        !           111: 
        !           112:        while (--n >= 0)
        !           113:        {
        !           114:                /*
        !           115:                 * Read the next line of input.
        !           116:                 */
        !           117:                pos = forw_line(pos);
        !           118:                if (pos == NULL_POSITION)
        !           119:                {
        !           120:                        /*
        !           121:                         * End of file: stop here unless the top line 
        !           122:                         * is still empty, or "force" is true.
        !           123:                         */
        !           124:                        eof = 1;
        !           125:                        if (!force && position(TOP) != NULL_POSITION)
        !           126:                                break;
        !           127:                        line = NULL;
        !           128:                }
        !           129:                /*
        !           130:                 * Add the position of the next line to the position table.
        !           131:                 * Display the current line on the screen.
        !           132:                 */
        !           133:                add_forw_pos(pos);
        !           134:                nlines++;
        !           135:                if (!repaint_flag)
        !           136:                        put_line();
        !           137:        }
        !           138: 
        !           139:        if (eof)
        !           140:                hit_eof++;
        !           141:        else
        !           142:                eof_check();
        !           143:        if (nlines == 0)
        !           144:                eof_bell();
        !           145:        else if (repaint_flag)
        !           146:                repaint();
        !           147: }
        !           148: 
        !           149: /*
        !           150:  * Display n lines, scrolling backward.
        !           151:  */
        !           152:        static void
        !           153: back(n, pos, force, only_last)
        !           154:        register int n;
        !           155:        POSITION pos;
        !           156:        int force;
        !           157:        int only_last;
        !           158: {
        !           159:        int nlines = 0;
        !           160:        int repaint_flag;
        !           161: 
        !           162:        repaint_flag = (n > back_scroll || (only_last && n > sc_height-1));
        !           163:        hit_eof = 0;
        !           164:        while (--n >= 0)
        !           165:        {
        !           166:                /*
        !           167:                 * Get the previous line of input.
        !           168:                 */
        !           169:                pos = back_line(pos);
        !           170:                if (pos == NULL_POSITION)
        !           171:                {
        !           172:                        /*
        !           173:                         * Beginning of file: stop here unless "force" is true.
        !           174:                         */
        !           175:                        if (!force)
        !           176:                                break;
        !           177:                        line = NULL;
        !           178:                }
        !           179:                /*
        !           180:                 * Add the position of the previous line to the position table.
        !           181:                 * Display the line on the screen.
        !           182:                 */
        !           183:                add_back_pos(pos);
        !           184:                nlines++;
        !           185:                if (!repaint_flag)
        !           186:                {
        !           187:                        home();
        !           188:                        add_line();
        !           189:                        put_line();
        !           190:                }
        !           191:        }
        !           192: 
        !           193:        eof_check();
        !           194:        if (nlines == 0)
        !           195:                eof_bell();
        !           196:        else if (repaint_flag)
        !           197:                repaint();
        !           198: }
        !           199: 
        !           200: /*
        !           201:  * Display n more lines, forward.
        !           202:  * Start just after the line currently displayed at the bottom of the screen.
        !           203:  */
        !           204:        public void
        !           205: forward(n, only_last)
        !           206:        int n;
        !           207:        int only_last;
        !           208: {
        !           209:        POSITION pos;
        !           210: 
        !           211:        pos = position(BOTTOM_PLUS_ONE);
        !           212:        if (pos == NULL_POSITION)
        !           213:        {
        !           214:                eof_bell();
        !           215:                hit_eof++;
        !           216:                return;
        !           217:        }
        !           218:        forw(n, pos, 0, only_last);
        !           219: }
        !           220: 
        !           221: /*
        !           222:  * Display n more lines, backward.
        !           223:  * Start just before the line currently displayed at the top of the screen.
        !           224:  */
        !           225:        public void
        !           226: backward(n, only_last)
        !           227:        int n;
        !           228:        int only_last;
        !           229: {
        !           230:        POSITION pos;
        !           231: 
        !           232:        pos = position(TOP);
        !           233:        if (pos == NULL_POSITION)
        !           234:        {
        !           235:                /* 
        !           236:                 * This will almost never happen,
        !           237:                 * because the top line is almost never empty. 
        !           238:                 */
        !           239:                eof_bell();
        !           240:                return;   
        !           241:        }
        !           242:        back(n, pos, 0, only_last);
        !           243: }
        !           244: 
        !           245: /*
        !           246:  * Repaint the screen, starting from a specified position.
        !           247:  */
        !           248:        static void
        !           249: prepaint(pos)  
        !           250:        POSITION pos;
        !           251: {
        !           252:        hit_eof = 0;
        !           253:        forw(sc_height-1, pos, 0, 0);
        !           254: }
        !           255: 
        !           256: /*
        !           257:  * Repaint the screen.
        !           258:  */
        !           259:        public void
        !           260: repaint()
        !           261: {
        !           262:        /*
        !           263:         * Start at the line currently at the top of the screen
        !           264:         * and redisplay the screen.
        !           265:         */
        !           266:        prepaint(position(TOP));
        !           267: }
        !           268: 
        !           269: /*
        !           270:  * Jump to the end of the file.
        !           271:  * It is more convenient to paint the screen backward,
        !           272:  * from the end of the file toward the beginning.
        !           273:  */
        !           274:        public void
        !           275: jump_forw()
        !           276: {
        !           277:        POSITION pos;
        !           278: 
        !           279:        if (ch_end_seek())
        !           280:        {
        !           281:                error("Cannot seek to end of file");
        !           282:                return;
        !           283:        }
        !           284:        pos = ch_tell();
        !           285:        clear();
        !           286:        pos_clear();
        !           287:        add_back_pos(pos);
        !           288:        back(sc_height - 1, pos, 0, 0);
        !           289: }
        !           290: 
        !           291: /*
        !           292:  * Jump to line n in the file.
        !           293:  */
        !           294:        public void
        !           295: jump_back(n)
        !           296:        register int n;
        !           297: {
        !           298:        register int c;
        !           299: 
        !           300:        /*
        !           301:         * This is done the slow way, by starting at the beginning
        !           302:         * of the file and counting newlines.
        !           303:         */
        !           304:        if (ch_seek((POSITION)0))
        !           305:        {
        !           306:                /* 
        !           307:                 * Probably a pipe with beginning of file no longer buffered. 
        !           308:                 */
        !           309:                error("Cannot get to beginning of file");
        !           310:                return;
        !           311:        }
        !           312: 
        !           313:        /*
        !           314:         * Start counting lines.
        !           315:         */
        !           316:        while (--n > 0)
        !           317:        {
        !           318:                while ((c = ch_forw_get()) != '\n')
        !           319:                        if (c == EOF)
        !           320:                        {
        !           321:                                error("File is not that long");
        !           322:                                /* {{ Maybe tell him how long it is? }} */
        !           323:                                return;
        !           324:                        }
        !           325:        }
        !           326: 
        !           327:        /*
        !           328:         * Finally found the place to start.
        !           329:         * Clear and redisplay the screen from there.
        !           330:         *
        !           331:         * {{ We *could* figure out if the new position is 
        !           332:         *    close enough to just scroll there without clearing
        !           333:         *    the screen, but it's not worth it. }}
        !           334:         */
        !           335:        prepaint(ch_tell());
        !           336: }
        !           337: 
        !           338: /*
        !           339:  * Jump to a specified percentage into the file.
        !           340:  * This is a poor compensation for not being able to
        !           341:  * quickly jump to a specific line number.
        !           342:  */
        !           343:        public void
        !           344: jump_percent(percent)
        !           345:        int percent;
        !           346: {
        !           347:        POSITION pos, len;
        !           348: 
        !           349:        /*
        !           350:         * Determine the position in the file
        !           351:         * (the specified percentage of the file's length).
        !           352:         */
        !           353:        if ((len = ch_length()) == NULL_POSITION)
        !           354:        {
        !           355:                error("Don't know length of file");
        !           356:                return;
        !           357:        }
        !           358:        pos = (percent * len) / 100;
        !           359:        jump_loc(pos);
        !           360: }
        !           361: 
        !           362:        public void
        !           363: jump_loc(pos)
        !           364:        POSITION pos;
        !           365: {
        !           366:        register int c;
        !           367:        register int nline;
        !           368:        POSITION tpos;
        !           369: 
        !           370:        /*
        !           371:         * See if the desired line is BEFORE the currently
        !           372:         * displayed screen.  If so, see if it is close enough 
        !           373:         * to scroll backwards to it.
        !           374:         */
        !           375:        tpos = position(TOP);
        !           376:        if (pos < tpos)
        !           377:        {
        !           378:                for (nline = 1;  nline <= back_scroll;  nline++)
        !           379:                {
        !           380:                        tpos = back_line(tpos);
        !           381:                        if (tpos == NULL_POSITION || tpos <= pos)
        !           382:                        {
        !           383:                                back(nline, position(TOP), 1, 0);
        !           384:                                return;
        !           385:                        }
        !           386:                }
        !           387:        } else if ((nline = onscreen(pos)) >= 0)
        !           388:        {
        !           389:                /*
        !           390:                 * The line is currently displayed.  
        !           391:                 * Just scroll there.
        !           392:                 */
        !           393:                forw(nline, position(BOTTOM_PLUS_ONE), 1, 0);
        !           394:                return;
        !           395:        }
        !           396: 
        !           397:        /*
        !           398:         * Line is not on screen.
        !           399:         * Back up to the beginning of the current line.
        !           400:         */
        !           401:        if (ch_seek(pos))
        !           402:        {
        !           403:                error("Cannot seek to that position");
        !           404:                return;
        !           405:        }
        !           406:        while ((c = ch_back_get()) != '\n' && c != EOF)
        !           407:                ;
        !           408:        if (c == '\n')
        !           409:                (void) ch_forw_get();
        !           410: 
        !           411:        /*
        !           412:         * Clear and paint the screen.
        !           413:         */
        !           414:        prepaint(ch_tell());
        !           415: }
        !           416: 
        !           417: /*
        !           418:  * The table of marks.
        !           419:  * A mark is simply a position in the file.
        !           420:  */
        !           421: static POSITION marks[26];
        !           422: 
        !           423: /*
        !           424:  * Initialize the mark table to show no marks are set.
        !           425:  */
        !           426:        public void
        !           427: init_mark()
        !           428: {
        !           429:        int i;
        !           430: 
        !           431:        for (i = 0;  i < 26;  i++)
        !           432:                marks[i] = NULL_POSITION;
        !           433: }
        !           434: 
        !           435: /*
        !           436:  * See if a mark letter is valid (between a and z).
        !           437:  */
        !           438:        static int
        !           439: badmark(c)
        !           440:        int c;
        !           441: {
        !           442:        if (c < 'a' || c > 'z')
        !           443:        {
        !           444:                error("Choose a letter between 'a' and 'z'");
        !           445:                return (1);
        !           446:        }
        !           447:        return (0);
        !           448: }
        !           449: 
        !           450: /*
        !           451:  * Set a mark.
        !           452:  */
        !           453:        public void
        !           454: setmark(c)
        !           455:        int c;
        !           456: {
        !           457:        if (badmark(c))
        !           458:                return;
        !           459:        marks[c-'a'] = position(TOP);
        !           460: }
        !           461: 
        !           462: /*
        !           463:  * Go to a previously set mark.
        !           464:  */
        !           465:        public void
        !           466: gomark(c)
        !           467:        int c;
        !           468: {
        !           469:        POSITION pos;
        !           470: 
        !           471:        if (badmark(c))
        !           472:                return;
        !           473:        if ((pos = marks[c-'a']) == NULL_POSITION)
        !           474:                error("mark not set");
        !           475:        else
        !           476:                jump_loc(pos);
        !           477: }
        !           478: 
        !           479: /*
        !           480:  * Search for the n-th occurence of a specified pattern, 
        !           481:  * either forward (direction == '/'), or backwards (direction == '?').
        !           482:  */
        !           483:        public void
        !           484: search(direction, pattern, n)
        !           485:        int direction;
        !           486:        char *pattern;
        !           487:        register int n;
        !           488: {
        !           489:        register int search_forward = (direction == '/');
        !           490:        POSITION pos, linepos;
        !           491: 
        !           492: #if RECOMP
        !           493:        char *re_comp();
        !           494:        char *errmsg;
        !           495: 
        !           496:        /*
        !           497:         * (re_comp handles a null pattern internally, 
        !           498:         *  so there is no need to check for a null pattern here.)
        !           499:         */
        !           500:        if ((errmsg = re_comp(pattern)) != NULL)
        !           501:        {
        !           502:                error(errmsg);
        !           503:                return;
        !           504:        }
        !           505: #else
        !           506: #if REGCMP
        !           507:        char *regcmp();
        !           508:        static char *cpattern = NULL;
        !           509: 
        !           510:        if (pattern == NULL || *pattern == '\0')
        !           511:        {
        !           512:                /*
        !           513:                 * A null pattern means use the previous pattern.
        !           514:                 * The compiled previous pattern is in cpattern, so just use it.
        !           515:                 */
        !           516:                if (cpattern == NULL)
        !           517:                {
        !           518:                        error("No previous regular expression");
        !           519:                        return;
        !           520:                }
        !           521:        } else
        !           522:        {
        !           523:                /*
        !           524:                 * Otherwise compile the given pattern.
        !           525:                 */
        !           526:                char *s;
        !           527:                if ((s = regcmp(pattern, 0)) == NULL)
        !           528:                {
        !           529:                        error("Invalid pattern");
        !           530:                        return;
        !           531:                }
        !           532:                if (cpattern != NULL)
        !           533:                        free(cpattern);
        !           534:                cpattern = s;
        !           535:        }
        !           536: #else
        !           537:        static char lpbuf[100];
        !           538:        static char *last_pattern = NULL;
        !           539: 
        !           540:        if (pattern == NULL || *pattern == '\0')
        !           541:        {
        !           542:                /*
        !           543:                 * Null pattern means use the previous pattern.
        !           544:                 */
        !           545:                if (last_pattern == NULL)
        !           546:                {
        !           547:                        error("No previous regular expression");
        !           548:                        return;
        !           549:                }
        !           550:                pattern = last_pattern;
        !           551:        } else
        !           552:        {
        !           553:                strcpy(lpbuf, pattern);
        !           554:                last_pattern = lpbuf;
        !           555:        }
        !           556: #endif
        !           557: #endif
        !           558: 
        !           559:        /*
        !           560:         * Figure out where to start the search.
        !           561:         */
        !           562: 
        !           563:        if (position(TOP) == NULL_POSITION)
        !           564:        {
        !           565:                /*
        !           566:                 * Nothing is currently displayed.
        !           567:                 * Start at the beginning of the file.
        !           568:                 * (This case is mainly for first_cmd searches,
        !           569:                 * for example, "+/xyz" on the command line.)
        !           570:                 */
        !           571:                pos = (POSITION)0;
        !           572:        } else if (!search_forward)
        !           573:        {
        !           574:                /*
        !           575:                 * Backward search: start just before the top line
        !           576:                 * displayed on the screen.
        !           577:                 */
        !           578:                pos = position(TOP);
        !           579:        } else if (top_search)
        !           580:        {
        !           581:                /*
        !           582:                 * Forward search and "start from top".
        !           583:                 * Start at the second line displayed on the screen.
        !           584:                 */
        !           585:                pos = position(TOP_PLUS_ONE);
        !           586:        } else
        !           587:        {
        !           588:                /*
        !           589:                 * Forward search but don't "start from top".
        !           590:                 * Start just after the bottom line displayed on the screen.
        !           591:                 */
        !           592:                pos = position(BOTTOM_PLUS_ONE);
        !           593:        }
        !           594: 
        !           595:        if (pos == NULL_POSITION)
        !           596:        {
        !           597:                /*
        !           598:                 * Can't find anyplace to start searching from.
        !           599:                 */
        !           600:                error("Nothing to search");
        !           601:                return;
        !           602:        }
        !           603: 
        !           604:        for (;;)
        !           605:        {
        !           606:                /*
        !           607:                 * Get lines until we find a matching one or 
        !           608:                 * until we hit end-of-file (or beginning-of-file 
        !           609:                 * if we're going backwards).
        !           610:                 */
        !           611:                if (sigs)
        !           612:                        /*
        !           613:                         * A signal aborts the search.
        !           614:                         */
        !           615:                        return;
        !           616: 
        !           617:                if (search_forward)
        !           618:                {
        !           619:                        /*
        !           620:                         * Read the next line, and save the 
        !           621:                         * starting position of that line in linepos.
        !           622:                         */
        !           623:                        linepos = pos;
        !           624:                        pos = forw_raw_line(pos);
        !           625:                } else
        !           626:                {
        !           627:                        /*
        !           628:                         * Read the previous line and save the
        !           629:                         * starting position of that line in linepos.
        !           630:                         */
        !           631:                        pos = back_raw_line(pos);
        !           632:                        linepos = pos;
        !           633:                }
        !           634: 
        !           635:                if (pos == NULL_POSITION)
        !           636:                {
        !           637:                        /*
        !           638:                         * We hit EOF/BOF without a match.
        !           639:                         */
        !           640:                        error("Pattern not found");
        !           641:                        return;
        !           642:                }
        !           643: 
        !           644:                /*
        !           645:                 * Test the next line to see if we have a match.
        !           646:                 * This is done in a variety of ways, depending
        !           647:                 * on what pattern matching functions are available.
        !           648:                 */
        !           649: #if REGCMP
        !           650:                if ( (regex(cpattern, line) != NULL)
        !           651: #else
        !           652: #if RECOMP
        !           653:                if ( (re_exec(line) == 1)
        !           654: #else
        !           655:                if ( (match(pattern, line))
        !           656: #endif
        !           657: #endif
        !           658:                                && (--n <= 0) )
        !           659:                        /*
        !           660:                         * Found the matching line.
        !           661:                         */
        !           662:                        break;
        !           663:        }
        !           664:        jump_loc(linepos);
        !           665: }
        !           666: 
        !           667: #if (!REGCMP) && (!RECOMP)
        !           668: /*
        !           669:  * We have neither regcmp() nor re_comp().
        !           670:  * We use this function to do simple pattern matching.
        !           671:  * It supports no metacharacters like *, etc.
        !           672:  */
        !           673:        static int
        !           674: match(pattern, buf)
        !           675:        char *pattern, *buf;
        !           676: {
        !           677:        register char *pp, *lp;
        !           678: 
        !           679:        for ( ;  *buf != '\0';  buf++)
        !           680:        {
        !           681:                for (pp = pattern, lp = buf;  *pp == *lp;  pp++, lp++)
        !           682:                        if (*pp == '\0' || *lp == '\0')
        !           683:                                break;
        !           684:                if (*pp == '\0')
        !           685:                        return (1);
        !           686:        }
        !           687:        return (0);
        !           688: }
        !           689: #endif

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