Return to macros.c CVS log

Up to [Research Unix] / researchv10no / cmd / visi

Annotation of researchv10no/cmd/visi/macros.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *      macros.c 1.8
        !             3:  *
        !             4:  *     Screen Handling Functions for Spreadsheet Program `vis'
        !             5:  *
        !             6:  *      A. F. Gettier
        !             7:  *      Bell Laboratories
        !             8:  *      Update made 11/15/82 10:50:58
        !             9:  *      Retrieved 11/15/82 13:22:33
        !            10:  */
        !            11: #include       <math.h>
        !            12: #include       <stdio.h>
        !            13: #include       "curses.h"
        !            14: #include       "vis.h"
        !            15: 
        !            16: extern int     LINES, COLS;
        !            17: extern struct qheader  Fixup;
        !            18: 
        !            19: extern struct colhdr   Col;
        !            20: extern struct rowhdr   Row;
        !            21: 
        !            22: /*
        !            23:  *     duplicate a block of definitions
        !            24:  */
        !            25: duplicate( fr, fc, tr, tc, ar, ac )
        !            26: int    fr, fc, tr, tc, ar, ac;
        !            27: {
        !            28:        char    tbuf[128];
        !            29:        int     i, or, oc, nr, nc;
        !            30:        struct rowlabel **r1;
        !            31:        struct node     *n, *n2;
        !            32:        /*
        !            33:         *      get the row offset
        !            34:         */
        !            35:        or = ar - fr;
        !            36:        oc = ac - fc;
        !            37:        /*
        !            38:         *      Now make all the copies
        !            39:         */
        !            40:        r1 = Row.table;
        !            41:        for ( i=fr; i<=tr && i<Row.size; i++ ) {
        !            42:                n = r1[i]->next;
        !            43:                while ( n != 0 ) {
        !            44:                        if ( n->col > tc )  break;
        !            45:                        if ( n->col >= fc ) {
        !            46:                                nr =  n->row + or;
        !            47:                                nc =  n->col + oc;
        !            48:                                n2 = getnode( nr, nc );
        !            49:                                (void)strcat(strcpy( tbuf, makevar( nr, nc ) ),
        !            50:                                    strchr( n->def, '=' ));
        !            51:                                n2->def = copystr( tbuf );
        !            52:                                qadd( &Fixup, n2 );
        !            53:                        }
        !            54:                        n = n->next;
        !            55:                }
        !            56:        }
        !            57: }
        !            58: 
        !            59: /*
        !            60:  *     replicate a block of definitions
        !            61:  */
        !            62: replicate( ar, ac, fr, fc, tr, tc )
        !            63: int    ar, ac, fr, fc, tr, tc;
        !            64: {
        !            65:        char    tbuf[128], *defin;
        !            66:        int     i, j;
        !            67:        struct node     *n;
        !            68:        /*
        !            69:         *      Is there a def to be copied
        !            70:         */
        !            71:        n = getnode( ar, ac );
        !            72:        if ( n->def == 0 )  {
        !            73:                (void)sprintf( tbuf, "Not previous definition at %s", 
        !            74:                    makevar( ar, ac ) );
        !            75:                yyerror( tbuf );
        !            76:                lexinit();
        !            77:        }
        !            78:        /*
        !            79:         *      get the definition part
        !            80:         */
        !            81:        defin = strchr( n->def, '=' );
        !            82:        if ( defin == 0 )  {
        !            83:                (void)sprintf( tbuf, "Bug in the definition at %s", 
        !            84:                    makevar( ar, ac ) );
        !            85:                yyerror( tbuf );
        !            86:                lexinit();
        !            87:        }
        !            88:        /*
        !            89:         *      Now make all the copies
        !            90:         */
        !            91:        for ( i=fr; i<=tr; i++ ) {
        !            92:                for ( j=fc; j<=tc; j++ ) {
        !            93:                        n = getnode( i, j );
        !            94:                        (void)strcat(strcpy( tbuf, makevar( i, j ) ), defin );
        !            95:                        n->def = copystr( tbuf );
        !            96:                        qadd( &Fixup, n );
        !            97:                }
        !            98:        }
        !            99: }
        !           100: 
        !           101: /*
        !           102:  *     Convert from a row and column format to a character string
        !           103:  */
        !           104: char *
        !           105: makevar( row, col )
        !           106: int    row, col;
        !           107: {
        !           108:        static char     buf[16];
        !           109:        int     i;
        !           110:        /*
        !           111:         *      and the letters on the vertical
        !           112:         */
        !           113:        i = col / 26;
        !           114:        if ( i > 0 )  i += 'A' - 1;
        !           115:        else i = ' ';
        !           116:        col =  col % 26 + 'A';
        !           117:        (void)sprintf( buf, "%c%c%d", i, col, row+1 );
        !           118:        return( buf );
        !           119: }
        !           120: 
        !           121: /*
        !           122:  *     List the HELP to the Terminal
        !           123:  */
        !           124: listhelp()
        !           125: {
        !           126:        int     cnt;
        !           127:        char    tbuf[128];
        !           128:        FILE    *fp;
        !           129:        WINDOW  *listwin;
        !           130: 
        !           131:        if ( (fp=fopen( HELPFILE, "r" )) == 0 ) {
        !           132:                (void)sprintf( tbuf, "Cannot open HELPFILE (%s)", HELPFILE );
        !           133:                yyerror( tbuf );
        !           134:                return;
        !           135:        }
        !           136:        listwin = newwin( LINES, COLS, 0, 0 );
        !           137:        wmove( listwin, 0, 0 );
        !           138:        wclear( listwin );
        !           139:        wrefresh( listwin );
        !           140:        loop {
        !           141:                werase( listwin );
        !           142:                for( cnt=0; cnt<LINES-2; cnt++ ) {
        !           143:                        if ( fgets( tbuf, 80, fp ) == NULL )  break;
        !           144:                        if( tbuf[0] == '\f' )  break;
        !           145:                        wmove( listwin, cnt, 0 );
        !           146:                        (void)wprintw( listwin, "%s", tbuf );
        !           147:                }
        !           148:                if ( cnt == 0 ) break;
        !           149:                wmove( listwin, LINES-2, (COLS-25)/2 );
        !           150:                wstandout( listwin );
        !           151:                (void)wprintw(listwin,"PRESS <RETURN> WHEN READY");
        !           152:                wstandend( listwin );
        !           153:                wrefresh( listwin );
        !           154:                wgetstr(  listwin, tbuf );
        !           155:        }
        !           156:        delwin( listwin );
        !           157:        touchwin( stdscr );
        !           158: }
        !           159: 
        !           160: /*
        !           161:  *     edit the definitions file
        !           162:  */
        !           163: editfile()
        !           164: {
        !           165:        FILE    *fp;
        !           166:        char    *file, bfr[128], *editor;
        !           167: 
        !           168: 
        !           169:        clear();
        !           170:        move( 0, 25 );
        !           171:        standout( );
        !           172:        printw( "Entering Editor, Please Wait" );
        !           173:        standend( );
        !           174:        move( 1, 0 );
        !           175:        refresh();
        !           176:        file = mktemp("/tmp/visXXXXXX");
        !           177: 
        !           178:        /*
        !           179:         *      Write the definitions out
        !           180:         */
        !           181: 
        !           182:        refresh();
        !           183:        if ( (fp=fopen( file, "w" )) == 0 ) {
        !           184:                char    errbuf[64];
        !           185:                (void)sprintf( errbuf, "Cannot open '%s'", file );
        !           186:                yyerror( errbuf );
        !           187:                lexinit();
        !           188:                return;
        !           189:        }
        !           190: 
        !           191:        else dumpfile( fp );
        !           192: 
        !           193:        (void)fclose( fp );
        !           194: 
        !           195:        /*
        !           196:         *      zero out the current definitions
        !           197:         */
        !           198: 
        !           199:        zerodef();
        !           200: 
        !           201:        /*
        !           202:         *      edit the file
        !           203:         */
        !           204: 
        !           205:        editor = getenv( "ED" );
        !           206: 
        !           207:        if ( editor == 0 || *editor == '\0' )
        !           208:                (void)sprintf( bfr, "ed %s", file );
        !           209:        else
        !           210:                (void)sprintf( bfr, "%s %s", editor, file );
        !           211: 
        !           212:        resetty();
        !           213:        (void)system( bfr );
        !           214:        noecho();
        !           215:        crmode();
        !           216: 
        !           217:        /*
        !           218:         *      clean up the screen
        !           219:         */
        !           220: 
        !           221:        clear();
        !           222:        prheading();
        !           223:        refresh();
        !           224: 
        !           225:        /*
        !           226:         *      Read in the new definitions
        !           227:         */
        !           228: 
        !           229:        if ( (fp=fopen( file, "r" )) == 0 ) {
        !           230:                char    errbuf[64];
        !           231:                (void)sprintf( errbuf, "Cannot open '%s'", file );
        !           232:                yyerror( errbuf );
        !           233:                lexinit();
        !           234:        }
        !           235:        else readfile( fp );
        !           236:        (void)unlink( file );
        !           237: }
        !           238: 
        !           239: quit()
        !           240: {
        !           241:        move( LINES-1, 0 );
        !           242:        clrtoeol();
        !           243:        refresh();
        !           244:        endwin();
        !           245:        resetty();
        !           246:        exit( 0 );
        !           247: }

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