backend.dcl 18.2 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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

BEPredefineListConstructorSymbol :: !Int !Int !BESymbKind !Int !Int !BackEnd -> BackEnd;
// void BEPredefineListConstructorSymbol(int constructorIndex,int moduleIndex,BESymbKind symbolKind,int head_strictnes,int tail_stricness);
BEPredefineListTypeSymbol :: !Int !Int !BESymbKind !Int !Int !BackEnd -> BackEnd;
// void BEPredefineListTypeSymbol(int typeIndex,int moduleIndex,BESymbKind symbolKind,int head_strictnes,int tail_stricness);
BEAdjustStrictListConsInstance :: !Int !Int !BackEnd -> BackEnd;
// void BEAdjustStrictListConsInstance(int functionIndex,int moduleIndex);
BEAdjustUnboxedListDeconsInstance :: !Int !Int !BackEnd -> BackEnd;
// void BEAdjustUnboxedListDeconsInstance(int functionIndex,int moduleIndex);
BEAdjustOverloadedNilFunction :: !Int !Int !BackEnd -> BackEnd;
// void BEAdjustOverloadedNilFunction(int functionIndex,int moduleIndex);
BEOverloadedConsSymbol :: !Int !Int !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
// BESymbolP BEOverloadedConsSymbol (int constructorIndex,int moduleIndex,int deconsIndex,int deconsModuleIndex);
BEOverloadedPushNode :: !Int !BESymbolP !BEArgP !BENodeIdListP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
// BENodeP BEOverloadedPushNode (int arity,BESymbolP symbol,BEArgP arguments,BENodeIdListP nodeIds,BENodeP decons_node);

86
BEPredefineConstructorSymbol :: !Int !Int !Int !BESymbKind !BackEnd -> BackEnd;
87
// void BEPredefineConstructorSymbol (int arity,int constructorIndex,int moduleIndex,BESymbKind symbolKind);
88
BEPredefineTypeSymbol :: !Int !Int !Int !BESymbKind !BackEnd -> BackEnd;
89
// void BEPredefineTypeSymbol (int arity,int typeIndex,int moduleIndex,BESymbKind symbolKind);
90
BEBasicSymbol :: !Int !BackEnd -> (!BESymbolP,!BackEnd);
91
// BESymbolP BEBasicSymbol (BESymbKind kind);
92
BEVarTypeNode :: !String !BackEnd -> (!BETypeNodeP,!BackEnd);
93
// BETypeNodeP BEVarTypeNode (CleanString name);
94
BETypeVars :: !BETypeVarP !BETypeVarListP !BackEnd -> (!BETypeVarListP,!BackEnd);
95
// BETypeVarListP BETypeVars (BETypeVarP typeVar,BETypeVarListP typeVarList);
96
BENoTypeVars :: !BackEnd -> (!BETypeVarListP,!BackEnd);
97
// BETypeVarListP BENoTypeVars ();
98
BENormalTypeNode :: !BESymbolP !BETypeArgP !BackEnd -> (!BETypeNodeP,!BackEnd);
99
// BETypeNodeP BENormalTypeNode (BESymbolP symbol,BETypeArgP args);
100
BEAnnotateTypeNode :: !BEAnnotation !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd);
101
// BETypeNodeP BEAnnotateTypeNode (BEAnnotation annotation,BETypeNodeP typeNode);
102
BEAttributeTypeNode :: !BEAttribution !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd);
103
// BETypeNodeP BEAttributeTypeNode (BEAttribution attribution,BETypeNodeP typeNode);
104
105
106
107
108
109
110
111
112
113
114
115
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);
116
BENoTypeArgs :: !BackEnd -> (!BETypeArgP,!BackEnd);
117
// BETypeArgP BENoTypeArgs ();
118
BETypeArgs :: !BETypeNodeP !BETypeArgP !BackEnd -> (!BETypeArgP,!BackEnd);
119
// BETypeArgP BETypeArgs (BETypeNodeP node,BETypeArgP nextArgs);
120
121
BETypeAlt :: !BETypeNodeP !BETypeNodeP !BEUniVarEquations !BackEnd -> (!BETypeAltP,!BackEnd);
// BETypeAltP BETypeAlt (BETypeNodeP lhs,BETypeNodeP rhs,BEUniVarEquations attributeEquations);
122
BENormalNode :: !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
123
// BENodeP BENormalNode (BESymbolP symbol,BEArgP args);
124
BEMatchNode :: !Int !BESymbolP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
125
// BENodeP BEMatchNode (int arity,BESymbolP symbol,BENodeP node);
126
BETupleSelectNode :: !Int !Int !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
127
// BENodeP BETupleSelectNode (int arity,int index,BENodeP node);
128
BEIfNode :: !BENodeP !BENodeP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
129
// BENodeP BEIfNode (BENodeP cond,BENodeP then,BENodeP elsje);
130
BEGuardNode :: !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
131
// BENodeP BEGuardNode (BENodeP cond,BENodeDefP thenNodeDefs,BEStrictNodeIdP thenStricts,BENodeP then,BENodeDefP elseNodeDefs,BEStrictNodeIdP elseStricts,BENodeP elsje);
132
133
134
135
BESetNodeDefRefCounts :: !BENodeP !BackEnd -> BackEnd;
// void BESetNodeDefRefCounts (BENodeP lhs);
BEAddNodeIdsRefCounts :: !Int !BESymbolP !BENodeIdListP !BackEnd -> BackEnd;
// void BEAddNodeIdsRefCounts (int sequenceNumber,BESymbolP symbol,BENodeIdListP nodeIds);
136
137
138
139
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);
140
141
142
143
BEEnterLocalScope :: !BackEnd -> BackEnd;
// void BEEnterLocalScope ();
BELeaveLocalScope :: !BENodeP !BackEnd -> BackEnd;
// void BELeaveLocalScope (BENodeP node);
144
145
146
147
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);
148
BESelectorNode :: !BESelectorKind !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
149
// BENodeP BESelectorNode (BESelectorKind selectorKind,BESymbolP fieldSymbol,BEArgP args);
150
BEUpdateNode :: !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
151
// BENodeP BEUpdateNode (BEArgP args);
152
BENodeIdNode :: !BENodeIdP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
153
// BENodeP BENodeIdNode (BENodeIdP nodeId,BEArgP args);
154
BENoArgs :: !BackEnd -> (!BEArgP,!BackEnd);
155
// BEArgP BENoArgs ();
156
BEArgs :: !BENodeP !BEArgP !BackEnd -> (!BEArgP,!BackEnd);
157
// BEArgP BEArgs (BENodeP node,BEArgP nextArgs);
158
BERuleAlt :: !Int !BENodeDefP !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BERuleAltP,!BackEnd);
159
// BERuleAltP BERuleAlt (int line,BENodeDefP lhsDefs,BENodeP lhs,BENodeDefP rhsDefs,BEStrictNodeIdP lhsStrictNodeIds,BENodeP rhs);
160
BERuleAlts :: !BERuleAltP !BERuleAltP !BackEnd -> (!BERuleAltP,!BackEnd);
161
// BERuleAltP BERuleAlts (BERuleAltP alt,BERuleAltP alts);
162
BENoRuleAlts :: !BackEnd -> (!BERuleAltP,!BackEnd);
163
// BERuleAltP BENoRuleAlts ();
164
BEDeclareNodeId :: !Int !Int !String !BackEnd -> BackEnd;
165
// void BEDeclareNodeId (int sequenceNumber,int lhsOrRhs,CleanString name);
166
BENodeId :: !Int !BackEnd -> (!BENodeIdP,!BackEnd);
167
// BENodeIdP BENodeId (int sequenceNumber);
168
BEWildCardNodeId :: !BackEnd -> (!BENodeIdP,!BackEnd);
169
// BENodeIdP BEWildCardNodeId ();
170
BENodeDef :: !Int !BENodeP !BackEnd -> (!BENodeDefP,!BackEnd);
171
// BENodeDefP BENodeDef (int sequenceNumber,BENodeP node);
172
BENoNodeDefs :: !BackEnd -> (!BENodeDefP,!BackEnd);
173
// BENodeDefP BENoNodeDefs ();
174
BENodeDefs :: !BENodeDefP !BENodeDefP !BackEnd -> (!BENodeDefP,!BackEnd);
175
// BENodeDefP BENodeDefs (BENodeDefP nodeDef,BENodeDefP nodeDefs);
176
BEStrictNodeId :: !BENodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
177
// BEStrictNodeIdP BEStrictNodeId (BENodeIdP nodeId);
178
BENoStrictNodeIds :: !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
179
// BEStrictNodeIdP BENoStrictNodeIds ();
180
BEStrictNodeIds :: !BEStrictNodeIdP !BEStrictNodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
181
// BEStrictNodeIdP BEStrictNodeIds (BEStrictNodeIdP strictNodeId,BEStrictNodeIdP strictNodeIds);
182
BERule :: !Int !Int !BETypeAltP !BERuleAltP !BackEnd -> (!BEImpRuleP,!BackEnd);
183
// BEImpRuleP BERule (int functionIndex,int isCaf,BETypeAltP type,BERuleAltP alts);
184
BEDeclareRuleType :: !Int !Int !String !BackEnd -> BackEnd;
185
// void BEDeclareRuleType (int functionIndex,int moduleIndex,CleanString name);
186
BEDefineRuleType :: !Int !Int !BETypeAltP !BackEnd -> BackEnd;
187
// void BEDefineRuleType (int functionIndex,int moduleIndex,BETypeAltP typeAlt);
188
BEAdjustArrayFunction :: !BEArrayFunKind !Int !Int !BackEnd -> BackEnd;
189
// void BEAdjustArrayFunction (BEArrayFunKind arrayFunKind,int functionIndex,int moduleIndex);
190
BENoRules :: !BackEnd -> (!BEImpRuleP,!BackEnd);
191
// BEImpRuleP BENoRules ();
192
BERules :: !BEImpRuleP !BEImpRuleP !BackEnd -> (!BEImpRuleP,!BackEnd);
193
// BEImpRuleP BERules (BEImpRuleP rule,BEImpRuleP rules);
194
BETypes :: !BETypeP !BETypeP !BackEnd -> (!BETypeP,!BackEnd);
195
// BETypeP BETypes (BETypeP type,BETypeP types);
196
BENoTypes :: !BackEnd -> (!BETypeP,!BackEnd);
197
// BETypeP BENoTypes ();
198
BEFlatType :: !BESymbolP !BETypeVarListP !BackEnd -> (!BEFlatTypeP,!BackEnd);
199
// BEFlatTypeP BEFlatType (BESymbolP symbol,BETypeVarListP arguments);
200
BEAlgebraicType :: !BEFlatTypeP !BEConstructorListP !BackEnd -> BackEnd;
201
// void BEAlgebraicType (BEFlatTypeP lhs,BEConstructorListP constructors);
202
BERecordType :: !Int !BEFlatTypeP !BETypeNodeP !BEFieldListP !BackEnd -> BackEnd;
203
// void BERecordType (int moduleIndex,BEFlatTypeP lhs,BETypeNodeP constructorType,BEFieldListP fields);
204
BEAbsType :: !BEFlatTypeP !BackEnd -> BackEnd;
205
// void BEAbsType (BEFlatTypeP lhs);
206
BEConstructors :: !BEConstructorListP !BEConstructorListP !BackEnd -> (!BEConstructorListP,!BackEnd);
207
// BEConstructorListP BEConstructors (BEConstructorListP constructor,BEConstructorListP constructors);
208
BENoConstructors :: !BackEnd -> (!BEConstructorListP,!BackEnd);
209
// BEConstructorListP BENoConstructors ();
210
BEConstructor :: !BETypeNodeP !BackEnd -> (!BEConstructorListP,!BackEnd);
211
// BEConstructorListP BEConstructor (BETypeNodeP type);
212
BEDeclareField :: !Int !Int !String !BackEnd -> BackEnd;
213
// void BEDeclareField (int fieldIndex,int moduleIndex,CleanString name);
214
BEField :: !Int !Int !BETypeNodeP !BackEnd -> (!BEFieldListP,!BackEnd);
215
// BEFieldListP BEField (int fieldIndex,int moduleIndex,BETypeNodeP type);
216
BEFields :: !BEFieldListP !BEFieldListP !BackEnd -> (!BEFieldListP,!BackEnd);
217
// BEFieldListP BEFields (BEFieldListP field,BEFieldListP fields);
218
BENoFields :: !BackEnd -> (!BEFieldListP,!BackEnd);
219
// BEFieldListP BENoFields ();
220
BEDeclareConstructor :: !Int !Int !String !BackEnd -> BackEnd;
221
// void BEDeclareConstructor (int constructorIndex,int moduleIndex,CleanString name);
222
BETypeVar :: !String !BackEnd -> (!BETypeVarP,!BackEnd);
223
// BETypeVarP BETypeVar (CleanString name);
224
BEDeclareType :: !Int !Int !String !BackEnd -> BackEnd;
225
// void BEDeclareType (int typeIndex,int moduleIndex,CleanString name);
226
BEDeclareFunction :: !String !Int !Int !Int !BackEnd -> BackEnd;
227
// void BEDeclareFunction (CleanString name,int arity,int functionIndex,int ancestor);
228
BECodeAlt :: !Int !BENodeDefP !BENodeP !BECodeBlockP !BackEnd -> (!BERuleAltP,!BackEnd);
229
// BERuleAltP BECodeAlt (int line,BENodeDefP lhsDefs,BENodeP lhs,BECodeBlockP codeBlock);
230
BEString :: !String !BackEnd -> (!BEStringListP,!BackEnd);
231
// BEStringListP BEString (CleanString cleanString);
232
BEStrings :: !BEStringListP !BEStringListP !BackEnd -> (!BEStringListP,!BackEnd);
233
// BEStringListP BEStrings (BEStringListP string,BEStringListP strings);
234
BENoStrings :: !BackEnd -> (!BEStringListP,!BackEnd);
235
// BEStringListP BENoStrings ();
236
BECodeParameter :: !String !BENodeIdP !BackEnd -> (!BECodeParameterP,!BackEnd);
237
// BECodeParameterP BECodeParameter (CleanString location,BENodeIdP nodeId);
238
BECodeParameters :: !BECodeParameterP !BECodeParameterP !BackEnd -> (!BECodeParameterP,!BackEnd);
239
// BECodeParameterP BECodeParameters (BECodeParameterP parameter,BECodeParameterP parameters);
240
BENoCodeParameters :: !BackEnd -> (!BECodeParameterP,!BackEnd);
241
// BECodeParameterP BENoCodeParameters ();
242
243
244
245
246
247
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 ();
248
BEAbcCodeBlock :: !Bool !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
249
// BECodeBlockP BEAbcCodeBlock (int inline,BEStringListP instructions);
250
BEAnyCodeBlock :: !BECodeParameterP !BECodeParameterP !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
251
// BECodeBlockP BEAnyCodeBlock (BECodeParameterP inParams,BECodeParameterP outParams,BEStringListP instructions);
252
BEDeclareIclModule :: !String !Int !Int !Int !Int !BackEnd -> BackEnd;
253
// void BEDeclareIclModule (CleanString name,int nFunctions,int nTypes,int nConstructors,int nFields);
254
BEDeclareDclModule :: !Int !String !Bool !Int !Int !Int !Int !BackEnd -> BackEnd;
255
// void BEDeclareDclModule (int moduleIndex,CleanString name,int systemModule,int nFunctions,int nTypes,int nConstructors,int nFields);
256
BEDeclarePredefinedModule :: !Int !Int !BackEnd -> BackEnd;
257
// void BEDeclarePredefinedModule (int nTypes,int nConstructors);
258
BEDefineRules :: !BEImpRuleP !BackEnd -> BackEnd;
259
// void BEDefineRules (BEImpRuleP rules);
260
BEGenerateCode :: !String !BackEnd -> (!Bool,!BackEnd);
261
// int BEGenerateCode (CleanString outputFile);
262
BEExportType :: !Int !Int !BackEnd -> BackEnd;
263
// void BEExportType (int dclTypeIndex,int iclTypeIndex);
264
BESwapTypes :: !Int !Int !BackEnd -> BackEnd;
265
// void BESwapTypes (int frm,int to);
266
BEExportConstructor :: !Int !Int !BackEnd -> BackEnd;
267
// void BEExportConstructor (int dclConstructorIndex,int iclConstructorIndex);
268
BEExportField :: !Int !Int !BackEnd -> BackEnd;
269
// void BEExportField (int dclTypeIndex,int iclTypeIndex);
270
BEExportFunction :: !Int !Int !BackEnd -> BackEnd;
271
// void BEExportFunction (int dclFunctionIndex,int iclFunctionIndex);
272
BEDefineImportedObjsAndLibs :: !BEStringListP !BEStringListP !BackEnd -> BackEnd;
273
// void BEDefineImportedObjsAndLibs (BEStringListP objs,BEStringListP libs);
274
BESetMainDclModuleN :: !Int !BackEnd -> BackEnd;
275
// void BESetMainDclModuleN (int main_dcl_module_n_parameter);
276
BEDeclareDynamicTypeSymbol :: !Int !Int !BackEnd -> BackEnd;
277
// void BEDeclareDynamicTypeSymbol (int typeIndex,int moduleIndex);
278
BEDynamicTempTypeSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
279
// BESymbolP BEDynamicTempTypeSymbol ();
280
281
282
kBEVersionCurrent:==0x02000211;
kBEVersionOldestDefinition:==0x02000211;
kBEVersionOldestImplementation:==0x02000211;
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
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
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;