/**************************************************************************** ** *A record.h GAP source Martin Schoenert ** *A @(#)$Id: record.h,v 3.7 1992/01/06 14:03:27 martin Rel $ ** *Y Copyright 1990-1992, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany ** ** This file declares the functions for computing with records. ** *H $Log: record.h,v $ *H Revision 3.7 1992/01/06 14:03:27 martin *H changed the implementation of '~' slightly *H *H Revision 3.6 1992/01/02 14:44:34 martin *H added magic variable '~' *H *H Revision 3.5 1992/01/02 13:12:28 martin *H changed 'Backtrace' to handle binary operators *H *H Revision 3.4 1991/05/29 15:28:29 martin *H added record operation 'in' *H *H Revision 3.3 1991/05/29 15:27:10 martin *H changed the record operations function names to '+', '-', etc. *H *H Revision 3.2 1991/05/29 15:25:35 martin *H changed the record operations to look at the right operand first *H *H Revision 3.1 1991/04/30 16:12:43 martin *H initial revision under RCS *H */ /**************************************************************************** ** *F EvRec( ) . . . . . . . . . . . . . . . . . . . evaluate a record ** ** 'EvRec' evaluates the record . Since records are constants and ** thus selfevaluating this simply returns . */ extern TypHandle EvRec P(( TypHandle hdRec )); /**************************************************************************** ** *V HdTilde . . . . . . . . . . . . . . . . . . . . . . . . . . variable '~' ** ** 'HdTilde' is the handle of the variable bag of the variable '~'. This ** variable can be used inside record and list literals to refer to the list ** or record that is currently being created. So for example '[ ~ ]' is the ** list that contains itself as only element. */ extern TypHandle HdTilde; /**************************************************************************** ** *F EvMakeRec() . . . evaluate record literal to record constant ** ** 'EvMakeRec' evaluates the record literal, i.e., not yet evaluated, record ** to a constant record. ** ** 'EvMakeRec' just calls 'MakeRec' telling it that the result goes into the ** variable '~'. Thus expressions in the variable record can refer to this ** variable and its subobjects to create objects that are not trees. */ extern TypHandle EvMakeRec P(( TypHandle hdLiteral )); /**************************************************************************** ** *F MakeRec(,,) . evaluate record literal to constant ** ** 'MakeRec' evaluates the record literal to a constant one and ** puts the result into the bag at position . is ** either the variable '~', a list, or a record. ** ** Because of literals like 'rec( a := rec( b := 1, c := ~.a.b ) )' we must ** enter the handle of the result into the superobject before we begin to ** evaluate the record literal. ** ** A record literal is very much like a record, except that at the even ** places the do not yet contain the values of the components, but ** expressions, which yield the elements. Evaluating a record literal thus ** means looping over the components, copying the names at the odd entries ** and evaluating the values at the even entries. */ extern TypHandle MakeRec P(( TypHandle hdDst, unsigned long ind, TypHandle hdLiteral )); /**************************************************************************** ** *F EvRecElm( ) . . . . . . . . . . . . . . . . get a record element ** ** 'EvRecElm' returns the value of 'PTR()[0] . PTR()[1]'. ** ** ' . ' ** ** This evaluates to the value of the record element with the name in ** the record . It is an error if the record has no ** element with the name . ** ** 'EvRecElm' simply iterates over the record looking for the record name. ** If it is found the corresponding value is returned. Note that it is ** not neccessary to compare the strings of the record names since every ** record name is store in a unique record name bag, i.e., no two record ** name bags have the same string. Thus we can simply compare handles. */ extern TypHandle EvRecElm P(( TypHandle hdElm )); /**************************************************************************** ** *F EvRecAss( ) . . . . . . . . . assign a value to a record element ** ** 'EvRecAss' assigns the value 'EVAL( [1] )' to the element with ** the name '[0][1]' in the record '[0][0]'. ** ** '. := ;' ** ** This assigns the value of the expression to the element with the ** name in the record . Further references to this element ** will return this new value, until another assignment is performed. If ** the record has no element with the name it is automatically ** extended. */ extern TypHandle EvRecAss P(( TypHandle hdAss )); /**************************************************************************** ** *F SumRec( , ) . . . . . . . . . . . . . . . . sum of two record *V HdCallSum . . . . . . . . . . . . . handle of the 'sum' function call bag ** ** 'SumRec' returns the sum of the two operands and , of which at ** least one must be a record. ** ** ' + ' ** ** The sum of two records or an object and a record is defined as follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '+', which is a function, ** or if the left operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '+' which is a function, ** then this function is called with and as arguments ** and ' + ' is the value returned by this function. ** ** In all other cases an error is raised. */ extern TypHandle SumRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallSum; /**************************************************************************** ** *F DiffRec( , ) . . . . . . . . . . . . difference of two record *V HdCallDiff . . . . . . . . . . . handle of the 'diff' function call bag ** ** 'DiffRec' returns the difference the of two operands and , of ** which at least one must be a record. ** ** ' - ' ** ** The difference of two records or an object and a record is defined as ** follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '-', which is a function, ** or if the left operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '-' which is a function, ** then this function is called with and as arguments ** and ' - ' is the value returned by this function. ** ** In all other cases an error is raised. */ extern TypHandle DiffRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallDiff; /**************************************************************************** ** *F ProdRec( , ) . . . . . . . . . . . . . . product of two record *V HdCallProd . . . . . . . . . . . handle of the 'prod' function call bag ** ** 'ProdRec' returns the product of the two operands and , of ** which at least one must be a record. ** ** ' * ' ** ** The product of two records or an object and a record is defined as ** follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '*', which is a function, ** or if the left operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '*' which is a function, ** then this function is called with and as arguments ** and ' * ' is the value returned by this function. ** ** In all other cases an error is raised. */ extern TypHandle ProdRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallProd; /**************************************************************************** ** *F QuoRec( , ) . . . . . . . . . . . . . quotient of two record *V HdCallQuo . . . . . . . . . . . . . handle of the 'quo' function call bag ** ** 'QuoRec' returns the quotient of the two operands and , of ** which at least one must be a record. ** ** ' / ' ** ** The quotient of two records or an object and a record is defined as ** follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '/', which is a function, ** or if the left operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '/' which is a function, ** then this function is called with and as arguments ** and ' / ' is the value returned by this function. ** ** In all other cases an error is raised. */ extern TypHandle QuoRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallQuo; /**************************************************************************** ** *F ModRec( , ) . . . . . . . . . . . . . remainder of two record *V HdCallMod . . . . . . . . . . . . . handle of the 'mod' function call bag ** ** 'ModRec' returns the remainder of the two operands and , of ** which at least one must be a record. ** ** ' mod ' ** ** The remainder of two records or an object and a record is defined as ** follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element 'mod', which is a function, ** or if the left operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element 'mod' which is a function, ** then this function is called with and as arguments ** and ' mod ' is the value returned by this function. ** ** In all other cases an error is raised. */ extern TypHandle ModRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallMod; /**************************************************************************** ** *F PowRec( , ) . . . . . . . . . . . . . . . power of two record *V HdCallPow . . . . . . . . . . . . . handle of the 'pow' function call bag ** ** 'PowRec' returns the power of the two operands and , of which ** at least one must be a record. ** ** ' ^ ' ** ** The power of two records or an object and a record is defined as follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '^', which is a function, ** or if the left operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '^' which is a function, ** then this function is called with and as arguments ** and ' ^ ' is the value returned by this function. ** ** In all other cases an error is raised. */ extern TypHandle PowRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallPow; /**************************************************************************** ** *F CommRec( , ) . . . . . . . . . . . . commutator of two record *V HdCallComm . . . . . . . . . . . handle of the 'comm' function call bag ** ** 'CommRec' returns the commutator of the two operands and , of ** which at least one must be a record. ** ** 'Comm( , )' ** ** The commutator of two records or an object and a record is defined as ** follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element 'comm', which is a function, ** or if the left operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element 'comm' which is a function, ** then this function is called with and as arguments ** and ' + ' is the value returned by this function. ** ** In all other cases an error is raised. */ extern TypHandle CommRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallComm; /**************************************************************************** ** *F EqRec( , ) . . . . . . . . . . . test if two record are equal *V HdCallEq . . . . . . . . . . . . . handle of the 'eq' function call bag ** ** 'EqRec' returns 'HdTrue' two operands and , of which at least ** one must be a record, are equal and 'HdFalse' otherwise. ** ** ' = ' ** ** The equal of two records or an object and a record is defined as follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '=', which is a function, ** or if the left operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '=' which is a function, ** then this function is called with and as arguments ** and ' = ' is the value returned by this function. ** ** In all other cases the operands are considered equal if both are records ** and they have the same names and all corresponding elements equal. */ extern TypHandle EqRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallEq; /**************************************************************************** ** *F LtRec( , ) . . . . . . test if one record is less than another *V HdCallLt . . . . . . . . . . . . . handle of the 'lt' function call bag ** ** 'LtRec' returns 'HdTrue' the operand is less than the operand ** and 'HdFalse' otherwise . At least one of the operands must be a record. ** ** ' < ' ** ** The lt of two records or an object and a record is defined as follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '<', which is a function, ** or if the left operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element '<' which is a function, ** then this function is called with and as arguments ** and ' < ' is the value returned by this function. ** ** In all other cases the operands are considered ltual if both are records ** and they have the same names and all corresponding elements ltual... */ extern TypHandle LtRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallLt; /**************************************************************************** ** *F InRec( , ) . . . . . . . . . . test if a record is in another *V HdCallIn . . . . . . . . . . . . . handle of the 'in' function call bag ** ** 'InRec' returns 'HdTrue' the operand is in the operand and ** 'HdFalse' otherwise . At least the right operand must be a record. ** ** ' in ' ** ** The 'in' of two records or an object and a record is defined as follows: ** ** If the right operand is a record ** and is has a element with the name 'operations', which is a record, ** and this record has a element 'in', which is a function, ** then this function is called with and as arguments ** and ' in ' is the value returned by this function. ** ** In all other cases an error is raised. */ extern TypHandle InRec P(( TypHandle hdL, TypHandle hdR )); extern TypHandle HdCallIn; /**************************************************************************** ** *F PrRec( ) . . . . . . . . . . . . . . . . . . . . print a record *V HdCallPrint . . . . . . . . . . . handle of the 'print' function call bag ** ** 'PrRec' prints the record with the handle . ** ** If has an element 'operations' which is a record ** and this record as an element 'print' which is a function ** then this function is called with as argument and should print it ** ** In all other cases the record is printed in the following form: ** ** 'rec( := ,... )' ** ** 'PrRec' is also called to print variable records, i.e., records that have ** not yet been evaluated. They are always printed in the second form. */ extern void PrRec P(( TypHandle hdRec )); extern TypHandle HdCallPrint; /**************************************************************************** ** *F PrRecElm( ) . . . . . . . . . . . . . . . print a record element ** ** 'PrRecElm' prints the record element in the following form: ** ** ' . ' */ extern void PrRecElm P(( TypHandle hdElm )); /**************************************************************************** ** *F PrRecAss( ) . . . . . . . . . . . . . . print a record assignment ** ** 'PrRecAss' prints the record assignment in the form: ** ** '. := ;' */ extern void PrRecAss P(( TypHandle hdAss )); /**************************************************************************** ** *F InitRec() . . . . . . . . . . . . . . . . intitialize the record package ** ** 'InitRec' initializes the record package. */ extern void InitRec P(( void )); /**************************************************************************** ** *E Emacs . . . . . . . . . . . . . . . . . . . . . . . local emacs variables ** ** Local Variables: ** mode: outline ** outline-regexp: "*F\\|*V\\|*T\\|*E" ** fill-column: 73 ** fill-prefix: "** " ** eval: (local-set-key "\t" 'c-indent-command) ** eval: (local-set-key ";" 'electric-c-semi ) ** eval: (local-set-key "{" 'electric-c-brace) ** eval: (local-set-key "}" 'electric-c-brace) ** eval: (hide-body) ** End: */