From 7f35586f4a2cef617916f06f6540b9b9f365cf94 Mon Sep 17 00:00:00 2001 From: Michael Lynch Date: Sun, 1 Sep 2019 19:45:59 +0100 Subject: [PATCH] Fixed standard alises --- src/Com/NoSyn/Ast/If/Expression.hs | 11 ++++----- src/Com/NoSyn/Ast/If/Parameter.hs | 24 +++++++++++-------- .../Program/Internal/FunctionEvaluation.hs | 16 ++++++------- test/{aliases.ns.disable => aliases.ns} | 4 ++-- 4 files changed, 28 insertions(+), 27 deletions(-) rename test/{aliases.ns.disable => aliases.ns} (69%) diff --git a/src/Com/NoSyn/Ast/If/Expression.hs b/src/Com/NoSyn/Ast/If/Expression.hs index bca82f4..ff59389 100644 --- a/src/Com/NoSyn/Ast/If/Expression.hs +++ b/src/Com/NoSyn/Ast/If/Expression.hs @@ -103,10 +103,8 @@ validFunctionPredicate' pg ((_, (VPointer x _)):xs) (y:ys) validFunctionPredicate' pg (x@(_, paramVariable@(VVariadic paramType _)):[]) (y:ys) | paramType `Set.member` y = validFunctionPredicate' pg [x] ys | otherwise = case (getAlphaTypeName (aliases pg) paramVariable) >>= (\x -> return $ x `Set.member` y) of - Valid _ x -> x + Valid _ x -> x && ((length ys) == 0) _ -> False - -- | (getAlphaTypeName (aliases pg) paramVariable) `Set.member` y = (length ys) == 0 - -- | otherwise = False generateExpression::ProgramEnvironment -> Expression -> CompilerStatus String generateExpression programEnvironment functionCall@(EFuncCall _ _) = do @@ -131,12 +129,11 @@ generateExpressionForConstParameter _ generatedExpression _ = return generatedEx validateAndGenerateD::ProgramEnvironment -> Set Ident -> Expression -> CompilerStatus (Either (Set Ident) (Ident, String)) validateAndGenerateD programEnvironment returnTypes functionCall@(EFuncCall funcName paramExprs) = do - -- unaliasedNonPointerReturnTypes <- sequence [lookupAtomicNoSynType x (aliases programEnvironment) | x <- (Data.Set.toList returnTypes), backTake 3 x /= "PTR"] - possibleFunctions <- possibleFunctionsFromReturnTypes programEnvironment nonPointerReturnTypes funcName (length paramExprs) + unaliasedNonPointerReturnTypes <- sequence [lookupAtomicNoSynType x (aliases programEnvironment) | x <- (Data.Set.toList returnTypes), backTake 3 x /= "PTR"] + possibleFunctions <- possibleFunctionsFromReturnTypes programEnvironment (Data.Set.fromList unaliasedNonPointerReturnTypes) funcName (length paramExprs) let parameterSets = parameterSetsFromPossibleFunctions possibleFunctions paramExprs in - validateAndGenerateD' programEnvironment nonPointerReturnTypes parameterSets functionCall + validateAndGenerateD' programEnvironment (Data.Set.fromList unaliasedNonPointerReturnTypes) parameterSets functionCall where - nonPointerReturnTypes = Data.Set.fromList $ Prelude.filter (\x -> backTake 3 x /= "PTR") (Data.Set.toList returnTypes) backTake x = reverse.(Prelude.take x).reverse validateAndGenerateD programEnvironment returnTypes (EConst const) = do diff --git a/src/Com/NoSyn/Ast/If/Parameter.hs b/src/Com/NoSyn/Ast/If/Parameter.hs index 3f79225..a39dde2 100644 --- a/src/Com/NoSyn/Ast/If/Parameter.hs +++ b/src/Com/NoSyn/Ast/If/Parameter.hs @@ -11,6 +11,7 @@ import Com.NoSyn.Ast.Traits.Listable as Listable import Data.List import Data.Map import Com.NoSyn.Environment.ProgramEnvironment +import Com.NoSyn.Environment.AliasEnvironment import Com.NoSyn.Error.CompilerStatus type Parameters = Block Parameter @@ -61,14 +62,17 @@ getAtomicTypeName pg paramType = lookupAtomicNoSynType paramType instance Blockable Parameter where blockSeparator _ = ", " -parameterToTuple::Parameter -> (Ident, Variable) -parameterToTuple (PConst paramType paramName) = - (paramName , (VConst paramType paramName)) -parameterToTuple (PPointer paramType paramName) = - (paramName , (VPointer paramType paramName)) -parameterToTuple (PVariadic paramType paramName) = - (paramName, (VVariadic paramType paramName)) +parameterToTuple::AliasEnvironment -> Parameter -> CompilerStatus (Ident, Variable) +parameterToTuple aliasEnvironment (PConst paramType paramName) = do + realParamType <- lookupAtomicNoSynType paramType aliasEnvironment + return (paramName , (VConst realParamType paramName)) +parameterToTuple aliasEnvironment (PPointer paramType paramName) = do + realParamType <- lookupAtomicNoSynType paramType aliasEnvironment + return (paramName , (VPointer realParamType paramName)) +parameterToTuple aliasEnvironment (PVariadic paramType paramName) = do + realParamType <- lookupAtomicNoSynType paramType aliasEnvironment + return (paramName, (VVariadic realParamType paramName)) -parametersToTuples::Parameters -> [(Ident, Variable)] -parametersToTuples parameters = - Prelude.map parameterToTuple (Listable.toList parameters) +parametersToTuples::AliasEnvironment -> Parameters -> CompilerStatus [(Ident, Variable)] +parametersToTuples aliasEnvironment parameters = + sequence $ Prelude.map (parameterToTuple aliasEnvironment) (Listable.toList parameters) diff --git a/src/Com/NoSyn/Evaluation/Program/Internal/FunctionEvaluation.hs b/src/Com/NoSyn/Evaluation/Program/Internal/FunctionEvaluation.hs index 1022e9e..473ad2d 100644 --- a/src/Com/NoSyn/Evaluation/Program/Internal/FunctionEvaluation.hs +++ b/src/Com/NoSyn/Evaluation/Program/Internal/FunctionEvaluation.hs @@ -36,15 +36,15 @@ programFunctionDefinitionEvaluate' aliasEnvironment (_:xs) currentFunctionEnviro createFunctionEntry::AliasEnvironment -> FunctionDefinition -> CompilerStatus (Ident, FunctionOverload) createFunctionEntry aliasEnvironment (FDNative functionName returnType parameters)= do _ <- lookupDType returnType aliasEnvironment - _ <- sequence $ Prelude.map (\(_, x) -> lookupDType (getTypeNoCheck x) aliasEnvironment) (parametersToTuples parameters) - return (functionName, FO { returnType = returnType, parameters = parameterOMap, parentModule = Nothing }) - where - parameterOMap = (Data.Map.Ordered.fromList (parametersToTuples parameters)) + unaliasedParameterList <- parametersToTuples aliasEnvironment parameters + unaliasedReturnType <- lookupAtomicNoSynType returnType aliasEnvironment + _ <- sequence $ Prelude.map (\(_, x) -> lookupDType (getTypeNoCheck x) aliasEnvironment) unaliasedParameterList + return (functionName, FO { returnType = unaliasedReturnType, parameters = (Data.Map.Ordered.fromList unaliasedParameterList), parentModule = Nothing }) createFunctionEntry aliasEnvironment (FDNoSyn functionName returnType parameters _)= do _ <- lookupDType returnType aliasEnvironment - _ <- sequence $ Prelude.map (\(_, x) -> lookupDType (getTypeNoCheck x) aliasEnvironment) (parametersToTuples parameters) - return (functionName, FO { returnType = returnType, parameters = parameterOMap, parentModule = Nothing}) - where - parameterOMap = (Data.Map.Ordered.fromList (parametersToTuples parameters)) + unaliasedParameterList <- parametersToTuples aliasEnvironment parameters + unaliasedReturnType <- lookupAtomicNoSynType returnType aliasEnvironment + _ <- sequence $ Prelude.map (\(_, x) -> lookupDType (getTypeNoCheck x) aliasEnvironment) unaliasedParameterList + return (functionName, FO { returnType = unaliasedReturnType, parameters = (Data.Map.Ordered.fromList unaliasedParameterList), parentModule = Nothing}) diff --git a/test/aliases.ns.disable b/test/aliases.ns similarity index 69% rename from test/aliases.ns.disable rename to test/aliases.ns index 132bf43..ed41de6 100644 --- a/test/aliases.ns.disable +++ b/test/aliases.ns @@ -8,10 +8,10 @@ Nothing infix_:=_(Int* a, AnotherInt b) { assignment(b, b); } -Nothing infix_+_(Int* a, AnotherInt b) { +Nothing infix_+_(AnotherInt* a, AnotherInt b) { a := add(a, b); } -Int add(Int a, Int b) { +Int add(Int a, AnotherInt b) { a; }