Occam 2 syntax tree tree access functions 30 Mar 1990

All 'selector' functions for attribute X are of the form XOf(node).
All 'modifier' functions for attribute X are of the form SetX(node, value).
All 'address'  functions for attribute X are of the form XAddr(node).


/*{{{  tag and location*/
int  TagOf(treenode *T)
void SetTag(treenode *T, int V)

SOURCEPOSN LocnOf(treenode *T)
void SetLocn(treenode *T, SOURCEPOSN V)

int FileLineOf(SOURCEPOSN L)
int FileNumOf(SOURCEPOSN *L)

SOURCEPOSN SetFileLine(SOURCEPOSN L, int M)
SOURCEPOSN SetFileNum(SOURCEPOSN L, int M)
/*}}}*/

/*{{{  actionnode*/
treenode *newactionnode (int t, SOURCEPOSN ln, treenode *l, treenode *r);

treenode * LHSOf(treenode *T)
treenode * RHSOf(treenode *T)

void SetLHS(treenode *T, treenode *V)
void SetRHS(treenode *T, treenode *V)

treenode ** LHSAddr(treenode *T)
treenode ** RHSAddr(treenode *T)
/*}}}*/

/*{{{  altnode*/
treenode *newaltnode (int t, SOURCEPOSN ln, treenode *g,
                             treenode *i, treenode *b);

treenode * AltGuardOf(treenode *T)
treenode * AltInputOf(treenode *T)
treenode * AltBodyOf(treenode *T)

void SetAltGuard(treenode *T, treenode *V)
void SetAltInput(treenode *T, treenode *V)
void SetAltBody(treenode *T, treenode *V)
void SetAltP1(treenode *T, BIT32 V)

treenode ** AltGuardAddr(treenode *T)
treenode ** AltInputAddr(treenode *T)
treenode ** AltBodyAddr(treenode *T)
/*}}}*/

/*{{{  These are the names for a array constructor node */
treenode * ACNameOf(treenode *T)
treenode * ACStartExpOf(treenode *T)
treenode * ACLengthExpOf(treenode *T)
treenode * ACValExpOf(treenode *T)

void SetACName(treenode *T, treenode *V)
void SetACStartExp(treenode *T, treenode *V)
void SetACLengthExp(treenode *T, treenode *V)
void SetACValExp(treenode *T, treenode *V)

treenode ** ACNameAddr(treenode *T)
treenode ** ACStartExpAddr(treenode *T)
treenode ** ACLengthExpAddr(treenode *T)
treenode ** ACValExpAddr(treenode *T)
/*}}}*/

/*{{{  arraynode*/
treenode *newarraynode (int t, SOURCEPOSN ln, treenode *d, treenode *tp);

treenode * ARDimLengthOf(treenode *T)
treenode * ARTypeOf(treenode *T)
INT32      ARDimOf(treenode *T)

void SetARDimLength(treenode *T, treenode *V)
void SetARType(treenode *T, treenode *V)
void SetARDim(treenode *T, INT32 V)

treenode ** ARDimLengthAddr(treenode *T)
treenode ** ARTypeAddr(treenode *T)
INT32     * ARDimAddr(treenode *T)
/*}}}*/

/*{{{  arraysubnode*/
treenode *newarraysubnode (int t, SOURCEPOSN ln, treenode *base, treenode *index);

treenode * ASBaseOf(treenode *T)
treenode * ASIndexOf(treenode *T)
treenode * ASExpOf(treenode *T)    /* S_ARRAYITEM only */
BIT32      ASOffsetOf(treenode *T) /* S_ARRAYITEM only */
treenode * ASLengthOf(treenode *T) /* S_ARRAYITEM only */

void SetASBase(treenode *T, treenode *V)
void SetASIndex(treenode *T, treenode *V)
void SetASExp(treenode *T, treenode *V)
void SetASOffset(treenode *T, BIT32 V)
void SetASLength(treenode *T, treenode *V)

treenode ** ASBaseAddr(treenode *T)
treenode ** ASIndexAddr(treenode *T)
treenode ** ASExpAddr(treenode *T)
BIT32     * ASOffsetAddr(treenode *T)
treenode ** ASLengthAddr(treenode *T)

#ifdef SIC
treenode * ASTempOf(treenode *T)
void SetASTemp(treenode *T, treenode *V)
treenode ** ASTempAddr(treenode *T)
#endif
/*}}}*/

/*{{{  channode*/
treenode *newchannode (int t, SOURCEPOSN ln, treenode *p);

treenode * ProtocolOf(treenode *T)

void SetProtocol(treenode *T, treenode *V)

treenode ** ProtocolAddr(treenode *T)
/*}}}*/

/*{{{  cnode*/
treenode *newcnode (int t, SOURCEPOSN ln, treenode *b);

treenode * CBodyOf(treenode *T)
treenode * CTempOf(treenode *T)

void SetCBody(treenode *T, treenode *V)
void SetCTemp(treenode *T, treenode *V)

treenode ** CBodyAddr(treenode *T)
/*}}}*/

/*{{{  condnode*/
treenode *newcondnode (int t, SOURCEPOSN ln, treenode *condition,
                              treenode *process);

treenode * CondGuardOf(treenode *T)
treenode * CondBodyOf(treenode *T)

void SetCondGuard(treenode *T, treenode *V)
void SetCondBody(treenode *T, treenode *V)

treenode ** CondGuardAddr(treenode *T)
treenode ** CondBodyAddr(treenode *T)
/*}}}*/

/*{{{  condexpnode  !!!! NOT USED !!!!*/
treenode *newcondexpnode (int t, SOURCEPOSN ln,
                          treenode *condition, treenode *true, treenode *false);

treenode * CondExpGuardOf(treenode *T)
treenode * CondExpTrueOf(treenode *T)
treenode * CondExpFalseOf(treenode *T)
int        CondExpTypeOf(treenode *T)

void SetCondExpGuard(treenode *T, treenode *V)
void SetCondExpTrue(treenode *T, treenode *V)
void SetCondExpFalse(treenode *T, treenode *V)
void SetCondExpType(treenode *T, int V)

treenode ** CondExpGuardAddr(treenode *T)
treenode ** CondExpTrueAddr(treenode *T)
treenode ** CondExpFalseAddr(treenode *T)
int       * CondExpTypeAddr(treenode *T)
/*}}}*/

/*{{{  connectnode    !!!! CONFIG only !!!!*/
treenode *newconnectnode (int t, SOURCEPOSN ln,
                          treenode *fn, treenode *fl, 
                          treenode *tn, treenode *tl);

treenode * ConnectFromNodeOf(treenode *T)
treenode * ConnectFromLinkOf(treenode *T)
treenode * ConnectToNodeOf(treenode *T)
treenode * ConnectToLinkOf(treenode *T)

void SetConnectFromNode(treenode *T, treenode *V)
void SetConnectFromLink(treenode *T, treenode *V)
void SetConnectToNode(treenode *T, treenode *V)
void SetConnectToLink(treenode *T, treenode *V)

treenode ** ConnectFromNodeAddr(treenode *T)
treenode ** ConnectFromLinkAddr(treenode *T)
treenode ** ConnectToNodeAddr(treenode *T)
treenode ** ConnectToLinkAddr(treenode *T)
/*}}}*/

/*{{{  confignode   !!!! NOT USED !!!!*/
treenode *newconfignode (int t, SOURCEPOSN ln, treenode *process);

treenode * ConfigBodyOf(treenode *T)

void SetConfigBody(treenode *T, treenode *V)

treenode ** ConfigBodyAddr(treenode *T)
/*}}}*/

/*{{{  constexpnode*/
treenode *newconstexpnode (int t, SOURCEPOSN ln, treenode *e,
                                  BIT32 h, BIT32 l);

treenode * CExpOf(treenode *T)
BIT32      HiValOf(treenode *T)
BIT32      LoValOf(treenode *T)
treenode * CENextOf(treenode *T)
INT32      CEOffsetOf(treenode *T)

void SetCExp(treenode *T, treenode *V)
void SetHiVal(treenode *T, BIT32 V)
void SetLoVal(treenode *T, BIT32 V)
void SetCENext(treenode *T, treenode *V)
void SetCEOffset(treenode *T, INT32 V)

treenode ** CExpAddr(treenode *T)
BIT32     * HiValAddr(treenode *T)
BIT32     * LoValAddr(treenode *T)
treenode ** CENextAddr(treenode *T)
INT32     * CEOffsetAddr(treenode *T)
/*}}}*/

/*{{{  consttablenode*/
treenode *newconsttablenode (int t, SOURCEPOSN ln, struct wordnodestruct *v,
                                    treenode *e);

wordnode * CTValOf(treenode *T)
treenode * CTExpOf(treenode *T)
treenode * CTNextOf(treenode *T)
int        CTLabelOf(treenode *T)

void SetCTVal(treenode *T, wordnode *V)
void SetCTExp(treenode *T, treenode *V)
void SetCTNext(treenode *T, treenode *V)
void SetCTLabel(treenode *T, int V)

wordnode ** CTValAddr(treenode *T)
treenode ** CTExpAddr(treenode *T)
treenode ** CTNextAddr(treenode *T)
int       * CTLabelAddr(treenode *T)
/*}}}*/

/*{{{  declnode*/
treenode *newdeclnode (int t, SOURCEPOSN ln, treenode *n,
                              treenode *val, treenode *b);

treenode * DNameOf(treenode *T)
treenode * DValOf(treenode *T)   /* Initialising value */
treenode * DBodyOf(treenode *T)  /* following process */

void SetDName(treenode *T, treenode *V)
void SetDVal(treenode *T, treenode *V)
void SetDBody(treenode *T, treenode *V)

treenode ** DNameAddr(treenode *T)
treenode ** DValAddr(treenode *T)
treenode ** DBodyAddr(treenode *T)

treenode *  PlaceExpOf(treenode *T)
treenode *  SetPlaceExp(treenode *T, treenode *V)
treenode ** PlaceExpAddr(treenode *T)
/*}}}*/

/*{{{  dopnode*/
treenode *newdopnode (int t, SOURCEPOSN ln, treenode *l, treenode *r, int type);

treenode * LeftOpOf(treenode *T)
treenode * RightOpOf(treenode *T)
int        DOpTypeOf(treenode *T)

void SetLeftOp(treenode *T, treenode *V)
void SetRightOp(treenode *T, treenode *V)
void SetDOpType(treenode *T, int V)

treenode ** LeftOpAddr(treenode *T)
treenode ** RightOpAddr(treenode *T)
int       * DOpTypeAddr(treenode *T)

#ifdef SIC
int         DOpTempOf(treenode *T)
void        SetDOpTemp(treenode *T, int V)
int       * DOpTempAddr(treenode *T)
#endif
/*}}}*/

/*{{{  fntypenode*/
treenode * FnTypeListOf(treenode *T)
treenode * FnParamsOf(treenode *T)

void SetFnTypeList(treenode *T, treenode *V)
void SetFnParams(treenode *T, treenode *V)

treenode ** FnTypeListAddr(treenode *T)
treenode ** FnParamsAddr(treenode *T)
/*}}}*/

/*{{{  hiddenparamnode*/
treenode *newhiddenparamnode (int t, SOURCEPOSN ln, treenode *e, int d);

treenode * HExpOf(treenode *T)
int        HDimensionOf(treenode *T)
/* When the hidden parameter is a function result pointer, this field
   contains the workspace offset of the parameter */
BIT32      HOffsetOf(treenode *T)

void SetHExp(treenode *T, treenode *V)
void SetHDimension(treenode *T, int V)
void SetHOffset(treenode *T, BIT32 V)

treenode ** HExpAddr(treenode *T)
int       * HDimensionAddr(treenode *T)
BIT32     * HOffsetAddr(treenode *T)
/*}}}*/

/*{{{  instancenode*/
treenode *newinstancenode (int t, SOURCEPOSN ln, treenode *n, treenode *p);

treenode * INameOf(treenode *T)
treenode * IParamListOf(treenode *T)
unsigned char ILoadSeqOf(treenode *T)
treenode *NParamListOf (treenode *n);

void SetIName(treenode *T, treenode *V)
void SetIParamList(treenode *T, treenode * V)
void SetILoadSeq(treenode *T, unsigned char V)
void SetNParamList (treenode *n, treenode *v);

treenode ** INameAddr(treenode *T)
treenode ** IParamListAddr(treenode *T)
unsigned char * ILoadSeqAddr(treenode *T)
/*}}}*/

/*{{{  leafnode*/
treenode *newleafnode (int t, SOURCEPOSN ln);
/*}}}*/

/*{{{  listnode*/
treenode *newlistnode (int t, SOURCEPOSN ln, treenode *l, treenode *r);

treenode * LeftOf(treenode *T)
treenode * RightOf(treenode *T)

void SetLeft(treenode *T, treenode *V)
void SetRight(treenode *T, treenode *V)

treenode ** LeftAddr(treenode *T)
treenode ** RightAddr(treenode *T)
/*}}}*/

/*{{{  litnode*/
treenode *newlitnode (int t, SOURCEPOSN ln, struct wordnodestruct *w);

wordnode * StringPtrOf(treenode *T)

void SetStringPtr(treenode *T, wordnode *V)

wordnode ** StringPtrAddr(treenode *T)
/*}}}*/

/*{{{  mopnode*/
treenode *newmopnode (int t, SOURCEPOSN ln, treenode *o, int type);

treenode * OpOf(treenode *T)
int        MOpTypeOf(treenode *T)

void SetOp(treenode *T, treenode *V)
void SetMOpType(treenode *T, int V)

treenode ** OpAddr(treenode *T)
int       * MOpTypeAddr(treenode *T)

#ifdef SIC
int         MOpTempOf(treenode *T)
void        SetMOpTemp(treenode *T, int V)
int       * MOpTempAddr(treenode *T)
#endif
/*}}}*/

/*{{{  namenode*/
treenode *newnamenode (int tag, SOURCEPOSN ln,
                             struct wordnodestruct *name,
                             treenode *type, treenode *spec,
                             int lexlevel, int scope,
                             int mode);

wordnode * NNameOf(treenode *N)
treenode * NTypeOf(treenode *N)
treenode * NDeclOf(treenode *N)
int        NLexLevelOf(treenode *N)
int        NNestedPriParOf(treenode *N)
int        NUsedOf(treenode *N)
BIT16      NScopeOf(treenode *N)
unsigned   NModeOf(treenode *N)
BIT32      NOffsetOf(treenode *N)
BIT32      NP0Of(treenode *N)
BIT32      NP1Of(treenode *N)
BIT32      NP2Of(treenode *N)
BIT32      NP3Of(treenode *N)
BIT32      NP4Of(treenode *N)
BIT32      NP5Of(treenode *N)
BIT32      NP6Of(treenode *N)

void SetNDeclType(treenode *N, treenode *V)  /* Unused ??? */
void SetNName(treenode *N, wordnode *V)
void SetNType(treenode *N, treenode *V)
void SetNDecl(treenode *N, treenode *V)
void SetNLexLevel(treenode *N, int V)
void SetNNestedPriPar(treenode *N, int V)
void SetNUsed(treenode *N, int V)
void SetNScope(treenode *N, BIT16 V)
void SetNMode(treenode *N, unsigned char V)
void SetNOffset(treenode *N, BIT32 V)
void SetNP0(treenode *N, BIT32 V)
void SetNP1(treenode *N, BIT32 V)
void SetNP2(treenode *N, BIT32 V)
void SetNP3(treenode *N, BIT32 V)
void SetNP4(treenode *N, BIT32 V)
void SetNP5(treenode *N, BIT32 V)
void SetNP6(treenode *N, BIT32 V)
void SetNP10(treenode *N, BIT32 V)

treenode ** NTypeAddr(treenode *N)
treenode ** NDeclAddr(treenode *N)
wordnode ** NNameAddr(treenode *N)
/*}}}*/

/*{{{  overlapnode*/
treenode * OBase1Of(treenode *T)
treenode * OCount1Of(treenode *T)
treenode * OBase2Of(treenode *T)
treenode * OCount2Of(treenode *T)

void SetOBase1(treenode *T, treenode *V)
void SetOCount1(treenode *T, treenode *V)
void SetOBase2(treenode *T, treenode *V)
void SetOCount2(treenode *T, treenode *V)

treenode ** OBase1Addr(treenode *T)
treenode ** OCount1Addr(treenode *T)
treenode ** OBase2Addr(treenode *T)
treenode ** OCount2Addr(treenode *T)
/*}}}*/

/*{{{  processornode*/
treenode *newprocessornode (int t, SOURCEPOSN ln, treenode *exp,
                            struct wordnodestruct *type,
                            treenode *process);

treenode * ProcessorExpOf(treenode *T)
wordnode * ProcessorTypeOf(treenode *T)
treenode * ProcessorBodyOf(treenode *T)

void SetProcessorExp(treenode *T, treenode *V)
void SetProcessorType(treenode *T, wordnode *V)
void SetProcessorBody(treenode *T, treenode *V)

treenode ** ProcessorExpAddr(treenode *T)
wordnode ** ProcessorTypeAddr(treenode *T)
treenode ** ProcessorBodyAddr(treenode *T)
/*}}}*/

/*{{{  replcnode / arrayconstructor*/
treenode *newreplcnode (int t, SOURCEPOSN ln, treenode *n,
                        treenode *s, treenode *l, treenode *b);

treenode * ReplCNameOf(treenode *T)
treenode * ReplCStartExpOf(treenode *T)
treenode * ReplCLengthExpOf(treenode *T)
treenode * ReplCBodyOf(treenode *T)
treenode * ReplCTempOf(treenode *T)

void SetReplCName(treenode *T, treenode *V)
void SetReplCStartExp(treenode *T, treenode *V)
void SetReplCLengthExp(treenode *T, treenode *V)
void SetReplCBody(treenode *T, treenode *V)
void SetReplCTemp(treenode *T, treenode *V)

treenode ** ReplCNameAddr(treenode *T)
treenode ** ReplCStartExpAddr(treenode *T)
treenode ** ReplCLengthExpAddr(treenode *T)
treenode ** ReplCBodyAddr(treenode *T)

/*}}}*/

/*{{{  segmentnode*/
treenode *newsegmentnode (int t, SOURCEPOSN ln, treenode *n, treenode *s,
                                 treenode *l);

treenode * SNameOf(treenode *T)
treenode * SStartExpOf(treenode *T)
treenode * SLengthExpOf(treenode *T)
treenode * SSubscriptExpOf(treenode *T)  -- SEGMENTITEM (backend) only
treenode * SCheckExpOf(treenode *T)
INT32      SOffsetOf(treenode *T)        -- SEGMENTITEM (backend) only

void SetSName(treenode *T, treenode *V)
void SetSStartExp(treenode *T, treenode *V)
void SetSLengthExp(treenode *T, treenode *V)
void SetSSubscriptExp(treenode *T, treenode *V)
void SetSCheckExp(treenode *T, treenode *V)
void SetSOffset(treenode *T, INT32 V)

treenode ** SNameAddr(treenode *T)
treenode ** SStartExpAddr(treenode *T)
treenode ** SLengthExpAddr(treenode *T)
treenode ** SSubscriptExpAddr(treenode *T)
treenode ** SCheckExpAddr(treenode *T)
INT32     * SOffsetAddr(treenode *T)
/*}}}*/

/*{{{  setnode    !!!! CONFIG only !!!!*/
treenode *newsetnode (int t, SOURCEPOSN ln, int r, treenode *n, 
                      treenode *l, treenode *i);

int        STRegOf(treenode *T)
treenode * STNodeOf(treenode *T)
treenode * STLinkOf(treenode *T)
treenode * STIntervalOf(treenode *T)

void SetSTReg(treenode *T, int V)
void SetSTNode(treenode *T, treenode *V)
void SetSTLink(treenode *T, treenode *V)
void SetSTInterval(treenode *T, treenode *V)

treenode ** STRegAddr(treenode *T)
treenode ** STNodeAddr(treenode *T)
treenode ** STLinkAddr(treenode *T)
treenode ** STIntervalAddr(treenode *T)
/*}}}*/

/*{{{  spacenode*/
treenode *newspacenode (int t, SOURCEPOSN ln, treenode *p,
                               BIT32 maxwsp, BIT32 datasize,
                               BIT32 vsusage, BIT32 nestedvs,
                               treenode *namechain, int cpoffset);

treenode * SpBodyOf(treenode *T)
INT32      SpMaxwspOf(treenode *T)
INT32      SpDatasizeOf(treenode *T)
INT32      SpVSUsageOf(treenode *T)
INT32      SpNestedVSOf(treenode *T)
treenode * SpNamechainOf(treenode *T)
int        SpLabelOf(treenode *T)
unsigned   SpCPOffsetOf(treenode *T)

void SetSpBody(treenode *T, treenode *V)
void SetSpMaxwsp(treenode *T, INT32 V)
void SetSpDatasize(treenode *T, INT32 V)
void SetSpVSUsage(treenode *T, INT32 V)
void SetSpNestedVS(treenode *T, INT32 V)
void SetSpNamechain(treenode *T, treenode *V)
void SetSpLabel(treenode *T, int V)
void SetSpCPOffset(treenode *T, unsigned char V)

treenode ** SpBodyAddr(treenode *T)
/*}}}*/

/*{{{  valofnode*/
treenode *newvalofnode (int t,SOURCEPOSN ln, treenode *b, treenode *r);

treenode * VLBodyOf(treenode *T)
treenode * VLResultListOf(treenode *T)

void SetVLBody(treenode *T, treenode *V)
void SetVLResultList(treenode *T, treenode *V)

treenode ** VLBodyAddr(treenode *T)
treenode ** VLResultListAddr(treenode *T)
/*}}}*/

/*{{{  variantnode*/
treenode *newvariantnode (int t, SOURCEPOSN ln, treenode *tl, treenode *b);

treenode * VRTaggedListOf(treenode *T)
treenode * VRBodyOf(treenode *T)

void SetVRTaggedList(treenode *T, treenode *V)
void SetVRBody(treenode *T, treenode *V)

treenode ** VRTaggedListAddr(treenode *T)
treenode ** VRBodyAddr(treenode *T)
/*}}}*/

/*{{{  wordnode*/
struct wordnodestruct *newwordnode (int t, char *name,
                                     int len, struct wordnodestruct *next);

unsigned char WTagOf(wordnode *N)
char     * WNameOf(wordnode *N)
int        WLengthOf(wordnode *N)
wordnode * WNextOf(wordnode *N)

void SetWTag(wordnode *N, unsigned char V)
void SetWName(wordnode *N, char *V)
void SetWLength(wordnode *N, int V)
void SetWNext(wordnode *N, wordnode *V)

char ** WNameAddr(wordnode *N)
/*}}}*/
