Return to speech.h CVS log

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

Annotation of coherent/b/kernel/FWB/speech.h, revision 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: /* speech.h: header file for speaking device drivers */
        !            10: 
        !            11: #ifndef MSDOS
        !            12: /* char far *  is the same as char * in Unix */
        !            13: #define far
        !            14: #endif
        !            15: 
        !            16: /* don't incorporate any C routines from libc.a,
        !            17:  * becaues they do stack checking, and this is not a normal stack.
        !            18:  * However, we can use the ctype macros and static _ctype[] array. */
        !            19: 
        !            20: #include <ctype.h>
        !            21: 
        !            22: #define WORDLEN 24 /* length of longest "word" */
        !            23: #define LINELEN 38 /* length of support command line */
        !            24: #define N_CMDS 32 /* number of available speech commands */
        !            25: 
        !            26: /* record additional keystrokes,
        !            27:  * when a speech command requires extra data.
        !            28:  * For instance, search through the circular buffer for a string,
        !            29:  * and start reading at that point. */
        !            30: struct MULTIKEY {
        !            31: char lastcmd; /* the multi-key command */
        !            32: char nextchar; /* command needs the next character */
        !            33: char nextline; /* command needs the next line */
        !            34: char textlen;
        !            35: short support; /* extra key, could be function key etc */
        !            36: char text[LINELEN];
        !            37: char lasttext[LINELEN];
        !            38: };
        !            39: 
        !            40: /* control structure for speaking session */
        !            41: extern struct SDCONTROL {
        !            42: struct MULTIKEY indata, outdata;
        !            43: char *bufbot, *buftop; /* the circular buffer */
        !            44: char *bufhead, *buftail; /* extend of text within the buffer */
        !            45: char *bufcur; /* position of internal cursor within the buffer */
        !            46: int (*dev_in)(); /* function to put char on device input queue */
        !            47: char talkcmd; /* talking command */
        !            48: char dumping; /* dumping text to a file? */
        !            49: char macsel; /* macro set selection, 0 through 9 */
        !            50: long drain_lbolt;
        !            51: /* flags/modes */
        !            52: char xparent; /* transparent mode, emulate the original driver */
        !            53: char buf_ok; /* send output characters to the circular buffer for reading */
        !            54: char ctrl_ok; /* allow control characters to enter the buffer for reading */
        !            55: char dev_ok; /* send output characters to the screen (or com port) */
        !            56: char rdflag; /* currently reading text */
        !            57: char onesymb; /* reading one symbol */
        !            58: char oneline; /* read one line at a time */
        !            59: char esc; /* last char was escape */
        !            60: char esc_lc; /* escape leftbrace received */
        !            61: /* arrays of text */
        !            62: /* punctuation pronounciation table, at most 10 letters per symbol.
        !            63:  * it turns out, you don't want long names for these anyways.
        !            64:  * it slows you down, reducing productivity.  */
        !            65: char punctab[40*10];
        !            66: /* bind keys to talking commands */
        !            67: char keymap[146];
        !            68: char defcbuf[80]; /* in case kalloc fails */
        !            69: } *sdcontrol[5];
        !            70: 
        !            71: /* the above structures are initialized upon startup.
        !            72:  * One should use kalloc() to allocate the circular
        !            73:  * buffer and replacement text space at load time rather than compile time. */
        !            74: 
        !            75: /* speech command structure, one for each possible command */
        !            76: extern struct SDCMD {
        !            77: char *desc; /* description */
        !            78: char brief[8];
        !            79: char nonempty; /* buffer must be nonempty */
        !            80: char rdline; /* read the current line */
        !            81: char rdsymb; /* read one symbol */
        !            82: char rdchar; /* read one character */
        !            83: char nextkey; /* needs next key to complete command */
        !            84: char nextline; /* needs line of text to complete command */
        !            85: } sdcmds[];
        !            86: 
        !            87: /* state variables, set when entering deferred speech routines */
        !            88: extern struct SDCONTROL *sdc;
        !            89: extern char sdw[];
        !            90: extern int sdsession, sdnoises, sdtones;
        !            91: extern int sd0synth, sd0comport;
        !            92: extern int sdscreenmode, sdoverride;
        !            93: 
        !            94: #ifdef MSDOS
        !            95: extern char *kalloc();
        !            96: #else
        !            97: extern char *allkp, *alloc();
        !            98: #define        kalloc(n)       alloc(allkp, n)
        !            99: #define kfree(p)       free(p)
        !           100: #endif
        !           101: 

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