backend.dcl 16.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
:: BEUniVarEquations;
:: BEAttributeKindList;
34
35
36
37
38
39
40
:: BEAnnotation :== Int;
:: BEAttribution :== Int;
:: BESymbKind :== Int;
:: BEArrayFunKind :== Int;
:: BESelectorKind :== Int;
:: BEUpdateKind :== Int;
BEGetVersion :: (!Int,!Int,!Int);
41
// void BEGetVersion (int* current,int* oldestDefinition,int* oldestImplementation);
42
BEInit :: !Int !UWorld -> (!BackEnd,!UWorld);
43
// BackEnd BEInit (int argc);
44
BEFree :: !BackEnd !UWorld -> UWorld;
45
// void BEFree (BackEnd backEnd);
46
BEArg :: !String !BackEnd -> BackEnd;
47
// void BEArg (CleanString arg);
48
BEDeclareModules :: !Int !BackEnd -> BackEnd;
49
// void BEDeclareModules (int nModules);
50
BESpecialArrayFunctionSymbol :: !BEArrayFunKind !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
51
// BESymbolP BESpecialArrayFunctionSymbol (BEArrayFunKind arrayFunKind,int functionIndex,int moduleIndex);
52
BEDictionarySelectFunSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
53
// BESymbolP BEDictionarySelectFunSymbol ();
54
BEDictionaryUpdateFunSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
55
// BESymbolP BEDictionaryUpdateFunSymbol ();
56
BEFunctionSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
57
// BESymbolP BEFunctionSymbol (int functionIndex,int moduleIndex);
58
BEConstructorSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
59
// BESymbolP BEConstructorSymbol (int constructorIndex,int moduleIndex);
60
BEFieldSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
61
// BESymbolP BEFieldSymbol (int fieldIndex,int moduleIndex);
62
BETypeSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
63
// BESymbolP BETypeSymbol (int typeIndex,int moduleIndex);
64
BEDontCareDefinitionSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
65
// BESymbolP BEDontCareDefinitionSymbol ();
66
BEBoolSymbol :: !Bool !BackEnd -> (!BESymbolP,!BackEnd);
67
// BESymbolP BEBoolSymbol (int value);
68
BELiteralSymbol :: !BESymbKind !String !BackEnd -> (!BESymbolP,!BackEnd);
69
// BESymbolP BELiteralSymbol (BESymbKind kind,CleanString value);
70
BEPredefineConstructorSymbol :: !Int !Int !Int !BESymbKind !BackEnd -> BackEnd;
71
// void BEPredefineConstructorSymbol (int arity,int constructorIndex,int moduleIndex,BESymbKind symbolKind);
72
BEPredefineTypeSymbol :: !Int !Int !Int !BESymbKind !BackEnd -> BackEnd;
73
// void BEPredefineTypeSymbol (int arity,int typeIndex,int moduleIndex,BESymbKind symbolKind);
74
BEBasicSymbol :: !Int !BackEnd -> (!BESymbolP,!BackEnd);
75
// BESymbolP BEBasicSymbol (BESymbKind kind);
76
BEVarTypeNode :: !String !BackEnd -> (!BETypeNodeP,!BackEnd);
77
// BETypeNodeP BEVarTypeNode (CleanString name);
78
BETypeVars :: !BETypeVarP !BETypeVarListP !BackEnd -> (!BETypeVarListP,!BackEnd);
79
// BETypeVarListP BETypeVars (BETypeVarP typeVar,BETypeVarListP typeVarList);
80
BENoTypeVars :: !BackEnd -> (!BETypeVarListP,!BackEnd);
81
// BETypeVarListP BENoTypeVars ();
82
BENormalTypeNode :: !BESymbolP !BETypeArgP !BackEnd -> (!BETypeNodeP,!BackEnd);
83
// BETypeNodeP BENormalTypeNode (BESymbolP symbol,BETypeArgP args);
84
BEAnnotateTypeNode :: !BEAnnotation !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd);
85
// BETypeNodeP BEAnnotateTypeNode (BEAnnotation annotation,BETypeNodeP typeNode);
86
BEAttributeTypeNode :: !BEAttribution !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd);
87
// BETypeNodeP BEAttributeTypeNode (BEAttribution attribution,BETypeNodeP typeNode);
88
89
90
91
92
93
94
95
96
97
98
99
BEAttributeKind :: !BEAttribution !BackEnd -> (!BEAttributeKindList,!BackEnd);
// BEAttributeKindList BEAttributeKind (BEAttribution attributeKind);
BENoAttributeKinds :: !BackEnd -> (!BEAttributeKindList,!BackEnd);
// BEAttributeKindList BENoAttributeKinds ();
BEAttributeKinds :: !BEAttributeKindList !BEAttributeKindList !BackEnd -> (!BEAttributeKindList,!BackEnd);
// BEAttributeKindList BEAttributeKinds (BEAttributeKindList elem,BEAttributeKindList list);
BEUniVarEquation :: !BEAttribution !BEAttributeKindList !BackEnd -> (!BEUniVarEquations,!BackEnd);
// BEUniVarEquations BEUniVarEquation (BEAttribution demanded,BEAttributeKindList offered);
BENoUniVarEquations :: !BackEnd -> (!BEUniVarEquations,!BackEnd);
// BEUniVarEquations BENoUniVarEquations ();
BEUniVarEquationsList :: !BEUniVarEquations !BEUniVarEquations !BackEnd -> (!BEUniVarEquations,!BackEnd);
// BEUniVarEquations BEUniVarEquationsList (BEUniVarEquations elem,BEUniVarEquations list);
100
BENoTypeArgs :: !BackEnd -> (!BETypeArgP,!BackEnd);
101
// BETypeArgP BENoTypeArgs ();
102
BETypeArgs :: !BETypeNodeP !BETypeArgP !BackEnd -> (!BETypeArgP,!BackEnd);
103
// BETypeArgP BETypeArgs (BETypeNodeP node,BETypeArgP nextArgs);
104
105
BETypeAlt :: !BETypeNodeP !BETypeNodeP !BEUniVarEquations !BackEnd -> (!BETypeAltP,!BackEnd);
// BETypeAltP BETypeAlt (BETypeNodeP lhs,BETypeNodeP rhs,BEUniVarEquations attributeEquations);
106
BENormalNode :: !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
107
// BENodeP BENormalNode (BESymbolP symbol,BEArgP args);
108
BEMatchNode :: !Int !BESymbolP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
109
// BENodeP BEMatchNode (int arity,BESymbolP symbol,BENodeP node);
110
BETupleSelectNode :: !Int !Int !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
111
// BENodeP BETupleSelectNode (int arity,int index,BENodeP node);
112
BEIfNode :: !BENodeP !BENodeP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
113
// BENodeP BEIfNode (BENodeP cond,BENodeP then,BENodeP elsje);
114
BEGuardNode :: !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
115
// BENodeP BEGuardNode (BENodeP cond,BENodeDefP thenNodeDefs,BEStrictNodeIdP thenStricts,BENodeP then,BENodeDefP elseNodeDefs,BEStrictNodeIdP elseStricts,BENodeP elsje);
116
117
118
119
BESetNodeDefRefCounts :: !BENodeP !BackEnd -> BackEnd;
// void BESetNodeDefRefCounts (BENodeP lhs);
BEAddNodeIdsRefCounts :: !Int !BESymbolP !BENodeIdListP !BackEnd -> BackEnd;
// void BEAddNodeIdsRefCounts (int sequenceNumber,BESymbolP symbol,BENodeIdListP nodeIds);
120
121
122
123
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);
124
125
126
127
BEEnterLocalScope :: !BackEnd -> BackEnd;
// void BEEnterLocalScope ();
BELeaveLocalScope :: !BENodeP !BackEnd -> BackEnd;
// void BELeaveLocalScope (BENodeP node);
128
129
130
131
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);
132
BESelectorNode :: !BESelectorKind !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
133
// BENodeP BESelectorNode (BESelectorKind selectorKind,BESymbolP fieldSymbol,BEArgP args);
134
BEUpdateNode :: !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
135
// BENodeP BEUpdateNode (BEArgP args);
136
BENodeIdNode :: !BENodeIdP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
137
// BENodeP BENodeIdNode (BENodeIdP nodeId,BEArgP args);
138
BENoArgs :: !BackEnd -> (!BEArgP,!BackEnd);
139
// BEArgP BENoArgs ();
140
BEArgs :: !BENodeP !BEArgP !BackEnd -> (!BEArgP,!BackEnd);
141
// BEArgP BEArgs (BENodeP node,BEArgP nextArgs);
142
BERuleAlt :: !Int !BENodeDefP !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BERuleAltP,!BackEnd);
143
// BERuleAltP BERuleAlt (int line,BENodeDefP lhsDefs,BENodeP lhs,BENodeDefP rhsDefs,BEStrictNodeIdP lhsStrictNodeIds,BENodeP rhs);
144
BERuleAlts :: !BERuleAltP !BERuleAltP !BackEnd -> (!BERuleAltP,!BackEnd);
145
// BERuleAltP BERuleAlts (BERuleAltP alt,BERuleAltP alts);
146
BENoRuleAlts :: !BackEnd -> (!BERuleAltP,!BackEnd);
147
// BERuleAltP BENoRuleAlts ();
148
BEDeclareNodeId :: !Int !Int !String !BackEnd -> BackEnd;
149
// void BEDeclareNodeId (int sequenceNumber,int lhsOrRhs,CleanString name);
150
BENodeId :: !Int !BackEnd -> (!BENodeIdP,!BackEnd);
151
// BENodeIdP BENodeId (int sequenceNumber);
152
BEWildCardNodeId :: !BackEnd -> (!BENodeIdP,!BackEnd);
153
// BENodeIdP BEWildCardNodeId ();
154
BENodeDef :: !Int !BENodeP !BackEnd -> (!BENodeDefP,!BackEnd);
155
// BENodeDefP BENodeDef (int sequenceNumber,BENodeP node);
156
BENoNodeDefs :: !BackEnd -> (!BENodeDefP,!BackEnd);
157
// BENodeDefP BENoNodeDefs ();
158
BENodeDefs :: !BENodeDefP !BENodeDefP !BackEnd -> (!BENodeDefP,!BackEnd);
159
// BENodeDefP BENodeDefs (BENodeDefP nodeDef,BENodeDefP nodeDefs);
160
BEStrictNodeId :: !BENodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
161
// BEStrictNodeIdP BEStrictNodeId (BENodeIdP nodeId);
162
BENoStrictNodeIds :: !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
163
// BEStrictNodeIdP BENoStrictNodeIds ();
164
BEStrictNodeIds :: !BEStrictNodeIdP !BEStrictNodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
165
// BEStrictNodeIdP BEStrictNodeIds (BEStrictNodeIdP strictNodeId,BEStrictNodeIdP strictNodeIds);
166
BERule :: !Int !Int !BETypeAltP !BERuleAltP !BackEnd -> (!BEImpRuleP,!BackEnd);
167
// BEImpRuleP BERule (int functionIndex,int isCaf,BETypeAltP type,BERuleAltP alts);
168
BEDeclareRuleType :: !Int !Int !String !BackEnd -> BackEnd;
169
// void BEDeclareRuleType (int functionIndex,int moduleIndex,CleanString name);
170
BEDefineRuleType :: !Int !Int !BETypeAltP !BackEnd -> BackEnd;
171
// void BEDefineRuleType (int functionIndex,int moduleIndex,BETypeAltP typeAlt);
172
BEAdjustArrayFunction :: !BEArrayFunKind !Int !Int !BackEnd -> BackEnd;
173
// void BEAdjustArrayFunction (BEArrayFunKind arrayFunKind,int functionIndex,int moduleIndex);
174
BENoRules :: !BackEnd -> (!BEImpRuleP,!BackEnd);
175
// BEImpRuleP BENoRules ();
176
BERules :: !BEImpRuleP !BEImpRuleP !BackEnd -> (!BEImpRuleP,!BackEnd);
177
// BEImpRuleP BERules (BEImpRuleP rule,BEImpRuleP rules);
178
BETypes :: !BETypeP !BETypeP !BackEnd -> (!BETypeP,!BackEnd);
179
// BETypeP BETypes (BETypeP type,BETypeP types);
180
BENoTypes :: !BackEnd -> (!BETypeP,!BackEnd);
181
// BETypeP BENoTypes ();
182
BEFlatType :: !BESymbolP !BETypeVarListP !BackEnd -> (!BEFlatTypeP,!BackEnd);
183
// BEFlatTypeP BEFlatType (BESymbolP symbol,BETypeVarListP arguments);
184
BEAlgebraicType :: !BEFlatTypeP !BEConstructorListP !BackEnd -> BackEnd;
185
// void BEAlgebraicType (BEFlatTypeP lhs,BEConstructorListP constructors);
186
BERecordType :: !Int !BEFlatTypeP !BETypeNodeP !BEFieldListP !BackEnd -> BackEnd;
187
// void BERecordType (int moduleIndex,BEFlatTypeP lhs,BETypeNodeP constructorType,BEFieldListP fields);
188
BEAbsType :: !BEFlatTypeP !BackEnd -> BackEnd;
189
// void BEAbsType (BEFlatTypeP lhs);
190
BEConstructors :: !BEConstructorListP !BEConstructorListP !BackEnd -> (!BEConstructorListP,!BackEnd);
191
// BEConstructorListP BEConstructors (BEConstructorListP constructor,BEConstructorListP constructors);
192
BENoConstructors :: !BackEnd -> (!BEConstructorListP,!BackEnd);
193
// BEConstructorListP BENoConstructors ();
194
BEConstructor :: !BETypeNodeP !BackEnd -> (!BEConstructorListP,!BackEnd);
195
// BEConstructorListP BEConstructor (BETypeNodeP type);
196
BEDeclareField :: !Int !Int !String !BackEnd -> BackEnd;
197
// void BEDeclareField (int fieldIndex,int moduleIndex,CleanString name);
198
BEField :: !Int !Int !BETypeNodeP !BackEnd -> (!BEFieldListP,!BackEnd);
199
// BEFieldListP BEField (int fieldIndex,int moduleIndex,BETypeNodeP type);
200
BEFields :: !BEFieldListP !BEFieldListP !BackEnd -> (!BEFieldListP,!BackEnd);
201
// BEFieldListP BEFields (BEFieldListP field,BEFieldListP fields);
202
BENoFields :: !BackEnd -> (!BEFieldListP,!BackEnd);
203
// BEFieldListP BENoFields ();
204
BEDeclareConstructor :: !Int !Int !String !BackEnd -> BackEnd;
205
// void BEDeclareConstructor (int constructorIndex,int moduleIndex,CleanString name);
206
BETypeVar :: !String !BackEnd -> (!BETypeVarP,!BackEnd);
207
// BETypeVarP BETypeVar (CleanString name);
208
BEDeclareType :: !Int !Int !String !BackEnd -> BackEnd;
209
// void BEDeclareType (int typeIndex,int moduleIndex,CleanString name);
210
BEDeclareFunction :: !String !Int !Int !Int !BackEnd -> BackEnd;
211
// void BEDeclareFunction (CleanString name,int arity,int functionIndex,int ancestor);
212
BECodeAlt :: !Int !BENodeDefP !BENodeP !BECodeBlockP !BackEnd -> (!BERuleAltP,!BackEnd);
213
// BERuleAltP BECodeAlt (int line,BENodeDefP lhsDefs,BENodeP lhs,BECodeBlockP codeBlock);
214
BEString :: !String !BackEnd -> (!BEStringListP,!BackEnd);
215
// BEStringListP BEString (CleanString cleanString);
216
BEStrings :: !BEStringListP !BEStringListP !BackEnd -> (!BEStringListP,!BackEnd);
217
// BEStringListP BEStrings (BEStringListP string,BEStringListP strings);
218
BENoStrings :: !BackEnd -> (!BEStringListP,!BackEnd);
219
// BEStringListP BENoStrings ();
220
BECodeParameter :: !String !BENodeIdP !BackEnd -> (!BECodeParameterP,!BackEnd);
221
// BECodeParameterP BECodeParameter (CleanString location,BENodeIdP nodeId);
222
BECodeParameters :: !BECodeParameterP !BECodeParameterP !BackEnd -> (!BECodeParameterP,!BackEnd);
223
// BECodeParameterP BECodeParameters (BECodeParameterP parameter,BECodeParameterP parameters);
224
BENoCodeParameters :: !BackEnd -> (!BECodeParameterP,!BackEnd);
225
// BECodeParameterP BENoCodeParameters ();
226
227
228
229
230
231
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 ();
232
BEAbcCodeBlock :: !Bool !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
233
// BECodeBlockP BEAbcCodeBlock (int inline,BEStringListP instructions);
234
BEAnyCodeBlock :: !BECodeParameterP !BECodeParameterP !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
235
// BECodeBlockP BEAnyCodeBlock (BECodeParameterP inParams,BECodeParameterP outParams,BEStringListP instructions);
236
BEDeclareIclModule :: !String !Int !Int !Int !Int !BackEnd -> BackEnd;
237
// void BEDeclareIclModule (CleanString name,int nFunctions,int nTypes,int nConstructors,int nFields);
238
BEDeclareDclModule :: !Int !String !Bool !Int !Int !Int !Int !BackEnd -> BackEnd;
239
// void BEDeclareDclModule (int moduleIndex,CleanString name,int systemModule,int nFunctions,int nTypes,int nConstructors,int nFields);
240
BEDeclarePredefinedModule :: !Int !Int !BackEnd -> BackEnd;
241
// void BEDeclarePredefinedModule (int nTypes,int nConstructors);
242
BEDefineRules :: !BEImpRuleP !BackEnd -> BackEnd;
243
// void BEDefineRules (BEImpRuleP rules);
244
BEGenerateCode :: !String !BackEnd -> (!Bool,!BackEnd);
245
// int BEGenerateCode (CleanString outputFile);
246
BEExportType :: !Int !Int !BackEnd -> BackEnd;
247
// void BEExportType (int dclTypeIndex,int iclTypeIndex);
248
BESwapTypes :: !Int !Int !BackEnd -> BackEnd;
249
// void BESwapTypes (int frm,int to);
250
BEExportConstructor :: !Int !Int !BackEnd -> BackEnd;
251
// void BEExportConstructor (int dclConstructorIndex,int iclConstructorIndex);
252
BEExportField :: !Int !Int !BackEnd -> BackEnd;
253
// void BEExportField (int dclTypeIndex,int iclTypeIndex);
254
BEExportFunction :: !Int !Int !BackEnd -> BackEnd;
255
// void BEExportFunction (int dclFunctionIndex,int iclFunctionIndex);
256
BEDefineImportedObjsAndLibs :: !BEStringListP !BEStringListP !BackEnd -> BackEnd;
257
// void BEDefineImportedObjsAndLibs (BEStringListP objs,BEStringListP libs);
258
BESetMainDclModuleN :: !Int !BackEnd -> BackEnd;
259
// void BESetMainDclModuleN (int main_dcl_module_n_parameter);
260
BEDeclareDynamicTypeSymbol :: !Int !Int !BackEnd -> BackEnd;
261
// void BEDeclareDynamicTypeSymbol (int typeIndex,int moduleIndex);
262
BEDynamicTempTypeSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
263
// BESymbolP BEDynamicTempTypeSymbol ();
264
265
266
kBEVersionCurrent:==0x02000211;
kBEVersionOldestDefinition:==0x02000211;
kBEVersionOldestImplementation:==0x02000211;
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
329
330
331
332
333
334
335
336
337
338
339
340
341
342
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;