support for cases in backend

git-svn-id: https://svn.cs.ru.nl/repos/clean-compiler/trunk@395 1f8540f1-abd5-4d5b-9d24-4c5ce8603e2d

4 files changed, 433 insertions, 198 deletions

diff --git a/backend/Clean System Files/backend_library b/backend/Clean System Files/backend_library
index 0f9aebc..acb9521 100644
--- a/backend/Clean System Files/backend_library
+++ b/backend/Clean System Files/backend_library
@@ -31,6 +31,10 @@ BEMatchNode
 BETupleSelectNode
 BEIfNode
 BEGuardNode
+BESwitchNode
+BECaseNode
+BEPushNode
+BEDefaultNode
 BESelectorNode
 BEUpdateNode
 BENodeIdNode
@@ -78,6 +82,9 @@ BENoStrings
 BECodeParameter
 BECodeParameters
 BENoCodeParameters
+BENodeIdListElem
+BENodeIds
+BENoNodeIds
 BEAbcCodeBlock
 BEAnyCodeBlock
 BEDeclareIclModule
diff --git a/backend/backend.dcl b/backend/backend.dcl
index 466e321..250972f 100644
--- a/backend/backend.dcl
+++ b/backend/backend.dcl
@@ -4,28 +4,30 @@ definition module backend;
 from StdString import String;
 //3.1
 
+:: CPtr :== Int;
 :: *UWorld :== Int;
-:: *BackEnd :== Int;
-:: BESymbolP :== Int;
-:: BETypeNodeP :== Int;
-:: BETypeArgP :== Int;
-:: BETypeAltP :== Int;
-:: BENodeP :== Int;
-:: BEArgP :== Int;
-:: BERuleAltP :== Int;
-:: BEImpRuleP :== Int;
-:: BETypeP :== Int;
-:: BEFlatTypeP :== Int;
-:: BETypeVarP :== Int;
-:: BETypeVarListP :== Int;
-:: BEConstructorListP :== Int;
-:: BEFieldListP :== Int;
-:: BENodeIdP :== Int;
-:: BENodeDefP :== Int;
-:: BEStrictNodeIdP :== Int;
-:: BECodeParameterP :== Int;
-:: BECodeBlockP :== Int;
-:: BEStringListP :== Int;
+:: *BackEnd;
+:: BESymbolP;
+:: BETypeNodeP;
+:: BETypeArgP;
+:: BETypeAltP;
+:: BENodeP;
+:: BEArgP;
+:: BERuleAltP;
+:: BEImpRuleP;
+:: BETypeP;
+:: BEFlatTypeP;
+:: BETypeVarP;
+:: BETypeVarListP;
+:: BEConstructorListP;
+:: BEFieldListP;
+:: BENodeIdP;
+:: BENodeDefP;
+:: BEStrictNodeIdP;
+:: BECodeParameterP;
+:: BECodeBlockP;
+:: BEStringListP;
+:: BENodeIdListP;
 :: BEAnnotation :== Int;
 :: BEAttribution :== Int;
 :: BESymbKind :== Int;
@@ -96,6 +98,14 @@ BEIfNode :: !BENodeP !BENodeP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
 // BENodeP BEIfNode (BENodeP cond,BENodeP then,BENodeP elsje);
 BEGuardNode :: !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BENodeDefP !BEStrictNodeIdP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
 // BENodeP BEGuardNode (BENodeP cond,BENodeDefP thenNodeDefs,BEStrictNodeIdP thenStricts,BENodeP then,BENodeDefP elseNodeDefs,BEStrictNodeIdP elseStricts,BENodeP elsje);
+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);
+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);
 BESelectorNode :: !BESelectorKind !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
 // BENodeP BESelectorNode (BESelectorKind selectorKind,BESymbolP fieldSymbol,BEArgP args);
 BEUpdateNode :: !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
@@ -190,6 +200,12 @@ BECodeParameters :: !BECodeParameterP !BECodeParameterP !BackEnd -> (!BECodePara
 // BECodeParameterP BECodeParameters (BECodeParameterP parameter,BECodeParameterP parameters);
 BENoCodeParameters :: !BackEnd -> (!BECodeParameterP,!BackEnd);
 // BECodeParameterP BENoCodeParameters ();
+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 ();
 BEAbcCodeBlock :: !Bool !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
 // BECodeBlockP BEAbcCodeBlock (int inline,BEStringListP instructions);
 BEAnyCodeBlock :: !BECodeParameterP !BECodeParameterP !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
@@ -222,9 +238,9 @@ BEDeclareDynamicTypeSymbol :: !Int !Int !BackEnd -> BackEnd;
 // void BEDeclareDynamicTypeSymbol (int typeIndex,int moduleIndex);
 BEDynamicTempTypeSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
 // BESymbolP BEDynamicTempTypeSymbol ();
-kBEVersionCurrent:==0x02000206;
-kBEVersionOldestDefinition:==0x02000204;
-kBEVersionOldestImplementation:==0x02000206;
+kBEVersionCurrent:==0x02000207;
+kBEVersionOldestDefinition:==0x02000207;
+kBEVersionOldestImplementation:==0x02000207;
 kBEDebug:==1;
 kPredefinedModuleIndex:==1;
 BENoAnnot:==0;
diff --git a/backend/backend.icl b/backend/backend.icl
index e943f69..2744e1d 100644
--- a/backend/backend.icl
+++ b/backend/backend.icl
@@ -4,28 +4,30 @@ implementation module backend;
 from StdString import String;
 //3.1
 
+:: CPtr :== Int;
 :: *UWorld :== Int;
-:: *BackEnd :== Int;
-:: BESymbolP :== Int;
-:: BETypeNodeP :== Int;
-:: BETypeArgP :== Int;
-:: BETypeAltP :== Int;
-:: BENodeP :== Int;
-:: BEArgP :== Int;
-:: BERuleAltP :== Int;
-:: BEImpRuleP :== Int;
-:: BETypeP :== Int;
-:: BEFlatTypeP :== Int;
-:: BETypeVarP :== Int;
-:: BETypeVarListP :== Int;
-:: BEConstructorListP :== Int;
-:: BEFieldListP :== Int;
-:: BENodeIdP :== Int;
-:: BENodeDefP :== Int;
-:: BEStrictNodeIdP :== Int;
-:: BECodeParameterP :== Int;
-:: BECodeBlockP :== Int;
-:: BEStringListP :== Int;
+:: *BackEnd :== CPtr;
+:: BESymbolP :== CPtr;
+:: BETypeNodeP :== CPtr;
+:: BETypeArgP :== CPtr;
+:: BETypeAltP :== CPtr;
+:: BENodeP :== CPtr;
+:: BEArgP :== CPtr;
+:: BERuleAltP :== CPtr;
+:: BEImpRuleP :== CPtr;
+:: BETypeP :== CPtr;
+:: BEFlatTypeP :== CPtr;
+:: BETypeVarP :== CPtr;
+:: BETypeVarListP :== CPtr;
+:: BEConstructorListP :== CPtr;
+:: BEFieldListP :== CPtr;
+:: BENodeIdP :== CPtr;
+:: BENodeDefP :== CPtr;
+:: BEStrictNodeIdP :== CPtr;
+:: BECodeParameterP :== CPtr;
+:: BECodeBlockP :== CPtr;
+:: BEStringListP :== CPtr;
+:: BENodeIdListP :== CPtr;
 :: BEAnnotation :== Int;
 :: BEAttribution :== Int;
 :: BESymbKind :== Int;
@@ -36,575 +38,617 @@ from StdString import String;
 BEGetVersion :: (!Int,!Int,!Int);
 BEGetVersion  = code {
 	ccall BEGetVersion ":VIII"
-}
+};
 // void BEGetVersion (int* current,int* oldestDefinition,int* oldestImplementation);
 
 BEInit :: !Int !UWorld -> (!BackEnd,!UWorld);
 BEInit a0 a1 = code {
 	ccall BEInit "I:I:I"
-}
+};
 // BackEnd BEInit (int argc);
 
 BEFree :: !BackEnd !UWorld -> UWorld;
 BEFree a0 a1 = code {
 	ccall BEFree "I:V:I"
-}
+};
 // void BEFree (BackEnd backEnd);
 
 BEArg :: !String !BackEnd -> BackEnd;
 BEArg a0 a1 = code {
 	ccall BEArg "S:V:I"
-}
+};
 // void BEArg (CleanString arg);
 
 BEDeclareModules :: !Int !BackEnd -> BackEnd;
 BEDeclareModules a0 a1 = code {
 	ccall BEDeclareModules "I:V:I"
-}
+};
 // void BEDeclareModules (int nModules);
 
 BESpecialArrayFunctionSymbol :: !BEArrayFunKind !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
 BESpecialArrayFunctionSymbol a0 a1 a2 a3 = code {
 	ccall BESpecialArrayFunctionSymbol "III:I:I"
-}
+};
 // BESymbolP BESpecialArrayFunctionSymbol (BEArrayFunKind arrayFunKind,int functionIndex,int moduleIndex);
 
 BEDictionarySelectFunSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
 BEDictionarySelectFunSymbol a0 = code {
 	ccall BEDictionarySelectFunSymbol ":I:I"
-}
+};
 // BESymbolP BEDictionarySelectFunSymbol ();
 
 BEDictionaryUpdateFunSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
 BEDictionaryUpdateFunSymbol a0 = code {
 	ccall BEDictionaryUpdateFunSymbol ":I:I"
-}
+};
 // BESymbolP BEDictionaryUpdateFunSymbol ();
 
 BEFunctionSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
 BEFunctionSymbol a0 a1 a2 = code {
 	ccall BEFunctionSymbol "II:I:I"
-}
+};
 // BESymbolP BEFunctionSymbol (int functionIndex,int moduleIndex);
 
 BEConstructorSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
 BEConstructorSymbol a0 a1 a2 = code {
 	ccall BEConstructorSymbol "II:I:I"
-}
+};
 // BESymbolP BEConstructorSymbol (int constructorIndex,int moduleIndex);
 
 BEFieldSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
 BEFieldSymbol a0 a1 a2 = code {
 	ccall BEFieldSymbol "II:I:I"
-}
+};
 // BESymbolP BEFieldSymbol (int fieldIndex,int moduleIndex);
 
 BETypeSymbol :: !Int !Int !BackEnd -> (!BESymbolP,!BackEnd);
 BETypeSymbol a0 a1 a2 = code {
 	ccall BETypeSymbol "II:I:I"
-}
+};
 // BESymbolP BETypeSymbol (int typeIndex,int moduleIndex);
 
 BEDontCareDefinitionSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
 BEDontCareDefinitionSymbol a0 = code {
 	ccall BEDontCareDefinitionSymbol ":I:I"
-}
+};
 // BESymbolP BEDontCareDefinitionSymbol ();
 
 BEBoolSymbol :: !Bool !BackEnd -> (!BESymbolP,!BackEnd);
 BEBoolSymbol a0 a1 = code {
 	ccall BEBoolSymbol "I:I:I"
-}
+};
 // BESymbolP BEBoolSymbol (int value);
 
 BELiteralSymbol :: !BESymbKind !String !BackEnd -> (!BESymbolP,!BackEnd);
 BELiteralSymbol a0 a1 a2 = code {
 	ccall BELiteralSymbol "IS:I:I"
-}
+};
 // BESymbolP BELiteralSymbol (BESymbKind kind,CleanString value);
 
 BEPredefineConstructorSymbol :: !Int !Int !Int !BESymbKind !BackEnd -> BackEnd;
 BEPredefineConstructorSymbol a0 a1 a2 a3 a4 = code {
 	ccall BEPredefineConstructorSymbol "IIII:V:I"
-}
+};
 // 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"
-}
+};
 // void BEPredefineTypeSymbol (int arity,int typeIndex,int moduleIndex,BESymbKind symbolKind);
 
 BEBasicSymbol :: !Int !BackEnd -> (!BESymbolP,!BackEnd);
 BEBasicSymbol a0 a1 = code {
 	ccall BEBasicSymbol "I:I:I"
-}
+};
 // BESymbolP BEBasicSymbol (BESymbKind kind);
 
 BEVarTypeNode :: !String !BackEnd -> (!BETypeNodeP,!BackEnd);
 BEVarTypeNode a0 a1 = code {
 	ccall BEVarTypeNode "S:I:I"
-}
+};
 // BETypeNodeP BEVarTypeNode (CleanString name);
 
 BETypeVars :: !BETypeVarP !BETypeVarListP !BackEnd -> (!BETypeVarListP,!BackEnd);
 BETypeVars a0 a1 a2 = code {
 	ccall BETypeVars "II:I:I"
-}
+};
 // BETypeVarListP BETypeVars (BETypeVarP typeVar,BETypeVarListP typeVarList);
 
 BENoTypeVars :: !BackEnd -> (!BETypeVarListP,!BackEnd);
 BENoTypeVars a0 = code {
 	ccall BENoTypeVars ":I:I"
-}
+};
 // BETypeVarListP BENoTypeVars ();
 
 BENormalTypeNode :: !BESymbolP !BETypeArgP !BackEnd -> (!BETypeNodeP,!BackEnd);
 BENormalTypeNode a0 a1 a2 = code {
 	ccall BENormalTypeNode "II:I:I"
-}
+};
 // BETypeNodeP BENormalTypeNode (BESymbolP symbol,BETypeArgP args);
 
 BEAnnotateTypeNode :: !BEAnnotation !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd);
 BEAnnotateTypeNode a0 a1 a2 = code {
 	ccall BEAnnotateTypeNode "II:I:I"
-}
+};
 // BETypeNodeP BEAnnotateTypeNode (BEAnnotation annotation,BETypeNodeP typeNode);
 
 BEAttributeTypeNode :: !BEAttribution !BETypeNodeP !BackEnd -> (!BETypeNodeP,!BackEnd);
 BEAttributeTypeNode a0 a1 a2 = code {
 	ccall BEAttributeTypeNode "II:I:I"
-}
+};
 // BETypeNodeP BEAttributeTypeNode (BEAttribution attribution,BETypeNodeP typeNode);
 
 BENoTypeArgs :: !BackEnd -> (!BETypeArgP,!BackEnd);
 BENoTypeArgs a0 = code {
 	ccall BENoTypeArgs ":I:I"
-}
+};
 // BETypeArgP BENoTypeArgs ();
 
 BETypeArgs :: !BETypeNodeP !BETypeArgP !BackEnd -> (!BETypeArgP,!BackEnd);
 BETypeArgs a0 a1 a2 = code {
 	ccall BETypeArgs "II:I:I"
-}
+};
 // BETypeArgP BETypeArgs (BETypeNodeP node,BETypeArgP nextArgs);
 
 BETypeAlt :: !BETypeNodeP !BETypeNodeP !BackEnd -> (!BETypeAltP,!BackEnd);
 BETypeAlt a0 a1 a2 = code {
 	ccall BETypeAlt "II:I:I"
-}
+};
 // BETypeAltP BETypeAlt (BETypeNodeP lhs,BETypeNodeP rhs);
 
 BENormalNode :: !BESymbolP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
 BENormalNode a0 a1 a2 = code {
 	ccall BENormalNode "II:I:I"
-}
+};
 // BENodeP BENormalNode (BESymbolP symbol,BEArgP args);
 
 BEMatchNode :: !Int !BESymbolP !BENodeP !BackEnd -> (!BENodeP,!BackEnd);
 BEMatchNode a0 a1 a2 a3 = code {
 	ccall BEMatchNode "III:I:I"
-}
+};
 // 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"
-}
+};
 // 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"
-}
+};
 // 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"
-}
+};
 // BENodeP BEGuardNode (BENodeP cond,BENodeDefP thenNodeDefs,BEStrictNodeIdP thenStricts,BENodeP then,BENodeDefP elseNodeDefs,BEStrictNodeIdP elseStricts,BENodeP elsje);
 
+BESwitchNode :: !BENodeIdP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
+BESwitchNode a0 a1 a2 = code {
+	ccall BESwitchNode "II:I:I"
+};
+// 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"
+};
+// BENodeP BECaseNode (int symbolArity,BESymbolP symbol,BENodeDefP nodeDefs,BEStrictNodeIdP strictNodeIds,BENodeP node);
+
+BEPushNode :: !Int !BESymbolP !BEArgP !BENodeIdListP !BackEnd -> (!BENodeP,!BackEnd);
+BEPushNode a0 a1 a2 a3 a4 = code {
+	ccall BEPushNode "IIII:I:I"
+};
+// 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"
+};
+// 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"
-}
+};
 // BENodeP BESelectorNode (BESelectorKind selectorKind,BESymbolP fieldSymbol,BEArgP args);
 
 BEUpdateNode :: !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
 BEUpdateNode a0 a1 = code {
 	ccall BEUpdateNode "I:I:I"
-}
+};
 // BENodeP BEUpdateNode (BEArgP args);
 
 BENodeIdNode :: !BENodeIdP !BEArgP !BackEnd -> (!BENodeP,!BackEnd);
 BENodeIdNode a0 a1 a2 = code {
 	ccall BENodeIdNode "II:I:I"
-}
+};
 // BENodeP BENodeIdNode (BENodeIdP nodeId,BEArgP args);
 
 BENoArgs :: !BackEnd -> (!BEArgP,!BackEnd);
 BENoArgs a0 = code {
 	ccall BENoArgs ":I:I"
-}
+};
 // BEArgP BENoArgs ();
 
 BEArgs :: !BENodeP !BEArgP !BackEnd -> (!BEArgP,!BackEnd);
 BEArgs a0 a1 a2 = code {
 	ccall BEArgs "II:I:I"
-}
+};
 // 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"
-}
+};
 // 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"
-}
+};
 // BERuleAltP BERuleAlts (BERuleAltP alt,BERuleAltP alts);
 
 BENoRuleAlts :: !BackEnd -> (!BERuleAltP,!BackEnd);
 BENoRuleAlts a0 = code {
 	ccall BENoRuleAlts ":I:I"
-}
+};
 // BERuleAltP BENoRuleAlts ();
 
 BEDeclareNodeId :: !Int !Int !String !BackEnd -> BackEnd;
 BEDeclareNodeId a0 a1 a2 a3 = code {
 	ccall BEDeclareNodeId "IIS:V:I"
-}
+};
 // void BEDeclareNodeId (int sequenceNumber,int lhsOrRhs,CleanString name);
 
 BENodeId :: !Int !BackEnd -> (!BENodeIdP,!BackEnd);
 BENodeId a0 a1 = code {
 	ccall BENodeId "I:I:I"
-}
+};
 // BENodeIdP BENodeId (int sequenceNumber);
 
 BEWildCardNodeId :: !BackEnd -> (!BENodeIdP,!BackEnd);
 BEWildCardNodeId a0 = code {
 	ccall BEWildCardNodeId ":I:I"
-}
+};
 // BENodeIdP BEWildCardNodeId ();
 
 BENodeDef :: !Int !BENodeP !BackEnd -> (!BENodeDefP,!BackEnd);
 BENodeDef a0 a1 a2 = code {
 	ccall BENodeDef "II:I:I"
-}
+};
 // BENodeDefP BENodeDef (int sequenceNumber,BENodeP node);
 
 BENoNodeDefs :: !BackEnd -> (!BENodeDefP,!BackEnd);
 BENoNodeDefs a0 = code {
 	ccall BENoNodeDefs ":I:I"
-}
+};
 // BENodeDefP BENoNodeDefs ();
 
 BENodeDefs :: !BENodeDefP !BENodeDefP !BackEnd -> (!BENodeDefP,!BackEnd);
 BENodeDefs a0 a1 a2 = code {
 	ccall BENodeDefs "II:I:I"
-}
+};
 // BENodeDefP BENodeDefs (BENodeDefP nodeDef,BENodeDefP nodeDefs);
 
 BEStrictNodeId :: !BENodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
 BEStrictNodeId a0 a1 = code {
 	ccall BEStrictNodeId "I:I:I"
-}
+};
 // BEStrictNodeIdP BEStrictNodeId (BENodeIdP nodeId);
 
 BENoStrictNodeIds :: !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
 BENoStrictNodeIds a0 = code {
 	ccall BENoStrictNodeIds ":I:I"
-}
+};
 // BEStrictNodeIdP BENoStrictNodeIds ();
 
 BEStrictNodeIds :: !BEStrictNodeIdP !BEStrictNodeIdP !BackEnd -> (!BEStrictNodeIdP,!BackEnd);
 BEStrictNodeIds a0 a1 a2 = code {
 	ccall BEStrictNodeIds "II:I:I"
-}
+};
 // 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"
-}
+};
 // 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"
-}
+};
 // 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"
-}
+};
 // 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"
-}
+};
 // void BEAdjustArrayFunction (BEArrayFunKind arrayFunKind,int functionIndex,int moduleIndex);
 
 BENoRules :: !BackEnd -> (!BEImpRuleP,!BackEnd);
 BENoRules a0 = code {
 	ccall BENoRules ":I:I"
-}
+};
 // BEImpRuleP BENoRules ();
 
 BERules :: !BEImpRuleP !BEImpRuleP !BackEnd -> (!BEImpRuleP,!BackEnd);
 BERules a0 a1 a2 = code {
 	ccall BERules "II:I:I"
-}
+};
 // BEImpRuleP BERules (BEImpRuleP rule,BEImpRuleP rules);
 
 BETypes :: !BETypeP !BETypeP !BackEnd -> (!BETypeP,!BackEnd);
 BETypes a0 a1 a2 = code {
 	ccall BETypes "II:I:I"
-}
+};
 // BETypeP BETypes (BETypeP type,BETypeP types);
 
 BENoTypes :: !BackEnd -> (!BETypeP,!BackEnd);
 BENoTypes a0 = code {
 	ccall BENoTypes ":I:I"
-}
+};
 // BETypeP BENoTypes ();
 
 BEFlatType :: !BESymbolP !BETypeVarListP !BackEnd -> (!BEFlatTypeP,!BackEnd);
 BEFlatType a0 a1 a2 = code {
 	ccall BEFlatType "II:I:I"
-}
+};
 // BEFlatTypeP BEFlatType (BESymbolP symbol,BETypeVarListP arguments);
 
 BEAlgebraicType :: !BEFlatTypeP !BEConstructorListP !BackEnd -> BackEnd;
 BEAlgebraicType a0 a1 a2 = code {
 	ccall BEAlgebraicType "II:V:I"
-}
+};
 // void BEAlgebraicType (BEFlatTypeP lhs,BEConstructorListP constructors);
 
 BERecordType :: !Int !BEFlatTypeP !BETypeNodeP !BEFieldListP !BackEnd -> BackEnd;
 BERecordType a0 a1 a2 a3 a4 = code {
 	ccall BERecordType "IIII:V:I"
-}
+};
 // void BERecordType (int moduleIndex,BEFlatTypeP lhs,BETypeNodeP constructorType,BEFieldListP fields);
 
 BEAbsType :: !BEFlatTypeP !BackEnd -> BackEnd;
 BEAbsType a0 a1 = code {
 	ccall BEAbsType "I:V:I"
-}
+};
 // void BEAbsType (BEFlatTypeP lhs);
 
 BEConstructors :: !BEConstructorListP !BEConstructorListP !BackEnd -> (!BEConstructorListP,!BackEnd);
 BEConstructors a0 a1 a2 = code {
 	ccall BEConstructors "II:I:I"
-}
+};
 // BEConstructorListP BEConstructors (BEConstructorListP constructor,BEConstructorListP constructors);
 
 BENoConstructors :: !BackEnd -> (!BEConstructorListP,!BackEnd);
 BENoConstructors a0 = code {
 	ccall BENoConstructors ":I:I"
-}
+};
 // BEConstructorListP BENoConstructors ();
 
 BEConstructor :: !BETypeNodeP !BackEnd -> (!BEConstructorListP,!BackEnd);
 BEConstructor a0 a1 = code {
 	ccall BEConstructor "I:I:I"
-}
+};
 // BEConstructorListP BEConstructor (BETypeNodeP type);
 
 BEDeclareField :: !Int !Int !String !BackEnd -> BackEnd;
 BEDeclareField a0 a1 a2 a3 = code {
 	ccall BEDeclareField "IIS:V:I"
-}
+};
 // 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"
-}
+};
 // BEFieldListP BEField (int fieldIndex,int moduleIndex,BETypeNodeP type);
 
 BEFields :: !BEFieldListP !BEFieldListP !BackEnd -> (!BEFieldListP,!BackEnd);
 BEFields a0 a1 a2 = code {
 	ccall BEFields "II:I:I"
-}
+};
 // BEFieldListP BEFields (BEFieldListP field,BEFieldListP fields);
 
 BENoFields :: !BackEnd -> (!BEFieldListP,!BackEnd);
 BENoFields a0 = code {
 	ccall BENoFields ":I:I"
-}
+};
 // BEFieldListP BENoFields ();
 
 BEDeclareConstructor :: !Int !Int !String !BackEnd -> BackEnd;
 BEDeclareConstructor a0 a1 a2 a3 = code {
 	ccall BEDeclareConstructor "IIS:V:I"
-}
+};
 // void BEDeclareConstructor (int constructorIndex,int moduleIndex,CleanString name);
 
 BETypeVar :: !String !BackEnd -> (!BETypeVarP,!BackEnd);
 BETypeVar a0 a1 = code {
 	ccall BETypeVar "S:I:I"
-}
+};
 // BETypeVarP BETypeVar (CleanString name);
 
 BEDeclareType :: !Int !Int !String !BackEnd -> BackEnd;
 BEDeclareType a0 a1 a2 a3 = code {
 	ccall BEDeclareType "IIS:V:I"
-}
+};
 // 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"
-}
+};
 // 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"
-}
+};
 // BERuleAltP BECodeAlt (int line,BENodeDefP lhsDefs,BENodeP lhs,BECodeBlockP codeBlock);
 
 BEString :: !String !BackEnd -> (!BEStringListP,!BackEnd);
 BEString a0 a1 = code {
 	ccall BEString "S:I:I"
-}
+};
 // BEStringListP BEString (CleanString cleanString);
 
 BEStrings :: !BEStringListP !BEStringListP !BackEnd -> (!BEStringListP,!BackEnd);
 BEStrings a0 a1 a2 = code {
 	ccall BEStrings "II:I:I"
-}
+};
 // BEStringListP BEStrings (BEStringListP string,BEStringListP strings);
 
 BENoStrings :: !BackEnd -> (!BEStringListP,!BackEnd);
 BENoStrings a0 = code {
 	ccall BENoStrings ":I:I"
-}
+};
 // BEStringListP BENoStrings ();
 
 BECodeParameter :: !String !BENodeIdP !BackEnd -> (!BECodeParameterP,!BackEnd);
 BECodeParameter a0 a1 a2 = code {
 	ccall BECodeParameter "SI:I:I"
-}
+};
 // BECodeParameterP BECodeParameter (CleanString location,BENodeIdP nodeId);
 
 BECodeParameters :: !BECodeParameterP !BECodeParameterP !BackEnd -> (!BECodeParameterP,!BackEnd);
 BECodeParameters a0 a1 a2 = code {
 	ccall BECodeParameters "II:I:I"
-}
+};
 // BECodeParameterP BECodeParameters (BECodeParameterP parameter,BECodeParameterP parameters);
 
 BENoCodeParameters :: !BackEnd -> (!BECodeParameterP,!BackEnd);
 BENoCodeParameters a0 = code {
 	ccall BENoCodeParameters ":I:I"
-}
+};
 // BECodeParameterP BENoCodeParameters ();
 
+BENodeIdListElem :: !BENodeIdP !BackEnd -> (!BENodeIdListP,!BackEnd);
+BENodeIdListElem a0 a1 = code {
+	ccall BENodeIdListElem "I:I:I"
+};
+// BENodeIdListP BENodeIdListElem (BENodeIdP nodeId);
+
+BENodeIds :: !BENodeIdListP !BENodeIdListP !BackEnd -> (!BENodeIdListP,!BackEnd);
+BENodeIds a0 a1 a2 = code {
+	ccall BENodeIds "II:I:I"
+};
+// BENodeIdListP BENodeIds (BENodeIdListP nid,BENodeIdListP nids);
+
+BENoNodeIds :: !BackEnd -> (!BENodeIdListP,!BackEnd);
+BENoNodeIds a0 = code {
+	ccall BENoNodeIds ":I:I"
+};
+// BENodeIdListP BENoNodeIds ();
+
 BEAbcCodeBlock :: !Bool !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
 BEAbcCodeBlock a0 a1 a2 = code {
 	ccall BEAbcCodeBlock "II:I:I"
-}
+};
 // BECodeBlockP BEAbcCodeBlock (int inline,BEStringListP instructions);
 
 BEAnyCodeBlock :: !BECodeParameterP !BECodeParameterP !BEStringListP !BackEnd -> (!BECodeBlockP,!BackEnd);
 BEAnyCodeBlock a0 a1 a2 a3 = code {
 	ccall BEAnyCodeBlock "III:I:I"
-}
+};
 // BECodeBlockP BEAnyCodeBlock (BECodeParameterP inParams,BECodeParameterP outParams,BEStringListP instructions);
 
 BEDeclareIclModule :: !String !Int !Int !Int !Int !BackEnd -> BackEnd;
 BEDeclareIclModule a0 a1 a2 a3 a4 a5 = code {
 	ccall BEDeclareIclModule "SIIII:V:I"
-}
+};
 // void BEDeclareIclModule (CleanString name,int nFunctions,int nTypes,int nConstructors,int nFields);
 
 BEDeclareDclModule :: !Int !String !Bool !Int !Int !Int !Int !BackEnd -> BackEnd;
 BEDeclareDclModule a0 a1 a2 a3 a4 a5 a6 a7 = code {
 	ccall BEDeclareDclModule "ISIIIII:V:I"
-}
+};
 // void BEDeclareDclModule (int moduleIndex,CleanString name,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"
-}
+};
 // void BEDeclarePredefinedModule (int nTypes,int nConstructors);
 
 BEDefineRules :: !BEImpRuleP !BackEnd -> BackEnd;
 BEDefineRules a0 a1 = code {
 	ccall BEDefineRules "I:V:I"
-}
+};
 // void BEDefineRules (BEImpRuleP rules);
 
 BEGenerateCode :: !String !BackEnd -> (!Bool,!BackEnd);
 BEGenerateCode a0 a1 = code {
 	ccall BEGenerateCode "S:I:I"
-}
+};
 // int BEGenerateCode (CleanString outputFile);
 
 BEExportType :: !Int !Int !BackEnd -> BackEnd;
 BEExportType a0 a1 a2 = code {
 	ccall BEExportType "II:V:I"
-}
+};
 // void BEExportType (int dclTypeIndex,int iclTypeIndex);
 
 BESwapTypes :: !Int !Int !BackEnd -> BackEnd;
 BESwapTypes a0 a1 a2 = code {
 	ccall BESwapTypes "II:V:I"
-}
+};
 // void BESwapTypes (int frm,int to);
 
 BEExportConstructor :: !Int !Int !BackEnd -> BackEnd;
 BEExportConstructor a0 a1 a2 = code {
 	ccall BEExportConstructor "II:V:I"
-}
+};
 // void BEExportConstructor (int dclConstructorIndex,int iclConstructorIndex);
 
 BEExportField :: !Int !Int !BackEnd -> BackEnd;
 BEExportField a0 a1 a2 = code {
 	ccall BEExportField "II:V:I"
-}
+};
 // void BEExportField (int dclTypeIndex,int iclTypeIndex);
 
 BEExportFunction :: !Int !Int !BackEnd -> BackEnd;
 BEExportFunction a0 a1 a2 = code {
 	ccall BEExportFunction "II:V:I"
-}
+};
 // void BEExportFunction (int dclFunctionIndex,int iclFunctionIndex);
 
 BEDefineImportedObjsAndLibs :: !BEStringListP !BEStringListP !BackEnd -> BackEnd;
 BEDefineImportedObjsAndLibs a0 a1 a2 = code {
 	ccall BEDefineImportedObjsAndLibs "II:V:I"
-}
+};
 // void BEDefineImportedObjsAndLibs (BEStringListP objs,BEStringListP libs);
 
 BESetMainDclModuleN :: !Int !BackEnd -> BackEnd;
 BESetMainDclModuleN a0 a1 = code {
 	ccall BESetMainDclModuleN "I:V:I"
-}
+};
 // void BESetMainDclModuleN (int main_dcl_module_n_parameter);
 
 BEDeclareDynamicTypeSymbol :: !Int !Int !BackEnd -> BackEnd;
 BEDeclareDynamicTypeSymbol a0 a1 a2 = code {
 	ccall BEDeclareDynamicTypeSymbol "II:V:I"
-}
+};
 // void BEDeclareDynamicTypeSymbol (int typeIndex,int moduleIndex);
 
 BEDynamicTempTypeSymbol :: !BackEnd -> (!BESymbolP,!BackEnd);
 BEDynamicTempTypeSymbol a0 = code {
 	ccall BEDynamicTempTypeSymbol ":I:I"
-}
+};
 // BESymbolP BEDynamicTempTypeSymbol ();
-kBEVersionCurrent:==0x02000206;
-kBEVersionOldestDefinition:==0x02000204;
-kBEVersionOldestImplementation:==0x02000206;
+kBEVersionCurrent:==0x02000207;
+kBEVersionOldestDefinition:==0x02000207;
+kBEVersionOldestImplementation:==0x02000207;
 kBEDebug:==1;
 kPredefinedModuleIndex:==1;
 BENoAnnot:==0;
diff --git a/backend/backendconvert.icl b/backend/backendconvert.icl
index 401f824..f769ce1 100644
--- a/backend/backendconvert.icl
+++ b/backend/backendconvert.icl
@@ -8,6 +8,7 @@ import frontend
 import backend
 import backendsupport, backendpreprocess
 import RWSDebug
+import StdDebug
 
 // trace macro
 (-*->) infixl
@@ -26,6 +27,11 @@ sfoldr op r l s
 		foldr [] = r
 		foldr [a:x] = op a (foldr x)
 
+// fix spelling, this will be removed when cases are implemented in the back end
+:: BackEndBody :== BackendBody
+BackEndBody x :== BackendBody x
+
+
 :: BEMonad a :== St !*BackEndState !a
 
 :: BackEnder :== *BackEndState -> *BackEndState
@@ -180,8 +186,8 @@ beFieldSymbol fieldIndex moduleIndex
 	:==	beFunction0 (BEFieldSymbol fieldIndex moduleIndex)
 beTypeSymbol typeIndex moduleIndex
 	:==	beFunction0 (BETypeSymbol typeIndex moduleIndex)
-beBasicSymbol typeSymbolIndex
-	:==	beFunction0 (BEBasicSymbol typeSymbolIndex)
+beBasicSymbol symbolIndex
+	:==	beFunction0 (BEBasicSymbol symbolIndex)
 beDontCareDefinitionSymbol
 	:==	beFunction0 BEDontCareDefinitionSymbol
 beNoArgs
@@ -304,6 +310,20 @@ beDefineImportedObjsAndLibs
 	:== beApFunction2 BEDefineImportedObjsAndLibs
 beAbsType
 	:== beApFunction1 BEAbsType
+beSwitchNode
+	:==	beFunction2 BESwitchNode
+beCaseNode symbolArity
+	:== beFunction4 (BECaseNode symbolArity)
+bePushNode symbolArity
+	:== beFunction3 (BEPushNode symbolArity)
+beDefaultNode
+	:==	beFunction3 BEDefaultNode
+beNoNodeIds
+	:==	beFunction0 BENoNodeIds
+beNodeIds
+	:==	beFunction2 BENodeIds
+beNodeIdListElem
+	:==	beFunction1 BENodeIdListElem
 // temporary hack
 beDynamicTempTypeSymbol
 	:== beFunction0 BEDynamicTempTypeSymbol
@@ -335,8 +355,7 @@ backEndConvertModulesH predefs {fe_icl = fe_icl =: {icl_name, icl_functions, icl
 					=	backEnd
 	#  backEnd
 		=	abort "front end abort" backEnd
-*/
-	#! backEnd = appBackEnd (BESetMainDclModuleN main_dcl_module_n) backEnd
+*/	#! backEnd = appBackEnd (BESetMainDclModuleN main_dcl_module_n) backEnd
 	#! backEnd
 		=	appBackEnd (BEDeclareModules (size fe_dcls)) backEnd
 	#! backEnd
@@ -589,6 +608,8 @@ instance declareVars Expression where
 	declareVars (Conditional {if_then, if_else}) dvInput
 		=	declareVars if_then dvInput
 		o`	declareVars if_else dvInput
+	declareVars (Case caseExpr) dvInput
+		=	declareVars caseExpr dvInput
 	declareVars (AnyCodeExpr _ outParams _) (_, varHeap)
 		=	foldState (declVar varHeap) outParams 
 	  where
@@ -609,6 +630,26 @@ instance declareVars BackendBody where
 		=	declareVars bb_args dvInput
 		o`	declareVars bb_rhs dvInput
 
+instance declareVars Case where
+	declareVars {case_expr, case_guards, case_default} dvInput
+		=	declareVars case_guards dvInput
+		o`	declareVars case_default dvInput
+
+instance declareVars CasePatterns where
+	declareVars (AlgebraicPatterns _ patterns) dvInput
+		=	declareVars patterns dvInput
+	declareVars (BasicPatterns _ patterns) dvInput
+		=	declareVars patterns dvInput
+
+instance declareVars AlgebraicPattern where
+	declareVars {ap_vars, ap_expr} dvInput
+		=	declareVars ap_vars dvInput
+		o`	declareVars ap_expr dvInput
+
+instance declareVars BasicPattern where
+	declareVars {bp_expr} dvInput
+		=	declareVars bp_expr dvInput
+
 :: ModuleIndex :== Index
 
 class declare a :: ModuleIndex !VarHeap a  -> BackEnder
@@ -972,6 +1013,7 @@ adjustArrayFunctions predefs arrayInstancesRange main_dcl_module_n functions dcl
 											_
 												->	identity) be
 
+
 		adjustIclArrayInstances :: IndexRange {#BEArrayFunKind} {#FunDef} -> BackEnder
 		adjustIclArrayInstances  {ir_from, ir_to} mapping instances
 			=	foldStateWithIndexRangeA (adjustIclArrayInstance mapping) ir_from ir_to instances
@@ -1009,7 +1051,7 @@ convertRules rules main_dcl_module_n aliasDummyId varHeap be
 convertRule :: Ident (Int,FunDef) Int VarHeap -> BEMonad BEImpRuleP
 convertRule aliasDummyId (index, {fun_type=Yes type, fun_body=body, fun_pos, fun_kind, fun_symb}) main_dcl_module_n varHeap
 	=	beRule index (cafness fun_kind)
-			(convertTypeAlt index main_dcl_module_n (type /* ->> ("convertRule", fun_symb.id_name, index, type) */))
+			(convertTypeAlt index main_dcl_module_n (type -*-> ("convertRule", fun_symb.id_name, index, type)))
 			(convertFunctionBody index (positionToLineNumber fun_pos) aliasDummyId body main_dcl_module_n varHeap)
 	where
 		cafness :: DefOrImpFunKind -> Int
@@ -1036,7 +1078,9 @@ convertRule aliasDummyId (index, {fun_type=Yes type, fun_body=body, fun_pos, fun
 
 convertTypeAlt :: Int ModuleIndex SymbolType -> BEMonad BETypeAltP
 convertTypeAlt functionIndex moduleIndex symbol=:{st_result}
-	=	beTypeAlt (beNormalTypeNode (beFunctionSymbol functionIndex moduleIndex) (convertSymbolTypeArgs symbol)) (convertAnnotTypeNode st_result)
+	=	beTypeAlt
+			(beNormalTypeNode (beFunctionSymbol functionIndex moduleIndex) (convertSymbolTypeArgs symbol))
+			(convertAnnotTypeNode st_result)
 
 convertSymbolTypeArgs :: SymbolType -> BEMonad BETypeArgP
 convertSymbolTypeArgs {st_args}
@@ -1093,13 +1137,10 @@ convertAnnotTypeNode {at_type, at_annotation, at_attribute}
 convertTypeNode :: Type -> BEMonad BETypeNodeP
 convertTypeNode (TB (BT_String type))
 	=	convertTypeNode type
-// tempory hack
 convertTypeNode (TB BT_Dynamic)
 	=	beNormalTypeNode beDynamicTempTypeSymbol beNoTypeArgs	
 convertTypeNode (TB basicType)
 	=	beNormalTypeNode (beBasicSymbol (convertBasicTypeKind basicType)) beNoTypeArgs	
-convertTypeNode (TB basicType)
-	=	beNormalTypeNode (beBasicSymbol (convertBasicTypeKind basicType)) beNoTypeArgs	
 convertTypeNode (TA typeSymbolIdent typeArgs)
 	=	beNormalTypeNode (convertTypeSymbolIdent typeSymbolIdent) (convertTypeArgs typeArgs)
 convertTypeNode (TV {tv_name})
@@ -1115,7 +1156,7 @@ convertTypeNode (a :@: b)
 convertTypeNode TE
 	=	beNormalTypeNode beDontCareDefinitionSymbol beNoTypeArgs
 convertTypeNode typeNode
-	=	undef <<- ("backendconvert, convertTypeNode: unknown type node", typeNode)
+	=	abort "convertTypeNode" <<- ("backendconvert, convertTypeNode: unknown type node", typeNode)
 
 consVariableToType :: ConsVariable -> Type
 consVariableToType (CV typeVar)
@@ -1129,45 +1170,96 @@ convertTypeArgs :: [AType] -> BEMonad BETypeArgP
 convertTypeArgs args
 	=	sfoldr (beTypeArgs o convertAnnotTypeNode) beNoTypeArgs args
 
+convertTransformedBody :: Int Int Ident TransformedBody Int VarHeap -> BEMonad BERuleAltP
+convertTransformedBody functionIndex lineNumber aliasDummyId body main_dcl_module_n varHeap
+	| isCodeBlock body.tb_rhs
+		=	declareVars body (aliasDummyId, varHeap)
+		o`	convertCodeBody functionIndex lineNumber aliasDummyId body main_dcl_module_n varHeap
+	// otherwise
+		=	declareVars body (aliasDummyId, varHeap)
+		o`	convertBody functionIndex lineNumber aliasDummyId (map FP_Variable body.tb_args) body.tb_rhs main_dcl_module_n varHeap
+
+isCodeBlock :: Expression -> Bool
+isCodeBlock (Case {case_expr=Var _, case_guards=AlgebraicPatterns _ [{ap_expr}]})
+	=	isCodeBlock ap_expr
+isCodeBlock (ABCCodeExpr _ _)
+	=	True
+isCodeBlock (AnyCodeExpr _ _ _)
+	=	True
+isCodeBlock expr
+	=	False
+
 convertFunctionBody :: Int Int Ident FunctionBody Int VarHeap -> BEMonad BERuleAltP
-convertFunctionBody functionIndex lineNumber aliasDummyId (BackendBody bodies) main_dcl_module_n varHeap
-	=	convertBackendBodies functionIndex lineNumber bodies varHeap
+convertFunctionBody functionIndex lineNumber aliasDummyId (BackEndBody bodies) main_dcl_module_n varHeap
+	=	convertBackEndBodies functionIndex lineNumber bodies main_dcl_module_n varHeap
 where
-	convertBackendBodies :: Int Int [BackendBody] VarHeap -> BEMonad BERuleAltP
-	convertBackendBodies functionIndex lineNumber bodies varHeap
-		=	sfoldr (beRuleAlts o (flip (convertBackendBody functionIndex lineNumber)) varHeap) beNoRuleAlts bodies
+	convertBackEndBodies :: Int Int [BackEndBody] Int VarHeap -> BEMonad BERuleAltP
+	convertBackEndBodies functionIndex lineNumber bodies main_dcl_module_n varHeap
+		=	sfoldr (beRuleAlts o convertBackEndBody functionIndex lineNumber aliasDummyId main_dcl_module_n varHeap) beNoRuleAlts bodies
+	where
+		convertBackEndBody :: Int Int Ident Int VarHeap BackEndBody -> BEMonad BERuleAltP
+		convertBackEndBody functionIndex lineNumber aliasDummyId main_dcl_module_n varHeap body
+			=	declareVars body (aliasDummyId, varHeap)
+			o`	convertBody functionIndex lineNumber aliasDummyId body.bb_args body.bb_rhs main_dcl_module_n varHeap
+convertFunctionBody functionIndex lineNumber aliasDummyId (TransformedBody body) main_dcl_module_n varHeap
+	=	convertTransformedBody functionIndex lineNumber aliasDummyId body main_dcl_module_n varHeap
+
+convertCodeBody :: Int Int Ident TransformedBody Int VarHeap -> BEMonad BERuleAltP
+convertCodeBody functionIndex lineNumber aliasDummyId body main_dcl_module_n varHeap
+	=	convertBody functionIndex lineNumber aliasDummyId patterns expr main_dcl_module_n varHeap
 	where
-		convertBackendBody :: Int Int BackendBody VarHeap -> BEMonad BERuleAltP
-		convertBackendBody functionIndex lineNumber body=:{bb_args, bb_rhs=ABCCodeExpr instructions inline} varHeap
-			=	beNoNodeDefs ==> \noNodeDefs
-			->	declareVars body (aliasDummyId, varHeap)
-			o`	beCodeAlt
-					lineNumber
-					(convertLhsNodeDefs bb_args noNodeDefs varHeap)
-					(convertBackendLhs functionIndex bb_args varHeap)
-					(beAbcCodeBlock inline (convertStrings instructions))
-		convertBackendBody functionIndex lineNumber body=:{bb_args, bb_rhs=AnyCodeExpr inParams outParams instructions} varHeap
-			=	beNoNodeDefs ==> \noNodeDefs
-			->	declareVars body (aliasDummyId, varHeap)
-			o`	beCodeAlt
-					lineNumber
-					(convertLhsNodeDefs bb_args noNodeDefs varHeap)
-					(convertBackendLhs functionIndex bb_args varHeap)
-					(beAnyCodeBlock (convertCodeParameters inParams varHeap) (convertCodeParameters outParams varHeap) (convertStrings instructions))
-		convertBackendBody functionIndex lineNumber body=:{bb_args, bb_rhs} varHeap
-			=	beNoNodeDefs ==> \noNodeDefs
-			->	declareVars body (aliasDummyId, varHeap)
-			o`	beRuleAlt
-					lineNumber
-					(convertLhsNodeDefs bb_args noNodeDefs varHeap)
-					(convertBackendLhs functionIndex bb_args varHeap)
-					(convertRhsNodeDefs aliasDummyId bb_rhs main_dcl_module_n varHeap)
-					(convertRhsStrictNodeIds bb_rhs varHeap)
-					(convertRootExpr aliasDummyId bb_rhs main_dcl_module_n varHeap)
-
-		convertBackendLhs :: Int [FunctionPattern] VarHeap -> BEMonad BENodeP
-		convertBackendLhs functionIndex patterns varHeap
-			=	beNormalNode (beFunctionSymbol functionIndex main_dcl_module_n) (convertPatterns patterns varHeap)
+		patterns
+			=	map (lookUpVar body.tb_rhs) body.tb_args
+		expr
+			=	codeBlock body.tb_rhs
+
+		lookUpVar :: Expression FreeVar -> FunctionPattern
+		lookUpVar (Case {case_expr=Var boundVar, case_guards=AlgebraicPatterns _ [ap]}) freeVar
+			| freeVar.fv_info_ptr == boundVar.var_info_ptr
+				=	FP_Algebraic ap.ap_symbol subPatterns No
+				with
+					subPatterns
+						=	map (lookUpVar ap.ap_expr) ap.ap_vars
+			// otherwise
+				=	lookUpVar ap.ap_expr freeVar
+		lookUpVar _ freeVar
+			=	FP_Variable freeVar
+
+		codeBlock :: Expression -> Expression
+		codeBlock (Case {case_expr=Var (var_infoPtr), case_guards=AlgebraicPatterns _ [{ap_expr}]})
+			=	codeBlock ap_expr
+		codeBlock expr
+			=	expr
+
+
+convertBody :: Int Int Ident [FunctionPattern] Expression Int VarHeap -> BEMonad BERuleAltP
+convertBody functionIndex lineNumber aliasDummyId args (ABCCodeExpr instructions inline) main_dcl_module_n varHeap
+	=	beNoNodeDefs ==> \noNodeDefs
+	->	beCodeAlt
+			lineNumber
+			(convertLhsNodeDefs args noNodeDefs varHeap)
+			(convertBackEndLhs functionIndex args main_dcl_module_n varHeap)
+			(beAbcCodeBlock inline (convertStrings instructions))
+convertBody functionIndex lineNumber aliasDummyId args (AnyCodeExpr inParams outParams instructions) main_dcl_module_n varHeap
+	=	beNoNodeDefs ==> \noNodeDefs
+	->	beCodeAlt
+			lineNumber
+			(convertLhsNodeDefs args noNodeDefs varHeap)
+			(convertBackEndLhs functionIndex args main_dcl_module_n varHeap)
+			(beAnyCodeBlock (convertCodeParameters inParams varHeap) (convertCodeParameters outParams varHeap) (convertStrings instructions))
+convertBody functionIndex lineNumber aliasDummyId args rhs main_dcl_module_n varHeap
+	=	beNoNodeDefs ==> \noNodeDefs
+	->	beRuleAlt
+			lineNumber
+			(convertLhsNodeDefs args noNodeDefs varHeap)
+			(convertBackEndLhs functionIndex args main_dcl_module_n varHeap)
+			(convertRhsNodeDefs aliasDummyId rhs main_dcl_module_n varHeap)
+			(convertRhsStrictNodeIds rhs varHeap)
+			(convertRootExpr aliasDummyId rhs main_dcl_module_n varHeap)
+
+convertBackEndLhs :: Int [FunctionPattern] Int VarHeap -> BEMonad BENodeP
+convertBackEndLhs functionIndex patterns main_dcl_module_n varHeap
+	=	beNormalNode (beFunctionSymbol functionIndex main_dcl_module_n) (convertPatterns patterns varHeap)
 
 convertStrings :: [{#Char}] -> BEMonad BEStringListP
 convertStrings strings
@@ -1253,6 +1345,11 @@ convertRootExpr aliasDummyId (Conditional {if_cond=cond, if_then=then, if_else=N
 				beNoNodeDefs
 				beNoStrictNodeIds
 				(beNormalNode (beBasicSymbol BEFailSymb) beNoArgs)
+convertRootExpr aliasDummyId (Case {case_expr, case_guards, case_default}) main_dcl_module_n varHeap
+	=	beSwitchNode (convertVar var.var_info_ptr varHeap) (convertCases case_guards aliasDummyId var case_default main_dcl_module_n varHeap)
+	where
+		var
+			=	caseVar case_expr
 convertRootExpr _ expr main_dcl_module_n varHeap
 	=	convertExpr expr main_dcl_module_n varHeap
 
@@ -1356,14 +1453,14 @@ convertRhsStrictNodeIds expression varHeap
 	=	convertStrictNodeIds (collectStrictNodeIds expression) varHeap
 
 convertLiteralSymbol :: BasicValue -> BEMonad BESymbolP
-convertLiteralSymbol (BVI string)
-	=	beLiteralSymbol BEIntDenot string
+convertLiteralSymbol (BVI intString)
+	=	beLiteralSymbol BEIntDenot intString
 convertLiteralSymbol (BVB bool)
 	=	beBoolSymbol bool
-convertLiteralSymbol (BVC string)
-	=	beLiteralSymbol BECharDenot string
-convertLiteralSymbol (BVR string)
-	=	beLiteralSymbol BERealDenot string
+convertLiteralSymbol (BVC charString)
+	=	beLiteralSymbol BECharDenot charString
+convertLiteralSymbol (BVR realString)
+	=	beLiteralSymbol BERealDenot realString
 convertLiteralSymbol (BVS string)
 	=	beLiteralSymbol BEStringDenot string 
 
@@ -1391,7 +1488,7 @@ where
 			convertSymbol {symb_kind=SK_Constructor {glob_module, glob_object}}
 				=	beConstructorSymbol glob_module glob_object // ->> ("convertSymbol", (glob_module, glob_object))
 			convertSymbol symbol
-				=	undef <<- ("backendconvert, convertSymbol: unknown symbol", symbol)
+				=	undef <<- ("backendconvert, convertSymbol: unknown symbol") // , symbol)
 	convertExpr (Var var) varHeap
 		=	beNodeIdNode (convertVar var.var_info_ptr varHeap) beNoArgs
 	convertExpr (f @ [a]) varHeap
@@ -1481,12 +1578,12 @@ where
 		=	beIfNode (convertExpr cond varHeap) (convertExpr if_then varHeap) (convertExpr else varHeap)
 
 	convertExpr  expr _
-		=	undef <<- ("backendconvert, convertExpr: unknown expression", expr)
+		=	undef <<- ("backendconvert, convertExpr: unknown expression" , expr)
 
 	convertArgs :: [Expression] VarHeap -> BEMonad BEArgP
 	convertArgs exprs varHeap
 		=	sfoldr (beArgs o flip convertExpr varHeap) beNoArgs exprs
-	
+
 	convertSelections :: (BEMonad BENodeP) VarHeap [(BESelectorKind, Selection)] -> (BEMonad BENodeP)
 	convertSelections expression varHeap selections
 		=	foldl (convertSelection varHeap) expression selections
@@ -1512,6 +1609,75 @@ where
 				dictionary
 					=	convertExpr (Selection No (Var dictionaryVar) dictionarySelections) varHeap
 
+caseVar :: Expression -> BoundVar
+caseVar (Var var)
+	=	var
+caseVar expr
+	=	undef <<- ("backendconvert, caseVar: unknown expression", expr)
+
+class convertCases a :: a Ident BoundVar (Optional Expression) Int VarHeap -> BEMonad BEArgP
+
+instance convertCases CasePatterns where
+	convertCases (AlgebraicPatterns _ patterns) aliasDummyId var default_case main_dcl_module_n varHeap
+		=	convertCases patterns aliasDummyId var default_case main_dcl_module_n varHeap
+	convertCases (BasicPatterns _ patterns) aliasDummyId var default_case main_dcl_module_n varHeap
+		=	convertCases patterns aliasDummyId var default_case main_dcl_module_n varHeap
+	// +++ other patterns ???
+
+instance convertCases [a] | convertCase a where
+	convertCases patterns aliasDummyId var optionalCase main_dcl_module_n varHeap
+		=	sfoldr (beArgs o convertCase main_dcl_module_n varHeap aliasDummyId var) (convertDefaultCase optionalCase aliasDummyId main_dcl_module_n varHeap) patterns
+
+class convertCase a :: Int VarHeap Ident BoundVar a -> BEMonad BENodeP
+
+instance convertCase AlgebraicPattern where
+	convertCase main_dcl_module_n varHeap aliasDummyId var {ap_symbol={glob_module,glob_object={ds_index}}, ap_vars, ap_expr}
+		| symbolArity == 0
+			=	beCaseNode 0
+					(beConstructorSymbol glob_module ds_index)
+					(convertRhsNodeDefs aliasDummyId ap_expr main_dcl_module_n varHeap)
+					(convertRhsStrictNodeIds ap_expr varHeap)
+					(convertRootExpr aliasDummyId ap_expr main_dcl_module_n varHeap)
+		// otherwise
+			=	beCaseNode symbolArity
+					(beConstructorSymbol glob_module ds_index) 
+					(convertRhsNodeDefs aliasDummyId ap_expr main_dcl_module_n varHeap)
+					(convertRhsStrictNodeIds ap_expr varHeap)
+					(bePushNode symbolArity
+						(beConstructorSymbol glob_module ds_index)
+						(beArgs (convertExpr (Var var) main_dcl_module_n varHeap) (beArgs (convertRootExpr aliasDummyId ap_expr main_dcl_module_n varHeap) beNoArgs))
+						(convertPatternVars ap_vars varHeap))
+		where
+			symbolArity
+				=	length ap_vars		// curried patterns ???
+
+instance convertCase BasicPattern where
+	convertCase main_dcl_module_n varHeap aliasDummyId _ {bp_value, bp_expr}
+		=	beCaseNode 0
+				(convertLiteralSymbol bp_value)
+				(convertRhsNodeDefs aliasDummyId bp_expr main_dcl_module_n varHeap)
+				(convertRhsStrictNodeIds bp_expr varHeap)
+				(convertRootExpr aliasDummyId bp_expr main_dcl_module_n varHeap)
+
+convertPatternVars :: [FreeVar] VarHeap -> BEMonad BENodeIdListP
+convertPatternVars vars varHeap
+	=	sfoldr (beNodeIds o flip convertPatternVar varHeap) beNoNodeIds vars
+
+convertPatternVar :: FreeVar VarHeap -> BEMonad BENodeIdListP
+convertPatternVar freeVar varHeap
+	=	beNodeIdListElem (convertVar freeVar.fv_info_ptr varHeap)
+
+convertDefaultCase :: (Optional Expression) Ident Int VarHeap -> BEMonad BEArgP
+convertDefaultCase No _ _ varHeap
+	=	beNoArgs
+convertDefaultCase (Yes expr) aliasDummyId main_dcl_module_n varHeap
+	=	beArgs
+			(beDefaultNode
+				(convertRhsNodeDefs aliasDummyId expr main_dcl_module_n varHeap)
+				(convertRhsStrictNodeIds expr varHeap)
+				(convertRootExpr aliasDummyId expr main_dcl_module_n varHeap))
+			beNoArgs
+
 selectionKindToArrayFunKind BESelector
 	=	BEArraySelectFun
 selectionKindToArrayFunKind BESelector_U
@@ -1536,6 +1702,8 @@ getVariableSequenceNumber varInfoPtr varHeap be
 			-> (sequenceNumber,be)
 		VI_Alias {var_info_ptr}
 			-> getVariableSequenceNumber var_info_ptr varHeap be
+		vi
+			-> abort "getVariableSequenceNumber" <<- vi
 
 markExports :: DclModule {#ClassDef} {#CheckedTypeDef} {#ClassDef} {#CheckedTypeDef} (Optional {#Int}) -> BackEnder
 markExports {dcl_conversions = Yes conversionTable} dclClasses dclTypes iclClasses iclTypes (Yes functionConversions)