Return to monitor.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / uucheck / checkperms

Annotation of coherent/d/bin/uucheck/checkperms/monitor.c, revision 1.1

1.1     ! root        1: /* monitor.c -
        !             2:  * Routines for handling a monitor file -- a places to stash input to be
        !             3:  * processed later.
        !             4:  * This package supports only a single monitor file.
        !             5:  * Monitor files are unlinked immdiately after they are opened, so they
        !             6:  * will just go away if a program halts for any reason.
        !             7:  */
        !             8: 
        !             9: #include <stdio.h>
        !            10: #include "checkperms.h"
        !            11: #include "monitor.h"
        !            12: 
        !            13: static FILE *monitor_fp = (FILE *)NULL;
        !            14: 
        !            15: void open_monitor_file()       /* Create a new monitor file.  */
        !            16: {
        !            17:        FILE *tmp_monitor;
        !            18:        static char tmp_file[]="/tmp/monXXXXXX";
        !            19: 
        !            20:        /* Try to open a tmp file.  */
        !            21:        strcpy(tmp_file, tempnam(NULL, "mon"));
        !            22: 
        !            23:        if((tmp_monitor = fopen(tmp_file, "w+")) == NULL) {
        !            24:                /* Do something useful in the way of error handling.  */
        !            25:        } /* if we can open the tmp file.  */
        !            26:        
        !            27:        /* Now unlink the tmp file so that we can just
        !            28:         * close it to make it go away.
        !            29:         */
        !            30:        unlink(tmp_file);
        !            31: 
        !            32:        /* CHECKPOINT - we've got an open file pointer on a nameless
        !            33:         * file.  */
        !            34:        monitor_fp = tmp_monitor;
        !            35:        /* Save current line for later reference.  */
        !            36:        oldlineno = lineno;
        !            37: } /* open_monitor_file() */
        !            38: 
        !            39: void close_monitor_file()      /* Close the monitor file.  */
        !            40: {
        !            41:        /* This makes the file go away, since it has already been unlinked.  */
        !            42:        fclose(monitor_fp);
        !            43: } /* close_monitor_file() */
        !            44: 
        !            45: void putchar_monitor_file(c)   /* Write to the monitor file.  */
        !            46:        char c;
        !            47: {
        !            48:        putc(c, monitor_fp);
        !            49: } /* write_monitor_file() */
        !            50: 
        !            51: int getchar_monitor_file()     /* Read from the monitor file.  */
        !            52: {
        !            53:        return(getc(monitor_fp));
        !            54: } /* read_monitor_file() */
        !            55: 
        !            56: int fseek_monitor_file(where, how)     /* Seek to an arbitrary position in the
        !            57:                                         * monitor file.
        !            58:                                         */
        !            59:        long where;
        !            60:        int how;
        !            61: {
        !            62:        return(fseek(monitor_fp, where, how));
        !            63:        lineno=-1000;   /* Set the line number to something meaningless.  */
        !            64: } /* fseek_monitor_file() */
        !            65: 
        !            66: void ungetchar_monitor_file(c)
        !            67:        char c;
        !            68: {
        !            69:        ungetc(c, monitor_fp);
        !            70: } /* ungetchar_monitor_file */
        !            71: 
        !            72: static boolean hava_char = FALSE;
        !            73: static int ungot_char;
        !            74: 
        !            75: void rewind_monitor_file()     /* Rewind the monitor file.  */
        !            76: {
        !            77:        rewind(monitor_fp);
        !            78:        hava_char = FALSE; /* Throw away any ungetc()d character.  */
        !            79:        hava_delay = FALSE; /* Throw away the delayed character.  */
        !            80:        lineno = oldlineno;
        !            81: } /* rewind_monitor_file() */
        !            82: 
        !            83: int my_getchar()
        !            84: {
        !            85:        int c;
        !            86: 
        !            87:        if(hava_char){
        !            88:                c = ungot_char;
        !            89:                hava_char = FALSE;
        !            90:        } else { /* Don't have an ungot character. */
        !            91:                if(reading_from_monitor_file){
        !            92:                        c = getchar_monitor_file();
        !            93:                } else {
        !            94:                        c = getchar();
        !            95:                }
        !            96: 
        !            97:                if(saving_to_monitor_file) {
        !            98:                        /* We want to save all but the last character
        !            99:                         * because the lexer has to read one character too
        !           100:                         * far for us to find an unindent.
        !           101:                         */
        !           102:                        if (hava_delay) {
        !           103:                                putchar_monitor_file(delayed_char);
        !           104:                        } else {
        !           105:                                hava_delay = TRUE;
        !           106:                        } /* if hava_delay */
        !           107:                        delayed_char = c;
        !           108:                } /* if saving to monitor file */
        !           109: 
        !           110:        } /* if have an ungot char */
        !           111:        
        !           112:        return(c);
        !           113: } /* my_getchar() */
        !           114: 
        !           115: int my_ungetchar(c)
        !           116:        int c;
        !           117: {
        !           118:        /* Do not use ungetch() at all because that will cause every
        !           119:         * ungetch()d character to appear (at least) twice in the monitor file.
        !           120:         */
        !           121: 
        !           122:        if (hava_char) { /* Can not unget more than one character.  */
        !           123:                return(EOF);
        !           124:        } else {
        !           125:                if (c != EOF) {
        !           126:                        hava_char = TRUE;
        !           127:                        ungot_char = (int) c;
        !           128:                        return(ungot_char);
        !           129:                } else {
        !           130:                        return(EOF);
        !           131:                }
        !           132:        } /* if hava_char already */
        !           133: 
        !           134:        
        !           135: } /* my_ungetchar() */

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