Contextual data representation and retrieval method

Abstract

A method for information representation and retrieval within a general-purpose digital computer. Information of all simple types is represented as points along dimensions, and compound information types are represented as the intersection of two or more dimensions in a multidimensional data space. A context of points is maintained externally, and is used selectively by an evaluator function which is used to return values which are bound to points in this data space, and to invoke conventional data processing functions which interact with the data space. Using the multidimensional representation and retrieval method, the processes and structures of conventional computing, such as variables, arrays, structures, lists, objects, and the like may be modeled or simulated.

Claims

I claim as my invention:

1. A method for representing an information item within the memory of a digital computer comprising the steps of:

(a) creating one or more DIMENSION data structures comprising at least a dimension name, and point type, and zero or more points;

(b) creating one or more POINT data structures comprising at least a dimension name, and a value;

(c) creating one or more BINDING data structures comprising at least a value point, and one or more points wherein all such points have different dimension names from one another, and wherein all such points are collectively labelled an INTERSECTION;

(d) selecting a group of DIMENSIONS useful for representing said information item, and creating POINTS representative of said information item within each of said selected DIMENSIONS;

(e) storing within said memory a BINDING representative of said information item, comprising a value POINT representative of said information item, and an INTERSECTION comprising all of said POINTS from said selected DIMENSIONS.

2. The method of claim 1 wherein one or more information items are stored within the memory of a digital computer, comprising the additional steps of:

(a) creating one or more AREA data structures comprising at least one or more BINDINGS; and

(b) storing within said AREAs, said BINDINGS representative of said information items.

3. The method of claim 1 wherein said BINDING data structures further contain a binding weight for designating the relative strength of said binding to the strength of other BINDING data structures.

4. The method of claim 3 wherein said BINDINGS are stored within said AREAS in rank order according to their associated binding weights.

5. The method of claim 1 further comprising creating one or more POINT data structures having one or more types selected from the group of "ALPHA", "COMPOUND", "DATAEL", "DICTIONARY", "BLOb", "INTEGER", "INTERSECTION", "INTMOD", "POINTINDEX", "SHELL", "SPECIAL", "STRUCTEL", "CODEMODULE", "UNFORMATTEDCODEMODULE", "CONTEXT", "LIST", "PRAGMA", "MEMPTR", "POSITION INDEP CODE MODULE", "BIGTEXT", "PINTMOD", "TIME", "BINDING", and "LOGICAL".

6. The method of claim 1 further comprising a method for evaluating an INTERSECTION comprising searching said memory for a BINDING containing only each and every POINT within said INTERSECTION, and if such a BINDING is present within said memory, returning the value POINT stored in said BINDING.

7. The method of claim 1 further comprising the steps of:

(a) creating a CONTEXT data structure comprising a dynamic list of POINTS, no two of which are in the same DIMENSION; and

(b) storing said CONTEXT data structure separately from and independently of said information item.

8. The method of claim 7 wherein said CONTEXT references one or more AREAs for consideration during evaluation.

9. The method of claim 7 further comprising a method for evaluating a first INTERSECTION and a CONTEXT, comprising searching said memory for a BINDING containing each and every POINT within said first INTERSECTION and one or more POINTS selected from within said context, and if such a BINDING is present within said memory, returning the value POINT stored in said BINDING.

10. The method of claim 9 wherein the fewest number of said POINTS within said CONTEXT are selected.

11. The method of claim 10 wherein the POINTS within said context are stored in a predetermined order, and are selected in said order.

12. The method of claim 10 wherein all values stored in all BINDINGS containing each and every POINT within said first INTERSECTION and one or more POINTS selected from within said CONTEXT are returned, together with a list of the selected CONTEXT POINTS for each value.

13. The method of claim 12 wherein said returned list is evaluated according to a predefined ranking schema to determine the single best returned value.

14. The method of claim 13 wherein said returned list is ordered in decreasing order of binding weight.

15. The method of claim 1 wherein at least one DIMENSION data structure contains at least one entry point to a set of executable computer instructions.

16. The method of claim 1 wherein at least one DIMENSION data structure contains at least one entry point to a data retrieval system containing a computer database.

17. The method of claim 16 wherein said DIMENSION data structure contains a call to an SQL database server.

18. The method of claim 16 wherein said DIMENSION data structure contains access methods for retrieval from an object database.

19. The method of claim 3 wherein said binding weight is equal to a predetermined scalar value associated with said information item.

20. The method of claim 19 wherein evaluation of an INTERSECTION relies on partial inequality of binding weight.

21. The method of claim 19 wherein said scalar value is representative of time.

22. The method of claim 19 wherein said scalar value is representative of a transaction count.

23. The method of information representation of claim 1 further comprising a method for undoing information storage in the memory of a digital computer wherein one or more POINTs is removed from the BINDING DIMENSION, thereby deleting the BINDINGs represented by said removed POINTs from memory.

24. The method of claim 1 further including a security operation wherein each desired operation of a computer system is preceded by evaluation of an INTERSECTION of the form Logical:Yes/No, wherein the CONTEXT contains information such as user, terminal, privileges, objects, operations, and executable code necessary to proper evaluation of said INTERSECTION.

25. The method of claim 1 wherein a SEQUENCE is defined as a POINT used to iterate through a list of POINTS, and SEQUENCE operators comprise Next, Prior, Count, and Position.

26. The method of claim 25 wherein the current CONTEXT is capable of modifying the SEQUENCE operators to change the order in which said list of POINTS is accessed.

27. The method of claim 7 wherein said CONTEXT is determined by implication from an INTERSECTION by iteratively evaluating undefined POINTS in said INTERSECTION through substitution of the value of the autocontext POINT in the DIMENSION of each such undefined POINT until no POINTS in said INTERSECTION remain undefined or the evaluation of an autocontext point fails or the evaluation of the said INTERSECTION fails.

Description

FIELD OF THE INVENTION

The present invention relates to the field of information representation and retrieval within a general-purpose digital computer. Information of all simple (one-dimensional) types is represented as points which are arrayed along dimensions (vectors), and compound information types are represented as the intersection of two or more dimensions in a multidimensional data space. A context, comprising one or more points may be established and maintained locally or globally, for use in evaluation of values within the data space. An evaluator function is used to return values which are bound to points in this data space, and to invoke conventional data processing functions which interact with the data space. The evaluator resolves values by selectively incorporating points from the context on an as-needed basis. Using the contextual representation and retrieval method, the processes and structures of conventional computing, such as variables, arrays, structures, lists, objects, and the like may be modeled or simulated.

BACKGROUND OF THE INVENTION

The representation of information within the memory of a general-purpose digital computer, and the organization and retrieval of that information is one of the classical problems of computing. The mere representation of alphanumeric characters which has become so commonplace was a major advance which required a complex mapping of (at first) seven bit values to corresponding characters and meta-characters in a standard, accepted order. The one-to-one mapping of the values [0,1,2 . . . 126] to the set of characters [NUL, SOH, STX . . . .about.] was not a simple task to standardize. It was not until 1965 that such a mapping became the ASCII standard.

The construction of data files using computers began with the sequential file, in which a series of records of a known and fixed length were concatenated together, and could be retrieved by the computation of an "offset" into the file, to arrive at the desired record. Thus, to arrive at the nth record in a file consisting of 80 byte records, one merely discarded the first (n.times.80) bytes read from the file, and retrieved the 80 bytes immediately following.

Later developments in data retrieval and storage technologies included the indexed sequential file which permitted variable length records without the need for sequential search in order to retrieve a desired record, and most recently, relational databases which use a common "key" field to relate multiple "tables" of information.

When coupled with a high level language capable of manipulating information and indices, the relational database can be a powerful tool for managing information. Each table is usually defined as a two-dimensional array of information, having columns which correspond to fields having a defined type, such as alpha, date, integer, real, and so on, while the rows correspond to individual records within the database. Relations are formed by the matching of values within designated fields of different tables. For instance, a typical business database may have a table for storing information about "people" comprising fields such as: Customer Number, First Name, Middle Initial, Last Name, Street Address, City, State, Zip Code, Telephone Number, and Social Security Number. Another table may list items purchased, and may include fields such as: Item Number, Number Purchased, Date Purchased, Item Price, Discount Applied, and Purchaser Customer Number. By knowing the Customer Number of a given customer (perhaps retrieved after a search for the customer's name in the "people" table, a listing of every item purchased by the customer may be retrieved from the "items purchased" table. Further relations are then possible in such an extended system to determine, for instance, the identity of the manufacturer of a particular item, the count of that item in current stock, and other information necessary to operation of a business.

Packaged together with tools for report formating, data manipulation, and user interface construction, relational databases are sometimes referred to as "Fourth Generation Languages" or simply "4GLs". While such 4GLs have proven application in business computing, they are inadequate for certain "real world" tasks, and are cumbersome for others.

The present invention comprises a method for database retrieval which may be termed "super-relational". It provides for an arbitrarily large number of simple information storage structures which may be combined in large numbers of ways, and economically stored and accessed using convention general-purpose digital computers (as opposed to special-purpose database systems such as the GScan or Teradata computer systems.)

BRIEF DESCRIPTION OF THE INVENTION

In the method of the present invention, all informational entities are treated as points along dimensional lines. For instance, every integer number is treated as a point along an "integer" dimension, every real number as a point along a "real" dimension, and every breed of dog as a point along a "breed_of_dog" dimension. In fact, dimensions can exist for any concept or item which requires representation in a data processing system. All that is required is that every point along a given dimension possess the same quality of interest as all other points along that dimension (consider such dimensions as "red_things" and "fruits").

A point in the method of the present invention is of the notational form:

dimension: label

where dimension is the name of the dimension (e.g., integer, real, or fruits), and label specifies a particular point along the named dimension (e.g., "3", "3.14159", or "apple").

A binding in the method of the present invention is an association of a value point .upsilon. with the intersection I of two or more other points p within the multidimensional space, so long as no two points are contained along the same dimension. A binding is represented by the notation:

[p.sub.1, p.sub.2, . . . p.sub.n ]=.upsilon.

where the intersection I consists of the points p.sub.1, p.sub.2, p.sub.n enclosed in brackets being bound to the value point .upsilon., and defining the intersection at value=.upsilon.(i.e., .upsilon. along the "value" dimension).

It is thus possible to reference a value .upsilon. by specifying a set of points p.sub.1, p.sub.2, . . . p.sub.n. A complete intersection is one in which all p.sub.n points are specified, while an incomplete intersection is one in which one or more points are missing.

The context set C in the method of the present invention is a set of points c such that no two points belong to the same dimension. A context is represented using the following notation:

[p.sub.1, p.sub.2, . . . p.sub.n.vertline.c.sub.1, c.sub.2, . . . c.sub.n ]

which means that the method will evaluate the intersection p.sub.1, p.sub.2, . . . p.sub.n within the context of points c.sub.1, c.sub.2, . . . c.sub.n. If the intersection specified in p.sub.1, p.sub.2, . . . p.sub.n is complete, then no further operation need occur. However, if that intersection is incomplete, then one or more points taken from the context C may be used to complete the intersection. For instance, the binding:

[a, b, c]=value

cannot be referenced as [a, b] because the intersection is incomplete. Given a context of

[a, b .vertline.c, d, e]

however, the intersection may be evaluated by using c from the context.

At the core of the method of the present invention is the evaluator E, which is a process which, given an intersection I, determines the value .upsilon., provided that I is a complete intersection, or is provided with a context C. That is,

E(I)=.upsilon. or E(I,C)=.upsilon.

The context C is preferably maintained externally to the evaluator, and points from the context are selected for use in evaluations on an as-needed basis. The evaluator must also be able to resolve ambiguities, that is, it must be able to choose between two or more possible (and complete) intersections in order to return a single value. Several approaches, such as simple point weighting are possible, and have been proven to be effective in the method of the present invention.

As will be more fully described below, the method of the present invention may be used to provide a function similar to that of a conventional relational database, but it may also be used to function as a programming language, object oriented framework, rule-based expert system shell, list processing engine, and many more extended functions now performed by special purpose hardware and software.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1a shows a dimension structure.

FIG. 1b shows a point structure.

FIG. 1c shows an intersection structure.

FIG. 1c,e shows a binding structure.

FIG. 2 shows an area structure and a context structure.

DETAILED DESCRIPTION OF THE INVENTION

In describing the method of the present invention, several conventions in addition to those outlined above are useful. The following dimensions are used:

The NId (for Name Identification) dimension contains all points used to name things.

These points represent various labels, names, variables and the like used within computer applications.

The Dimension dimension contains a point for each dimension within the multidimensional space.

When it is necessary to have multiple points on a given dimension bound to the same value point, the notational convention used is:

dimension:p1, p2, . . . pn which defines an explicit list of points

or

dimension:p1. . . p2 which defines a range of points

or simply

dimension:{all} which defines all points on the dimension

    Point Data Structure
    #define V4DPI_PntType_Int 0                                        /*
     Integer Point Value */
    #define V4DPI_PntType_Char 1                                       /*
     Character String */
    #define V4DPI_PntType_Dict 2                                       /*
     Dictionary Entry */
    #define V4DPI_PntType_Real 3                                       /* Real
     Number */
    #define V4DPI_PntType_Isct 4                                       /*
     Intersection (Grouping is number of
                                                                       points
     in the intersection) */
    #define V4DPI_PntType_Foreign 5                                    /*
     Foreign data type (ex: qtyuom) */
    #define V4DPI_PntType_Special 6                                    /*
     Special points (e.g. (ALL), (CURRENT)) */
    #define V4DPI_PntType_Shell 7                                      /* This
     is a shell for other points */
    #define V4DPI_PntType_FrgnDataE1 8                                 /* Field
     specification for foreign file */
    #define V4DPI_PntType_FrgnStructE1 9                               /*
     Structure specification for a foreign file */
    #define V4DPI_PntType_CmpndIsct 10                                 /*
     Compound Intersection: dim=[ ... ], [ ... dim= ]
                                                                       ... */
    #define V4DPI_PntType_V3Mod 11                                     /* V3
     Module Call */
    #define V4DPI_PntType_V3ModRaw 12                                  /* V3
     Module Call with no translation (points passed "as is") */
    #define V4DPI_PntType_Context 13                                   /* A
     Context point */
    #define V4DPI_PntType_List 14                                      /* A
     "special" (internally maintained) list */
    #define V4DPI_PntType_Pragma 15                                    /* A
     point which holds junk for IntMods,
                                                                       not to
     be pushed onto context */
    #define V4DPI_PntType_IntMod 16                                    /* A
     point which evaluates via internal (to
                                                                       V4)
     module */
    #define V4DPI_PntType_PntIdx 17                                    /* A
     point which points to internal point
                                                                       buffer
     ("expanded" by V4) */
    #define V4DPI_PntType_MemPtr 18                                    /* A
     memory pointer */
    #define V4DPI_PntType_V3PicMod 19                                  /* A V3
     PIC module (module stored in same area as point?) */
    #define V4DPI_PntType_BigText 20                                   /* A big
     text string (see V3PicMod above) */
    #define V4DPI_PntType_PIntMod 21                                   /*
     Partial Eval IntMod (last argument is continued evaluation) */
    #define V4DPI_PntType_Time 22                                      /*
     Time/Transaction - Bindings searched in
                                                                       reverse
     "chronological" order */
    #define V4DPI_PntType_Binding 23                                   /*
     Binding info - used for erasing/tracking bindings */
    #define V4DPI_PntType_Logical 24                                   /*
     Logical (Yes/No) */
    #define V4DPI_PntVerify_InArea 1                                   /*
     Verify point in Area */
    #define V4DPI_PntVerify_Dict 2                                     /*
     Verify point in dictionary */
    #define V4DPI_PntVerify_Range 3                                    /* Point
     must be within range */
    #define V4DPI_PntVerify_Ref 4                                      /*
     Verify point as REF in another area */
    #define V4DPI_Grouping_Single 0                                    /*
     Single Point */
    /* Numbers 1-12 indicate a mix-list of so many entries */
    #define V4DPI_Grouping_All 15                                      /* Point
     represents all points in dimension
                                                                       (e.g.
     dim=all) */
    #define V4DPI_Grouping_Current 16                                  /* Point
     represents current value of dimension in
                                                                       context
     */
    #define V4DPI_Grouping_Binding 17                                  /* Point
     represents value of point in binding
     resulting in this intersection */
    #define V4DPI_Grouping_List 18                                     /* Point
     represents value of point within
                                                                       current
     list iteration */
    #define V4DPI_Grouping_Now 19                                      /* Point
     represents "current" time */
    #define V4DPI_Grouping_LastBind 20                                 /* Point
     represents bind point of last binding */
    #define V4DPI_AlphaVal_Max 1024                                    /* Max
     bytes in a point value */
    #define V4DPI_CharString_Max 250                                   /* Max
     bytes in character string */
    #define V4DPI_PointHdr_Bytes 8                                     /*
     Number of bytes in point header */
    #define V4DPI_FormatOpt_ShowDim                                    /* Show
     "dim=" in output */
    #define V4DPI_FormatOpt_ShowBytes 2                                /* Show
     bytes required to store point */
    #define V4DPI_FormatOpt_Trace V4DPI_FormatOpt_ShowDim .vertline.
     V4DPI_FormatOpt_ShowBytes
    #define V4DPI_FormatOpt_Default 0
    struct V4DPI_Point
    {   unsigned short Dim ;                                           /*
     Dimension of this point */
        unsigned short Bytes ;                                         /*
     Number of bytes in this point */
        unsigned char PntType ;                                        /* Type
     of point - see V4DPI_PntType_xxx */
        unsigned char Grouping ;                                       /*
     Grouping of points - see V4DPI_Grouping_xxx */
        unsigned char LHSCnt                                           /* If
     intersection then number of points below
                                                                       before
     ".vertline." i (left-hand-size count) */
        CHARFIELD NestedIsct : 1 ;                                     /* If
     this is intersection then TRUE if
                                                                       nested
     intersections within */
        CHARFIELD Quoted : 1 ;                                         /* If
     TRUE then point is "quoted" and should not
                                                                       be
     evaluated */
        union
        {   int IntVal ;
            char *MemPtr ;                                             /*
     Pointer to memory */
            unsigned char AlphaVal[V4DPI_AlphaVal_Max]
        }   Value
    } ;
    typedef struct V4DPI_Point P ;                                     /* To
     make life easier */
    #define V4DPI_ShortAlphaVal_Max 8
    #define V4DPI_ShortPointHdr_Bytes 4
    #define V4DPI_Shortpoint_Limit V4DPI_ShortAlphaVal_Max+V4DPI_PointHdr_Bytes
    struct V4DPI_ShortPoint                                            /* Used
     for "little points" stored directly within bindlist */
    {   unsigned short Dim ;                                           /*
     Dimension of this point */
        unsigned short Bytes ;                                         /*
     Number of bytes in this point */
        unsigned char PntType ;                                        /* Type
     of point - see V4DPI_PntType_xxx */
        union
        {   int IntVal ;
            char AlphaVal[V4DPI_ShortAlphaVal_Max] ;
        }   Value ;
    } ;
    Dimension Data Structure
    #define V4DPI_WorkRelHNum 7                                        /* RelH
     for process-specific work area */
    #define V4DPI_DimInfo_DimNameMax 31                                /* Max
     bytes in dimension name */
    #define V4DPI_DimInfo_RelHReview_Const 1                           /*
     Bindings are defined at dimension
     definition - cannot change */
    #define V4DPI_DimInfo_RelHReview_Area 0                            /*
     Review RNum/Category whenever an
                                                                       area is
     loaded or unloaded */
    #define V4DPI_DimInfo_RelHReview Bind 2                            /*
     Review with each binding for this
     dimension (VERY EXPENSIVE OPTION!!) */
    struct V4DPI_DimInfo
    {   union V4IS_KeyPrefix kp ;                                      /*
     Type=V4, SubType=DimInfo, Mode=Int,
                                                                       Length=8
     */
        int DimId                                                      /*
     Dimension code (actually dictionary entry for
                                                                       Dim
     name) */
        char DimName[V4DPI_DimInfo_DimNameMax+1] ;
        short PointType ;                                              /* Type
     of point allowed for this dimension-
     V4DPI_PntType_xxx */
        short PointVerify ;                                            /* How
     to verify (accept) this point-
     V4DPI_PntVerify_xxx */
        short RangeOK ;                                                /* TRUE
     if point ranges (xxx..yyy) are allowed */
        short ListOK ;                                                 /* TRUE
     if point lists (xxx,yyy,zzz) are allowed
                                                                       */
        short IsModule ;                                               /* TRUE
     if point links to external (V3) module */
        short UniqueOK ;                                               /* If
     TRUE then allowed to specify point as
     dim={NEW} */
        short DictType ;                                               /*
     Dictionary type- V4DPI_DictType_xxx */
        int BindList ;                                                 /* If
     TRUE then dimension can become key to
                                                                       BindList
     entry */
        short ExpandMacro ;                                            /*
     Number of bytes in macro below (i.e.
                                                                       TRUE if
     expansion on parse) */
        char Macro_Buf[100+1] ;                                        /* Macro
     buffer to expand on point acceptance */
        short RelHNum ;                                                /*
     Relative Heirarchy Number for this dimension
                                                                       (for
     bindings) */
        char RelHCategory[31+1] ;                                      /*
     Category code for bindings */
        short RelHReview ;                                             /* How
     often to review RelHNum/Category-
     V4DPI_DimInfo_RelHReview_xxx */
        char AcceptorModule[31+1] ;                                    /* Name
     of V3 Acceptor module */
        int AcceptorObject[2] ;                                        /*
     OBJREF for acceptor module */
        char DisplayerModule[31+1] ;                                   /* Name
     of V3 Displayer module */
        int DisplayerObject[2] ;                                       /*
     OBJREF for displayer */
                                                                       /*
     Following MUST be at end of dimension info !!!*/
        struct V4DPI_Point AutoCtxPnt ;                                /* If
     not NULL then point to be used for Auto-
                                                                       Context
     lookups */
    } ;
    struct V4DPI_DimUnique                                             /*
     Structure of record holding next
     available point number for a dimension */
    {   union V4IS_KeyPrefix kp ;                                      /*
     Type=V4, SubType=DimInfo, Mode=Int,
                                                                       Length=8
     */
        int DimId ;                                                    /*
     Dimension code */
        unsigned long NextAvailPntNum ;                                /* Next
     available number (will have RelH prefix!)
                                                                       [SHOULD
     BE UNSIGNED!!!] */
    } ;
    #define V4DPI_PointIntMix_Max 12
    struct V4DPI_Point_IntMix                                          /*
     Defines a list of integer points/ranges */
    { struct ( int BeginInt,EndInt ;                                   /* Begin
     & End in range (end=begin for single) */
              } Entry[V4DPI_PointIntMix_Max] ;
    } ;
    #define V4DPI_PointAlphaMix_Max 12                                 /* Max
     number of Alpha mixes in point */
    struct V4DPI_PointAlphaMix
    {   struct { unsigned short BeginIndex
              unsigned short EndIndex
              } Entry[V4DPI_PointAlphaMix_Max] ;
    } ;
    union V4DPI_PointMask



    {   struct
        {   unsigned AreaId : 8 ;                                      /* Area
     "owning" point */
            unsigned long PointId : 24 ;                               /* Point
     Id */
        }   fld ;
        int all ;
    } ;
    #define XTRHNUMDIM(dimid) (dimid>>13)                        /*
     Extract heirarch num from
     dimension ID */
    #define ADDHNUMDIM(hnum,dimid) ((hnum<<13) .vertline. (dimid&0x1FFF))
     /* Add heirarchy
                                                                       number
     to dimension */
    #define XTRHNUMDICT(dictnum) ((((unsigned long)dictnum)>>28)&7)
     /*Extract hnum from
     dictionary entry (external) */
    #define ADDHNUMDICT (hnum, dictnum) ((hnum<<28) .vertline.
     (dictnum&0x0FFFFFFF))
    #define ISDICTEXT(dictnum) ((dictnum>>28)!=0)                /* TRUE
     if dictnum is external */
    #define MAXDIMNUM 0xFFFF                                           /*
     Highest allowed dimension number
     (including 3 bit prefix) */
    #define DIMDICT (int *)-1                                          /*
     Special flag to tell DictEntryGet to
                                                                       look for
     dimension name */
    #define V4DPI_DictType_Dim 1                                       /* A
     dimension entry */
    #define V4DPI_DictType_Int 2                                       /* An
     internal (to area) entry */
    #define V4DPI_DictType_Ext 3                                       /* An
     external entry (can
     participate in bindings in other areas) */
    #define V4DPI_DictEntryVal_Max 31                                  /* Max
     number of bytes in dictionary entry */
    struct V4DPI_DictEntry
    {   union V4IS_KeyPrefix kp ;                                      /*
     Type=V4, SubType=Dict,
     Mode=Alpha, */
        char EntryVal[V4DPI_DictEntryVal_Max+4] ;                      /*
     Dictionary entry */
        /* int EntryId ; */                                            /*
     Corresponding numeric entry
     (immediately follows EntryVal) */
    } ;
    struct V4DPI_RevDictEntry
    {   union V4IS_KeyPrefix kp ;                                      /*
     Type=V4, SubType=RevDict,
     Mode=Int, Len=8 */
        int EntryId ;                                                  /*
     Numeric entry (ref) */
        char EntryVal[V4DPI_DictEntryVal_Max+4] ;                      /*
     Corresponding Dictionary entry */
    };
    /* Define special dimensions */
    #define Dim_Dim 1                                                  /*
     Dimension dimension */
    #define Dim_BindHNum 2                                             /*
     BindHNum */
    #define Dim_BindCategory 3
    #define Dim_BindLifeTime 4
    #define Dim_BindWeight 5
    #define Dim_StartDimIndex 10                                       /*
     Starting number for other
     dimensions (must be greater than last above) */
    Binding Data Structure
    struct V4DPI_Binding
    {   union V4IS_KeyPrefix kp ;                                      /*
     Type=V4, SubType=Value, Mode=Int,
                                                                       Len=8 */
        int ValueId                                                    /* Key
     to this value (see bindlist
                                                                       below
     for linkage) */
        unsigned short Bytes ;                                         /*
     Number of bytes in this binding */
        unsigned short IsctIndex ;                                     /* Index
     into Buffer for start of intersection */
        int BindWgt ;                                                  /*
     Binding Weight */
        char Buffer[V4IS_BktSize_Max] ;                                /* Value
     then Isct in here (NOTE: Must be
                                                                       "int"
     aligned!!!) */
    } ;
    /* Format of BindList (this is rather complicated- schematic below should
     help */
    /*  header info (V4DPI_BindList)
        BindList_Value entry                                           Points
     immediate follow
     (Buffer[ValueStart])
        BindList_Value entry                                           Multiple
     points in decreasing weight
        BindList_Value entry                                           so that
     first one to "match" is the one to take
        ...
        BindList_Dim                                                   at
     Buffer[DimStart] & contains list of
                                                                       offsets
     to points below
                                                                       (Note:
     first offset is 0 so that all this can float)
        dim=value point                                                starting
     at Buffer[PointStart]
        dim=value point                                                these
     points are one after the
                                                                       other,
     offset by "size" field
        ...
    */
    #define V4DPI_BindList_BufMax 10000                                /* Max
     bytes in binding list */
    struct V4DPI_BindList
    {   union V4IS_KeyPrefix kp ;                                      /*
     Type=Binding, AuxVal=Dim,
     key=point, Mode=Int, Len=8 */
        int DimPntVal ;                                                /* Point
     value (often NId point) */
        unsigned short Bytes ;                                         /*
     Number of bytes in this binding list */
        unsigned short ValueCnt ;                                      /*
     Number of values */
        unsigned short ValueStart;                                     /*
     Starting index below for values */
        unsigned short DimStart ;                                      /* Index
     below to start of dim=value points */
        unsigned short PointCnt ;                                      /*
     Number of dim=value points */
        unsigned short PointStart ;                                    /* Start
     within Buffer below */
        int LUBindId ;                                                 /* Last
     used bind id for this list */
        unsigned char Buffer[V4DPI_BindList_BufMax] ;                  /* Data
     buffer (NOTE: Must be "int"
                                                                       aligned)
     */
    } ;
    #define V4DPI_IsctDimMax 30                                        /* Max
     number of dimensions in an intersection */
    struct V4DPI_BindList_Value
    {   struct V4DPI_Shortpoint sp ;                                   /* Bind
     point value (if sp.Bytes ==
                                                                       0 then
     sp.Value.IntVal is ValueId) */
        int BindWgt ;                                                  /*
     Binding Weight */
        unsigned char Bytes ;                                          /*
     Number of bytes (aligned) in this entry */
        unsigned char BindId ;                                         /*
     Binding Id for this value */
        unsigned char IndexCnt ;                                       /*
     Number of index entries below */
        unsigned char DimPos[V4DPI_IsctDimMax] ;                       /*,
     Position in DimEntryIndex below of
     dim=value associated with this value */
    } ;
    typedef struct V4DPI_BindList_Value BLV ;                          /* To
     make life easier */
    #define V4DPI_BindList_DimMax 500                                  /* Max
     dimensions below */
    struct V4DPI_BindList_Dim
    {   short DimCnt ;                                                 /*
     Number of dimensions indexed below */
        unsigned short DimEntryIndex[V4DPI_BindList_DimMax] ;          /* Index
     to dim==value point in
     BindList.Buffer */
    } ;
    struct V4DPI_BindpointVal                                          /*
     Format of Value for a Binding Point */
    {   unsigned short Dim ;                                           /*
     Dimension */
        unsigned short BindId ;                                        /*
     Binding Id in list */
        int DimPntVal ;                                                /* Point
     Value for binding list (these
                                                                       first 3
     fields used to form key) */
        unsigned short AreaId ;                                        /*
     AreaId of area containing binding list */
    } ;
    struct V4DPI_EvalList
    {   short Init ;                                                   /* TRUE
     if this has been initialized */
        short SkipCnt ;                                                /*
     Number of calls to skip before returning
                                                                       value (0
     to return value) */
        short RetumCnt ;                                               /*
     Number of times to return value */
        short AreaCnt ;                                                /*
     Number of areas below */
        short AreaMatch ;                                              /* Set
     by IsctEval to area/nbl below which
                                                                       finally
     matched */
        struct
        {   struct V4DPI_BindList *nbl ;                               /* Bind
     list for this area */
            struct V4DPI_BindList_Dim *nbld ;                          /*
     Pointer to dimension list */
            struct V4DPI_BindList_Value *nblv ;                        /*
     Pointer to current value in list */
            int Valx ;                                                 /*
     Current value index (0 thru nbl->ValueCnt) */
            int CurWgt ;                                               /*
     Weight of current contender (-1 pick
                                                                       next, 0=
     no more) */
            char DimTest[V4DPI_BindList_DimMax] ;                      /* By
     dimension in nbld, 0=no test, 1=test
                                                                       OK,
     -1=test False */
            int AreaId ;                                               /* Area
     ID */
        }   Area[16] ;
    } ;
    #define V4DPI_AreaBindInfo_Dim_Max 250                             /* Max
     number of dimensions in
                                                                       record
     below */
    struct V4DPI_AreaBindInfo
    {   union V4IS_KeyPrefix kp ;                                      /* Type
     = V4, Subtype=BindInfo,
     Mode=Int, Len=8 */
        int key ;                                                      /* 0 for
     now */
        unsigned short Bytes ;                                         /*
     Number of bytes in this record */
        short DimCnt ;                                                 /*
     Number of dimensions below */
        unsigned short DimsWithBind[V4DPI_AreaBindInfo_Dim_Max] ;      /* List
     of dimensions in
                                                                       area
     with bind records */
    } ;
    Evaluator Functionality
    struct kwlist
    {   int value ; char entry[15] ; } ;
        struct kwlist comlist[ ] = { { 1, "AREA" }, { 2, "BIND" }, {3,
     "CONTEXT"0 }, { 4,
                             "DIMENSION" },
                             { 5, "INCLUDE" }, { 6, "POINT" }, { 7, "=" }, { 8,
                             "BUCKET" }, { 9, "SET" },
                             { 10, "EXIT" }, { 11, "APPEND" }, { 12, "INSERT"
     }, { 13,
                             "{/" },
                             { 14, "DUMP" }, { 15, "EVALUATE" }, { 16, "IF" },
     { 17,
                             "ELSE" }, { 18, "ENDIF" },
                             { 19, "ARGUMENTS" }, { 20, "ECHO" }, { 21,
     "ELSEIF" }, {
                             22, "ERROR" },
                             { 23, "IF1" }, {-1, " "} } ;
        struct kwlist dimlist[ ] = { {0, ";"}, { 1, "ACCEPTOR" }, { 2,
     "BINDING" }, { 3,
                             "DISPLAYER" }, { 4, "MACRO" },
                             { 5, "MULTIPLE" },{ 6, "RANGE" }, { 8, "UNIQUE" },
     { 9,
                             "VERIFY" },
                             { 10, "INTERNAL" }, { 11, "EXTERNAL" }, { 12,
     "DIMENSION"
                             },
                             { 13, "HEIRARCHY" }, { 14, "CATEGORY" }, { 15,
     "REVIEW" },



                             { 16, "AUTOCONTEXT" }, {-1, " "}
                             } ;
        struct kwlist dimrlist[ ] = { { V4DPI_DimInfo_RelHReview_Const,
     "CONSTANT" },
                             {V4DPI_DimInfo_RelHReview_Area, "AREA" },
                             { V4DPI_DimInfo_RelHReview_Bind, "BINDING" }, {
     -1, " "}
                             } ;
        struct kwlist arealist[ ]= { { 1, "CREATE" }, { 2, "READ" }, { 3,
     "UPDATE" }, { 4,
                             "CLOSE" }, { 5, "CREATEIF" }, {-1, " "} } ;
        struct kwlist ahilist[ ]= { { 0, ";"}, { 1, "HEIRARCHY"}, { 2,
     "EXTDICTUPD"}, { 3,
                             "INTDICTUPD" }, { 4,"BINDINGUPD" },
                             { 5, "PRIMARY" }, { 6, "SLAVE" }, { 7,
     "CATEGORIES" }, {
                             8, "NOEXTDICTUPD" },
                             { 9, "NOINTDICTUPD" }, 10, "NOBINDINGUPD" }, { 11,
                             "NEWMACRO" }, { 12, "BUCKETSIZE" }, {-1," "}
                             } ;
        struct kwlist ctxlist[ ]= { { 1, "ADD" }, { 4, "EXAMINE" }, { 2, "POP"
     }, { 3,
                             "PUSH" }, {-1, " "} } ;
        struct kwlist setlist[ ] = { {0, ";"}, { 1, "ECHO" }, { 2, "NOECHO" },
     { 3, "RESULTS"
                             }, { 4, "NORESULTS" },
                             { 5, "TRACE"}, { 6, "NOTRACE" }, { 7, "MACROBIND"
     }, { 8,
                             "MACROCALL"}, { 9, "TEXTBIND"},
                             { 10, "PARAMETER"}, {-1, " "}
                             } ;
        struct kwlist iflist[ ]= { { 1, "DEFINED" }, { 2, "EMPTY" }, { 3,
     "SAME" }, { 4,
                             "NUMERIC" },
                             { -1, " " }
                             } ;
    struct kwlist pntlist[ ] = {
            { V4DPI_PntType_Char, "ALPHA" },
            { V4DPI_PntType_CmpndIsct, "COMPOUND" },
            { V4DPI_PntType_FrgnDataE1, "DATAEL" },
            { V4DPI_PntType_Dict, "DICTIONARY" },
            { V4DPI_PntType_Foreign, "FOREIGN" },
            { V4DPI_PntType_Int, "INTEGER" },
            { V4DPI_PntType_Isct, "INTERSECTION" },
            { V4DPI_PntType_IntMod, "INTMOD" },
            { V4DPI_PntType_PntIdx, "POINTINDEX" },
            { V4DPI_PntType_Shell, "SHELL" },
            { V4DPI_PntType_Special, "SPECIAL" },
            { V4DPI_PntType_FrgnStructE1, "STRUCTEL" },
            { V4DPI_PntType_V3Mod, "V3MOD"},
            { V4DPI_PntType_V3ModRaw, "V3MODRAW" },
            { V4DPI_PntType_Context, "CONTEXT" },
            { V4DPI_PntType_List, "LIST" },
            { V4DPI_PntType_Pragma, "PRAGMA" },
            { V4DPI_PntType_Me,Ptr, "MEMPTR" },
            { V4DPI_PntType_V3PicMod, "V3PICMOD" },
            { V4DPI_PntType_BigText, "BIGTEXT" },
            { V4DPI_PntType_PIntMod, "PINTMOD" },
            { V4DPI_PntType_Time, "TIME" },
            { V4DPI_PntType_Binding, "BINDING" },
            { V4DPI_PntType_Logical, "LOGICAL" },
            { -1, " "}
        } ;
    /* v4eval_Eval - Evaluates a text string */
    /* Call: xxx = v4eval_Eval( tcb , ctx , multeval , inittrace , initresult)
        where tcb is pointer to token control block (V4LEX_TknCtrlBLk)
            ctx is the current context,
            multeval is TRUE for multi-line evaluations, FALSE for single
     command,
            inittrace is initial trace setting,
            initresult is initial results setting
    v4eval_Eval(tcb,ctx,multeval,inittrace,initresult)
        struct V4LEX_TknCtrlBlk *tcb ;
        struct V4C_Context *ctx ;
        int multeval,inittrace,initresult
    ...
    eval_it: strcat(tbuf,".backslash.r") ; v4lex_InitTCB(&ttcb) ;
                            v4lex_NestInput(&ttcb,0,tbuf,V4LEX_InpMode_String)
                            ;
            v4dpi_PointParse(ctx,&isctpt,&ttcb) ; v4eval_ChkEOL(&ttcb) ;
            if (v4dpi_IsctEval(&valpt,&isctpt,ctx,NULLP,FALSE,&aid,NULLP) ==
     NULLP)
            v4_error(tcb, "V4","Eval","MACNOTDEF","No such macro currently
     defined: %s",cname) ;
    /*      Set up key for this entry */
            bt = (struct V4LEX_BigText *)v4mm_AllocChunk(sizeof *bt,FALSE) ;
            bt->kp.fld.KeyType = V4IS_KeyType_V4 ; bt->kp.fld.KeyMode =
                               V4IS_KeyMode_Int ;
            bt->kp.fld.Bytes = V4IS_IntKey_Bytes ; bt->kp.fld.AuxVal =
                               V4IS_SubType_BigText ; bt->Key =
                               valpt.Value.IntVal ;
            if (v4is_PositionKey(aid,bt,&btx,0,V4IS_PosDCKL) != V4RES_PosKey)
            v4_error(tcb,"V4","Eval","LOADMACFAIL","Could not load macro (%s)
     from
                               V4 area (%d)",cname,aid) ;
            strcpy(mname,cname) ;                                      /* Save
     name in case
                                                                       we may
     reference again */
            v4is_GetData(aid,bt,sizeof *bt,0)                          /* Copy
     into bt */
            if (gotfile)                                               /* If
     copying to file then do it */
            {   for(i=0;filename[i]!=0;i++) { filename[i] =
     tolower(filename[i]) ; }
                               ;
                if ((fp = fopen(v3_logical_decoder(filename,FALSE),(gotfile ==
                               V_OpCode_Rangle ? "w" : "a"))) == NULLP)
                v4_error(tcb,"V4","Eval","FOPENERR","Could not write/append to
     file
                               %s (%d)",filename,errno) ;
                fputs(bt->BigBuf,fp) ; fclose(fp) ;
            }   else                                                   /* If
     expanding macro then blow into lexical */
            {   v4lex_NestInput(tcb,NULLP,bt->BigBuf,V4LEX_InpMode_String) ;
                tcb->ilvl[tcb->ilx].arglist = (char
                               *)v4mm_AllocChunk(strlen(argbuf)+1) ;
                strcpy(tcb->ilvl[tcb->ilx].arglist,argbuf) ;     /* Copy
     argument list
                               into level buffer */
            } ;
            break ;
            case 0: /* End of line (i.e. blank) */ continue ;
            case 13: /* Got "{/" - Create a new "macro" or text entry */
             if (bt != NULLP) { memset(bt,0,sizeof *bt) ; }
             else { bt = (struct V4LEX_BigText *)v4mm_AllocChunk(sizeof
     *bt,FALSE)
                               ; } ;                                   /*
     Allocate temp buffer */
            v4lex_NextTkn(tcb,0) ;                                     /* Get
     macro/entry name */
            strcpy(mname,tcb->keyword) ;                            /* Copy
     name and any extra stuff till end of line (below) */
    /*      Parse rest of: {/macro [( argument name list)] "optional args" }
     < file
                               */
            gotnest = FALSE ; v4lex_NextTkn(tcb,V4LEX_Option_RetEOL) ;
            argbuf[0] = 0                                              /* Zap
     parameter name list */
            if (tcb->opcode == V_OpCode_LParen)
            {   strcpy(argbuf,"Argument ") ;                           /* Set
     up dummy command to handle arguments */
                for (i=0;i<V4LEX_Tkn_ArgMax;i++)
                {   v4lex_NextTkn(tcb,0) ;
                    if (tcb->type != V4LEX_TknType_Keyword)
                    v4_error(tcb,"V4","Eval","INVMACARGNAME","Not a valid macro
     argument name") ;
                    strcat (argbuf,tcb->keyword) ; strcat(argbuf," ") /*;
     Keep track of argument names */
                    v4lex_NextTkn(tcb,0) ; if (tcb->opcode ==
     V_OpCode_Comma) continue ;
                    if (tcb->opcode == V_Opcode_RParen) break ;
                    v4_error(tcb,"V4","Eval","INVMACARGTERM","Expecting comma
     or right
                               paren after argument name") ;
                } ; strcat(argbuf,";") ;
                v4lex_NextTkn(tcb,V4LEX_Option_RetEOL) ;
            } ;
            if (tcb->type == V4LEX_TknType_String)
            { strcpy(xdims,tcb->string) ;
     v4lex_NextTkn(tcb,V4LEX_Option_RetEOL) ;
                               } else { xdims[0] = 0 ; } ;
            if (tcb->opcode == V_OpCode_RBrace)
            {   v4lex_NextTkn(tcb,V4LEX_Option_RetEOL) ;
                if (tcb->opcode != V_OpCode_Langle)
                v4_error(tcb,"V4","Eval","MISSINGLBRKT","Expecting
     .backslash."<\" after
                               closing brace in macro/text declaration") ;
                v4lex NextTkn(tcb,V4LEX_Option_RetEOL) ;
                if (tcb->type == V4LEX_TknType_Keyword)
                {   for(i=strlen(tcb->keyword)-1;i>=0;i--) {
     tcb->keyword[i] =
                               tolower(tcb->keyword[i]) ; } ;
                    strcpy(tcb->string,tcb->keyword) ; strcat
     (tcb->string,".v4b") ;
                } ;
                if ((incfp =
     fopen(v3_logical_decoder(tcb->string,TRUE),"r")) == 0)
                v4_error(tcb,"V4","Eval","INVINCFILE","Could not access file to
                               INCLUDE %s (%d)",tcb->string,errno) ;
                gotnest = TRUE ; strcpy(tbuf,tcb->string) ;
            } ;
            v4eval_ChkEOL(tcb) ;                                       /*
     Verify EOL */
            if (gotnest) { v4lex_NestInput(tcb,incfp,tbuf,V4LEX_InpMode_File) ;
                               gotnest = tcb->ilx ; } ;
            tcb->need_input_line = TRUE ;                           /* Force
     to new line */
            if (strlen(textbind) > 0)                               /*
     Handle different depending on text/macro */
            {   for(mp=bt->BigBuf,*mp=NULLP,savemp=NULLP,nest=1;;)
                {   v4lex_ReadNextLine(tcb.1) ;
                    if (gotnest) { if (gotnest != tcb->ilx) break ; }
                    else { if
     (strncmp(tcb->ilvl[tcb->ilx].input_str,"}",1) == 0)
                               nest++
                         if
     (strncmp(tcb->ilvl[tcb->ilx].input_str,"!{",2) == 0)
                               nest++
                         if (strncmp(tcb->ilvl[tcb->ilx].input_str,"}",1)
     == 0)
                               nest-- ;
                         if (strncmp(tcb->ilvl[tcb->ilx].input_str,"!",2)
     == 0)
                               nest-- ;
                         if (nest <= 0) { tcb->need_input_line = TRUE ;
     break ; } ;
                      } ;
                    strcat(mp,tcb->ilvl[tcb>ilx].input_str) ; mp +=
     strlen(tcb-
                               >ilvl[tcb->ilx].input_str) ;
                } ; *mp = NULLP
            }   else
            {   mp = bt->BigBuf
                if (strlen(argbuf) > 0) { strcpy(mp,argbuf) ; mp +=
     strlen(argbuf) ; } ;
                *mp = 0 ;
                for (savemp=NULLP;;)
                (   v4lex_NextTkn(tcb,V4LEX_Option_ForceAsIs) ;
                    if (gotnest) { if (gotnest != tcb->ilx) break ; }
                    else { if (savemp != NULLP)                         /* Look
     for end of macro definition - 2 part process */
                           {   if (strcmp(tcb->string,mname) == 0)
                               { mp = savemp ; break ; } else { savemp = NULLP
     ; continue ; } ;
                           } ;
                           if (strcmp(tcb->string,"}/") == 0) savemp = mp ;
     /* (second part) */
                       } ;
                    strcat(mp,tcb->string) ; strcat(mp," ") ; mp +=
     (strlen(tcb->string)+1) ;
                } ; *(mp-1) = NULLP ;
            } ;
            bt->Bytes = (char *)mp - (char *)bt + 1 ;               /* Get
     length of the entry */
            if (strlen(macrobind) == 0 && strlen(textbind) == 0) break ; /* No
     "Set MacroBind"- then just save locally */
            strcpy(bindbuf,(strlen(macrobind) > 0 ? macrobind : textbind)) ;
            for (i=0,l=0;;i++)
            {   switch (bindbuf[i])
                {   case 0: tbuf[1] = 0 ; goto eval_it2 ;
                    case `*`: tbuf[1] = 0 ; strcat(tbuf,mname) ;
                           if (strlen(xdims) > 0) { strcat(tbuf," ") ;
                               strcat(tbuf,xdims) ; } ;
                           l = strlen(tbuf) ; break ;
                    default: tbuf[l++] = bindbuf[i] ; break ;
                } ;
            } ;
    eval_it2: strcat(tbuf,".backslash.r") ; v4lex_InitTCB(&ttcb)
                              v4lex_NestInput
     (&ttcb,0,tbuf,V4LEX_InpMode_String)
                              ;
              v4dpi_PointParse(ctx, &isctpt, &ttcb) ;
     v4dpi_PointParse(ctx,&valpt,&ttcb)
                               ;
              v4eval_ChkEOL(&ttcb) ;                                   /*
     Verify EOL */
              v4ctx_FrameAddDim(ctx,V4C_FrameId_Real,&valpt,0)         /* Add
     point to current context */
              v4dpi_BindListMake(&bindpt,&valpt,&isctpt,&nbl,ctx,&aid) ;
        /*    Set up key for this entry */
              bt->kp.fld.KeyType = V4IS_KeyType_V4 ; bt->kp.fld.KeyMode =
                                 V4IS_KeyMode_Int ; bt->kp.fld.Bytes =
                                 V4IS_IntKey_Bytes ;
              bt->kp.fld.AuxVal = V4IS_SubType_BigText ; bt->Key =
     valpt.Value.IntVal ;
    /*        Now write it all out */
     v4is_Insert(aid,bt,bt,bt->
     Bytes,V41S_PCB_DataMode_Data,V4IS_DataCmp_None,0,
              FALSE,FALSE,0) ;
              if (results) printf("Wrote macro %s to area
     %d.backslash.n",mname,aid) ;
              break
              case 11:                                                 /*
     APPEND [intersection] value */
              case 12:                                                 /*



     INSERT [intersection] value */
              v4dpi_PointParse(ctx,&isctpt,tcb) ;
              v4dpi_PointParse(ctx,&valpt,tcb) ;
              if (valpt.Grouping == V4DPI_Grouping_Current)            /* Pull
     value
                                                                       from
     context? {CONTEXT} */
              {   if ((dpt = v4ctx_DimValue(ctx,valpt.Dim,FALSE)) == NULLP)
                  v4_error(tcb,"V4","AppIns","PTNOTINCTX","Could not find value
     point in current context") ;
                  memcpy (&valpt,dpt,dpt->Bytes) ;
              } ;
              v4eval_ChkEOL(tcb) ;                                     /*
     Verify EOL */
              bind = (struct V4DPI_Binding
     *)v4dpi_IsctEval(&point,&isctpt,ctx,NULLP,trace,&a
                               id,NULLP) ;
              if (bind == NULLP) v4_error(0,"V4","Append","NOAPNDINSPT","No
     point
                               found to APPEND/INSERT to") ;
              memcpy(&bindpt,bind,bind->Bytes) ;                    /* Copy
     binding into temp buffer */
              bind = &bindpt ;
              dpt = (struct V4DPI_Point *)&bind->Buffer ;           /* Get
     pointer to list point */
              isct = (Struct V4DPI_Point *)&bind->Buffer[bind->IsctIndex]
     ;
              memcpy(&isctpt,isct,isct->Bytes) ;                    /* Copy
     intersection into temp */
              lp = (struct V4L_ListPoint *)&dpt->Value ;            /* Link
     to list */
              v41_ListPoint_Modify(lp,(cx==11 ? V4L_ListAction_Append :
                               V4L_ListAction_Insert),&valpt) ;
              dpt->Bytes = ALIGN((char
     *)&dpt->Value.AlphaVal[lp->Bytes] - (char
                               *)dpt) ;
              bind->IsctIndex = ALIGN(dpt->Bytes) ;              /* Get
     new offset for trailing intersection */
              memcpy(&bind->Buffer[bind->IsctIndex],&isctpt,isctpt.Bytes)
     ; /* Put intersection back */
              bind->Bytes = (char
     *)&bind->Buffer[bind->IsctIndex+isctpt.Bytes) -
                               (char *)bind ;
              Rewrite the binding back from whence it came */
              v4is_Replace (aid,bind,bind,bind,bind-
     >Bytes,V4IS_PCB_DataMode_Index,V4IS_DataCmp_None,0
                               ,0) ;
              if (results)
              { v4dpi_PointToString(&result,dpt,ctx,-1) ; printf("List =
                               %s.backslash.n",result) ; } ;
              break ;
              case 19:                                                 /*
     ARGUMENTS namelist */
              b = 0 ;                                                  /* Used
     to track if all start with same char */
              for(i=0;i<V4LEX_Tkn_ArgMax;i++)
              {   v4lex_NextTkn(tcb,V4LEX_Option_RetEOL) ;
                  if (tcb->type != V4LEX_TknType_Keyword) break ;
                  if (b == 0) { b = tcb->keyword[0] ; }
                  else { if (b != tcb->keyword[0]) b = TRUE ; };
                  strcpy(tcb->ilvl[tcb->ilx)
     .macarg[i].name,tcb->keyword) ; /* Just save in name list for this
     level */
              } ;
              tcb->ilvl[tcb->ilx].HaveMacroArgNames = b ;        /* Flag
     that we got names */
              break ;
              case 1:                                                  /* AREA
     mode [fileame options] */
              memset(&pcb,0,sizeof pcb) ;
              strcpy(pcb.V3name,"testu") ; pcb.BktSize = 8192
              pcb.DataMode = V4IS_PCB_DataMode_Auto ; pcb.AccessMode = -1 ;
              pcb.DfltPutMode = V4IS_PCB_GP_Insert ; pcb.MinCmpBytes = 500 ;
                               pcb.DfltDataMode = 500;
              memset(&ahi,0,sizeof ahi) ; ahi.IsPrimary = TRUE ;
                               strcpy(ahi.BindCatList, "KERNEL") ;
              ahi.BindingsUpd = TRUE ; ahi.IntDictUpd = TRUE ; ahi.ExtDictUpd =
     TRUE ;
              switch (v4eval_NextKeyWord(arealist,tcb))
              {   default: v4_error(tcb,"V4","Eval","INVAREAACCKW","Invalid
     AREA access
                               keyword: %s",tcb->keyword) ;
                  case 1: /* CREATE */ pcb.OpenMode = V4IS_PCB_OM_New ;
                               ahi.RelHNum = 5 ; break ;
                  case 2: /* READ */ pcb.OpenMode = V4IS_PCB_OM_Read ;
                               break ;
                  case 3: /* UPDATE */ pcb.OpenMode = V4IS_PCB_OM_Update ;
                               break ;
                  case 4: /* CLOSE */ v4ctx_AreaClose(ctx,-1) ; goto
                               end_area ;
                  case 5: /* CREATEIF */ pcb.OpenMode = V4IS_PCB_OM_NewIf ;
                               ahi.RelHNum = 5 ; break ;
              } ;

    itx_Point - Converting from V4 Point to Text
    Syntax
        itx_point(point, buffer, flags)
    point       a v4 point (V4Point)
    buffer      the text string/buffer to be updated (alpha)
    flags       any combination of standard itx flags (int)
    Description
        This module is used to convert a point from its internal representation
     (as a pointer)
        to a printable format.
    Example
        dcl v4point pt,*res;
        loop
        {xti_Point(tty_Get(`Eval?`),pt,0);res := v4_EvalPoint(pt);
         if sys_address(res) then
         {itx_Point(res;buf;0);p`The result is`,buf;};
        };
    /undefined_module/ - Auto-Loading Undefined Module
    Syntax
        v3_Set_Parameter(/undefined_module/, string)
    string      a V4 intersection to be evaluated whenever an
                undefined module is referenced. The string
                may contain one or more asterisks which are
                replaced with the actual module to be defined.
                (alpha)
    Description
        This format of the "v3_Set_Parameter" module is used to define a V4
     intersection
        "mask" which is to be expanded and evaluated whenever an undefined V3
     module is
        referenced.
    Example
        The example below causes V4 to substitute in the undefined module where
     the
        asterisk is, evaluate the resulting intersection and load the resulting
     module
        reference.
        v3_Set_Parameter(/undefined_module/,"[* Dim:Macro]");
    v4_AreaClose - Closing a V4 Area
    Syntax
        v4_AreaClose(areaid)
    areaid      the numeric area id to be closed (int)
    Description
        The "v4_AreaClose" module is used to close a V4 area that has been
     previously
        opened with the call "v4_AreaOpen". The area is closed and all
     references to the area
        are removed from the current context.
        Note that all areas are closed upon V3/V4 exit.
    Example
        id := v4_AreaOpen(`clientstuff`,nil);
        . . .
        v4_AreaClose(id);
    v4_AreaOpen - Opening a V4 Area
    Syntax
        areaid = v4_AreaOpen(filename, nil)
    filename    the name of the file to be opened as a V4 area
                (string)
    nil         "nil" indicates a default open to read-only (nil)
        The form above opens an existing V4 area for read-only access. The form
     below is a
        more generalized version and may be used to open existing areas for
     read/update and
        also to create new areas.
        areaid = v4_AreaOpen(filename, ahibuf)
    filename    the name of the file to be opened as a V4 area
                (string)
    ahibuf      a reference to the structure v4_ahi which
                contains information on the definition of an
                area. (V4C_AreaHInfo)
        The format below is the most general form:
        areaid = v4_AreaOpen(pcbbuf, ahibuf)
    pcbbuf      a reference to a v4_pcb structure which
                contains detailed information for declaring a
                new area file. (V4IS_ParControlBlk)
    ahibuf      a reference to the structure v4_ahi which
                contains information on the definition of an
                area. (V4C_AreaHInfo)
    Description
        The module, "v4_AreaOpen" is used to open a new or existing V4 area for
     access by
        the V4 multi-dimensional database. Several different modes of the call
     are available:
    Example
        v4_AreaOpen(`v3_syslib:v4kernel`,nil); /* Open V4 kernel, read only */
    v4_BigBufGet/v4_BigBufPut - Reading and Writing "Big Buffers"
    Syntax
        bytes = v4_BigBufGet(bufid, dstbuf)
    bytes       this module returns the number of bytes in
                the big buffer (int)
    bufid       the buffer identifier/key (int)
    dstbuf      the v3 string buffer to be updated with the
                "big buffer" (V4LEX_BigText)
        writing a "big buffer" is done with the following module:
        aid = v4_BigBufPut(bufid, srcbuf)
    aid         the area identifier indicating which area the
                "big buffer" was put into. (int)
    bufid       the buffer id to store (int)
    srcbuf      the v3 buffer to be stored. (V4LEX_BigText)
    Description
        A "big buffer" is an entry within a V4 area which contains one or more
     lines of text or
        any other data.
    Example
        dcl struct V4LEX_BigText bt;
        dcl sr text,sa;
        v4_AreaOpen("v3lib",nil);
        v4_BigBufGet("[V3_IOUNIT Dim:Macro]"),bt);
        loop(text==bt.bigbuf;str_len(text);)
        {sa == str_break(`.backslash.n`,text); p sa;};
    v4_BindPoint - Returns the V4 Point Corresponding to the Last Binding
    Syntax
        point = v4_BindPoint(dimid)
    point       the point corresponding to the last binding
                (v4point)
    dimid       a dimension of type Bind to be used for the
                returned point (v4point)
    Description
        This module returns the point corresponding to the last binding made
     within the
        current V4 environment.
    Example
        v4_Bind(point,value);
        bpoint := v4_BindPoint(v4_DimId(`Binding`));
    v4_Bind - Binding an Intersection to a Value
    Syntax
        aid = v4_Bind(intersection, value)
    aid         the area id where the binding was stored (int)
    intersection may be either a V4 point corresponding to an
                intersection or a text string in the format of a
                valid V4 intersection. (v4point/string)
    value       may be either a V4 point or a text string in
                the format of a valid V4 point.
                (v4point/string)
    Description
        The "v4_Bind" module is used to bind points in an intersection to a
     value point. The
        format of the call is:
    Example
        dcl v4point *isct,*val;
        xti_Point(tty_Get(`Enter Isct?`),isct,0);
        xti_Point(tty_Get(`and value?`),val,0);
        v4_Bind(isct,val);
    v4_Close - Closing a V4IS Area
    Syntax
        v4_Close(pcb)
    pcb         the V4IS area's parameter control block.
                (V4IS_ParControlBlk)
    Description
        Closes the V4IS area specified in the pcb.
    Example
        pcb.FileName := `important.dat`;
        pcb.OpenMode := xxx
        v4_Open(pcb);
        . . .
        v4_Close(pcb);
    v4_ContextAdd - Adding a Point to the Context
        Adding a new point or replacing a point for a dimension already in the
     context is done
        with:
    Syntax
          v4_ContextAdd(frameid, point))
    frameid     the id of the frame to which the point is to be
                added (use 0 for the current frame). (int)
    point       may be a V4 point or a text string
                representing a point. (v4point/string)
    Description
        Adds the specified point to the current context for the specified
     frame. In most cases,
        the point is to be added to the current frame which is referenced via
     frameid 0. If a
        point already exists in the context with the same dimension then it is
     replaced by the
        new point.
    Example
        v4_ContextAdd(0,`Client:ABC`);
        xti_Point(`Vendor:1233`,pt,0);
        v4_ContextAdd(0,pt);
    v4_ContextPop - Popping of a Context Frame
    Syntax
        v4_ContextPop(framenum)
    framenum    the framenumber to be popped off. Note that
                all frames pushed after this framenumber will
                also be popped. (int)
    Description
        This module pops off one or more frames from the current context. If
     framenum is
        given and nonzero then all frames up to the specified frame are popped.
    Example
        framenum := v4_ContextPush(`Level12`);
        . . .
        v4_ContexPop(framenum);
    v4_ContextPush - Pushing a new Context Frame
    Syntax
        frameid = v4_ContextPush(framename)
    frameid     the unique frame number generated for this
                context push. (int)
    framename   a text string naming this frame. Frame names
                do not necessarily have to be unique. (string)
    Description
        This module pushes a new frame with a name of framename onto the
     current V4
        context. The frameid is returned and may be used in subsequent context
     calls.
    Example
        framenum := v4_ContextPush(str_concat(Level),lvl+=1);
    v4_DataElVal - Extracting a Value from a Buffer
    Syntax
        value = v4_DataELVal(buffer, des/despt)
    value       the resulting V3 value extracted from buffer
    buffer      usually a record buffer containing multiple
                fields (alpha)
    des         a data element descriptor or point (v4point)
    Description
        This module is used to extract a value (i.e. field) from a buffer based
     on the field's
        data element structure.
    v4_DimGet - Obtaining the Dimension ID
    Syntax
        dimid = v4_DimGet(dimname)
        dimid = v4_DimGet(point)
    dimid       the dimension's numeric id (int)
    dimname     the text name of the dimension (string)
    point       the dimension id corresponding to any V4
                point can also be obtained. (v4point)
    Description
        This module returns the dimension id associated with a dimension name
     or returns
        the dimension id for a specific point.
    Example
        xti_Point(tty_get("Enter Point?"),point,0);
        dimid := v4_DimGet(point);
    v4_DimMake - Creating a New Dimension
    Syntax



        dimid = v4_DimMake(diminfo)
    dimid       the new dimension's unique numeric identifier
                (int)
    diminfo     the structure which defines the new
                dimension. (V4DPI_DimInfo)
    Description
        New dimensions can be created with this call. The argument, diminfo,
     must be
        properly set or all sorts of ugly errors can occur.
    Example
        del struct V4DPI_DimInfo di;
        di.DimName := `Customer`;di.PointType := #V4DPI_PntType_Integer;
        di.UniqueOK := /true/;
        v4_DimMake(di);
    v4_Eval & v4_EvalPoint - Evaluating an Intersection
    Syntax
        logical = v4_Eval(updateval, isctpt/string)
    logical     (int)
    updateeval
    isct        (v4point/string)
        The second call is more general and simply returns a V4 point
     corresponding the
        value of the intersection:
        valpt = v4_EvalPoint(isctpt/string)
    valpt       the value of the evaluated intersection
                (v4point)
    isctpt      an intersection or string to be converted to an
                intersection (v4point/string)
    Description
        The evaluation of an intersection can be done through one of two calls.
     The first call
        is the more convenient form in that it updates a V3 variable with the
     result
        (performing the necessary conversions from V4 to V3:
    v4_Get - Getting a V4IS Record
        The module, "v4_Get" is used to read a record from a V4IS area:
    Syntax
        v4_Get(pcb)
    pcb   the area's parameter control block
          (V4IS_ParControlBlk)
    Description
        Gets a record from the specified area.
    Example
        pcb.DfltGetBuf == iobuf; pcb.DfltGetMode := V4IS_PCB_GP_Next;
        v4_Get(pcb);/* Read "next" record */
    v4_IsctMake - Making an intersection
    Syntax
        point = v4_IsctMake(src, appndpt)
    point       the point corresponding to the intersection
                (v4point)
    src         the base intersection to be appended to or nil
                to start a new intersection (V4point/nil)
    appndpt     the point to be appended (v4point)
    Description
        V4 intersections can be built up, point by point, with this module. To
     create a new
        intersection, first call with src equal to nil. To add points to the
     intersection, call the
        module with the point returned on the first call.
    Example
        isct := v4_IsctMake(nil,pt1); /* Create new isct */
        v4_IsctMake(isct,pt2);   /* Append second point */
    v4_Open - Opening a V4IS Area
    Syntax
        v4_Open(pcb)
    pcb         the area parameter control block
                (V4IS_ParControlBlk)
    Description
        V4IS areas are created or opened for input/output with this call. See
     the definition of
        the parameter control block at the end of this manual for more
     information.
    v4_PointCopy - Copying a V4 Point
    Syntax
        v4_PointCopy(dstpoint, srcpoint)
    dstpoint    the point to be updated (v4point)
    srcpoint    the point to be copied (v4point)
    Description
        This module copies a point. Its main use is for copying points returned
     by many of the
        v4_xxx modules. These points have a limited lifetime and if a point is
     needed for an
        extended period of time then it should be copied into a more permanent
     home.
        Note that if dstpoint is an uninitialized pointer then space will be
     allocated and
        assigned to it before the copy.
    v4_PointMake - Making a V4 Point
    Syntax
        point = v4_PointMake(src, dimnum, value [,endvalue])
    point       a reference to the resulting point (v4point)
    src         nil to create a new point, or an existing point
                to be updated with a new value/range
                (v4point/nil)
    dimnum      the dimension id for this point (int)
    value       the value for this point or . . . (int/string)
    endvalue    if endvalue is specified the value becomes
                "value . . . endvalue" (int/string)
    Description
        This module is used to create a point with a single value or multiple
     value through
        multiple calls to the module.
    Example
        newpt := v4_PointMake(nil,v4_DimId(`Months`),9301,9302);
        v4_PointMake(newpt,nil,9305);
        v4_PointMake(newpt,nil,9307,9312);
        itx_Point(newpt,buf,0);
        p buf;
        Months:9301 . . . 9302,9305,9307 . . . 9312
    v4_PointRemove - Removing a Point from an Area
    Syntax
        v4_PointRemove(point)
    point       the point to be removed (v4point)
    Description
        This module attempts to remove the specified point for the current V4
     runtime
        environment. Currently only one type of point can be removed - a
     binding point.
    Example
        v4_Bind(isct,value);
        bindpt := v4_BindPoint(xxx);
        . . .
        v4_PointRemove(bindpt); /* Remove the binding point */
    v4_Put - Writing a V4IS Record
    Syntax
        v4_Put(pcb)
    pcb         the parameter control block for the area.
                (V4IS_ParControlBlk)
    Description
        Inserts, replaces or deletes a record based on parameters specified in
     the pcb.
    Example
        pcb.PutBuf == iobuf; pcb.PutMode := _V4IS_PCB_GP_Keyed;
        v4_Put(pcb);
    v4_ScanForDim - Scanning Areas for a Pattern
    Syntax
        handle = v4_ScanForDim(handle, dimid, filterisct, isct, val, misct,
     xisctp)
    handle      the dimension's numeric id (int)
    dimid       the text name of the dimension (int)
    filterisct  an intersection to act as a filter. Only
                intersections containing all of the points in
                this point will be matched. (v4point)
    isct        this is updated with the intersection for the
                current match (v4point)
    val         this is updated with the value of the current
                match (v4point)
    misct       if given, this is updated with the points in isct
                which were matched filterisct (v4point)
    xisctp      if given, this is updated with the points in isct
                which were not matched. (v4point)
    Description
        The module below is used to scan all open areas in the current context
     for bindings
        containing a particular dimension:
    v4_SetTrace - Controlling the "trace" Facility
    Syntax
        oldset = v4_SetTrace(newset)
    oldset      the trace setting prior to this call (int)
    newset      the new trace setting. See below for values.
                (int)
    Description
        Sets the V4 tracing facilities based on the argument. The trace can be
     enabled in a
        variety of modes as described in the table below
    Example
        oldsetting := v4_SetTrace(/true/);
    v4_ValueGet - Updating a V3 Value with a V4 Point Value
    Syntax
        logical = v4_ValueGet(u3dst, point)
    logical     True if the module succeeds, False otherwise.
                (int)
    v3dst       any V3 variable
    point       a point to have value extracted. (v4point)
    Description
        This module is used to extract the "value" portion of a point, convert
     it to V3 format
        and update the u3dst with the value.
    xti_Point - Converting a V3 String to a V4 Point
    Syntax
        xti_point(buffer, point, flags)
    buffer      a text buffer describing the point (string)
    point       a V3 variable declared as either a pointer or
                V4 point. (v4point)
    flags       (int)
    Description
        Converts the text buffer to a V4 point. The second argument must be
     declared as
        either a pointer or a V4 point. If given as an unitialized pointer
     (i.e. sys_address is 0)
        then memory will be automatically allocated for the point.
    mod_Unload - Unloading a V3 Module from the Current Runtime Environment
    Syntax
        mod_Unload(modulen)
    module      the name of the V3 module to be unloaded
                (string)
    Description
        Unloads the module specified from the current V3 environment. The
     module must
        have been previously loaded as a stand-alone PIC module (i.e. not as
     part of a
        package).
    Example
        mod_Unload(`exec_sec_login`);

        mode      how the area is to be opened, Create to create a new
                  area, Read to read an existing area, Update to read
                  and/or update an existing area, CreateIf to create an
                  area if it does not already exist, and Close to close an
                  area.
        filename  the name of the area
        options   a list of options when creating a new area

    Hierarchy number     Assigns the area to a hierarchy. This is a
                         number from 1 to 7. The V4 kernel is always
                         number 1.
    ExtDictUpd           Allow external dictionary updates.
    IntDictUpd           Allow internal dictionary updates.
    BindingUpd           Allow binding updates.
    Primary              A primary area
    Slave                A slave area.
    Categories list      Categories are as listed
    NoExtDictUpd         Do not permit external dictionary updates
    NoIntDictUpd         Do not permit internal dictionary updates
    NoBindingUpd         Do not permit bindings
    NewMacro macroname   Specifies a macro to be invoked whenever the
                         area is created (for use with the CreateIf mode).
    BucketSize bytes     Specifies the bucket size of the area. The
                         total number of bindings permitted to a binding
                         point is indirectly related to the bucket size.
                         In most cases the default bucket size should
                         be acceptable.

    name          the name of the dimension
    type          the dimension type or how the dimension is to be used
    attributes    a list of optional attributes

    Alpha       A character string
    BigText     A large, multi-line chunk of text
    Binding     A V4 Binding
    Compound    A compound intersection used in iterations
    Context     A context point, expanded into components upon evaluation
    DataEl      A data element specification (the offset, length, datatype,
                etc.)
    Dictionary  A dictionary point-stored as a number, displayed as a
                keyword
    Foreign     A foreign data structure
    Integer     An integer number
    Intersection An intersection
    IntMod      An internal module
    List        A list of values
    Logical     A logical (true/false) value
    MemPtr      A memory pointer
    PIntMod     A partial internal module
    PointIndex  A number representing a V4-allocated datastructure
    Pragma      A pragmatic point (usually invisible)
    Shell       A shell point, values are other points
    Special     Points specified with the "{xxx}" construct
    StructEL    A structure specification
    Time        A time or transaction point
    V3Mod       A link to a V3 module
    V3PicMod    A link to the PIC definition of a V3 module
    V3ModRaw    A link to a V3 module

    Acceptor module   Defines a V3 acceptor module for the dimension.
    AutoContext point Defines a V4 point to be used in auto-context look-
                      ups. See below for more information on this feature
    Binding num       Assigns a binding weight number to this dimension.
                      See below for more information.
    Displayer module  Defines a V3 displayer module for this dimension
    Macro string      Declares a macro string to be used when creating
                      points. Not currently used.
    Multiple logical  Allows multiple values to be specified as a single
                      point (ex: dim:a,b,c)
    Range logical     Allows a range of values to be specified as a single
                      point (ex: dim:a . . . b)
    Unique            Allows the user to create new points on this
                      dimension with the (new) construct.
    Verify            Not currently used
    Internal          Who knows
    External          Opposite of Internal
    Dimension         Who knows
    Heirarchy n       Specifies the Heirarchy for this dimension
    Category xxx      Not currently used
    Review how        Not currently used

                         Dimension Types
    Alpha       A character string
    BigText     A large, multi-line chunk of text
    Binding     A V4 Binding
    Compound    A compound intersection used in iterations
    Context     A context point, expanded into components upon evaluation
    DataEl      A data element specification (the offset, length, datatype,
                etc.)
    Dictionary  A dictionary point-stored as a number, displayed as a
                keyword
    Foreign     A foreign data structure
    Integer     An integer number
    Intersection An intersection
    IntMod      An internal module
    List        A list of values
    Logical     A logical (true/false) value
    MemPtr      A memory pointer
    PIntMod     A partial internal module
    PointIndex  A number representing a V4-allocated datastructure
    Pragma      A pragmatic point (usually invisible)
    Shell       A shell point, values are other points
    Special     Points specified with the "{xxx}" construct
    StructEL    A structure specification
    Time        A time or transaction point
    V3Mod       A link to a V3 module
    V3PicMod    A link to the PIC definition of a V3 module
    V3ModRaw    A link to a V3 module

    struct V4DPI_BindPointVal        /* Format of Value for a
    */                               Binding Point
    {unsigned short Dim ;            /* Dimension */
    unsigned short BindId ;          /* Binding Id in list */
    int DimPntVal ;                  /* Point Value for binding list
    (these first 3 fields used to form key) */
    unsigned short AreaId ;          /* AreaId of area containing
    binding list */
    } ;

        fileref     the file reference number
        element     the element number for this field
        name        the name of this field
        dimname     the dimension name (or V3 object name)
        v3datatype  the V3 datatype code (see /DT_xxx/)
        keynum      the key number if field is a key
        owner       the structure id owning this field
        offset      the offset within the owner structure
        bytes       the number of bytes for this field
        decimals    the number of decimal places implied in this field

        fileref     the file reference number
        structnum   a unique structure number
        element     a unique element number
        bytes       the total number of bytes in one occurrence of this
                    structure
        occurs      the total number of times this structure occurs in
                    parent
        countfield  a reference to a count field (if one exists)
        offset      the starting offset in the parent structure

        v3mod   is a dimension of type V3Mod
        module  is the name of the V3 module to be called
        result  is the dimension of the returned value from V3. The V4
                evaluator converts the V3 value into a format consistent
                with this dimension
        argpt   arguments to be passed to the V3 module. These are
                converted from V4 formats to V3 formats.