Return to error.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / bin / me

Annotation of coherent/g/usr/bin/me/error.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Micro-EMACS extension for MWC -- Search for next/previous error in
        !             3:  * error buffer.  This module must "know" the format of each type of
        !             4:  * error message produced by the compiler that the error message is
        !             5:  * generated by.
        !             6:  */
        !             7: 
        !             8: #include       <stdio.h>
        !             9: #include       "ed.h"
        !            10: 
        !            11: /*
        !            12:  * Find a window associated with the buffer list.
        !            13:  */
        !            14: 
        !            15: WINDOW *
        !            16: wfind(bp)
        !            17: BUFFER *bp;
        !            18: {
        !            19:        register WINDOW *wp;
        !            20: 
        !            21:        wp = wheadp;
        !            22:        while (wp != NULL) {
        !            23:                if (wp->w_bufp == bp)
        !            24:                        return wp;
        !            25:                wp = wp->w_wndp;
        !            26:        }
        !            27:        return NULL;
        !            28: }
        !            29: 
        !            30: /*
        !            31:  * Search forward in the error buffer for an error message.
        !            32:  */
        !            33: 
        !            34: forwerr(dir)
        !            35: {
        !            36:        register LINE   *lp;
        !            37:        register WINDOW *wp;
        !            38:        register uchar  *tp;
        !            39:        register int    c;
        !            40:        register int    error_line;
        !            41:        uchar           error_text[81];
        !            42:        uchar           *et;
        !            43: 
        !            44:        if ((wp = wfind(errbp)) == NULL)
        !            45:                return FALSE;
        !            46: 
        !            47:        error_line = 0;
        !            48:        lp = wp->w_dotp;
        !            49:        if (wp->w_doto)
        !            50:                lp = dir ? lback(lp) : lforw(lp);
        !            51: 
        !            52:        for (; lp != errbp->b_linep; lp = dir ? lback(lp) : lforw(lp)) {
        !            53:                int len, prev;
        !            54: 
        !            55:                tp = lp->l_text;
        !            56:                for (len = llength(lp), prev = '(';
        !            57:                    len && ((*tp < '0') || (*tp > '9') || (prev != '('));
        !            58:                    prev = *tp++, len--)
        !            59:                        ;
        !            60:                while (len-- && ((c = *tp++ - '0') >= 0) && (c <= 9)) {
        !            61:                        error_line *= 10;
        !            62:                        error_line += c;
        !            63:                }
        !            64:                if (!error_line)
        !            65:                        continue;
        !            66:                et = error_text;
        !            67:                while ((len-- > 0) && ((*et++ = *tp++) != 0)) {
        !            68:                        if ((et - error_text) > (term.t_ncol - 15))
        !            69:                                break;
        !            70:                }
        !            71:                *et = 0;
        !            72:                mlwrite("[%d:%s]",error_line, error_text);
        !            73:                break;
        !            74:        }
        !            75: 
        !            76:        if (!error_line) {
        !            77:                mlwrite("[No more errors.]");
        !            78:                return FALSE;
        !            79:        }
        !            80: 
        !            81:        wp->w_dotp = lp;                /* set dot to this line */
        !            82:        wp->w_doto = 1;
        !            83:        wp->w_force = 1;
        !            84:        wp->w_flag |= WFFORCE | WFMOVE;
        !            85:        gotofline(TRUE, error_line);
        !            86:        return TRUE;
        !            87: }
        !            88: 
        !            89: /*
        !            90:  * Make sure we have an error window.
        !            91:  */
        !            92: 
        !            93: errwind()
        !            94: {
        !            95:        register BUFFER *bp;
        !            96:        register BUFFER *obp;
        !            97:        register WINDOW *wp;
        !            98:        register int    r;
        !            99: 
        !           100:        if ((runswitch & CF_ERROR) == 0) {
        !           101:                mlwrite("[no error buffer]");
        !           102:                return FALSE;
        !           103:        }
        !           104: 
        !           105:        if ((bp = errbp) == NULL) {
        !           106:                mlwrite( "[No error buffer]" );
        !           107:                return FALSE;
        !           108:        }
        !           109: 
        !           110:        if (bp->b_nwnd == 0) {                  /* If this buffer is not */
        !           111:                if ((wp=wpopup()) == NULL) {    /* in a window, display it */
        !           112:                        mlwrite("[Can't open window for error buffer]");
        !           113:                        return FALSE;
        !           114:                }
        !           115:                obp = wp->w_bufp;               /* Get the old buffer ptr */
        !           116:                if (--obp->b_nwnd == 0) {
        !           117:                        obp->b_dotp  = wp->w_dotp;
        !           118:                        obp->b_doto  = wp->w_doto;
        !           119:                        obp->b_markp = wp->w_markp;
        !           120:                        obp->b_marko = wp->w_marko;
        !           121:                }
        !           122:                wp->w_bufp = bp;
        !           123:                ++bp->b_nwnd;
        !           124:                wp->w_linep = lback(bp->b_dotp);
        !           125:                wp->w_dotp  = bp->b_dotp;
        !           126:                wp->w_doto  = bp->b_doto;
        !           127:                wp->w_markp = bp->b_markp;
        !           128:                wp->w_marko = bp->b_marko;
        !           129:                wp->w_flag |= WFMODE|WFHARD;
        !           130:                if ((r = wp->w_ntrows - ERRLINES) > 0) {
        !           131:                        BUFFER *owp;
        !           132: 
        !           133:                        owp = curwp;
        !           134:                        curwp = wp;
        !           135:                        shrinkwind(0,r);
        !           136:                        curwp = owp;
        !           137:                }
        !           138: 
        !           139:        }
        !           140:        return TRUE;
        !           141: }
        !           142: 
        !           143: /*
        !           144:  * Find the next error line in the error file.
        !           145:  */
        !           146: nexterr(f,n)
        !           147: {
        !           148:        if (n < 0)
        !           149:                return preverr(f, -n);
        !           150: 
        !           151:        if (errwind() == FALSE)
        !           152:                return FALSE;
        !           153: 
        !           154:        return forwerr(0);
        !           155: }
        !           156: 
        !           157: /*
        !           158:  * Find the previous error line in the error buffer.
        !           159:  */
        !           160: preverr(f,n)
        !           161: {
        !           162:        if (n < 0)
        !           163:                return nexterr(f, -n);
        !           164: 
        !           165:        if (errwind() == FALSE)
        !           166:                return FALSE;
        !           167: 
        !           168:        return forwerr(-1);
        !           169: }
        !           170: 
        !           171: /*
        !           172:  * Read in the error file, giving it a buffer.
        !           173:  */
        !           174: readerr()
        !           175: {
        !           176:        register BUFFER *bp;
        !           177:        uchar   bname[NBUFN];
        !           178: 
        !           179:        makename(bname, "error-buffer");        /* New buffer name.     */
        !           180: #if    GEM
        !           181:        fixname(bname);
        !           182:        fixname(errfile);
        !           183: #endif
        !           184:        if ((errbp = bp = bfind(bname, TRUE, 0)) == NULL) {
        !           185:                mlwrite("Cannot create error buffer");
        !           186:                return (FALSE);
        !           187:        }
        !           188:        if (--curbp->b_nwnd == 0) {             /* Undisplay.           */
        !           189:                curbp->b_dotp = curwp->w_dotp;
        !           190:                curbp->b_doto = curwp->w_doto;
        !           191:                curbp->b_markp = curwp->w_markp;
        !           192:                curbp->b_marko = curwp->w_marko;
        !           193:        }
        !           194:        bp->b_flag |= BFNOWRT|BFERROR;          /* Mark the buffer...   */
        !           195:        curbp = bp;                             /* Switch to it.        */
        !           196:        curwp->w_bufp = bp;
        !           197:        curbp->b_nwnd++;
        !           198:        return (readin(errfile));               /* Read it in.          */
        !           199: }

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