backend.dcl 15.9 KB
Newer Older
Ronny Wichers Schreur's avatar
Ronny Wichers Schreur committed
1
definition module backend;
2
3
4
5
6

//1.3
from StdString import String;
//3.1

7
:: CPtr :== Int;
8
:: *UWorld :== Int;
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
:: *BackEnd;
:: BESymbolP;
:: BETypeNodeP;
:: BETypeArgP;
:: BETypeAltP;
:: BENodeP;
:: BEArgP;
:: BERuleAltP;
:: BEImpRuleP;
:: BETypeP;
:: BEFlatTypeP;
:: BETypeVarP;
:: BETypeVarListP;
:: BEConstructorListP;
:: BEFieldListP;
:: BENodeIdP;
:: BENodeDefP;
:: BEStrictNodeIdP;
:: BECodeParameterP;
:: BECodeBlockP;
:: BEStringListP;
:: BENodeIdListP;
31
:: BENodeIdRefCountListP;
32
33
34
35
36
37
38
:: BEAnnotation :== Int;
:: BEAttribution :== Int;
:: BESymbKind :== Int;
:: BEArrayFunKind :== Int;
:: BESelectorKind :== Int;
:: BEUpdateKind :== Int;
BEGetVersion :: (!Int,!Int,!Int);
39
// void BEGetVersion (int* current,int* oldestDefinition,int* oldestImplementation);
40
BEInit :: !Int !UWorld -> (!BackEnd,!UWorld);
41
// BackEnd BEInit (int argc);
42
BEFree :: !BackEnd !UWorld -> UWorld;
43
// void BEFree (BackEnd backEnd);
44
BEArg :: !String !BackEnd -> BackEnd;
45
// void BEArg (CleanString arg);
46
BEDeclareModules :: !Int !BackEnd -> BackEnd;
47
// void BEDeclareModules (int nModules);
48
BESpecialArrayFunctionSymbol :: !BEArrayFunKind !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
49
// BESymbolP BESpecialArrayFunctionSymbol (BEArrayFunKind arrayFunKind,int functionIndex,int moduleIndex);
50
BEDictionarySelectFunSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
51
// BESymbolP BEDictionarySelectFunSymbol ();
52
BEDictionaryUpdateFunSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
53
// BESymbolP BEDictionaryUpdateFunSymbol ();
54
BEFunctionSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
55
// BESymbolP BEFunctionSymbol (int functionIndex,int moduleIndex);
56
BEConstructorSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
57
// BESymbolP BEConstructorSymbol (int constructorIndex,int moduleIndex);
58
BEFieldSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
59
// BESymbolP BEFieldSymbol (int fieldIndex,int moduleIndex);
60
BETypeSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
61
// BESymbolP BETypeSymbol (int typeIndex,int moduleIndex);
62
BEDontCareDefinitionSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
63
// BESymbolP BEDontCareDefinitionSymbol ();
64
BEBoolSymbol :: !Bool !BackEnd -> (!BESymbolP,!BackEnd);
65
// BESymbolP BEBoolSymbol (int value);
66
BELiteralSymbol :: !BESymbKind !String !BackEnd -> (!BESymbolP,!BackEnd);
67
// BESymbolP BELiteralSymbol (BESymbKind kind,CleanString value);
68
BEPredefineConstructorSymbol :: !Int !Int !Int !BESymbKind !BackEnd -> BackEnd;
69
// void BEPredefineConstructorSymbol (int arity,int constructorIndex,int moduleIndex,BESymbKind symbolKind);
70
BEPredefineTypeSymbol :: !Int !Int !Int !BESymbKind !BackEnd -> BackEnd;
71
// void BEPredefineTypeSymbol (int arity,int typeIndex,int moduleIndex,BESymbKind symbolKind);
72
BEBasicSymbol :: !Int !BackEnd -> (!BESymbolP,!BackEnd);
73
// BESymbolP BEBasicSymbol (BESymbKind kind);
74
BEVarTypeNode :: !String !BackEnd -> (!BETypeNodeP,!BackEnd);
75
// BETypeNodeP BEVarTypeNode (CleanString name);
76
BETypeVars :: !BETypeVarP !BETypeVarListP !BackEnd -> (!BETypeVarListP,!BackEnd);
77
// BETypeVarListP BETypeVars (BETypeVarP typeVar,BETypeVarListP typeVarList);
78
BENoTypeVars :: !BackEnd -> (!BETypeVarListP,!BackEnd);
79
// BETypeVarListP BENoTypeVars ();
80
BENormalTypeNode :: !BESymbolP !BETypeArgP !BackEnd -> (!BETypeNodeP,!BackEnd);
81
// BETypeNodeP BENormalTypeNode (BESymbolP symbol,BETypeArgP args);
82
BEAnnotateTypeNode :: !BEAnnotation !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd);
83
// BETypeNodeP BEAnnotateTypeNode (BEAnnotation annotation,BETypeNodeP typeNode);
84
BEAttributeTypeNode :: !BEAttribution !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd);
85
// BETypeNodeP BEAttributeTypeNode (BEAttribution attribution,BETypeNodeP typeNode);
86
BENoTypeArgs :: !BackEnd -> (!BETypeArgP,!BackEnd);
87
// BETypeArgP BENoTypeArgs ();
88
BETypeArgs :: !BETypeNodeP !BETypeArgP !BackEnd -> (!BETypeArgP,!BackEnd);
89
// BETypeArgP BETypeArgs (BETypeNodeP node,BETypeArgP nextArgs);
90
BETypeAlt :: !BETypeNodeP !BETypeNodeP !BackEnd -> (!BETypeAltP,!BackEnd);
91
// BETypeAltP BETypeAlt (BETypeNodeP lhs,BETypeNodeP rhs);
92
BENormalNode :: !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
93
// BENodeP BENormalNode (BESymbolP symbol,BEArgP args);
94
BEMatchNode :: !Int !BESymbolP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
95
// BENodeP BEMatchNode (int arity,BESymbolP symbol,BENodeP node);
96
BETupleSelectNode :: !Int !Int !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
97
// BENodeP BETupleSelectNode (int arity,int index,BENodeP node);
98
BEIfNode :: !BENodeP !BENodeP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
99
// BENodeP BEIfNode (BENodeP cond,BENodeP then,BENodeP elsje);
100
BEGuardNode :: !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
101
// BENodeP BEGuardNode (BENodeP cond,BENodeDefP thenNodeDefs,BEStrictNodeIdP thenStricts,BENodeP then,BENodeDefP elseNodeDefs,BEStrictNodeIdP elseStricts,BENodeP elsje);
102
103
104
105
BESetNodeDefRefCounts :: !BENodeP !BackEnd -> BackEnd;
// void BESetNodeDefRefCounts (BENodeP lhs);
BEAddNodeIdsRefCounts :: !Int !BESymbolP !BENodeIdListP !BackEnd -> BackEnd;
// void BEAddNodeIdsRefCounts (int sequenceNumber,BESymbolP symbol,BENodeIdListP nodeIds);
106
107
108
109
BESwitchNode :: !BENodeIdP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
// BENodeP BESwitchNode (BENodeIdP nodeId,BEArgP caseNode);
BECaseNode :: !Int !BESymbolP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
// BENodeP BECaseNode (int symbolArity,BESymbolP symbol,BENodeDefP nodeDefs,BEStrictNodeIdP strictNodeIds,BENodeP node);
110
111
112
113
BEEnterLocalScope :: !BackEnd -> BackEnd;
// void BEEnterLocalScope ();
BELeaveLocalScope :: !BENodeP !BackEnd -> BackEnd;
// void BELeaveLocalScope (BENodeP node);
114
115
116
117
BEPushNode :: !Int !BESymbolP !BEArgP !BENodeIdListP !BackEnd -> (!BENodeP,!BackEnd);
// BENodeP BEPushNode (int arity,BESymbolP symbol,BEArgP arguments,BENodeIdListP nodeIds);
BEDefaultNode :: !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
// BENodeP BEDefaultNode (BENodeDefP nodeDefs,BEStrictNodeIdP strictNodeIds,BENodeP node);
118
BESelectorNode :: !BESelectorKind !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
119
// BENodeP BESelectorNode (BESelectorKind selectorKind,BESymbolP fieldSymbol,BEArgP args);
120
BEUpdateNode :: !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
121
// BENodeP BEUpdateNode (BEArgP args);
122
BENodeIdNode :: !BENodeIdP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
123
// BENodeP BENodeIdNode (BENodeIdP nodeId,BEArgP args);
124
BENoArgs :: !BackEnd -> (!BEArgP,!BackEnd);
125
// BEArgP BENoArgs ();
126
BEArgs :: !BENodeP !BEArgP !BackEnd -> (!BEArgP,!BackEnd);
127
// BEArgP BEArgs (BENodeP node,BEArgP nextArgs);
128
BERuleAlt :: !Int !BENodeDefP !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BERuleAltP,!BackEnd);
129
// BERuleAltP BERuleAlt (int line,BENodeDefP lhsDefs,BENodeP lhs,BENodeDefP rhsDefs,BEStrictNodeIdP lhsStrictNodeIds,BENodeP rhs);
130
BERuleAlts :: !BERuleAltP !BERuleAltP !BackEnd -> (!BERuleAltP,!BackEnd);
131
// BERuleAltP BERuleAlts (BERuleAltP alt,BERuleAltP alts);
132
BENoRuleAlts :: !BackEnd -> (!BERuleAltP,!BackEnd);
133
// BERuleAltP BENoRuleAlts ();
134
BEDeclareNodeId :: !Int !Int !String !BackEnd -> BackEnd;
135
// void BEDeclareNodeId (int sequenceNumber,int lhsOrRhs,CleanString name);
136
BENodeId :: !Int !BackEnd -> (!BENodeIdP,!BackEnd);
137
// BENodeIdP BENodeId (int sequenceNumber);
138
BEWildCardNodeId :: !BackEnd -> (!BENodeIdP,!BackEnd);
139
// BENodeIdP BEWildCardNodeId ();
140
BENodeDef :: !Int !BENodeP !BackEnd -> (!BENodeDefP,!BackEnd);
141
// BENodeDefP BENodeDef (int sequenceNumber,BENodeP node);
142
BENoNodeDefs :: !BackEnd -> (!BENodeDefP,!BackEnd);
143
// BENodeDefP BENoNodeDefs ();
144
BENodeDefs :: !BENodeDefP !BENodeDefP !BackEnd -> (!BENodeDefP,!BackEnd);
145
// BENodeDefP BENodeDefs (BENodeDefP nodeDef,BENodeDefP nodeDefs);
146
BEStrictNodeId :: !BENodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
147
// BEStrictNodeIdP BEStrictNodeId (BENodeIdP nodeId);
148
BENoStrictNodeIds :: !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
149
// BEStrictNodeIdP BENoStrictNodeIds ();
150
BEStrictNodeIds :: !BEStrictNodeIdP !BEStrictNodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
151
// BEStrictNodeIdP BEStrictNodeIds (BEStrictNodeIdP strictNodeId,BEStrictNodeIdP strictNodeIds);
152
BERule :: !Int !Int !BETypeAltP !BERuleAltP !BackEnd -> (!BEImpRuleP,!BackEnd);
153
// BEImpRuleP BERule (int functionIndex,int isCaf,BETypeAltP type,BERuleAltP alts);
154
BEDeclareRuleType :: !Int !Int !String !BackEnd -> BackEnd;
155
// void BEDeclareRuleType (int functionIndex,int moduleIndex,CleanString name);
156
BEDefineRuleType :: !Int !Int !BETypeAltP !BackEnd -> BackEnd;
157
// void BEDefineRuleType (int functionIndex,int moduleIndex,BETypeAltP typeAlt);
158
BEAdjustArrayFunction :: !BEArrayFunKind !Int !Int !BackEnd -> BackEnd;
159
// void BEAdjustArrayFunction (BEArrayFunKind arrayFunKind,int functionIndex,int moduleIndex);
160
BENoRules :: !BackEnd -> (!BEImpRuleP,!BackEnd);
161
// BEImpRuleP BENoRules ();
162
BERules :: !BEImpRuleP !BEImpRuleP !BackEnd -> (!BEImpRuleP,!BackEnd);
163
// BEImpRuleP BERules (BEImpRuleP rule,BEImpRuleP rules);
164
BETypes :: !BETypeP !BETypeP !BackEnd -> (!BETypeP,!BackEnd);
165
// BETypeP BETypes (BETypeP type,BETypeP types);
166
BENoTypes :: !BackEnd -> (!BETypeP,!BackEnd);
167
// BETypeP BENoTypes ();
168
BEFlatType :: !BESymbolP !BETypeVarListP !BackEnd -> (!BEFlatTypeP,!BackEnd);
169
// BEFlatTypeP BEFlatType (BESymbolP symbol,BETypeVarListP arguments);
170
BEAlgebraicType :: !BEFlatTypeP !BEConstructorListP !BackEnd -> BackEnd;
171
// void BEAlgebraicType (BEFlatTypeP lhs,BEConstructorListP constructors);
172
BERecordType :: !Int !BEFlatTypeP !BETypeNodeP !BEFieldListP !BackEnd -> BackEnd;
173
// void BERecordType (int moduleIndex,BEFlatTypeP lhs,BETypeNodeP constructorType,BEFieldListP fields);
174
BEAbsType :: !BEFlatTypeP !BackEnd -> BackEnd;
175
// void BEAbsType (BEFlatTypeP lhs);
176
BEConstructors :: !BEConstructorListP !BEConstructorListP !BackEnd -> (!BEConstructorListP,!BackEnd);
177
// BEConstructorListP BEConstructors (BEConstructorListP constructor,BEConstructorListP constructors);
178
BENoConstructors :: !BackEnd -> (!BEConstructorListP,!BackEnd);
179
// BEConstructorListP BENoConstructors ();
180
BEConstructor :: !BETypeNodeP !BackEnd -> (!BEConstructorListP,!BackEnd);
181
// BEConstructorListP BEConstructor (BETypeNodeP type);
182
BEDeclareField :: !Int !Int !String !BackEnd -> BackEnd;
183
// void BEDeclareField (int fieldIndex,int moduleIndex,CleanString name);
184
BEField :: !Int !Int !BETypeNodeP !BackEnd -> (!BEFieldListP,!BackEnd);
185
// BEFieldListP BEField (int fieldIndex,int moduleIndex,BETypeNodeP type);
186
BEFields :: !BEFieldListP !BEFieldListP !BackEnd -> (!BEFieldListP,!BackEnd);
187
// BEFieldListP BEFields (BEFieldListP field,BEFieldListP fields);
188
BENoFields :: !BackEnd -> (!BEFieldListP,!BackEnd);
189
// BEFieldListP BENoFields ();
190
BEDeclareConstructor :: !Int !Int !String !BackEnd -> BackEnd;
191
// void BEDeclareConstructor (int constructorIndex,int moduleIndex,CleanString name);
192
BETypeVar :: !String !BackEnd -> (!BETypeVarP,!BackEnd);
193
// BETypeVarP BETypeVar (CleanString name);
194
BEDeclareType :: !Int !Int !String !BackEnd -> BackEnd;
195
// void BEDeclareType (int typeIndex,int moduleIndex,CleanString name);
196
BEDeclareFunction :: !String !Int !Int !Int !BackEnd -> BackEnd;
197
// void BEDeclareFunction (CleanString name,int arity,int functionIndex,int ancestor);
198
BECodeAlt :: !Int !BENodeDefP !BENodeP !BECodeBlockP !BackEnd -> (!BERuleAltP,!BackEnd);
199
// BERuleAltP BECodeAlt (int line,BENodeDefP lhsDefs,BENodeP lhs,BECodeBlockP codeBlock);
200
BEString :: !String !BackEnd -> (!BEStringListP,!BackEnd);
201
// BEStringListP BEString (CleanString cleanString);
202
BEStrings :: !BEStringListP !BEStringListP !BackEnd -> (!BEStringListP,!BackEnd);
203
// BEStringListP BEStrings (BEStringListP string,BEStringListP strings);
204
BENoStrings :: !BackEnd -> (!BEStringListP,!BackEnd);
205
// BEStringListP BENoStrings ();
206
BECodeParameter :: !String !BENodeIdP !BackEnd -> (!BECodeParameterP,!BackEnd);
207
// BECodeParameterP BECodeParameter (CleanString location,BENodeIdP nodeId);
208
BECodeParameters :: !BECodeParameterP !BECodeParameterP !BackEnd -> (!BECodeParameterP,!BackEnd);
209
// BECodeParameterP BECodeParameters (BECodeParameterP parameter,BECodeParameterP parameters);
210
BENoCodeParameters :: !BackEnd -> (!BECodeParameterP,!BackEnd);
211
// BECodeParameterP BENoCodeParameters ();
212
213
214
215
216
217
BENodeIdListElem :: !BENodeIdP !BackEnd -> (!BENodeIdListP,!BackEnd);
// BENodeIdListP BENodeIdListElem (BENodeIdP nodeId);
BENodeIds :: !BENodeIdListP !BENodeIdListP !BackEnd -> (!BENodeIdListP,!BackEnd);
// BENodeIdListP BENodeIds (BENodeIdListP nid,BENodeIdListP nids);
BENoNodeIds :: !BackEnd -> (!BENodeIdListP,!BackEnd);
// BENodeIdListP BENoNodeIds ();
218
BEAbcCodeBlock :: !Bool !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
219
// BECodeBlockP BEAbcCodeBlock (int inline,BEStringListP instructions);
220
BEAnyCodeBlock :: !BECodeParameterP !BECodeParameterP !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
221
// BECodeBlockP BEAnyCodeBlock (BECodeParameterP inParams,BECodeParameterP outParams,BEStringListP instructions);
222
BEDeclareIclModule :: !String !Int !Int !Int !Int !BackEnd -> BackEnd;
223
// void BEDeclareIclModule (CleanString name,int nFunctions,int nTypes,int nConstructors,int nFields);
224
BEDeclareDclModule :: !Int !String !Bool !Int !Int !Int !Int !BackEnd -> BackEnd;
225
// void BEDeclareDclModule (int moduleIndex,CleanString name,int systemModule,int nFunctions,int nTypes,int nConstructors,int nFields);
226
BEDeclarePredefinedModule :: !Int !Int !BackEnd -> BackEnd;
227
// void BEDeclarePredefinedModule (int nTypes,int nConstructors);
228
BEDefineRules :: !BEImpRuleP !BackEnd -> BackEnd;
229
// void BEDefineRules (BEImpRuleP rules);
230
BEGenerateCode :: !String !BackEnd -> (!Bool,!BackEnd);
231
// int BEGenerateCode (CleanString outputFile);
232
BEExportType :: !Int !Int !BackEnd -> BackEnd;
233
// void BEExportType (int dclTypeIndex,int iclTypeIndex);
234
BESwapTypes :: !Int !Int !BackEnd -> BackEnd;
235
// void BESwapTypes (int frm,int to);
236
BEExportConstructor :: !Int !Int !BackEnd -> BackEnd;
237
// void BEExportConstructor (int dclConstructorIndex,int iclConstructorIndex);
238
BEExportField :: !Int !Int !BackEnd -> BackEnd;
239
// void BEExportField (int dclTypeIndex,int iclTypeIndex);
240
BEExportFunction :: !Int !Int !BackEnd -> BackEnd;
241
// void BEExportFunction (int dclFunctionIndex,int iclFunctionIndex);
242
BEDefineImportedObjsAndLibs :: !BEStringListP !BEStringListP !BackEnd -> BackEnd;
243
// void BEDefineImportedObjsAndLibs (BEStringListP objs,BEStringListP libs);
244
BESetMainDclModuleN :: !Int !BackEnd -> BackEnd;
245
// void BESetMainDclModuleN (int main_dcl_module_n_parameter);
246
BEDeclareDynamicTypeSymbol :: !Int !Int !BackEnd -> BackEnd;
247
// void BEDeclareDynamicTypeSymbol (int typeIndex,int moduleIndex);
248
BEDynamicTempTypeSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
249
// BESymbolP BEDynamicTempTypeSymbol ();
250
kBEVersionCurrent:==0x02000209;
251
kBEVersionOldestDefinition:==0x02000204;
252
kBEVersionOldestImplementation:==0x02000209;
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
kBEDebug:==1;
kPredefinedModuleIndex:==1;
BENoAnnot:==0;
BEStrictAnnot:==1;
BENoUniAttr:==0;
BENotUniqueAttr:==1;
BEUniqueAttr:==2;
BEExistsAttr:==3;
BEUniqueVariable:==4;
BEFirstUniVarNumber:==5;
BEIntType:==0;
BEBoolType:==1;
BECharType:==2;
BERealType:==3;
BEFileType:==4;
BEStringType:==5;
BEWorldType:==6;
BEProcIdType:==7;
BERedIdType:==8;
BENrOfBasicTypes:==9;
BEIntDenot:==10;
BEBoolDenot:==11;
BECharDenot:==12;
BERealDenot:==13;
BENrOfBasicDenots:==14;
BEStringDenot:==15;
BEFunType:==16;
BEArrayType:==17;
BEStrictArrayType:==18;
BEUnboxedArrayType:==19;
BEListType:==20;
BETupleType:==21;
BEEmptyType:==22;
BEDynamicType:==23;
BENrOfPredefTypes:==24;
BETupleSymb:==25;
BEConsSymb:==26;
BENilSymb:==27;
BEApplySymb:==28;
BEIfSymb:==29;
BEFailSymb:==30;
BEAllSymb:==31;
BESelectSymb:==32;
BENrOfPredefFunsOrConses:==33;
BEDefinition:==34;
BENewSymbol:==35;
BEInstanceSymb:==36;
BEEmptySymbol:==37;
BEFieldSymbolList:==38;
BEErroneousSymb:==39;
BECreateArrayFun:==0;
BEArraySelectFun:==1;
BEUnqArraySelectFun:==2;
BEArrayUpdateFun:==3;
BEArrayReplaceFun:==4;
BEArraySizeFun:==5;
BEUnqArraySizeFun:==6;
BE_CreateArrayFun:==7;
BE_UnqArraySelectFun:==8;
BE_UnqArraySelectNextFun:==9;
BE_UnqArraySelectLastFun:==10;
BE_ArrayUpdateFun:==11;
BENoArrayFun:==12;
BESelectorDummy:==0;
BESelector:==1;
BESelector_U:==2;
BESelector_F:==3;
BESelector_L:==4;
BESelector_N:==5;
BEUpdateDummy:==0;
BEUpdate:==1;
BEUpdate_U:==2;
BELhsNodeId:==0;
BERhsNodeId:==1;
BEIsNotACaf:==0;
BEIsACaf:==1;