diff options
Diffstat (limited to 'backend')
| -rw-r--r-- | backend/backend.icl | 258 |
1 files changed, 130 insertions, 128 deletions
diff --git a/backend/backend.icl b/backend/backend.icl index e0bb73f..cb25dd1 100644 --- a/backend/backend.icl +++ b/backend/backend.icl @@ -42,758 +42,758 @@ BEGetVersion = code { BEInit :: !Int !UWorld -> (!BackEnd,!UWorld); BEInit a0 a1 = code { - ccall BEInit "I:I:I" + ccall BEInit "I:p:p" } // BackEnd BEInit (int argc); BECloseFiles :: !BackEnd -> BackEnd; BECloseFiles a0 = code { - ccall BECloseFiles ":V:I" + ccall BECloseFiles ":V:p" } // void BECloseFiles (); BEFree :: !BackEnd !UWorld -> UWorld; BEFree a0 a1 = code { - ccall BEFree "I:V:I" + ccall BEFree "p:V:p" } // void BEFree (BackEnd backEnd); BEArg :: !String !BackEnd -> BackEnd; BEArg a0 a1 = code { - ccall BEArg "S:V:I" + ccall BEArg "S:V:p" } // void BEArg (CleanString arg); BEDeclareModules :: !Int !BackEnd -> BackEnd; BEDeclareModules a0 a1 = code { - ccall BEDeclareModules "I:V:I" + ccall BEDeclareModules "I:V:p" } // void BEDeclareModules (int nModules); BEBindSpecialModule :: !BESpecialIdentIndex !Int !BackEnd -> BackEnd; BEBindSpecialModule a0 a1 a2 = code { - ccall BEBindSpecialModule "II:V:I" + ccall BEBindSpecialModule "II:V:p" } // void BEBindSpecialModule (BESpecialIdentIndex index,int moduleIndex); BEBindSpecialFunction :: !BESpecialIdentIndex !Int !Int !BackEnd -> BackEnd; BEBindSpecialFunction a0 a1 a2 a3 = code { - ccall BEBindSpecialFunction "III:V:I" + ccall BEBindSpecialFunction "III:V:p" } // void BEBindSpecialFunction (BESpecialIdentIndex index,int functionIndex,int moduleIndex); BESpecialArrayFunctionSymbol :: !BEArrayFunKind !Int !Int !BackEnd -> (!BESymbolP,!BackEnd); BESpecialArrayFunctionSymbol a0 a1 a2 a3 = code { - ccall BESpecialArrayFunctionSymbol "III:I:I" + ccall BESpecialArrayFunctionSymbol "III:p:p" } // BESymbolP BESpecialArrayFunctionSymbol (BEArrayFunKind arrayFunKind,int functionIndex,int moduleIndex); BEDictionarySelectFunSymbol :: !BackEnd -> (!BESymbolP,!BackEnd); BEDictionarySelectFunSymbol a0 = code { - ccall BEDictionarySelectFunSymbol ":I:I" + ccall BEDictionarySelectFunSymbol ":p:p" } // BESymbolP BEDictionarySelectFunSymbol (); BEDictionaryUpdateFunSymbol :: !BackEnd -> (!BESymbolP,!BackEnd); BEDictionaryUpdateFunSymbol a0 = code { - ccall BEDictionaryUpdateFunSymbol ":I:I" + ccall BEDictionaryUpdateFunSymbol ":p:p" } // BESymbolP BEDictionaryUpdateFunSymbol (); BEFunctionSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd); BEFunctionSymbol a0 a1 a2 = code { - ccall BEFunctionSymbol "II:I:I" + ccall BEFunctionSymbol "II:p:p" } // BESymbolP BEFunctionSymbol (int functionIndex,int moduleIndex); BEConstructorSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd); BEConstructorSymbol a0 a1 a2 = code { - ccall BEConstructorSymbol "II:I:I" + ccall BEConstructorSymbol "II:p:p" } // BESymbolP BEConstructorSymbol (int constructorIndex,int moduleIndex); BEFieldSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd); BEFieldSymbol a0 a1 a2 = code { - ccall BEFieldSymbol "II:I:I" + ccall BEFieldSymbol "II:p:p" } // BESymbolP BEFieldSymbol (int fieldIndex,int moduleIndex); BETypeSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd); BETypeSymbol a0 a1 a2 = code { - ccall BETypeSymbol "II:I:I" + ccall BETypeSymbol "II:p:p" } // BESymbolP BETypeSymbol (int typeIndex,int moduleIndex); BEDontCareDefinitionSymbol :: !BackEnd -> (!BESymbolP,!BackEnd); BEDontCareDefinitionSymbol a0 = code { - ccall BEDontCareDefinitionSymbol ":I:I" + ccall BEDontCareDefinitionSymbol ":p:p" } // BESymbolP BEDontCareDefinitionSymbol (); BEBoolSymbol :: !Bool !BackEnd -> (!BESymbolP,!BackEnd); BEBoolSymbol a0 a1 = code { - ccall BEBoolSymbol "I:I:I" + ccall BEBoolSymbol "I:p:p" } // BESymbolP BEBoolSymbol (int value); BELiteralSymbol :: !BESymbKind !String !BackEnd -> (!BESymbolP,!BackEnd); BELiteralSymbol a0 a1 a2 = code { - ccall BELiteralSymbol "IS:I:I" + ccall BELiteralSymbol "IS:p:p" } // BESymbolP BELiteralSymbol (BESymbKind kind,CleanString value); BEPredefineListConstructorSymbol :: !Int !Int !BESymbKind !Int !Int !BackEnd -> BackEnd; BEPredefineListConstructorSymbol a0 a1 a2 a3 a4 a5 = code { - ccall BEPredefineListConstructorSymbol "IIIII:V:I" + ccall BEPredefineListConstructorSymbol "IIIII:V:p" } // void BEPredefineListConstructorSymbol (int constructorIndex,int moduleIndex,BESymbKind symbolKind,int head_strictness,int tail_strictness); BEPredefineListTypeSymbol :: !Int !Int !BESymbKind !Int !Int !BackEnd -> BackEnd; BEPredefineListTypeSymbol a0 a1 a2 a3 a4 a5 = code { - ccall BEPredefineListTypeSymbol "IIIII:V:I" + ccall BEPredefineListTypeSymbol "IIIII:V:p" } // void BEPredefineListTypeSymbol (int typeIndex,int moduleIndex,BESymbKind symbolKind,int head_strictness,int tail_strictness); BEAdjustStrictListConsInstance :: !Int !Int !BackEnd -> BackEnd; BEAdjustStrictListConsInstance a0 a1 a2 = code { - ccall BEAdjustStrictListConsInstance "II:V:I" + ccall BEAdjustStrictListConsInstance "II:V:p" } // void BEAdjustStrictListConsInstance (int functionIndex,int moduleIndex); BEAdjustUnboxedListDeconsInstance :: !Int !Int !BackEnd -> BackEnd; BEAdjustUnboxedListDeconsInstance a0 a1 a2 = code { - ccall BEAdjustUnboxedListDeconsInstance "II:V:I" + ccall BEAdjustUnboxedListDeconsInstance "II:V:p" } // void BEAdjustUnboxedListDeconsInstance (int functionIndex,int moduleIndex); BEAdjustOverloadedNilFunction :: !Int !Int !BackEnd -> BackEnd; BEAdjustOverloadedNilFunction a0 a1 a2 = code { - ccall BEAdjustOverloadedNilFunction "II:V:I" + ccall BEAdjustOverloadedNilFunction "II:V:p" } // void BEAdjustOverloadedNilFunction (int functionIndex,int moduleIndex); BEOverloadedConsSymbol :: !Int !Int !Int !Int !BackEnd -> (!BESymbolP,!BackEnd); BEOverloadedConsSymbol a0 a1 a2 a3 a4 = code { - ccall BEOverloadedConsSymbol "IIII:I:I" + ccall BEOverloadedConsSymbol "IIII:p:p" } // BESymbolP BEOverloadedConsSymbol (int constructorIndex,int moduleIndex,int deconsIndex,int deconsModuleIndex); BEOverloadedPushNode :: !Int !BESymbolP !BEArgP !BENodeIdListP !BENodeP !BackEnd -> (!BENodeP,!BackEnd); BEOverloadedPushNode a0 a1 a2 a3 a4 a5 = code { - ccall BEOverloadedPushNode "IIIII:I:I" + ccall BEOverloadedPushNode "Ipppp:p:p" } // BENodeP BEOverloadedPushNode (int arity,BESymbolP symbol,BEArgP arguments,BENodeIdListP nodeIds,BENodeP decons_node); BEPredefineConstructorSymbol :: !Int !Int !Int !BESymbKind !BackEnd -> BackEnd; BEPredefineConstructorSymbol a0 a1 a2 a3 a4 = code { - ccall BEPredefineConstructorSymbol "IIII:V:I" + ccall BEPredefineConstructorSymbol "IIII:V:p" } // void BEPredefineConstructorSymbol (int arity,int constructorIndex,int moduleIndex,BESymbKind symbolKind); BEPredefineTypeSymbol :: !Int !Int !Int !BESymbKind !BackEnd -> BackEnd; BEPredefineTypeSymbol a0 a1 a2 a3 a4 = code { - ccall BEPredefineTypeSymbol "IIII:V:I" + ccall BEPredefineTypeSymbol "IIII:V:p" } // void BEPredefineTypeSymbol (int arity,int typeIndex,int moduleIndex,BESymbKind symbolKind); BEBasicSymbol :: !Int !BackEnd -> (!BESymbolP,!BackEnd); BEBasicSymbol a0 a1 = code { - ccall BEBasicSymbol "I:I:I" + ccall BEBasicSymbol "I:p:p" } // BESymbolP BEBasicSymbol (BESymbKind kind); BEVarTypeNode :: !String !BackEnd -> (!BETypeNodeP,!BackEnd); BEVarTypeNode a0 a1 = code { - ccall BEVarTypeNode "S:I:I" + ccall BEVarTypeNode "S:p:p" } // BETypeNodeP BEVarTypeNode (CleanString name); BETypeVarListElem :: !BETypeVarP !BEAttribution !BackEnd -> (!BETypeVarListP,!BackEnd); BETypeVarListElem a0 a1 a2 = code { - ccall BETypeVarListElem "II:I:I" + ccall BETypeVarListElem "pI:p:p" } // BETypeVarListP BETypeVarListElem (BETypeVarP typeVar,BEAttribution attribute); BETypeVars :: !BETypeVarListP !BETypeVarListP !BackEnd -> (!BETypeVarListP,!BackEnd); BETypeVars a0 a1 a2 = code { - ccall BETypeVars "II:I:I" + ccall BETypeVars "pp:p:p" } // BETypeVarListP BETypeVars (BETypeVarListP typeVarListElem,BETypeVarListP typeVarList); BENoTypeVars :: !BackEnd -> (!BETypeVarListP,!BackEnd); BENoTypeVars a0 = code { - ccall BENoTypeVars ":I:I" + ccall BENoTypeVars ":p:p" } // BETypeVarListP BENoTypeVars (); BENormalTypeNode :: !BESymbolP !BETypeArgP !BackEnd -> (!BETypeNodeP,!BackEnd); BENormalTypeNode a0 a1 a2 = code { - ccall BENormalTypeNode "II:I:I" + ccall BENormalTypeNode "pp:p:p" } // BETypeNodeP BENormalTypeNode (BESymbolP symbol,BETypeArgP args); BEAnnotateTypeNode :: !BEAnnotation !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd); BEAnnotateTypeNode a0 a1 a2 = code { - ccall BEAnnotateTypeNode "II:I:I" + ccall BEAnnotateTypeNode "Ip:p:p" } // BETypeNodeP BEAnnotateTypeNode (BEAnnotation annotation,BETypeNodeP typeNode); BEAddForAllTypeVariables :: !BETypeVarListP !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd); BEAddForAllTypeVariables a0 a1 a2 = code { - ccall BEAddForAllTypeVariables "II:I:I" + ccall BEAddForAllTypeVariables "pp:p:p" } // BETypeNodeP BEAddForAllTypeVariables (BETypeVarListP vars,BETypeNodeP type); BEAttributeTypeNode :: !BEAttribution !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd); BEAttributeTypeNode a0 a1 a2 = code { - ccall BEAttributeTypeNode "II:I:I" + ccall BEAttributeTypeNode "Ip:p:p" } // BETypeNodeP BEAttributeTypeNode (BEAttribution attribution,BETypeNodeP typeNode); BEAttributeKind :: !BEAttribution !BackEnd -> (!BEAttributeKindList,!BackEnd); BEAttributeKind a0 a1 = code { - ccall BEAttributeKind "I:I:I" + ccall BEAttributeKind "I:p:p" } // BEAttributeKindList BEAttributeKind (BEAttribution attributeKind); BENoAttributeKinds :: !BackEnd -> (!BEAttributeKindList,!BackEnd); BENoAttributeKinds a0 = code { - ccall BENoAttributeKinds ":I:I" + ccall BENoAttributeKinds ":p:p" } // BEAttributeKindList BENoAttributeKinds (); BEAttributeKinds :: !BEAttributeKindList !BEAttributeKindList !BackEnd -> (!BEAttributeKindList,!BackEnd); BEAttributeKinds a0 a1 a2 = code { - ccall BEAttributeKinds "II:I:I" + ccall BEAttributeKinds "pp:p:p" } // BEAttributeKindList BEAttributeKinds (BEAttributeKindList elem,BEAttributeKindList list); BEUniVarEquation :: !BEAttribution !BEAttributeKindList !BackEnd -> (!BEUniVarEquations,!BackEnd); BEUniVarEquation a0 a1 a2 = code { - ccall BEUniVarEquation "II:I:I" + ccall BEUniVarEquation "Ip:p:p" } // BEUniVarEquations BEUniVarEquation (BEAttribution demanded,BEAttributeKindList offered); BENoUniVarEquations :: !BackEnd -> (!BEUniVarEquations,!BackEnd); BENoUniVarEquations a0 = code { - ccall BENoUniVarEquations ":I:I" + ccall BENoUniVarEquations ":p:p" } // BEUniVarEquations BENoUniVarEquations (); BEUniVarEquationsList :: !BEUniVarEquations !BEUniVarEquations !BackEnd -> (!BEUniVarEquations,!BackEnd); BEUniVarEquationsList a0 a1 a2 = code { - ccall BEUniVarEquationsList "II:I:I" + ccall BEUniVarEquationsList "pp:p:p" } // BEUniVarEquations BEUniVarEquationsList (BEUniVarEquations elem,BEUniVarEquations list); BENoTypeArgs :: !BackEnd -> (!BETypeArgP,!BackEnd); BENoTypeArgs a0 = code { - ccall BENoTypeArgs ":I:I" + ccall BENoTypeArgs ":p:p" } // BETypeArgP BENoTypeArgs (); BETypeArgs :: !BETypeNodeP !BETypeArgP !BackEnd -> (!BETypeArgP,!BackEnd); BETypeArgs a0 a1 a2 = code { - ccall BETypeArgs "II:I:I" + ccall BETypeArgs "pp:p:p" } // BETypeArgP BETypeArgs (BETypeNodeP node,BETypeArgP nextArgs); BETypeAlt :: !BETypeNodeP !BETypeNodeP !BEUniVarEquations !BackEnd -> (!BETypeAltP,!BackEnd); BETypeAlt a0 a1 a2 a3 = code { - ccall BETypeAlt "III:I:I" + ccall BETypeAlt "ppp:p:p" } // BETypeAltP BETypeAlt (BETypeNodeP lhs,BETypeNodeP rhs,BEUniVarEquations attributeEquations); BENormalNode :: !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd); BENormalNode a0 a1 a2 = code { - ccall BENormalNode "II:I:I" + ccall BENormalNode "pp:p:p" } // BENodeP BENormalNode (BESymbolP symbol,BEArgP args); BEMatchNode :: !Int !BESymbolP !BENodeP !BackEnd -> (!BENodeP,!BackEnd); BEMatchNode a0 a1 a2 a3 = code { - ccall BEMatchNode "III:I:I" + ccall BEMatchNode "Ipp:p:p" } // BENodeP BEMatchNode (int arity,BESymbolP symbol,BENodeP node); BETupleSelectNode :: !Int !Int !BENodeP !BackEnd -> (!BENodeP,!BackEnd); BETupleSelectNode a0 a1 a2 a3 = code { - ccall BETupleSelectNode "III:I:I" + ccall BETupleSelectNode "IIp:p:p" } // BENodeP BETupleSelectNode (int arity,int index,BENodeP node); BEIfNode :: !BENodeP !BENodeP !BENodeP !BackEnd -> (!BENodeP,!BackEnd); BEIfNode a0 a1 a2 a3 = code { - ccall BEIfNode "III:I:I" + ccall BEIfNode "ppp:p:p" } // BENodeP BEIfNode (BENodeP cond,BENodeP then,BENodeP elsje); BEGuardNode :: !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BENodeP,!BackEnd); BEGuardNode a0 a1 a2 a3 a4 a5 a6 a7 = code { - ccall BEGuardNode "IIIIIII:I:I" + ccall BEGuardNode "ppppppp:p:p" } // BENodeP BEGuardNode (BENodeP cond,BENodeDefP thenNodeDefs,BEStrictNodeIdP thenStricts,BENodeP then,BENodeDefP elseNodeDefs,BEStrictNodeIdP elseStricts,BENodeP elsje); BESetNodeDefRefCounts :: !BENodeP !BackEnd -> BackEnd; BESetNodeDefRefCounts a0 a1 = code { - ccall BESetNodeDefRefCounts "I:V:I" + ccall BESetNodeDefRefCounts "p:V:p" } // void BESetNodeDefRefCounts (BENodeP lhs); BEAddNodeIdsRefCounts :: !Int !BESymbolP !BENodeIdListP !BackEnd -> BackEnd; BEAddNodeIdsRefCounts a0 a1 a2 a3 = code { - ccall BEAddNodeIdsRefCounts "III:V:I" + ccall BEAddNodeIdsRefCounts "Ipp:V:p" } // void BEAddNodeIdsRefCounts (int sequenceNumber,BESymbolP symbol,BENodeIdListP nodeIds); BESwitchNode :: !BENodeIdP !BEArgP !BackEnd -> (!BENodeP,!BackEnd); BESwitchNode a0 a1 a2 = code { - ccall BESwitchNode "II:I:I" + ccall BESwitchNode "pp:p:p" } // BENodeP BESwitchNode (BENodeIdP nodeId,BEArgP caseNode); BECaseNode :: !Int !BESymbolP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BENodeP,!BackEnd); BECaseNode a0 a1 a2 a3 a4 a5 = code { - ccall BECaseNode "IIIII:I:I" + ccall BECaseNode "Ipppp:p:p" } // BENodeP BECaseNode (int symbolArity,BESymbolP symbol,BENodeDefP nodeDefs,BEStrictNodeIdP strictNodeIds,BENodeP node); BEEnterLocalScope :: !BackEnd -> BackEnd; BEEnterLocalScope a0 = code { - ccall BEEnterLocalScope ":V:I" + ccall BEEnterLocalScope ":V:p" } // void BEEnterLocalScope (); BELeaveLocalScope :: !BENodeP !BackEnd -> BackEnd; BELeaveLocalScope a0 a1 = code { - ccall BELeaveLocalScope "I:V:I" + ccall BELeaveLocalScope "p:V:p" } // void BELeaveLocalScope (BENodeP node); BEPushNode :: !Int !BESymbolP !BEArgP !BENodeIdListP !BackEnd -> (!BENodeP,!BackEnd); BEPushNode a0 a1 a2 a3 a4 = code { - ccall BEPushNode "IIII:I:I" + ccall BEPushNode "Ippp:p:p" } // BENodeP BEPushNode (int arity,BESymbolP symbol,BEArgP arguments,BENodeIdListP nodeIds); BEDefaultNode :: !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BENodeP,!BackEnd); BEDefaultNode a0 a1 a2 a3 = code { - ccall BEDefaultNode "III:I:I" + ccall BEDefaultNode "ppp:p:p" } // BENodeP BEDefaultNode (BENodeDefP nodeDefs,BEStrictNodeIdP strictNodeIds,BENodeP node); BESelectorNode :: !BESelectorKind !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd); BESelectorNode a0 a1 a2 a3 = code { - ccall BESelectorNode "III:I:I" + ccall BESelectorNode "Ipp:p:p" } // BENodeP BESelectorNode (BESelectorKind selectorKind,BESymbolP fieldSymbol,BEArgP args); BEUpdateNode :: !BEArgP !BackEnd -> (!BENodeP,!BackEnd); BEUpdateNode a0 a1 = code { - ccall BEUpdateNode "I:I:I" + ccall BEUpdateNode "p:p:p" } // BENodeP BEUpdateNode (BEArgP args); BENodeIdNode :: !BENodeIdP !BEArgP !BackEnd -> (!BENodeP,!BackEnd); BENodeIdNode a0 a1 a2 = code { - ccall BENodeIdNode "II:I:I" + ccall BENodeIdNode "pp:p:p" } // BENodeP BENodeIdNode (BENodeIdP nodeId,BEArgP args); BENoArgs :: !BackEnd -> (!BEArgP,!BackEnd); BENoArgs a0 = code { - ccall BENoArgs ":I:I" + ccall BENoArgs ":p:p" } // BEArgP BENoArgs (); BEArgs :: !BENodeP !BEArgP !BackEnd -> (!BEArgP,!BackEnd); BEArgs a0 a1 a2 = code { - ccall BEArgs "II:I:I" + ccall BEArgs "pp:p:p" } // BEArgP BEArgs (BENodeP node,BEArgP nextArgs); BERuleAlt :: !Int !BENodeDefP !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BERuleAltP,!BackEnd); BERuleAlt a0 a1 a2 a3 a4 a5 a6 = code { - ccall BERuleAlt "IIIIII:I:I" + ccall BERuleAlt "Ippppp:p:p" } // BERuleAltP BERuleAlt (int line,BENodeDefP lhsDefs,BENodeP lhs,BENodeDefP rhsDefs,BEStrictNodeIdP lhsStrictNodeIds,BENodeP rhs); BERuleAlts :: !BERuleAltP !BERuleAltP !BackEnd -> (!BERuleAltP,!BackEnd); BERuleAlts a0 a1 a2 = code { - ccall BERuleAlts "II:I:I" + ccall BERuleAlts "pp:p:p" } // BERuleAltP BERuleAlts (BERuleAltP alt,BERuleAltP alts); BENoRuleAlts :: !BackEnd -> (!BERuleAltP,!BackEnd); BENoRuleAlts a0 = code { - ccall BENoRuleAlts ":I:I" + ccall BENoRuleAlts ":p:p" } // BERuleAltP BENoRuleAlts (); BEDeclareNodeId :: !Int !Int !String !BackEnd -> BackEnd; BEDeclareNodeId a0 a1 a2 a3 = code { - ccall BEDeclareNodeId "IIS:V:I" + ccall BEDeclareNodeId "IIS:V:p" } // void BEDeclareNodeId (int sequenceNumber,int lhsOrRhs,CleanString name); BENodeId :: !Int !BackEnd -> (!BENodeIdP,!BackEnd); BENodeId a0 a1 = code { - ccall BENodeId "I:I:I" + ccall BENodeId "I:p:p" } // BENodeIdP BENodeId (int sequenceNumber); BEWildCardNodeId :: !BackEnd -> (!BENodeIdP,!BackEnd); BEWildCardNodeId a0 = code { - ccall BEWildCardNodeId ":I:I" + ccall BEWildCardNodeId ":p:p" } // BENodeIdP BEWildCardNodeId (); BENodeDef :: !Int !BENodeP !BackEnd -> (!BENodeDefP,!BackEnd); BENodeDef a0 a1 a2 = code { - ccall BENodeDef "II:I:I" + ccall BENodeDef "Ip:p:p" } // BENodeDefP BENodeDef (int sequenceNumber,BENodeP node); BENoNodeDefs :: !BackEnd -> (!BENodeDefP,!BackEnd); BENoNodeDefs a0 = code { - ccall BENoNodeDefs ":I:I" + ccall BENoNodeDefs ":p:p" } // BENodeDefP BENoNodeDefs (); BENodeDefs :: !BENodeDefP !BENodeDefP !BackEnd -> (!BENodeDefP,!BackEnd); BENodeDefs a0 a1 a2 = code { - ccall BENodeDefs "II:I:I" + ccall BENodeDefs "pp:p:p" } // BENodeDefP BENodeDefs (BENodeDefP nodeDef,BENodeDefP nodeDefs); BEStrictNodeId :: !BENodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd); BEStrictNodeId a0 a1 = code { - ccall BEStrictNodeId "I:I:I" + ccall BEStrictNodeId "p:p:p" } // BEStrictNodeIdP BEStrictNodeId (BENodeIdP nodeId); BENoStrictNodeIds :: !BackEnd -> (!BEStrictNodeIdP,!BackEnd); BENoStrictNodeIds a0 = code { - ccall BENoStrictNodeIds ":I:I" + ccall BENoStrictNodeIds ":p:p" } // BEStrictNodeIdP BENoStrictNodeIds (); BEStrictNodeIds :: !BEStrictNodeIdP !BEStrictNodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd); BEStrictNodeIds a0 a1 a2 = code { - ccall BEStrictNodeIds "II:I:I" + ccall BEStrictNodeIds "pp:p:p" } // BEStrictNodeIdP BEStrictNodeIds (BEStrictNodeIdP strictNodeId,BEStrictNodeIdP strictNodeIds); BERule :: !Int !Int !BETypeAltP !BERuleAltP !BackEnd -> (!BEImpRuleP,!BackEnd); BERule a0 a1 a2 a3 a4 = code { - ccall BERule "IIII:I:I" + ccall BERule "IIpp:p:p" } // BEImpRuleP BERule (int functionIndex,int isCaf,BETypeAltP type,BERuleAltP alts); BEDeclareRuleType :: !Int !Int !String !BackEnd -> BackEnd; BEDeclareRuleType a0 a1 a2 a3 = code { - ccall BEDeclareRuleType "IIS:V:I" + ccall BEDeclareRuleType "IIS:V:p" } // void BEDeclareRuleType (int functionIndex,int moduleIndex,CleanString name); BEDefineRuleType :: !Int !Int !BETypeAltP !BackEnd -> BackEnd; BEDefineRuleType a0 a1 a2 a3 = code { - ccall BEDefineRuleType "III:V:I" + ccall BEDefineRuleType "IIp:V:p" } // void BEDefineRuleType (int functionIndex,int moduleIndex,BETypeAltP typeAlt); BEAdjustArrayFunction :: !BEArrayFunKind !Int !Int !BackEnd -> BackEnd; BEAdjustArrayFunction a0 a1 a2 a3 = code { - ccall BEAdjustArrayFunction "III:V:I" + ccall BEAdjustArrayFunction "III:V:p" } // void BEAdjustArrayFunction (BEArrayFunKind arrayFunKind,int functionIndex,int moduleIndex); BENoRules :: !BackEnd -> (!BEImpRuleP,!BackEnd); BENoRules a0 = code { - ccall BENoRules ":I:I" + ccall BENoRules ":p:p" } // BEImpRuleP BENoRules (); BERules :: !BEImpRuleP !BEImpRuleP !BackEnd -> (!BEImpRuleP,!BackEnd); BERules a0 a1 a2 = code { - ccall BERules "II:I:I" + ccall BERules "pp:p:p" } // BEImpRuleP BERules (BEImpRuleP rule,BEImpRuleP rules); BETypes :: !BETypeP !BETypeP !BackEnd -> (!BETypeP,!BackEnd); BETypes a0 a1 a2 = code { - ccall BETypes "II:I:I" + ccall BETypes "pp:p:p" } // BETypeP BETypes (BETypeP type,BETypeP types); BENoTypes :: !BackEnd -> (!BETypeP,!BackEnd); BENoTypes a0 = code { - ccall BENoTypes ":I:I" + ccall BENoTypes ":p:p" } // BETypeP BENoTypes (); BEFlatType :: !BESymbolP !BEAttribution !BETypeVarListP !BackEnd -> (!BEFlatTypeP,!BackEnd); BEFlatType a0 a1 a2 a3 = code { - ccall BEFlatType "III:I:I" + ccall BEFlatType "pIp:p:p" } // BEFlatTypeP BEFlatType (BESymbolP symbol,BEAttribution attribution,BETypeVarListP arguments); BEAlgebraicType :: !BEFlatTypeP !BEConstructorListP !BackEnd -> BackEnd; BEAlgebraicType a0 a1 a2 = code { - ccall BEAlgebraicType "II:V:I" + ccall BEAlgebraicType "pp:V:p" } // void BEAlgebraicType (BEFlatTypeP lhs,BEConstructorListP constructors); BERecordType :: !Int !BEFlatTypeP !BETypeNodeP !Int !BEFieldListP !BackEnd -> BackEnd; BERecordType a0 a1 a2 a3 a4 a5 = code { - ccall BERecordType "IIIII:V:I" + ccall BERecordType "IppIp:V:p" } // void BERecordType (int moduleIndex,BEFlatTypeP lhs,BETypeNodeP constructorType,int is_boxed_record,BEFieldListP fields); BEAbsType :: !BEFlatTypeP !BackEnd -> BackEnd; BEAbsType a0 a1 = code { - ccall BEAbsType "I:V:I" + ccall BEAbsType "p:V:p" } // void BEAbsType (BEFlatTypeP lhs); BEConstructors :: !BEConstructorListP !BEConstructorListP !BackEnd -> (!BEConstructorListP,!BackEnd); BEConstructors a0 a1 a2 = code { - ccall BEConstructors "II:I:I" + ccall BEConstructors "pp:p:p" } // BEConstructorListP BEConstructors (BEConstructorListP constructor,BEConstructorListP constructors); BENoConstructors :: !BackEnd -> (!BEConstructorListP,!BackEnd); BENoConstructors a0 = code { - ccall BENoConstructors ":I:I" + ccall BENoConstructors ":p:p" } // BEConstructorListP BENoConstructors (); BEConstructor :: !BETypeNodeP !BackEnd -> (!BEConstructorListP,!BackEnd); BEConstructor a0 a1 = code { - ccall BEConstructor "I:I:I" + ccall BEConstructor "p:p:p" } // BEConstructorListP BEConstructor (BETypeNodeP type); BEDeclareField :: !Int !Int !String !BackEnd -> BackEnd; BEDeclareField a0 a1 a2 a3 = code { - ccall BEDeclareField "IIS:V:I" + ccall BEDeclareField "IIS:V:p" } // void BEDeclareField (int fieldIndex,int moduleIndex,CleanString name); BEField :: !Int !Int !BETypeNodeP !BackEnd -> (!BEFieldListP,!BackEnd); BEField a0 a1 a2 a3 = code { - ccall BEField "III:I:I" + ccall BEField "IIp:p:p" } // BEFieldListP BEField (int fieldIndex,int moduleIndex,BETypeNodeP type); BEFields :: !BEFieldListP !BEFieldListP !BackEnd -> (!BEFieldListP,!BackEnd); BEFields a0 a1 a2 = code { - ccall BEFields "II:I:I" + ccall BEFields "pp:p:p" } // BEFieldListP BEFields (BEFieldListP field,BEFieldListP fields); BENoFields :: !BackEnd -> (!BEFieldListP,!BackEnd); BENoFields a0 = code { - ccall BENoFields ":I:I" + ccall BENoFields ":p:p" } // BEFieldListP BENoFields (); BEDeclareConstructor :: !Int !Int !String !BackEnd -> BackEnd; BEDeclareConstructor a0 a1 a2 a3 = code { - ccall BEDeclareConstructor "IIS:V:I" + ccall BEDeclareConstructor "IIS:V:p" } // void BEDeclareConstructor (int constructorIndex,int moduleIndex,CleanString name); BETypeVar :: !String !BackEnd -> (!BETypeVarP,!BackEnd); BETypeVar a0 a1 = code { - ccall BETypeVar "S:I:I" + ccall BETypeVar "S:p:p" } // BETypeVarP BETypeVar (CleanString name); BEDeclareType :: !Int !Int !String !BackEnd -> BackEnd; BEDeclareType a0 a1 a2 a3 = code { - ccall BEDeclareType "IIS:V:I" + ccall BEDeclareType "IIS:V:p" } // void BEDeclareType (int typeIndex,int moduleIndex,CleanString name); BEDeclareFunction :: !String !Int !Int !Int !BackEnd -> BackEnd; BEDeclareFunction a0 a1 a2 a3 a4 = code { - ccall BEDeclareFunction "SIII:V:I" + ccall BEDeclareFunction "SIII:V:p" } // void BEDeclareFunction (CleanString name,int arity,int functionIndex,int ancestor); BECodeAlt :: !Int !BENodeDefP !BENodeP !BECodeBlockP !BackEnd -> (!BERuleAltP,!BackEnd); BECodeAlt a0 a1 a2 a3 a4 = code { - ccall BECodeAlt "IIII:I:I" + ccall BECodeAlt "Ippp:p:p" } // BERuleAltP BECodeAlt (int line,BENodeDefP lhsDefs,BENodeP lhs,BECodeBlockP codeBlock); BEString :: !String !BackEnd -> (!BEStringListP,!BackEnd); BEString a0 a1 = code { - ccall BEString "S:I:I" + ccall BEString "S:p:p" } // BEStringListP BEString (CleanString cleanString); BEStrings :: !BEStringListP !BEStringListP !BackEnd -> (!BEStringListP,!BackEnd); BEStrings a0 a1 a2 = code { - ccall BEStrings "II:I:I" + ccall BEStrings "pp:p:p" } // BEStringListP BEStrings (BEStringListP string,BEStringListP strings); BENoStrings :: !BackEnd -> (!BEStringListP,!BackEnd); BENoStrings a0 = code { - ccall BENoStrings ":I:I" + ccall BENoStrings ":p:p" } // BEStringListP BENoStrings (); BECodeParameter :: !String !BENodeIdP !BackEnd -> (!BECodeParameterP,!BackEnd); BECodeParameter a0 a1 a2 = code { - ccall BECodeParameter "SI:I:I" + ccall BECodeParameter "Sp:p:p" } // BECodeParameterP BECodeParameter (CleanString location,BENodeIdP nodeId); BECodeParameters :: !BECodeParameterP !BECodeParameterP !BackEnd -> (!BECodeParameterP,!BackEnd); BECodeParameters a0 a1 a2 = code { - ccall BECodeParameters "II:I:I" + ccall BECodeParameters "pp:p:p" } // BECodeParameterP BECodeParameters (BECodeParameterP parameter,BECodeParameterP parameters); BENoCodeParameters :: !BackEnd -> (!BECodeParameterP,!BackEnd); BENoCodeParameters a0 = code { - ccall BENoCodeParameters ":I:I" + ccall BENoCodeParameters ":p:p" } // BECodeParameterP BENoCodeParameters (); BENodeIdListElem :: !BENodeIdP !BackEnd -> (!BENodeIdListP,!BackEnd); BENodeIdListElem a0 a1 = code { - ccall BENodeIdListElem "I:I:I" + ccall BENodeIdListElem "p:p:p" } // BENodeIdListP BENodeIdListElem (BENodeIdP nodeId); BENodeIds :: !BENodeIdListP !BENodeIdListP !BackEnd -> (!BENodeIdListP,!BackEnd); BENodeIds a0 a1 a2 = code { - ccall BENodeIds "II:I:I" + ccall BENodeIds "pp:p:p" } // BENodeIdListP BENodeIds (BENodeIdListP nid,BENodeIdListP nids); BENoNodeIds :: !BackEnd -> (!BENodeIdListP,!BackEnd); BENoNodeIds a0 = code { - ccall BENoNodeIds ":I:I" + ccall BENoNodeIds ":p:p" } // BENodeIdListP BENoNodeIds (); BEAbcCodeBlock :: !Bool !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd); BEAbcCodeBlock a0 a1 a2 = code { - ccall BEAbcCodeBlock "II:I:I" + ccall BEAbcCodeBlock "Ip:p:p" } // BECodeBlockP BEAbcCodeBlock (int inline,BEStringListP instructions); BEAnyCodeBlock :: !BECodeParameterP !BECodeParameterP !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd); BEAnyCodeBlock a0 a1 a2 a3 = code { - ccall BEAnyCodeBlock "III:I:I" + ccall BEAnyCodeBlock "ppp:p:p" } // BECodeBlockP BEAnyCodeBlock (BECodeParameterP inParams,BECodeParameterP outParams,BEStringListP instructions); BEDeclareIclModule :: !String !String !Int !Int !Int !Int !BackEnd -> BackEnd; BEDeclareIclModule a0 a1 a2 a3 a4 a5 a6 = code { - ccall BEDeclareIclModule "SSIIII:V:I" + ccall BEDeclareIclModule "SSIIII:V:p" } // void BEDeclareIclModule (CleanString name,CleanString modificationTime,int nFunctions,int nTypes,int nConstructors,int nFields); BEDeclareDclModule :: !Int !String !String !Bool !Int !Int !Int !Int !BackEnd -> BackEnd; BEDeclareDclModule a0 a1 a2 a3 a4 a5 a6 a7 a8 = code { - ccall BEDeclareDclModule "ISSIIIII:V:I" + ccall BEDeclareDclModule "ISSIIIII:V:p" } // void BEDeclareDclModule (int moduleIndex,CleanString name,CleanString modificationTime,int systemModule,int nFunctions,int nTypes,int nConstructors,int nFields); BEDeclarePredefinedModule :: !Int !Int !BackEnd -> BackEnd; BEDeclarePredefinedModule a0 a1 a2 = code { - ccall BEDeclarePredefinedModule "II:V:I" + ccall BEDeclarePredefinedModule "II:V:p" } // void BEDeclarePredefinedModule (int nTypes,int nConstructors); BEDefineRules :: !BEImpRuleP !BackEnd -> BackEnd; BEDefineRules a0 a1 = code { - ccall BEDefineRules "I:V:I" + ccall BEDefineRules "p:V:p" } // void BEDefineRules (BEImpRuleP rules); BEGenerateCode :: !String !BackEnd -> (!Bool,!BackEnd); BEGenerateCode a0 a1 = code { - ccall BEGenerateCode "S:I:I" + ccall BEGenerateCode "S:I:p" } // int BEGenerateCode (CleanString outputFile); BEExportType :: !Bool !Int !BackEnd -> BackEnd; BEExportType a0 a1 a2 = code { - ccall BEExportType "II:V:I" + ccall BEExportType "II:V:p" } // void BEExportType (int isDictionary,int typeIndex); BEExportConstructor :: !Int !BackEnd -> BackEnd; BEExportConstructor a0 a1 = code { - ccall BEExportConstructor "I:V:I" + ccall BEExportConstructor "I:V:p" } // void BEExportConstructor (int constructorIndex); BEExportField :: !Bool !Int !BackEnd -> BackEnd; BEExportField a0 a1 a2 = code { - ccall BEExportField "II:V:I" + ccall BEExportField "II:V:p" } // void BEExportField (int isDictionaryField,int fieldIndex); BEExportFunction :: !Int !BackEnd -> BackEnd; BEExportFunction a0 a1 = code { - ccall BEExportFunction "I:V:I" + ccall BEExportFunction "I:V:p" } // void BEExportFunction (int functionIndex); BEDefineImportedObjsAndLibs :: !BEStringListP !BEStringListP !BackEnd -> BackEnd; BEDefineImportedObjsAndLibs a0 a1 a2 = code { - ccall BEDefineImportedObjsAndLibs "II:V:I" + ccall BEDefineImportedObjsAndLibs "pp:V:p" } // void BEDefineImportedObjsAndLibs (BEStringListP objs,BEStringListP libs); BEInsertForeignExport :: !BESymbolP !Int !BackEnd -> BackEnd; BEInsertForeignExport a0 a1 a2 = code { - ccall BEInsertForeignExport "II:V:I" + ccall BEInsertForeignExport "pI:V:p" } // void BEInsertForeignExport (BESymbolP symbol_p,int stdcall); BESetMainDclModuleN :: !Int !BackEnd -> BackEnd; BESetMainDclModuleN a0 a1 = code { - ccall BESetMainDclModuleN "I:V:I" + ccall BESetMainDclModuleN "I:V:p" } // void BESetMainDclModuleN (int main_dcl_module_n_parameter); BEStrictPositions :: !Int !BackEnd -> (!Int,!Int,!BackEnd); BEStrictPositions a0 a1 = code { - ccall BEStrictPositions "I:VII:I" + ccall BEStrictPositions "I:VIp:p" } // void BEStrictPositions (int functionIndex,int* bits,int** positions); /* BECopyInts :: !Int !Int !Int -> Int; BECopyInts a0 a1 a2 = code { - ccall BECopyInts "III:I" + ccall BECopyInts "Ipp:I" } */ // int BECopyInts (int cLength,int* ints,int* cleanArray); BEGetIntFromArray :: !Int !Int -> Int; BEGetIntFromArray a0 a1 = code { - ccall BEGetIntFromArray "II:I" + ccall BEGetIntFromArray "Ip:I" } // int BEGetIntFromArray (int index,int* ints); BEDeclareDynamicTypeSymbol :: !Int !Int !BackEnd -> BackEnd; BEDeclareDynamicTypeSymbol a0 a1 a2 = code { - ccall BEDeclareDynamicTypeSymbol "II:V:I" + ccall BEDeclareDynamicTypeSymbol "II:V:p" } // void BEDeclareDynamicTypeSymbol (int typeIndex,int moduleIndex); BEDynamicTempTypeSymbol :: !BackEnd -> (!BESymbolP,!BackEnd); BEDynamicTempTypeSymbol a0 = code { - ccall BEDynamicTempTypeSymbol ":I:I" + ccall BEDynamicTempTypeSymbol ":p:p" } // BESymbolP BEDynamicTempTypeSymbol (); kBEVersionCurrent:==0x02116000; @@ -818,7 +818,7 @@ BEStringType:==5; BEWorldType:==6; BEProcIdType:==7; BERedIdType:==8; -BENrOfBasicTypes:==9; +BERationalDenot:==9; BEIntDenot:==10; BEBoolDenot:==11; BECharDenot:==12; @@ -874,7 +874,9 @@ BESpecialIdentUndef:==2; BESpecialIdentStdBool:==3; BESpecialIdentAnd:==4; BESpecialIdentOr:==5; -BESpecialIdentCount:==6; +BESpecialIdentPrelude:==6; +BESpecialIdentSeq:==7; +BESpecialIdentCount:==8; BELhsNodeId:==0; BERhsNodeId:==1; BEIsNotACaf:==0; |