Return to ctlmod.h CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / ctlmod

Annotation of 43BSD/ingres/source/ctlmod/ctlmod.h, revision 1.1

1.1     ! root        1: /*
        !             2: **  CTLMOD.H -- control module header file
        !             3: **
        !             4: **     This header file defines all the internal data structures
        !             5: **     used by the control module.
        !             6: **
        !             7: **     If something other than the control module or the initializer
        !             8: **     has to include this, something is wrong!
        !             9: **
        !            10: **     Compilation Flags:
        !            11: **             xCM_DEBUG -- if set, certain code is compiled in that
        !            12: **                     does consistancy checks on the data structures
        !            13: **                     at opportune times.
        !            14: **             xMONITOR -- if set, turns on performance evaluation
        !            15: **                     code.
        !            16: **             xCTR1, xCTR2, xCTR3 -- if set, turns on various levels
        !            17: **                     of trace information.  These must be properly
        !            18: **                     nested; if xCTR2 is set, xCTR1 *MUST* be set.
        !            19: **
        !            20: **     Version:
        !            21: **             @(#)ctlmod.h    8.1     12/31/84
        !            22: */
        !            23: 
        !            24: 
        !            25: 
        !            26: 
        !            27: 
        !            28: 
        !            29: /* include some other files */
        !            30: # include      "state.h"
        !            31: # include      "proc.h"
        !            32: # include      <pv.h>
        !            33: # include      "pipes.h"
        !            34: # include      <func.h>
        !            35: # include      <pmon.h>
        !            36: # include      <setjmp.h>
        !            37: 
        !            38: /* basic constants */
        !            39: # include      <useful.h>
        !            40: 
        !            41: 
        !            42: /*
        !            43: **  Trace Flag settings.
        !            44: */
        !            45: 
        !            46: # include      <trace.h>
        !            47: # define       xCTR1           1
        !            48: # define       xCTR2           1
        !            49: # define       xCTR3           1
        !            50: # define       xCM_DEBUG       1
        !            51: # define       xMONITOR        1
        !            52: 
        !            53: /*
        !            54: **  STRUCT CM -- the configuration structure.
        !            55: */
        !            56: 
        !            57: struct _cm_t
        !            58: {
        !            59:        char    cm_myname[12];          /* my process name */
        !            60:        state_t cm_state[CM_MAXST];     /* the state descriptions */
        !            61:        proc_t  cm_proc[CM_MAXPROC];    /* the process descriptions */
        !            62:        int     cm_myproc;              /* my process id */
        !            63:        char    cm_input;               /* the current input file */
        !            64:        char    cm_rinput;              /* the reset input file */
        !            65: };
        !            66: 
        !            67: /*
        !            68: **  STRUCT CTX -- the context structure.
        !            69: **
        !            70: **     There is one of these around for every currently known
        !            71: **     context.  There is a pipe block associated with the
        !            72: **     context, defined in call() or main(); only a pointer
        !            73: **     is kept here so that the pipe block can be more efficiently
        !            74: **     allocated off the stack.
        !            75: **
        !            76: **     Some of the fields describe the NEXT block in the sequence.
        !            77: **     These are: ctx_size, ctx_link.
        !            78: **
        !            79: **     Ctx_cmark is useful ONLY when this block is not currently
        !            80: **     active.
        !            81: **
        !            82: **     Ctx_qt should be of type 'struct qthdr *'; it is 'char *' to
        !            83: **     avoid including qtree.h.  It points to the saved query
        !            84: **     tree header after the first qt is read in.
        !            85: **
        !            86: **     Ctx_pv MUST be last.
        !            87: */
        !            88: 
        !            89: typedef struct _ctx_t
        !            90: {
        !            91:        char            *ctx_name;      /* the printname of this proc */
        !            92:        pb_t            *ctx_ppb;       /* the pb associated w/ this ctx */
        !            93:        short           *ctx_tvect;     /* the trace vect for this ctx */
        !            94:        int             (*ctx_errfn)(); /* the error handling function */
        !            95:        char            *ctx_qt;        /* pointer to saved Qt struct */
        !            96:        struct fn_def   *ctx_fn;        /* pointer to fn descriptor */
        !            97:        char            *ctx_glob;      /* ptr to saved global area */
        !            98:        struct _ctx_t   *ctx_link;      /* a link to the next ctx */
        !            99:        struct monitor  *ctx_mon;       /* ptr to monitor struct */
        !           100:        short           ctx_size;       /* the size of the next ctx */
        !           101:        bool            ctx_init;       /* set if between initp & call */
        !           102:        bool            ctx_new;        /* set if this is a new context */
        !           103:        char            ctx_resp;       /* process to respond to */
        !           104:        int             ctx_cmark;      /* the Qbuf context mark */
        !           105:        int             ctx_pmark;      /* the Qbuf parameter mark */
        !           106:        jmp_buf         ctx_jbuf;       /* longjmp point on fatal error */
        !           107:        long            ctx_ofiles;     /* files that should be kept open */
        !           108:        int             ctx_pc;         /* the parm count */
        !           109:        PARM            ctx_pv[PV_MAXPC+1];     /* the parm vector */
        !           110: }  ctx_t;
        !           111: 
        !           112: extern ctx_t   Ctx;            /* the current context */
        !           113: extern char    Qbuf[];         /* the free space buffer */
        !           114: extern int     QbufSize;       /* the size of Qbuf */
        !           115: extern struct _cm_t    Cm;     /* the system configuration */
        !           116: extern int     Syncs[CM_MAXPROC];      /* the number of SYNCs expected */
        !           117: 
        !           118: 
        !           119: /*
        !           120: **  ERROR NUMBERS
        !           121: */
        !           122: 
        !           123: # define       ERR_QBUF        100     /* Qbuf overflow */

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