diff options
Diffstat (limited to 'backendC/CleanCompilerSources/backend.h')
| -rw-r--r-- | backendC/CleanCompilerSources/backend.h | 424 |
1 files changed, 424 insertions, 0 deletions
diff --git a/backendC/CleanCompilerSources/backend.h b/backendC/CleanCompilerSources/backend.h new file mode 100644 index 0000000..8445908 --- /dev/null +++ b/backendC/CleanCompilerSources/backend.h @@ -0,0 +1,424 @@ +/* version info */ + +# define kBEVersionCurrent 0x02000203 +# define kBEVersionOldestDefinition 0x02000203 +# define kBEVersionOldestImplementation 0x02000203 + +# define kBEDebug 1 + +/* pointer types */ + +Clean (:: *UWorld :== Int) + +typedef struct BackEnd *BackEnd; +Clean (:: *BackEnd :== Int) + +typedef struct symbol *BESymbolP; +Clean (:: BESymbolP :== Int) + +typedef struct type_node *BETypeNodeP; +Clean (:: BETypeNodeP :== Int) + +typedef struct type_arg *BETypeArgP; +Clean (:: BETypeArgP :== Int) + +typedef struct type_alt *BETypeAltP; +Clean (:: BETypeAltP :== Int) + +typedef struct node *BENodeP; +Clean (:: BENodeP :== Int) + +typedef struct arg *BEArgP; +Clean (:: BEArgP :== Int) + +typedef struct rule_alt *BERuleAltP; +Clean (:: BERuleAltP :== Int) + +typedef struct imp_rule *BEImpRuleP; +Clean (:: BEImpRuleP :== Int) + +typedef struct type *BETypeP; +Clean (:: BETypeP :== Int) + +typedef struct flat_type *BEFlatTypeP; +Clean (:: BEFlatTypeP :== Int) + +typedef struct type_var *BETypeVarP; +Clean (:: BETypeVarP :== Int) + +typedef struct type_var_list *BETypeVarListP; +Clean (:: BETypeVarListP :== Int) + +typedef struct constructor_list *BEConstructorListP; +Clean (:: BEConstructorListP :== Int) + +typedef struct field_list *BEFieldListP; +Clean (:: BEFieldListP :== Int) + +typedef struct node_id *BENodeIdP; +Clean (:: BENodeIdP :== Int) + +typedef struct node_def *BENodeDefP; +Clean (:: BENodeDefP :== Int) + +typedef struct strict_node_id *BEStrictNodeIdP; +Clean (:: BEStrictNodeIdP :== Int) + +typedef struct parameter *BECodeParameterP; +Clean (:: BECodeParameterP :== Int) + +typedef struct code_block *BECodeBlockP; +Clean (:: BECodeBlockP :== Int) + +typedef struct string_list *BEStringListP; +Clean (:: BEStringListP :== Int) + +/* constants */ +# define kIclModuleIndex 0 +# define kPredefinedModuleIndex 1 + +/* enum types */ +typedef int BEAnnotation; +Clean (:: BEAnnotation :== Int) +enum { + BENoAnnot, BEStrictAnnot +}; + +typedef int BEAttribution; +Clean (:: BEAttribution :== Int) +enum { + BENoUniAttr, BENotUniqueAttr, BEUniqueAttr, BEExistsAttr, BEUniqueVariable, BEFirstUniVarNumber +}; + +typedef int BESymbKind; +Clean (:: BESymbKind :== Int) +enum { + BEIntType, BEBoolType, BECharType, BERealType, + BEFileType, BEStringType, BEWorldType, BEProcIdType, + BERedIdType, + BENrOfBasicTypes, + + BEIntDenot, BEBoolDenot, BECharDenot, BERealDenot, + BENrOfBasicDenots, + + BEStringDenot, + BEFunType, BEArrayType, BEStrictArrayType, BEUnboxedArrayType, BEListType, BETupleType, BEEmptyType, + BEDynamicType, + BENrOfPredefTypes, + + BETupleSymb, BEConsSymb, BENilSymb, + BEApplySymb, BEIfSymb, BEFailSymb, BEAllSymb, + BESelectSymb, + BENrOfPredefFunsOrConses, + + BEDefinition, BENewSymbol, BEInstanceSymb, BEEmptySymbol, BEFieldSymbolList, + BEErroneousSymb +}; + +typedef int BEArrayFunKind; +Clean (::BEArrayFunKind :== Int) +enum { + BECreateArrayFun, BEArraySelectFun, BEUnqArraySelectFun, BEArrayUpdateFun, + BEArrayReplaceFun, BEArraySizeFun, BEUnqArraySizeFun, + BE_CreateArrayFun,BE_UnqArraySelectFun,BE_UnqArraySelectNextFun,BE_UnqArraySelectLastFun, + BE_ArrayUpdateFun, + BENoArrayFun +}; + +typedef int BESelectorKind; +Clean (::BESelectorKind :== Int) +enum { + BESelectorDummy, BESelector, BESelector_U, BESelector_F, BESelector_L, BESelector_N +}; + +typedef int BEUpdateKind; +Clean (::BEUpdateKind :== Int) +enum { + BEUpdateDummy, BEUpdate, BEUpdate_U +}; + + +/* functions */ + +void BEGetVersion (int *current, int *oldestDefinition, int *oldestImplementation); +Clean (BEGetVersion :: (Int, Int, Int)) + +BackEnd BEInit (int argc); +Clean (BEInit :: Int UWorld -> (BackEnd, UWorld)) + +void BEFree (BackEnd backEnd); +Clean (BEFree :: BackEnd UWorld -> UWorld) + +void BEArg (CleanString arg); +Clean (BEArg :: String BackEnd -> BackEnd) + +void BEDeclareModules (int nModules); +Clean (BEDeclareModules :: Int BackEnd -> BackEnd) + +void BEDeclarePredefinedSymbols (int nConstructors, int nTypes); +Clean (BEDeclarePredefinedSymbols :: Int Int BackEnd -> BackEnd) + +BESymbolP BESpecialArrayFunctionSymbol (BEArrayFunKind arrayFunKind, int functionIndex, int moduleIndex); +Clean (BESpecialArrayFunctionSymbol :: BEArrayFunKind Int Int BackEnd -> (BESymbolP, BackEnd)) + +BESymbolP BEDictionarySelectFunSymbol (void); +Clean (BEDictionarySelectFunSymbol :: BackEnd -> (BESymbolP, BackEnd)) + +BESymbolP BEDictionaryUpdateFunSymbol (void); +Clean (BEDictionaryUpdateFunSymbol :: BackEnd -> (BESymbolP, BackEnd)) + +BESymbolP BEFunctionSymbol (int functionIndex, int moduleIndex); +Clean (BEFunctionSymbol :: Int Int BackEnd -> (BESymbolP, BackEnd)) + +BESymbolP BEConstructorSymbol (int constructorIndex, int moduleIndex); +Clean (BEConstructorSymbol :: Int Int BackEnd -> (BESymbolP, BackEnd)) + +BESymbolP BEFieldSymbol (int fieldIndex, int moduleIndex); +Clean (BEFieldSymbol :: Int Int BackEnd -> (BESymbolP, BackEnd)) + +BESymbolP BETypeSymbol (int typeIndex, int moduleIndex); +Clean (BETypeSymbol :: Int Int BackEnd -> (BESymbolP, BackEnd)) + +BESymbolP BEDontCareDefinitionSymbol (void); +Clean (BEDontCareDefinitionSymbol :: BackEnd -> (BESymbolP, BackEnd)) + +BESymbolP BEBoolSymbol (int value); +Clean (BEBoolSymbol :: Bool BackEnd -> (BESymbolP, BackEnd)) + +BESymbolP BELiteralSymbol (BESymbKind kind, CleanString value); +Clean (BELiteralSymbol :: BESymbKind String BackEnd -> (BESymbolP, BackEnd)) + +void BEPredefineConstructorSymbol (int arity, int constructorIndex, int moduleIndex, BESymbKind symbolKind); +Clean (BEPredefineConstructorSymbol :: Int Int Int BESymbKind BackEnd -> BackEnd) + +void BEPredefineTypeSymbol (int arity, int typeIndex, int moduleIndex, BESymbKind symbolKind); +Clean (BEPredefineTypeSymbol :: Int Int Int BESymbKind BackEnd -> BackEnd) + +BESymbolP BEBasicSymbol (BESymbKind kind); +Clean (BEBasicSymbol :: Int BackEnd -> (BESymbolP, BackEnd)) + +BETypeNodeP BEVarTypeNode (CleanString name); +Clean (BEVarTypeNode :: String BackEnd -> (BETypeNodeP, BackEnd)) + +BETypeVarListP BETypeVars (BETypeVarP typeVar, BETypeVarListP typeVarList); +Clean (BETypeVars :: BETypeVarP BETypeVarListP BackEnd -> (BETypeVarListP, BackEnd)) + +BETypeVarListP BENoTypeVars (void); +Clean (BENoTypeVars :: BackEnd -> (BETypeVarListP, BackEnd)) + +BETypeNodeP BENormalTypeNode (BESymbolP symbol, BETypeArgP args); +Clean (BENormalTypeNode :: BESymbolP BETypeArgP BackEnd -> (BETypeNodeP, BackEnd)) + +BETypeNodeP BEAnnotateTypeNode (BEAnnotation annotation, BETypeNodeP typeNode); +Clean (BEAnnotateTypeNode :: BEAnnotation BETypeNodeP BackEnd -> (BETypeNodeP, BackEnd)) + +BETypeNodeP BEAttributeTypeNode (BEAttribution attribution, BETypeNodeP typeNode); +Clean (BEAttributeTypeNode :: BEAttribution BETypeNodeP BackEnd -> (BETypeNodeP, BackEnd)) + +BETypeArgP BENoTypeArgs (void); +Clean (BENoTypeArgs :: BackEnd -> (BETypeArgP, BackEnd)) + +BETypeArgP BETypeArgs (BETypeNodeP node, BETypeArgP nextArgs); +Clean (BETypeArgs :: BETypeNodeP BETypeArgP BackEnd -> (BETypeArgP, BackEnd)) + +BETypeAltP BETypeAlt (BETypeNodeP lhs, BETypeNodeP rhs); +Clean (BETypeAlt :: BETypeNodeP BETypeNodeP BackEnd -> (BETypeAltP, BackEnd)) + +BENodeP BENormalNode (BESymbolP symbol, BEArgP args); +Clean (BENormalNode :: BESymbolP BEArgP BackEnd -> (BENodeP, BackEnd)) + +BENodeP BEMatchNode (int arity, BESymbolP symbol, BENodeP node); +Clean (BEMatchNode :: Int BESymbolP BENodeP BackEnd -> (BENodeP, BackEnd)) + +BENodeP BETupleSelectNode (int arity, int index, BENodeP node); +Clean (BETupleSelectNode :: Int Int BENodeP BackEnd -> (BENodeP, BackEnd)) + +BENodeP BEIfNode (BENodeP cond, BENodeP then, BENodeP elsje); +Clean (BEIfNode :: BENodeP BENodeP BENodeP BackEnd -> (BENodeP, BackEnd)) + +BENodeP BEGuardNode (BENodeP cond, BENodeDefP thenNodeDefs, BEStrictNodeIdP thenStricts, BENodeP then, BENodeDefP elseNodeDefs, BEStrictNodeIdP elseStricts, BENodeP elsje); +Clean (BEGuardNode :: BENodeP BENodeDefP BEStrictNodeIdP BENodeP BENodeDefP BEStrictNodeIdP BENodeP BackEnd -> (BENodeP, BackEnd)) + +BENodeP BESelectorNode (BESelectorKind selectorKind, BESymbolP fieldSymbol, BEArgP args); +Clean (BESelectorNode :: BESelectorKind BESymbolP BEArgP BackEnd -> (BENodeP, BackEnd)) + +BENodeP BEUpdateNode (BEArgP args); +Clean (BEUpdateNode :: BEArgP BackEnd -> (BENodeP, BackEnd)) + +BENodeP BENodeIdNode (BENodeIdP nodeId, BEArgP args); +Clean (BENodeIdNode :: BENodeIdP BEArgP BackEnd -> (BENodeP, BackEnd)) + +BEArgP BENoArgs (void); +Clean (BENoArgs :: BackEnd -> (BEArgP, BackEnd)) + +BEArgP BEArgs (BENodeP node, BEArgP nextArgs); +Clean (BEArgs :: BENodeP BEArgP BackEnd -> (BEArgP, BackEnd)) + +BERuleAltP BERuleAlt (int line, BENodeDefP lhsDefs, BENodeP lhs, BENodeDefP rhsDefs, BEStrictNodeIdP lhsStrictNodeIds, BENodeP rhs); +Clean (BERuleAlt :: Int BENodeDefP BENodeP BENodeDefP BEStrictNodeIdP BENodeP BackEnd -> (BERuleAltP, BackEnd)) + +BERuleAltP BERuleAlts (BERuleAltP alt, BERuleAltP alts); +Clean (BERuleAlts :: BERuleAltP BERuleAltP BackEnd -> (BERuleAltP, BackEnd)) + +BERuleAltP BENoRuleAlts (void); +Clean (BENoRuleAlts :: BackEnd -> (BERuleAltP, BackEnd)) + +# define BELhsNodeId 0 +# define BERhsNodeId 1 +void BEDeclareNodeId (int sequenceNumber, int lhsOrRhs, CleanString name); +Clean (BEDeclareNodeId :: Int Int String BackEnd -> BackEnd) + +BENodeIdP BENodeId (int sequenceNumber); +Clean (BENodeId :: Int BackEnd -> (BENodeIdP, BackEnd)) + +BENodeIdP BEWildCardNodeId (void); +Clean (BEWildCardNodeId :: BackEnd -> (BENodeIdP, BackEnd)) + +BENodeDefP BENodeDef (int sequenceNumber, BENodeP node); +Clean (BENodeDef :: Int BENodeP BackEnd -> (BENodeDefP, BackEnd)) + +BENodeDefP BENoNodeDefs (void); +Clean (BENoNodeDefs :: BackEnd -> (BENodeDefP, BackEnd)) + +BENodeDefP BENodeDefs (BENodeDefP nodeDef, BENodeDefP nodeDefs); +Clean (BENodeDefs :: BENodeDefP BENodeDefP BackEnd -> (BENodeDefP, BackEnd)) + +BEStrictNodeIdP BEStrictNodeId (BENodeIdP nodeId); +Clean (BEStrictNodeId :: BENodeIdP BackEnd -> (BEStrictNodeIdP, BackEnd)) + +BEStrictNodeIdP BENoStrictNodeIds (void); +Clean (BENoStrictNodeIds :: BackEnd -> (BEStrictNodeIdP, BackEnd)) + +BEStrictNodeIdP BEStrictNodeIds (BEStrictNodeIdP strictNodeId, BEStrictNodeIdP strictNodeIds); +Clean (BEStrictNodeIds :: BEStrictNodeIdP BEStrictNodeIdP BackEnd -> (BEStrictNodeIdP, BackEnd)) + +# define BEIsNotACaf 0 +# define BEIsACaf 1 +BEImpRuleP BERule (int functionIndex, int isCaf, BETypeAltP type, BERuleAltP alts); +Clean (BERule :: Int Int BETypeAltP BERuleAltP BackEnd -> (BEImpRuleP, BackEnd)) + +void BEDeclareRuleType (int functionIndex, int moduleIndex, CleanString name); +Clean (BEDeclareRuleType :: Int Int String BackEnd -> BackEnd) + +void BEDefineRuleType (int functionIndex, int moduleIndex, BETypeAltP typeAlt); +Clean (BEDefineRuleType :: Int Int BETypeAltP BackEnd -> BackEnd) + +void BEAdjustArrayFunction (BEArrayFunKind arrayFunKind, int functionIndex, int moduleIndex); +Clean (BEAdjustArrayFunction :: BEArrayFunKind Int Int BackEnd -> BackEnd) + +BEImpRuleP BENoRules (void); +Clean (BENoRules :: BackEnd -> (BEImpRuleP, BackEnd)) + +BEImpRuleP BERules (BEImpRuleP rule, BEImpRuleP rules); +Clean (BERules :: BEImpRuleP BEImpRuleP BackEnd -> (BEImpRuleP, BackEnd)) + +BETypeP BETypes (BETypeP type, BETypeP types); +Clean (BETypes :: BETypeP BETypeP BackEnd -> (BETypeP, BackEnd)) + +BETypeP BENoTypes (void); +Clean (BENoTypes :: BackEnd -> (BETypeP, BackEnd)) + +BEFlatTypeP BEFlatType (BESymbolP symbol, BETypeVarListP arguments); +Clean (BEFlatType :: BESymbolP BETypeVarListP BackEnd -> (BEFlatTypeP, BackEnd)) + +void BEAlgebraicType (BEFlatTypeP lhs, BEConstructorListP constructors); +Clean (BEAlgebraicType:: BEFlatTypeP BEConstructorListP BackEnd -> BackEnd) + +void BERecordType (int moduleIndex, BEFlatTypeP lhs, BETypeNodeP constructorType, BEFieldListP fields); +Clean (BERecordType :: Int BEFlatTypeP BETypeNodeP BEFieldListP BackEnd -> BackEnd) + +void BEAbsType (BEFlatTypeP lhs); +Clean (BEAbsType :: BEFlatTypeP BackEnd -> BackEnd) + +BEConstructorListP BEConstructors (BEConstructorListP constructor, BEConstructorListP constructors); +Clean (BEConstructors:: BEConstructorListP BEConstructorListP BackEnd -> (BEConstructorListP, BackEnd)) + +BEConstructorListP BENoConstructors (void); +Clean (BENoConstructors:: BackEnd -> (BEConstructorListP, BackEnd)) + +BEConstructorListP BEConstructor (BETypeNodeP type); +Clean (BEConstructor:: BETypeNodeP BackEnd -> (BEConstructorListP, BackEnd)) + +void BEDeclareField (int fieldIndex, int moduleIndex, CleanString name); +Clean (BEDeclareField :: Int Int String BackEnd -> BackEnd) + +BEFieldListP BEField (int fieldIndex, int moduleIndex, BETypeNodeP type); +Clean (BEField :: Int Int BETypeNodeP BackEnd -> (BEFieldListP, BackEnd)) + +BEFieldListP BEFields (BEFieldListP field, BEFieldListP fields); +Clean (BEFields:: BEFieldListP BEFieldListP BackEnd -> (BEFieldListP, BackEnd)) + +BEFieldListP BENoFields (void); +Clean (BENoFields:: BackEnd -> (BEFieldListP, BackEnd)) + +void BEDeclareConstructor (int constructorIndex, int moduleIndex, CleanString name); +Clean (BEDeclareConstructor:: Int Int String BackEnd -> BackEnd) + +BETypeVarP BETypeVar (CleanString name); +Clean (BETypeVar:: String BackEnd -> (BETypeVarP, BackEnd)) + +void BEDeclareType (int typeIndex, int moduleIndex, CleanString name); +Clean (BEDeclareType:: Int Int String BackEnd -> BackEnd) + +void BEDeclareFunction (CleanString name, int arity, int functionIndex, int ancestor); +Clean (BEDeclareFunction :: String Int Int Int BackEnd -> BackEnd) + +BERuleAltP BECodeAlt (int line, BENodeDefP lhsDefs, BENodeP lhs, BECodeBlockP codeBlock); +Clean (BECodeAlt:: Int BENodeDefP BENodeP BECodeBlockP BackEnd -> (BERuleAltP, BackEnd)) + +BEStringListP BEString (CleanString cleanString); +Clean (BEString:: String BackEnd -> (BEStringListP, BackEnd)) + +BEStringListP BEStrings (BEStringListP string, BEStringListP strings); +Clean (BEStrings:: BEStringListP BEStringListP BackEnd -> (BEStringListP, BackEnd)) + +BEStringListP BENoStrings (void); +Clean (BENoStrings:: BackEnd -> (BEStringListP, BackEnd)) + +BECodeParameterP BECodeParameter (CleanString location, BENodeIdP nodeId); +Clean (BECodeParameter:: String BENodeIdP BackEnd -> (BECodeParameterP, BackEnd)) + +BECodeParameterP BECodeParameters (BECodeParameterP parameter, BECodeParameterP parameters); +Clean (BECodeParameters:: BECodeParameterP BECodeParameterP BackEnd -> (BECodeParameterP, BackEnd)) + +BECodeParameterP BENoCodeParameters (void); +Clean (BENoCodeParameters:: BackEnd -> (BECodeParameterP, BackEnd)) + +BECodeBlockP BEAbcCodeBlock (int inline, BEStringListP instructions); +Clean (BEAbcCodeBlock:: Bool BEStringListP BackEnd -> (BECodeBlockP, BackEnd)) + +BECodeBlockP BEAnyCodeBlock (BECodeParameterP inParams, BECodeParameterP outParams, BEStringListP instructions); +Clean (BEAnyCodeBlock:: BECodeParameterP BECodeParameterP BEStringListP BackEnd -> (BECodeBlockP, BackEnd)) + +void BEDeclareIclModule (CleanString name, int nFunctions, int nTypes, int nConstructors, int nFields); +Clean (BEDeclareIclModule :: String Int Int Int Int BackEnd -> BackEnd) + +void BEDeclareDclModule (int moduleIndex, CleanString name, int systemModule, int nFunctions, int nTypes, int nConstructors, int nFields); +Clean (BEDeclareDclModule :: Int String Bool Int Int Int Int BackEnd -> BackEnd) + +void BEDeclarePredefinedModule (int nTypes, int nConstructors); +Clean (BEDeclarePredefinedModule :: Int Int BackEnd -> BackEnd) + +void BEDefineRules (BEImpRuleP rules); +Clean (BEDefineRules :: BEImpRuleP BackEnd -> BackEnd) + +int BEGenerateCode (CleanString outputFile); +Clean (BEGenerateCode :: String BackEnd -> (Bool, BackEnd)) + +void BEExportType (int dclTypeIndex, int iclTypeIndex); +Clean (BEExportType :: Int Int BackEnd -> BackEnd) + +void BESwapTypes (int frm, int to); +Clean (BESwapTypes :: Int Int BackEnd -> BackEnd) + +void BEExportConstructor (int dclConstructorIndex, int iclConstructorIndex); +Clean (BEExportConstructor :: Int Int BackEnd -> BackEnd) + +void BEExportField (int dclTypeIndex, int iclTypeIndex); +Clean (BEExportField :: Int Int BackEnd -> BackEnd) + +void BEExportFunction (int dclFunctionIndex, int iclFunctionIndex); +Clean (BEExportFunction :: Int Int BackEnd -> BackEnd) + +void BEDefineImportedObjsAndLibs (BEStringListP objs, BEStringListP libs); +Clean (BEDefineImportedObjsAndLibs :: BEStringListP BEStringListP BackEnd -> BackEnd) |