Parse local variables

lib/Language/Elna/Glue.hs

@@ -15,13 +15,15 @@ import qualified Data.Text.Lazy as Text.Lazy
 import qualified Data.Vector as Vector
 import Data.Word (Word32)
 import qualified Language.Elna.Frontend.AST as AST
+import Language.Elna.Frontend.Types (Type(..))
 import Language.Elna.Backend.Intermediate
     ( Label(..)
     , Operand(..)
     , Quadruple(..)
     , Variable(..)
     )
-import Language.Elna.Frontend.SymbolTable (SymbolTable)
+import Language.Elna.Frontend.SymbolTable (Info(..), SymbolTable)
+import qualified Language.Elna.Frontend.SymbolTable as SymbolTable
 import GHC.Records (HasField(..))
 
 data Paste = Paste
@@ -98,20 +100,20 @@ statement localTable (AST.IfStatement ifCondition ifStatement elseStatement) = d
             <> Vector.snoc ifStatements (LabelQuadruple endLabel)
         Nothing -> Vector.fromList [jumpConstructor ifLabel, GoToQuadruple endLabel, LabelQuadruple ifLabel]
             <> Vector.snoc ifStatements (LabelQuadruple endLabel)
-{- statement localTable (AST.AssignmentStatement variableAccess' assignee) = do
+statement localTable (AST.AssignmentStatement variableAccess' assignee) = do
     (rhsOperand, rhsStatements) <- expression localTable assignee
     let variableType' = variableType variableAccess' localTable
     accessResult <- variableAccess localTable variableAccess' Nothing variableType' mempty
     pure $ rhsStatements <> case accessResult of
-            (AST.Identifier identifier, Just accumulatedIndex, accumulatedStatements) ->
+            {-(AST.Identifier identifier, Just accumulatedIndex, accumulatedStatements) ->
                 Vector.snoc accumulatedStatements
                     $ ArrayAssignQuadruple rhsOperand accumulatedIndex
-                    $ Variable identifier
+                    $ LocalVariable identifier -}
             (AST.Identifier identifier, Nothing, accumulatedStatements) ->
                 Vector.snoc accumulatedStatements
                     $ AssignQuadruple rhsOperand
-                    $ Variable identifier
-statement localTable (AST.WhileStatement whileCondition whileStatement) = do
+                    $ LocalVariable 0
+{- statement localTable (AST.WhileStatement whileCondition whileStatement) = do
     (conditionStatements, jumpConstructor) <- condition localTable whileCondition
     startLabel <- createLabel
     endLabel <- createLabel
@@ -189,20 +191,17 @@ condition localTable (AST.GreaterOrEqualCondition lhs rhs) = do
         ( lhsStatements <> rhsStatements
         , GreaterOrEqualQuadruple lhsOperand rhsOperand
         )
-{-
-import Language.Elna.Types (Type(..))
-import qualified Language.Elna.SymbolTable as SymbolTable
 
 variableAccess
     :: SymbolTable
     -> AST.VariableAccess
-    -> Maybe Operand
+    -> Maybe (Operand Variable)
     -> Type
-    -> Vector Quadruple
-    -> Glue (AST.Identifier, Maybe Operand, Vector Quadruple)
+    -> Vector (Quadruple Variable)
+    -> Glue (AST.Identifier, Maybe (Operand Variable), Vector (Quadruple Variable))
 variableAccess _ (AST.VariableAccess identifier) accumulatedIndex _ accumulatedStatements =
     pure (identifier, accumulatedIndex, accumulatedStatements)
-variableAccess localTable (AST.ArrayAccess access1 index1) Nothing (ArrayType _ baseType) _ = do
+{- variableAccess localTable (AST.ArrayAccess access1 index1) Nothing (ArrayType _ baseType) _ = do
     (indexPlace, statements) <- expression localTable index1
     variableAccess localTable access1 (Just indexPlace) baseType statements
 variableAccess localTable (AST.ArrayAccess arrayAccess' arrayIndex) (Just baseIndex) (ArrayType arraySize baseType) statements = do
@@ -216,14 +215,14 @@ variableAccess localTable (AST.ArrayAccess arrayAccess' arrayIndex) (Just baseIn
      in variableAccess localTable arrayAccess' (Just resultOperand) baseType
         $ statements <> indexCalculation <> statements'
 variableAccess _ _ _ _ _ = error "Array access operator doesn't match the type."
-
+-}
 variableType :: AST.VariableAccess -> SymbolTable -> Type
 variableType (AST.VariableAccess identifier) symbolTable
     | Just (TypeInfo type') <- SymbolTable.lookup identifier symbolTable = type'
     | otherwise = error "Undefined type."
-variableType (AST.ArrayAccess arrayAccess' _) symbolTable =
-    variableType arrayAccess' symbolTable
--}
+{-variableType (AST.ArrayAccess arrayAccess' _) symbolTable =
+    variableType arrayAccess' symbolTable -}
+
 expression :: SymbolTable -> AST.Expression -> Glue (Operand Variable, Vector (Quadruple Variable))
 expression localTable = \case
     (AST.LiteralExpression literal') -> pure (literal literal', mempty)
@@ -242,8 +241,9 @@ expression localTable = \case
         binaryExpression ProductQuadruple lhs rhs
     (AST.DivisionExpression lhs rhs) ->
         binaryExpression DivisionQuadruple lhs rhs
-{-    (AST.VariableExpression variableExpression) -> do
-        let variableType' = variableType variableExpression localTable
+    (AST.VariableExpression variableExpression) -> do
+        pure (VariableOperand (LocalVariable 0), mempty)
+        {- let variableType' = variableType variableExpression localTable
         variableAccess' <- variableAccess localTable variableExpression Nothing variableType' mempty
         case variableAccess' of
             (AST.Identifier identifier, Nothing, statements) ->