Return to savebuf.c CVS log

Up to [MW Coherent from dump] / coherent / b / kernel / FWB2

Annotation of coherent/b/kernel/FWB2/savebuf.c, revision 1.1.1.1

1.1       root        1: /*-----------------------------------------------------------------------------
                      2:        Talking BIOS device driver for the AT&T PC6300.
                      3:        Copyright (C) Karl Dahlke 1987
                      4:        This software may be freely used and distributed
                      5:        for any non-profit purpose.
                      6:  *-----------------------------------------------------------------------------
                      7:  */
                      8: 
                      9: /* savebuf.c: save the accumulated text in a session file */
                     10: 
                     11: #include <stdio.h>
                     12: #ifdef MSDOS
                     13: #include <dos.h>
                     14: #else
                     15: #include <sgtty.h>
                     16: #endif
                     17: 
                     18: #ifdef MSDOS
                     19: struct
                     20: {
                     21:        char far *bufbot;
                     22:        char far *buftop;
                     23:        char far *buftail;
                     24:        char far *bufhead;
                     25: } devparams;
                     26: 
                     27: struct WORDREGS regs;
                     28: 
                     29: setenv(){} /* no environment */
                     30: #endif
                     31: 
                     32: char *filename = "session.log";
                     33: 
                     34: 
                     35: main(argc, argv)
                     36: int argc;
                     37: char **argv;
                     38: {
                     39:        FILE *f;
                     40:        register char c;
                     41: #ifdef MSDOS
                     42: int fh;
                     43: char far *cp;
                     44: short i, j;
                     45: #else
                     46: int bsize;
                     47: char *buf, *malloc();
                     48: #endif
                     49: 
                     50:        if(argc > 1) filename = argv[1];
                     51:        if(argc > 2)    {
                     52:                fprintf(stderr, "usage: savebuf [file]\n");
                     53:                exit(1);
                     54:        }
                     55: 
                     56:        f = fopen(filename, "w");
                     57:        if(!f)  {
                     58:                fprintf(stderr, "savebuf: cannot create file %s\n", filename);
                     59:                exit(1);
                     60:        }
                     61: 
                     62: #ifdef MSDOS
                     63:        /* get device driver parameters from ioctl call */
                     64: fh = open("SPEAK$", 0);
                     65:        regs.bx = fh;
                     66:        regs.ax = 0x4402; /* read ioctl string */
                     67:        regs.cx = 16; /* get 16 bytes */
                     68:        regs.dx = (unsigned) &devparams;
                     69:        intdos(&regs, &regs);
                     70:        if(regs.cflag & 1 || regs.ax != 16)     {
                     71:                fprintf(stderr, "savebuf: bad ioctl() call on device driver SPEAK$\n");
                     72:                exit(1);
                     73:        }
                     74: 
                     75: close(fh);
                     76: 
                     77: if(devparams.bufbot) {
                     78: if(!devparams.buftop) { /* indicates screen mode */
                     79:        cp = devparams.bufbot;
                     80: for(i=0; i<25; ++i) {
                     81: for(j=0; j<80; ++j) {
                     82: putc(*cp, f);
                     83: cp += 2;
                     84: }
                     85: putc('\n', f);
                     86: }
                     87: } else {
                     88:        cp = devparams.buftail;
                     89: while(cp != devparams.bufhead) {
                     90: c = *cp;
                     91:                if(c == '\r') c = '\n';
                     92:                putc(c,f);
                     93: if(++cp == devparams.buftop) cp = devparams.bufbot;
                     94: } /* end loop writing file */
                     95: } /* screen/line */
                     96: } /* nonzero pointers */
                     97: 
                     98: #else
                     99: 
                    100: /* I assume stdin is opened to the speech device driver */
                    101: if(ioctl(0, TIOCSDSIZE, &bsize) < 0) {
                    102: fprintf(stderr, "ioctl failed, cannot get size of text buffer from speech device driver\n");
                    103: exit(1);
                    104: }
                    105: 
                    106: if(!(buf = malloc(bsize))) {
                    107: fprintf(stderr, "cannot malloc %d bytes for text buffer\n", bsize);
                    108: exit(1);
                    109: }
                    110: 
                    111: /* now copy the text */
                    112: if(ioctl(0, TIOCSDGETBUF, buf) < 0) {
                    113: fprintf(stderr, "ioctl failed, cannot copy text buffer from speech device driver\n");
                    114: exit(1);
                    115: }
                    116: 
                    117: /* now write the file */
                    118: while((c = *buf++) > 0) {
                    119: if(c == '\r') c = '\n';
                    120: putc(c,f);
                    121: } /* end writing text buffer to file */
                    122: #endif
                    123: 
                    124:        fclose(f);
                    125:        exit(0);
                    126: } /* main */
                    127: 

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