Return to stune.c CVS log

Up to [MW Coherent from dump] / coherent / b / STREAMS / conf_79

Annotation of coherent/b/STREAMS/conf_79/stune.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *-IMPORTS:
        !             3:  *     <sys/compat.h>
        !             4:  *             CONST
        !             5:  *             USE_PROTO
        !             6:  *             ARGS ()
        !             7:  *     <stdlib.h>
        !             8:  *             NULL
        !             9:  *             malloc ()
        !            10:  *             free ()
        !            11:  */
        !            12: 
        !            13: #include <sys/compat.h>
        !            14: #include <stdlib.h>
        !            15: 
        !            16: #include "ehand.h"
        !            17: #include "symbol.h"
        !            18: #include "read.h"
        !            19: #include "mtune.h"
        !            20: 
        !            21: #include "stune.h"
        !            22: 
        !            23: LOCAL stune_t *        _stunes;
        !            24: 
        !            25: 
        !            26: /*
        !            27:  * Read lines from an "stune" file.
        !            28:  */
        !            29: 
        !            30: #ifdef USE_PROTO
        !            31: LOCAL int (read_stune) (input_t * input, lex_t * lexp)
        !            32: #else
        !            33: LOCAL int
        !            34: read_stune ARGS ((input, lexp))
        !            35: input_t              * input;
        !            36: lex_t        * lexp;
        !            37: #endif
        !            38: {
        !            39:        int             ch = '\n';
        !            40:        stune_t       * stunep;
        !            41:        ehand_t         err;
        !            42: 
        !            43:        if ((stunep = (stune_t *) malloc (sizeof (* stunep))) == NULL)
        !            44:                throw_error ("out of memory in read_stune ()");
        !            45: 
        !            46:        if (PUSH_HANDLER (err) == 0) {
        !            47:                /*
        !            48:                 * If the first thing on the line works out to be an EOF,
        !            49:                 * then bail out without an error.
        !            50:                 */
        !            51: 
        !            52:                ch = read_symbol (input, lexp, & stunep->st_name);
        !            53: 
        !            54:                if (stunep->st_name == NULL) {
        !            55:                        /*
        !            56:                         * We allow an EOF at the beginning of a line and we
        !            57:                         * also allow a blank line.
        !            58:                         */
        !            59: 
        !            60:                        goto at_eof;
        !            61:                }
        !            62:                check_not_eol (ch);
        !            63: 
        !            64:                if ((stunep->st_mtune = find_mtune (stunep->st_name)) == NULL)
        !            65:                        throw_error ("Parameter name not in 'mtune' file");
        !            66: 
        !            67:                if (stunep->st_mtune->mt_stune != NULL)
        !            68:                        throw_error ("Two values configured for parameter");
        !            69: 
        !            70:                /*
        !            71:                 * Pull in the parameter value
        !            72:                 */
        !            73: 
        !            74:                ch = read_longs (input, lexp, & stunep->st_value, NO_RANGE);
        !            75: 
        !            76:                if (stunep->st_value < stunep->st_mtune->mt_min ||
        !            77:                    stunep->st_value > stunep->st_mtune->mt_max)
        !            78:                        throw_error ("Parameter value outside configurable range");
        !            79: 
        !            80:                ch = expect_eol (input, lexp, ch);
        !            81: 
        !            82:                /*
        !            83:                 * Having passed all the reasonableness checks, we link the
        !            84:                 * new entry into the chain.
        !            85:                 */
        !            86: 
        !            87:                stunep->st_mtune->mt_stune = stunep;
        !            88: 
        !            89:                stunep->st_next = _stunes;
        !            90:                _stunes = stunep;
        !            91:        } else {
        !            92: 
        !            93:                free (stunep);
        !            94:                CHAIN_ERROR (err);
        !            95:        }
        !            96: 
        !            97: at_eof:
        !            98:        POP_HANDLER (err);
        !            99:        return ch;
        !           100: }
        !           101: 
        !           102: 
        !           103: #if 0
        !           104: /*
        !           105:  * Regenerate an 'stune' line from the stored record.
        !           106:  */
        !           107: 
        !           108: #ifdef USE_PROTO
        !           109: void (write_stune) (stune_t * stunep, FILE * out)
        !           110: #else
        !           111: void
        !           112: write_stune ARGS ((stunep, out))
        !           113: stune_t              * stunep;
        !           114: FILE         * out;
        !           115: #endif
        !           116: {
        !           117:        (void) fprintf (out, "%-8s %-7ld\n",
        !           118:                        stunep->st_name->s_data,
        !           119:                        stunep->st_value);
        !           120: }
        !           121: #endif
        !           122: 
        !           123: 
        !           124: /*
        !           125:  * Suck in a complete 'stune' file.
        !           126:  */
        !           127: 
        !           128: #ifdef USE_PROTO
        !           129: void (read_stune_file) (CONST char * name)
        !           130: #else
        !           131: void
        !           132: read_stune_file ARGS ((name))
        !           133: CONST char    *        name;
        !           134: #endif
        !           135: {
        !           136:        read_dev_file (name, read_stune);
        !           137: }

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