Return to speech.h CVS log

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

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

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