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