private void SplitFunctionDefinitionNode(FunctionDefinitionNode node) { if (!node.IsExternLib) { node.FunctionBody.Body = SplitMulitpleAssignment(node.FunctionBody.Body); } }
protected virtual void EmitClassDeclNode(ref ProtoCore.AST.AssociativeAST.ClassDeclNode classDeclNode) { //EmitCode(classDeclNode.ToString()); //EmitCode("class "); //EmitCode(classDeclNode.className); //EmitCode("\n{\n"); List <ProtoCore.AST.AssociativeAST.AssociativeNode> varList = classDeclNode.varlist; foreach (ProtoCore.AST.AssociativeAST.AssociativeNode varMember in varList) { //how is var member stored? if (varMember is ProtoCore.AST.AssociativeAST.VarDeclNode) { AST.AssociativeAST.VarDeclNode varDecl = varMember as ProtoCore.AST.AssociativeAST.VarDeclNode; EmitVarDeclNode(ref varDecl); } } List <ProtoCore.AST.AssociativeAST.AssociativeNode> funcList = classDeclNode.funclist; foreach (ProtoCore.AST.AssociativeAST.AssociativeNode funcMember in funcList) { if (funcMember is ProtoCore.AST.AssociativeAST.FunctionDefinitionNode) { AST.AssociativeAST.FunctionDefinitionNode funcDefNode = funcMember as ProtoCore.AST.AssociativeAST.FunctionDefinitionNode; EmitFunctionDefNode(ref funcDefNode); } } //EmitCode("}\n"); }
private static void InsertBinaryOperationMethod(Core core, CodeBlockNode root, Operator op, PrimitiveType r, PrimitiveType op1, PrimitiveType op2, int retRank = 0, int op1rank = 0, int op2rank = 0) { FunctionDefinitionNode funcDefNode = new FunctionDefinitionNode(); funcDefNode.access = CompilerDefinitions.AccessModifier.kPublic; funcDefNode.IsAssocOperator = true; funcDefNode.IsBuiltIn = true; funcDefNode.Name = Op.GetOpFunction(op); funcDefNode.ReturnType = new Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r, rank = retRank }; ArgumentSignatureNode args = new ArgumentSignatureNode(); args.AddArgument(new VarDeclNode() { Access = CompilerDefinitions.AccessModifier.kPublic, NameNode = AstFactory.BuildIdentifier(DSASM.Constants.kLHS), ArgumentType = new Type { Name = core.TypeSystem.GetType((int)op1), UID = (int)op1, rank = op1rank } }); args.AddArgument(new VarDeclNode() { Access = CompilerDefinitions.AccessModifier.kPublic, NameNode = AstFactory.BuildIdentifier(DSASM.Constants.kRHS), ArgumentType = new Type { Name = core.TypeSystem.GetType((int)op2), UID = (int)op2, rank = op2rank } }); funcDefNode.Signature = args; CodeBlockNode body = new CodeBlockNode(); var lhs = AstFactory.BuildIdentifier(DSASM.Constants.kLHS); var rhs = AstFactory.BuildIdentifier(DSASM.Constants.kRHS); var binaryExpr = AstFactory.BuildBinaryExpression(lhs, rhs, op); body.Body.Add(AstFactory.BuildReturnStatement(binaryExpr)); funcDefNode.FunctionBody = body; root.Body.Add(funcDefNode); }
private static void InsertBinaryOperationMethod(Core core, ProtoCore.AST.Node root, Operator op, PrimitiveType r, PrimitiveType op1, PrimitiveType op2, int retRank = 0, int op1rank = 0, int op2rank = 0) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); funcDefNode.access = ProtoCore.DSASM.AccessSpecifier.kPublic; funcDefNode.IsAssocOperator = true; funcDefNode.IsBuiltIn = true; funcDefNode.Name = Op.GetOpFunction(op); funcDefNode.ReturnType = new ProtoCore.Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r, rank = retRank}; ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kLHS), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)op1), UID = (int)op1, rank = op1rank} }); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kRHS), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)op2), UID = (int)op2, rank = op2rank} }); funcDefNode.Signature = args; ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Keyword.Return, ProtoCore.PrimitiveType.kTypeReturn); ProtoCore.AST.AssociativeAST.IdentifierNode lhs = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kLHS); ProtoCore.AST.AssociativeAST.IdentifierNode rhs = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kRHS); body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = _return, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = lhs, RightNode = rhs, Optr = op } }); funcDefNode.FunctionBody = body; (root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode); }
private ProtoCore.AST.AssociativeAST.AssociativeNode ParseMethod(MethodInfo method) { ProtoCore.Type retype = CLRModuleType.GetProtoCoreType(method.ReturnType, Module); bool propaccessor = isPropertyAccessor(method); bool isOperator = isOverloadedOperator(method); FFIMethodAttributes mattrs = new FFIMethodAttributes(method); if (method.IsStatic && method.DeclaringType == method.ReturnType && !propaccessor && !isOperator) { //case for named constructor. Must return a pointer type if (!Object.Equals(method.ReturnType, CLRType)) { throw new InvalidOperationException("Unexpected type for constructor {0D28FC00-F8F4-4049-AD1F-BBC34A68073F}"); } retype = ProtoCoreType; ConstructorDefinitionNode node = ParsedNamedConstructor(method, method.Name, retype); node.MethodAttributes = mattrs; return(node); } //Need to hide property accessor from design script users, prefix with % string prefix = (isOperator || propaccessor) ? "%" : ""; var func = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); if (isOperator) { func.Name = string.Format("{0}{1}", prefix, GetDSOperatorName(method.Name)); } else { func.Name = string.Format("{0}{1}", prefix, method.Name); } func.Pattern = null; func.Signature = ParseArgumentSignature(method); if ((retype.IsIndexable && mattrs.AllowRankReduction) || (typeof(object).Equals(method.ReturnType))) { retype.rank = Constants.kArbitraryRank; } func.ReturnType = retype; func.FunctionBody = null; func.access = ProtoCore.Compiler.AccessSpecifier.kPublic; func.IsDNI = false; func.IsExternLib = true; func.ExternLibName = Module.Name; func.IsStatic = method.IsStatic; func.MethodAttributes = mattrs; return(func); }
private static void InsertInlineConditionOperationMethod(Core core, ProtoCore.AST.Node root, PrimitiveType condition, PrimitiveType r) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); funcDefNode.access = ProtoCore.Compiler.AccessSpecifier.kPublic; funcDefNode.Name = ProtoCore.DSASM.Constants.kInlineCondition; funcDefNode.ReturnType = new ProtoCore.Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r }; ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.Compiler.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, "%condition"), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)condition), UID = (int)condition } }); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.Compiler.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, "%trueExp"), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)r), UID = (int)r } }); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.Compiler.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, "%falseExp"), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)r), UID = (int)r } }); funcDefNode.Signature = args; ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Keyword.Return, ProtoCore.PrimitiveType.kTypeReturn); ProtoCore.AST.AssociativeAST.IdentifierNode con = BuildAssocIdentifier(core, "%condition"); ProtoCore.AST.AssociativeAST.IdentifierNode t = BuildAssocIdentifier(core, "%trueExp"); ProtoCore.AST.AssociativeAST.IdentifierNode f = BuildAssocIdentifier(core, "%falseExp"); body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = _return, Optr = Operator.assign, RightNode = new ProtoCore.AST.AssociativeAST.InlineConditionalNode() { ConditionExpression = con, TrueExpression = t, FalseExpression = f } }); funcDefNode.FunctionBody = body; (root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode); }
/// <summary> /// Gets the has id of a function signature given the name and argument types /// </summary> /// <param name="functionDef"></param> /// <returns></returns> public static int GetFunctionHash(ProtoCore.AST.AssociativeAST.FunctionDefinitionNode functionDef) { Validity.Assert(null != functionDef); string functionDescription = functionDef.Name; foreach (ProtoCore.AST.AssociativeAST.VarDeclNode argNode in functionDef.Signature.Arguments) { functionDescription += argNode.ArgumentType.ToString(); } return(functionDescription.GetHashCode()); }
private static void InsertBinaryOperationMethod(Core core, ProtoCore.AST.Node root, Operator op, PrimitiveType r, PrimitiveType op1, PrimitiveType op2, int retRank = 0, int op1rank = 0, int op2rank = 0) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); funcDefNode.access = ProtoCore.Compiler.AccessSpecifier.kPublic; funcDefNode.IsAssocOperator = true; funcDefNode.IsBuiltIn = true; funcDefNode.Name = Op.GetOpFunction(op); funcDefNode.ReturnType = new ProtoCore.Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r, rank = retRank }; ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.Compiler.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kLHS), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)op1), UID = (int)op1, rank = op1rank } }); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.Compiler.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kRHS), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)op2), UID = (int)op2, rank = op2rank } }); funcDefNode.Signature = args; ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Keyword.Return, ProtoCore.PrimitiveType.kTypeReturn); ProtoCore.AST.AssociativeAST.IdentifierNode lhs = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kLHS); ProtoCore.AST.AssociativeAST.IdentifierNode rhs = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kRHS); body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = _return, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = lhs, RightNode = rhs, Optr = op } }); funcDefNode.FunctionBody = body; (root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode); }
private static ProtoCore.AST.AssociativeAST.FunctionDefinitionNode GenerateBuiltInMethodSignatureNode(ProtoCore.Lang.BuiltInMethods.BuiltInMethod method) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode fDef = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); fDef.Name = ProtoCore.Lang.BuiltInMethods.GetMethodName(method.ID); fDef.ReturnType = method.ReturnType; fDef.IsExternLib = true; fDef.IsBuiltIn = true; fDef.BuiltInMethodId = method.ID; fDef.Signature = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); fDef.MethodAttributes = method.MethodAttributes; foreach (KeyValuePair<string, ProtoCore.Type> param in method.Parameters) { ProtoCore.AST.AssociativeAST.VarDeclNode arg = new ProtoCore.AST.AssociativeAST.VarDeclNode(); arg.NameNode = new ProtoCore.AST.AssociativeAST.IdentifierNode { Name = param.Key, Value = param.Key }; arg.ArgumentType = param.Value; fDef.Signature.AddArgument(arg); } return fDef; }
private ProtoCore.AST.AssociativeAST.FunctionDefinitionNode ParseFieldAccessor(FieldInfo f) { if (null == f || !IsBrowsable(f)) { return(null); } ProtoCore.AST.AssociativeAST.FunctionDefinitionNode func = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); func.Name = string.Format("%get_{0}", f.Name); func.Pattern = null; func.Singnature = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); func.ReturnType = CLRModuleType.GetProtoCoreType(f.FieldType, Module); func.FunctionBody = null; func.access = ProtoCore.DSASM.AccessSpecifier.kPublic; func.IsDNI = false; func.IsExternLib = true; func.ExternLibName = Module.Name; func.IsStatic = f.IsStatic; return(func); }
private ProtoCore.AST.AssociativeAST.AssociativeNode ParseMethod(MethodInfo method) { ProtoCore.Type retype = CLRModuleType.GetProtoCoreType(method.ReturnType, Module); bool propaccessor = isPropertyAccessor(method); if (method.IsStatic && method.DeclaringType == method.ReturnType && !propaccessor) { //case for named constructor. Must return a pointer type if (!Object.Equals(method.ReturnType, CLRType)) { throw new InvalidOperationException("Unexpected type for constructor {0D28FC00-F8F4-4049-AD1F-BBC34A68073F}"); } retype = ProtoCoreType; return(ParsedNamedConstructor(method, method.Name, retype)); } //Need to hide property accessor from design script users, prefix with % string prefix = propaccessor ? "%" : ""; ProtoCore.AST.AssociativeAST.FunctionDefinitionNode func = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); func.Name = string.Format("{0}{1}", prefix, method.Name); func.Pattern = null; func.Singnature = ParseArgumentSignature(method); if (retype.IsIndexable && AllowsRankReduction(method)) { retype.rank = -1; } func.ReturnType = retype; func.FunctionBody = null; func.access = ProtoCore.DSASM.AccessSpecifier.kPublic; func.IsDNI = false; func.IsExternLib = true; func.ExternLibName = Module.Name; func.IsStatic = method.IsStatic; return(func); }
private static ProtoCore.AST.AssociativeAST.FunctionDefinitionNode GenerateBuiltInMethodSignatureNode(ProtoCore.Lang.BuiltInMethods.BuiltInMethod method) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode fDef = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); fDef.Name = ProtoCore.Lang.BuiltInMethods.GetMethodName(method.ID); fDef.ReturnType = method.ReturnType; fDef.IsExternLib = true; fDef.IsBuiltIn = true; fDef.BuiltInMethodId = method.ID; fDef.Signature = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); fDef.MethodAttributes = method.MethodAttributes; foreach (KeyValuePair <string, ProtoCore.Type> param in method.Parameters) { ProtoCore.AST.AssociativeAST.VarDeclNode arg = new ProtoCore.AST.AssociativeAST.VarDeclNode(); arg.NameNode = new ProtoCore.AST.AssociativeAST.IdentifierNode { Name = param.Key, Value = param.Key }; arg.ArgumentType = param.Value; fDef.Signature.AddArgument(arg); } return(fDef); }
// The following methods are used to insert methods to the bottom of the AST and convert operator to these method calls // to support replication on operators private static void InsertUnaryOperationMethod(Core core, ProtoCore.AST.Node root, UnaryOperator op, PrimitiveType r, PrimitiveType operand) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); funcDefNode.access = ProtoCore.CompilerDefinitions.AccessModifier.kPublic; funcDefNode.IsAssocOperator = true; funcDefNode.IsBuiltIn = true; funcDefNode.Name = Op.GetUnaryOpFunction(op); funcDefNode.ReturnType = new ProtoCore.Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r }; ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.CompilerDefinitions.AccessModifier.kPublic, NameNode = BuildAssocIdentifier(core, "%param"), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)operand), UID = (int)operand } }); funcDefNode.Signature = args; ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Keyword.Return, ProtoCore.PrimitiveType.kTypeReturn); ProtoCore.AST.AssociativeAST.IdentifierNode param = BuildAssocIdentifier(core, "%param"); body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = _return, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new ProtoCore.AST.AssociativeAST.UnaryExpressionNode() { Expression = param, Operator = op } }); funcDefNode.FunctionBody = body; (root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode); }
private void EmitClassDeclNode(AssociativeNode node, ref ProtoCore.Type inferedType, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone) { ClassDeclNode classDecl = node as ClassDeclNode; // Handling n-pass on class declaration if (ProtoCore.DSASM.AssociativeCompilePass.kClassName == compilePass) { ProtoCore.DSASM.ClassNode cnode = new ProtoCore.DSASM.ClassNode(); cnode.name = classDecl.className; cnode.size = classDecl.varlist.Count; cnode.IsImportedClass = classDecl.IsImportedClass; cnode.typeSystem = core.TypeSystem; globalClassIndex = core.ClassTable.Append(cnode); CodeRangeTable.AddClassBlockRangeEntry(globalClassIndex, classDecl.line, classDecl.col, classDecl.endLine, classDecl.endCol, core.CurrentDSFileName); } else if (ProtoCore.DSASM.AssociativeCompilePass.kClassHeirarchy == compilePass) { // Class heirarchy pass // Populating each class entry with their respective base classes globalClassIndex = core.ClassTable.IndexOf(classDecl.className); ProtoCore.DSASM.ClassNode cnode = core.ClassTable.ClassNodes[globalClassIndex]; if (null != classDecl.superClass) { for (int n = 0; n < classDecl.superClass.Count; ++n) { int baseClass = core.ClassTable.IndexOf(classDecl.superClass[n]); if (ProtoCore.DSASM.Constants.kInvalidIndex != baseClass) { cnode.baseList.Add(baseClass); cnode.coerceTypes.Add(baseClass, (int)ProtoCore.DSASM.ProcedureDistance.kCoerceBaseClass); } } } } else if (ProtoCore.DSASM.AssociativeCompilePass.kClassMemVar == compilePass) { // Class member variable pass // Populating each class entry symbols with their respective member variables globalClassIndex = core.ClassTable.IndexOf(classDecl.className); ProtoCore.DSASM.ClassNode cnode = core.ClassTable.ClassNodes[globalClassIndex]; // Handle member vars from base class if (null != classDecl.superClass) { for (int n = 0; n < classDecl.superClass.Count; ++n) { int baseClass = core.ClassTable.IndexOf(classDecl.superClass[n]); if (ProtoCore.DSASM.Constants.kInvalidIndex != baseClass) { // Append the members variables of every class that this class inherits from foreach (ProtoCore.DSASM.SymbolNode symnode in core.ClassTable.ClassNodes[baseClass].symbols.symbolList.Values) { // It is a member variables if (ProtoCore.DSASM.Constants.kGlobalScope == symnode.functionIndex) { Debug.Assert(!symnode.isArgument); int symbolIndex = AllocateMemberVariable(globalClassIndex, symnode.isStatic ? symnode.classScope : baseClass, symnode.name, symnode.datatype, symnode.access, symnode.isStatic); if (symbolIndex != ProtoCore.DSASM.Constants.kInvalidIndex) cnode.size += ProtoCore.DSASM.Constants.kPointerSize; } } } else { Debug.Assert(false, "n-pass compile error, fixme Jun...."); } } } // This list will store all static properties initialization // expression (say x = 1). List<BinaryExpressionNode> staticPropertyInitList = new List<BinaryExpressionNode>(); foreach (VarDeclNode vardecl in classDecl.varlist) { IdentifierNode varIdent = null; if (vardecl.NameNode is IdentifierNode) { varIdent = vardecl.NameNode as IdentifierNode; } else if (vardecl.NameNode is BinaryExpressionNode) { BinaryExpressionNode bNode = vardecl.NameNode as BinaryExpressionNode; varIdent = bNode.LeftNode as IdentifierNode; if (vardecl.IsStatic) staticPropertyInitList.Add(bNode); else cnode.defaultArgExprList.Add(bNode); } else { Debug.Assert(false, "Check generated AST"); } // It is possible that fail to allocate variable. In that // case we should remove initializing expression from // cnode's defaultArgExprList ProtoCore.Type datatype = vardecl.ArgumentType; if (string.IsNullOrEmpty(vardecl.ArgumentType.Name)) datatype.UID = (int)PrimitiveType.kTypeVar; else { datatype.UID = core.TypeSystem.GetType(vardecl.ArgumentType.Name); if (datatype.UID == ProtoCore.DSASM.Constants.kInvalidIndex) datatype.UID = (int)PrimitiveType.kTypeVar; } datatype.Name = core.TypeSystem.GetType(datatype.UID); int symbolIndex = ProtoCore.DSASM.Constants.kInvalidIndex; if (varIdent is ProtoCore.AST.AssociativeAST.TypedIdentifierNode) symbolIndex = AllocateTypedMemberVariable(globalClassIndex, globalClassIndex, varIdent.Value, datatype, vardecl.access, vardecl.IsStatic); else symbolIndex = AllocateMemberVariable(globalClassIndex, globalClassIndex, varIdent.Value, datatype, vardecl.access, vardecl.IsStatic); if (symbolIndex != ProtoCore.DSASM.Constants.kInvalidIndex && !classDecl.IsExternLib) { ProtoCore.DSASM.SymbolNode memVar = vardecl.IsStatic ? core.CodeBlockList[0].symbolTable.symbolList[symbolIndex] : core.ClassTable.ClassNodes[globalClassIndex].symbols.symbolList[symbolIndex]; EmitGetterForMemVar(classDecl, memVar); EmitSetterForMemVar(classDecl, memVar); } } classOffset = 0; // Now we are going to create a static function __init_static_properties() // which will initialize all static properties. We will emit a // call to this function after all classes have been compiled. if (staticPropertyInitList.Count > 0) { FunctionDefinitionNode initFunc = new FunctionDefinitionNode() { Name = ProtoCore.DSASM.Constants.kStaticPropertiesInitializer, Singnature = new ArgumentSignatureNode(), Pattern = null, ReturnType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)PrimitiveType.kTypeNull), UID = (int)PrimitiveType.kTypeNull }, FunctionBody = new CodeBlockNode(), IsExternLib = false, IsDNI = false, ExternLibName = null, access = ProtoCore.DSASM.AccessSpecifier.kPublic, IsStatic = true }; classDecl.funclist.Add(initFunc); staticPropertyInitList.ForEach(bNode => initFunc.FunctionBody.Body.Add(bNode)); initFunc.FunctionBody.Body.Add(new BinaryExpressionNode() { LeftNode = new IdentifierNode() { Value = ProtoCore.DSDefinitions.Kw.kw_return, Name = ProtoCore.DSDefinitions.Kw.kw_return, datatype = core.TypeSystem.BuildTypeObject(PrimitiveType.kTypeReturn, false) }, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new NullNode() }); } } else if (ProtoCore.DSASM.AssociativeCompilePass.kClassMemFuncSig == compilePass) { // Class member variable pass // Populating each class entry vtables with their respective member variables signatures globalClassIndex = core.ClassTable.IndexOf(classDecl.className); foreach (AssociativeNode funcdecl in classDecl.funclist) { DfsTraverse(funcdecl, ref inferedType); } if (!classDecl.IsExternLib) { ProtoCore.DSASM.ProcedureTable vtable = core.ClassTable.ClassNodes[globalClassIndex].vtable; if (vtable.IndexOfExact(classDecl.className, new List<ProtoCore.Type>()) == ProtoCore.DSASM.Constants.kInvalidIndex) { ConstructorDefinitionNode defaultConstructor = new ConstructorDefinitionNode(); defaultConstructor.Name = classDecl.className; defaultConstructor.localVars = 0; defaultConstructor.Signature = new ArgumentSignatureNode(); defaultConstructor.Pattern = null; defaultConstructor.ReturnType = new ProtoCore.Type { Name = "var", UID = 0 }; defaultConstructor.FunctionBody = new CodeBlockNode(); defaultConstructor.baseConstr = null; defaultConstructor.access = ProtoCore.DSASM.AccessSpecifier.kPublic; defaultConstructor.IsExternLib = false; defaultConstructor.ExternLibName = null; DfsTraverse(defaultConstructor, ref inferedType); classDecl.funclist.Add(defaultConstructor); } } } else if (ProtoCore.DSASM.AssociativeCompilePass.kClassMemFuncBody == compilePass) { // Class member variable pass // Populating the function body of each member function defined in the class vtables globalClassIndex = core.ClassTable.IndexOf(classDecl.className); foreach (AssociativeNode funcdecl in classDecl.funclist) { // reset the inferedtype between functions inferedType = new ProtoCore.Type(); DfsTraverse(funcdecl, ref inferedType, false, null, subPass); } } // Reset the class index core.ClassIndex = globalClassIndex = ProtoCore.DSASM.Constants.kGlobalScope; }
private void EmitMemberVariables(ClassDeclNode classDecl, GraphNode graphNode = null) { // Class member variable pass // Populating each class entry symbols with their respective member variables int thisClassIndex = core.ClassTable.GetClassId(classDecl.ClassName); globalClassIndex = thisClassIndex; if (!unPopulatedClasses.ContainsKey(thisClassIndex)) { return; } ProtoCore.DSASM.ClassNode thisClass = core.ClassTable.ClassNodes[thisClassIndex]; // Handle member vars from base class if (null != classDecl.BaseClasses) { for (int n = 0; n < classDecl.BaseClasses.Count; ++n) { int baseClassIndex = core.ClassTable.GetClassId(classDecl.BaseClasses[n]); if (ProtoCore.DSASM.Constants.kInvalidIndex != baseClassIndex) { // To handle the case that a base class is defined after // this class. if (unPopulatedClasses.ContainsKey(baseClassIndex)) { EmitMemberVariables(unPopulatedClasses[baseClassIndex], graphNode); globalClassIndex = thisClassIndex; } ClassNode baseClass = core.ClassTable.ClassNodes[baseClassIndex]; // Append the members variables of every class that this class inherits from foreach (ProtoCore.DSASM.SymbolNode symnode in baseClass.Symbols.symbolList.Values) { // It is a member variables if (ProtoCore.DSASM.Constants.kGlobalScope == symnode.functionIndex) { Validity.Assert(!symnode.isArgument); int symbolIndex = AllocateMemberVariable(thisClassIndex, symnode.isStatic ? symnode.classScope : baseClassIndex, symnode.name, symnode.datatype.rank, symnode.access, symnode.isStatic); if (symbolIndex != ProtoCore.DSASM.Constants.kInvalidIndex) thisClass.Size += ProtoCore.DSASM.Constants.kPointerSize; } } } else { Validity.Assert(false, "n-pass compile error, fixme Jun...."); } } } // This list will store all static properties initialization // expression (say x = 1). List<BinaryExpressionNode> staticPropertyInitList = new List<BinaryExpressionNode>(); foreach (VarDeclNode vardecl in classDecl.Variables) { IdentifierNode varIdent = null; if (vardecl.NameNode is IdentifierNode) { varIdent = vardecl.NameNode as IdentifierNode; BinaryExpressionNode bNode = new BinaryExpressionNode(); var thisNode =AstFactory.BuildIdentifier(ProtoCore.DSDefinitions.Keyword.This); var propNode =AstFactory.BuildIdentifier(varIdent.Value); bNode.LeftNode = AstFactory.BuildIdentList(thisNode, propNode); NodeUtils.CopyNodeLocation(bNode, vardecl); bNode.Optr = ProtoCore.DSASM.Operator.assign; bool skipInitialization = false; // Initialize it to default value by manually add the right hand side node if (vardecl.ArgumentType.rank == 0) { switch (vardecl.ArgumentType.Name) { case "double": bNode.RightNode = new DoubleNode(0); break; case "int": bNode.RightNode = new IntNode(0); break; case "bool": bNode.RightNode = new BooleanNode(false); break; default: skipInitialization = true; break; } } else if (vardecl.ArgumentType.rank > 0) { if (!vardecl.ArgumentType.Name.Equals("var")) bNode.RightNode = new ExprListNode(); else skipInitialization = true; } else if(vardecl.ArgumentType.rank.Equals(ProtoCore.DSASM.Constants.kArbitraryRank)) { if (!vardecl.ArgumentType.Name.Equals("var")) bNode.RightNode = new NullNode(); else skipInitialization = true; } if (!skipInitialization) { if (vardecl.IsStatic) staticPropertyInitList.Add(bNode); else thisClass.DefaultArgExprList.Add(bNode); } } else if (vardecl.NameNode is BinaryExpressionNode) { BinaryExpressionNode bNode = vardecl.NameNode as BinaryExpressionNode; varIdent = bNode.LeftNode as IdentifierNode; bNode.endCol = vardecl.endCol; bNode.endLine = vardecl.endLine; if (vardecl.IsStatic) staticPropertyInitList.Add(bNode); else thisClass.DefaultArgExprList.Add(bNode); } else { Validity.Assert(false, "Check generated AST"); } // It is possible that fail to allocate variable. In that // case we should remove initializing expression from // cnode's defaultArgExprList int symbolIndex = AllocateMemberVariable(thisClassIndex, thisClassIndex, varIdent.Value, vardecl.ArgumentType.rank, vardecl.Access, vardecl.IsStatic); if (symbolIndex == ProtoCore.DSASM.Constants.kInvalidIndex) { Validity.Assert(thisClass.DefaultArgExprList.Count > 0); thisClass.DefaultArgExprList.RemoveAt(thisClass.DefaultArgExprList.Count - 1); } // Only generate getter/setter for non-ffi class else if (!classDecl.IsExternLib) { ProtoCore.DSASM.SymbolNode prop = vardecl.IsStatic ? core.CodeBlockList[0].symbolTable.symbolList[symbolIndex] : core.ClassTable.ClassNodes[thisClassIndex].Symbols.symbolList[symbolIndex]; string typeName = vardecl.ArgumentType.Name; if (String.IsNullOrEmpty(typeName)) { prop.datatype = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeVar, Constants.kArbitraryRank); } else { int type = core.TypeSystem.GetType(typeName); if (type == (int)PrimitiveType.kInvalidType) { string message = String.Format(ProtoCore.Properties.Resources.kTypeUndefined, typeName); core.BuildStatus.LogWarning(ProtoCore.BuildData.WarningID.kTypeUndefined, message, core.CurrentDSFileName, vardecl.line, vardecl.col, graphNode); prop.datatype = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeVar, 0); } else { int rank = vardecl.ArgumentType.rank; prop.datatype = core.TypeSystem.BuildTypeObject(type, rank); if (type != (int)PrimitiveType.kTypeVar || prop.datatype.IsIndexable) { prop.staticType = prop.datatype; } } } EmitGetterForProperty(classDecl, prop); EmitSetterForProperty(classDecl, prop); } } classOffset = 0; // Now we are going to create a static function __init_static_properties() // which will initialize all static properties. We will emit a // call to this function after all classes have been compiled. if (staticPropertyInitList.Count > 0 && !classDecl.IsExternLib) { FunctionDefinitionNode initFunc = new FunctionDefinitionNode { Name = ProtoCore.DSASM.Constants.kStaticPropertiesInitializer, Signature = new ArgumentSignatureNode(), Pattern = null, ReturnType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)PrimitiveType.kTypeNull), UID = (int)PrimitiveType.kTypeNull }, FunctionBody = new CodeBlockNode(), IsExternLib = false, IsDNI = false, ExternLibName = null, Access = ProtoCore.CompilerDefinitions.AccessModifier.kPublic, IsStatic = true }; classDecl.Procedures.Add(initFunc); staticPropertyInitList.ForEach(bNode => initFunc.FunctionBody.Body.Add(bNode)); initFunc.FunctionBody.Body.Add(AstFactory.BuildReturnStatement(new NullNode())); } unPopulatedClasses.Remove(thisClassIndex); }
private void EmitGetterForProperty(ProtoCore.AST.AssociativeAST.ClassDeclNode cnode, ProtoCore.DSASM.SymbolNode prop) { FunctionDefinitionNode getter = new FunctionDefinitionNode { Name = ProtoCore.DSASM.Constants.kGetterPrefix + prop.name, Signature = new ArgumentSignatureNode(), Pattern = null, ReturnType = prop.datatype, FunctionBody = new CodeBlockNode(), IsExternLib = false, IsDNI = false, ExternLibName = null, Access = prop.access, IsStatic = prop.isStatic, IsAutoGenerated = true }; var ret = AstFactory.BuildIdentifier(ProtoCore.DSDefinitions.Keyword.Return); var ident =AstFactory.BuildIdentifier(prop.name); var retStatement = AstFactory.BuildBinaryExpression(ret, ident, Operator.assign); getter.FunctionBody.Body.Add(retStatement); cnode.Procedures.Add(getter); }
private List<AssociativeNode> GetASTNodesDependentOnFunctionList(FunctionDefinitionNode functionNode) { // Determine if the modified function was used in any of the current nodes List<AssociativeNode> modifiedNodes = new List<AssociativeNode>(); // Iterate through the vm graphnodes at the global scope that contain a function call //foreach (ProtoCore.AssociativeGraph.GraphNode gnode in runnerCore.DSExecutable.instrStreamList[0].dependencyGraph.GraphList) Validity.Assert(null != core.GraphNodeCallList); foreach (ProtoCore.AssociativeGraph.GraphNode gnode in core.GraphNodeCallList) { if (gnode.isActive) { // Iterate through the current ast nodes foreach (KeyValuePair<System.Guid, Subtree> kvp in currentSubTreeList) { foreach (AssociativeNode assocNode in kvp.Value.AstNodes) { if (assocNode is BinaryExpressionNode) { if (gnode.exprUID == (assocNode as BinaryExpressionNode).ExpressionUID) { // Check if the procedure associatied with this graphnode matches thename and arg count of the modified proc if (null != gnode.firstProc) { if (gnode.firstProc.Name == functionNode.Name && gnode.firstProc.ArgumentInfos.Count == functionNode.Signature.Arguments.Count) { // If it does, create a new ast tree for this graphnode and append it to deltaAstList modifiedNodes.Add(assocNode); } } } } } } } } return modifiedNodes; }
private ProtoCore.AST.AssociativeAST.FunctionDefinitionNode ParseFieldAccessor(FieldInfo f) { if (null == f || SupressesImport(f)) return null; ProtoCore.AST.AssociativeAST.FunctionDefinitionNode func = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); func.Name = string.Format("%get_{0}", f.Name); func.Pattern = null; func.Signature = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); func.ReturnType = CLRModuleType.GetProtoCoreType(f.FieldType, Module); func.FunctionBody = null; func.access = ProtoCore.Compiler.AccessSpecifier.kPublic; func.IsDNI = false; func.IsExternLib = true; func.ExternLibName = Module.Name; func.IsStatic = f.IsStatic; return func; }
public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes) { Func<string, string[], object[], object> backingMethod = DSCore.Formula.Evaluate; // Format input names to be used as function parameters var inputs = InPorts.Select(x => x.PortName.Replace(' ', '_')).ToList(); /* def formula_partial(<params>) { * return = DSCore.Formula.Evaluate(<FormulaString>, <InPortData Names>, <params>); * } */ var functionDef = new FunctionDefinitionNode { Name = "__formula_" + AstIdentifierGuid, Signature = new ArgumentSignatureNode { Arguments = inputs.Select(AstFactory.BuildParamNode).ToList() }, ReturnType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var), FunctionBody = new CodeBlockNode { Body = new List<AssociativeNode> { AstFactory.BuildReturnStatement( AstFactory.BuildFunctionCall( backingMethod, new List<AssociativeNode> { AstFactory.BuildStringNode(FormulaString), AstFactory.BuildExprList( InPorts.Select( x => AstFactory.BuildStringNode(x.PortName) as AssociativeNode).ToList()), AstFactory.BuildExprList( inputs.Select(AstFactory.BuildIdentifier) .Cast<AssociativeNode>() .ToList()) })) } } }; if (IsPartiallyApplied) { return new AssociativeNode[] { functionDef, AstFactory.BuildAssignment( GetAstIdentifierForOutputIndex(0), AstFactory.BuildFunctionObject( functionDef.Name, InPorts.Count, Enumerable.Range(0, InPorts.Count).Where(index=>InPorts[index].IsConnected), inputAstNodes)) }; } else { UseLevelAndReplicationGuide(inputAstNodes); return new AssociativeNode[] { functionDef, AstFactory.BuildAssignment( GetAstIdentifierForOutputIndex(0), AstFactory.BuildFunctionCall( functionDef.Name, inputAstNodes)) }; } }
void Associative_functiondecl(out ProtoCore.AST.AssociativeAST.AssociativeNode node, List<ProtoCore.AST.AssociativeAST.AssociativeNode> attrs = null, ProtoCore.CompilerDefinitions.AccessModifier access = ProtoCore.CompilerDefinitions.AccessModifier.Public, bool isStatic = false) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode f = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); string methodName; ProtoCore.AST.AssociativeAST.AssociativeNode argumentSignature; ProtoCore.Type returnType; ProtoCore.AST.AssociativeAST.AssociativeNode pattern; string externLibName = ""; bool isExternLib = false; bool isDNI = false; Expect(27); NodeUtils.SetNodeLocation(f, t); Associative_MethodSignature(out methodName, out argumentSignature, out pattern, out returnType); if (isExternLib && "var" == returnType.Name){ errors.Warning(String.Format("External function {0} does not have a return type defined. Defaulting to var.", methodName)); } f.IsExternLib = isExternLib; f.IsDNI = isDNI; f.ExternLibName = externLibName; f.Name = methodName; f.Pattern = pattern; f.ReturnType = returnType; f.Access = access; f.Attributes = attrs; f.Signature = argumentSignature as ProtoCore.AST.AssociativeAST.ArgumentSignatureNode; f.IsStatic = isStatic; ProtoCore.AST.AssociativeAST.AssociativeNode functionBody = null; if (la.kind == 23) { Get(); } else if (la.kind == 51) { Get(); Associative_FunctionalMethodBodySingleLine(out functionBody); } else if (la.kind == 45) { Associative_FunctionalMethodBodyMultiLine(out functionBody); } else SynErr(72); f.FunctionBody = functionBody as ProtoCore.AST.AssociativeAST.CodeBlockNode; node = f; }
private void Initialize(FunctionDefinitionNode functionDefinitionNode) { }
public GlobalInstanceProc() { classIndex = ProtoCore.DSASM.Constants.kInvalidIndex; procNode = null; }
public override AssociativeNode VisitFunctionDefinitionNode(FunctionDefinitionNode node) { // Not applying renaming to function defintion node, otherwise // function defintion would depend on variables that defined in // code block node, and there are implicit dependency between // code block node that uses this funciton and code block node // that defines this function. return node; }
public ThisPointerProcOverload() { classIndex = ProtoCore.DSASM.Constants.kInvalidIndex; procNode = null; }
private void EmitGetterForMemVar(ProtoCore.AST.AssociativeAST.ClassDeclNode cnode, ProtoCore.DSASM.SymbolNode memVar) { FunctionDefinitionNode getter = new FunctionDefinitionNode() { Name = ProtoCore.DSASM.Constants.kGetterPrefix + memVar.name, Singnature = new ArgumentSignatureNode(), Pattern = null, ReturnType = core.TypeSystem.BuildTypeObject((int)PrimitiveType.kTypeVar, false), FunctionBody = new CodeBlockNode(), IsExternLib = false, IsDNI = false, ExternLibName = null, access = memVar.access, IsStatic = memVar.isStatic }; getter.FunctionBody.Body.Add(new BinaryExpressionNode() { // return = property; LeftNode = new IdentifierNode() { Value = ProtoCore.DSDefinitions.Kw.kw_return, Name = ProtoCore.DSDefinitions.Kw.kw_return, datatype = core.TypeSystem.BuildTypeObject(PrimitiveType.kTypeReturn, false) }, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new IdentifierNode() { Value = memVar.name, Name = memVar.name, datatype = core.TypeSystem.BuildTypeObject(PrimitiveType.kTypeVar, false) } }); cnode.funclist.Add(getter); }
private static void InsertDotMemVarMethod(Core core, ProtoCore.AST.Node root) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); funcDefNode.access = ProtoCore.DSASM.AccessSpecifier.kPublic; funcDefNode.Name = ProtoCore.DSASM.Constants.kDotArgMethodName; funcDefNode.ReturnType = new ProtoCore.Type() { Name = core.TypeSystem.GetType((int)PrimitiveType.kTypeVar), UID = (int)PrimitiveType.kTypeVar }; ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kLHS), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)PrimitiveType.kTypeVar), UID = (int)PrimitiveType.kTypeVar } }); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kRHS), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)PrimitiveType.kTypeInt), UID = (int)PrimitiveType.kTypeInt } }); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, "%rhsDimExprList"), ArgumentType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeInt, 1) }); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, "%rhsDim"), ArgumentType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeInt, 0) }); funcDefNode.Signature = args; ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Keyword.Return, ProtoCore.PrimitiveType.kTypeReturn); ProtoCore.AST.AssociativeAST.DotFunctionBodyNode dotNode = new ProtoCore.AST.AssociativeAST.DotFunctionBodyNode(args.Arguments[0].NameNode, args.Arguments[1].NameNode, args.Arguments[2].NameNode, args.Arguments[3].NameNode); body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = _return, Optr = ProtoCore.DSASM.Operator.assign, RightNode = dotNode}); funcDefNode.FunctionBody = body; (root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode); }
private void EmitSetterForMemVar(ProtoCore.AST.AssociativeAST.ClassDeclNode cnode, ProtoCore.DSASM.SymbolNode memVar) { var argument = new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = new ProtoCore.AST.AssociativeAST.IdentifierNode() { Value = ProtoCore.DSASM.Constants.kTempArg, Name = ProtoCore.DSASM.Constants.kTempArg, datatype = core.TypeSystem.BuildTypeObject(PrimitiveType.kTypeVar, false) }, ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)PrimitiveType.kTypeVar), UID = (int)PrimitiveType.kTypeVar } }; var argumentSingature = new ArgumentSignatureNode(); argumentSingature.AddArgument(argument); FunctionDefinitionNode setter = new FunctionDefinitionNode() { Name = ProtoCore.DSASM.Constants.kSetterPrefix + memVar.name, Singnature = argumentSingature, Pattern = null, ReturnType = core.TypeSystem.BuildTypeObject((int)PrimitiveType.kTypeNull, false), FunctionBody = new CodeBlockNode(), IsExternLib = false, IsDNI = false, ExternLibName = null, access = memVar.access, IsStatic = memVar.isStatic }; // property = %tmpArg setter.FunctionBody.Body.Add(new BinaryExpressionNode() { // return = property; LeftNode = new IdentifierNode() { Value = memVar.name, Name = memVar.name, datatype = core.TypeSystem.BuildTypeObject(PrimitiveType.kTypeVar, false) }, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new IdentifierNode() { Value = ProtoCore.DSASM.Constants.kTempArg, Name = ProtoCore.DSASM.Constants.kTempArg, datatype = core.TypeSystem.BuildTypeObject(PrimitiveType.kTypeVar, false) } }); // return = null; setter.FunctionBody.Body.Add(new BinaryExpressionNode() { LeftNode = new IdentifierNode() { Value = ProtoCore.DSDefinitions.Kw.kw_return, Name = ProtoCore.DSDefinitions.Kw.kw_return, datatype = core.TypeSystem.BuildTypeObject(PrimitiveType.kTypeReturn, false) }, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new NullNode() }); cnode.funclist.Add(setter); }
void Associative_functiondecl(out ProtoCore.AST.AssociativeAST.AssociativeNode node, ProtoCore.CompilerDefinitions.AccessModifier access = ProtoCore.CompilerDefinitions.AccessModifier.Public, bool isStatic = false) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode f = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); string methodName; ProtoCore.AST.AssociativeAST.AssociativeNode argumentSignature; ProtoCore.Type returnType; string externLibName = ""; bool isExternLib = false; Expect(27); NodeUtils.SetNodeLocation(f, t); Associative_MethodSignature(out methodName, out argumentSignature, out returnType); if (isExternLib && "var" == returnType.Name){ errors.Warning(String.Format("External function {0} does not have a return type defined. Defaulting to var.", methodName)); } f.IsExternLib = isExternLib; f.ExternLibName = externLibName; f.Name = methodName; f.ReturnType = returnType; f.Access = access; f.Signature = argumentSignature as ProtoCore.AST.AssociativeAST.ArgumentSignatureNode; f.IsStatic = isStatic; ProtoCore.AST.AssociativeAST.AssociativeNode functionBody = null; Associative_FunctionDefinitionBody(out functionBody); f.FunctionBody = functionBody as ProtoCore.AST.AssociativeAST.CodeBlockNode; node = f; }
/// <summary> /// Sets the function to an inactive state where it can no longer be used by the front-end and backend /// </summary> /// <param name="functionDef"></param> public void SetFunctionInactive(FunctionDefinitionNode functionDef) { // DS language only supports function definition on the global and first language block scope // TODO Jun: Determine if it is still required to combine function tables in the codeblocks and callsite // Update the functiond definition in the codeblocks int hash = CoreUtils.GetFunctionHash(functionDef); ProcedureNode procNode = null; foreach (CodeBlock block in CodeBlockList) { // Update the current function definition in the current block procNode = block.procedureTable.Procedures.FirstOrDefault(p => p.HashID == hash); int index = procNode == null ? Constants.kInvalidIndex: procNode.ID; if (Constants.kInvalidIndex == index) continue; procNode.IsActive = false; // Remove staled graph nodes var graph = block.instrStream.dependencyGraph; graph.GraphList.RemoveAll(g => g.classIndex == ClassIndex && g.procIndex == index); graph.RemoveNodesFromScope(Constants.kGlobalScope, index); // Make a copy of all symbols defined in this function var localSymbols = block.symbolTable.symbolList.Values .Where(n => n.classScope == Constants.kGlobalScope && n.functionIndex == index) .ToList(); foreach (var symbol in localSymbols) { block.symbolTable.UndefineSymbol(symbol); } break; } if (null != procNode) { // Remove codeblock defined in procNode from CodeBlockList and CompleteCodeBlockList foreach (int cbID in procNode.ChildCodeBlocks) { CompleteCodeBlockList.RemoveAll(x => x.codeBlockId == cbID); foreach (CodeBlock cb in CodeBlockList) { cb.children.RemoveAll(x => x.codeBlockId == cbID); } } } // Update the function definition in global function tables foreach (KeyValuePair<int, Dictionary<string, FunctionGroup>> functionGroupList in DSExecutable.FunctionTable.GlobalFuncTable) { foreach (KeyValuePair<string, FunctionGroup> functionGroup in functionGroupList.Value) { functionGroup.Value.FunctionEndPoints.RemoveAll(func => func.procedureNode.HashID == hash); } } }
/// <summary> /// Compiles a collection of Dynamo nodes into a function definition for a custom node. /// </summary> /// <param name="def"></param> /// <param name="funcBody"></param> /// <param name="outputs"></param> /// <param name="parameters"></param> public void CompileCustomNodeDefinition( CustomNodeDefinition def, IEnumerable<NodeModel> funcBody, List<AssociativeNode> outputs, IEnumerable<string> parameters) { OnAstNodeBuilding(def.FunctionId); var functionBody = new CodeBlockNode(); functionBody.Body.AddRange(CompileToAstNodes(funcBody, false)); if (outputs.Count > 1) { /* rtn_array = {}; * rtn_array[key0] = out0; * rtn_array[key1] = out1; * ... * return = rtn_array; */ // return array, holds all outputs string rtnName = "__temp_rtn_" + def.FunctionId.ToString().Replace("-", String.Empty); functionBody.Body.Add( AstFactory.BuildAssignment( AstFactory.BuildIdentifier(rtnName), AstFactory.BuildExprList(new List<string>()))); // indexers for each output IEnumerable<AssociativeNode> indexers = def.ReturnKeys != null ? def.ReturnKeys.Select(AstFactory.BuildStringNode) as IEnumerable<AssociativeNode> : Enumerable.Range(0, outputs.Count).Select(AstFactory.BuildIntNode); functionBody.Body.AddRange( outputs.Zip( indexers, (outputId, indexer) => // for each outputId and return key // pack the output into the return array AstFactory.BuildAssignment(AstFactory.BuildIdentifier(rtnName, indexer), outputId))); // finally, return the return array functionBody.Body.Add(AstFactory.BuildReturnStatement(AstFactory.BuildIdentifier(rtnName))); } else { // For single output, directly return that identifier or null. AssociativeNode returnValue = outputs.Count == 1 ? outputs[0] : new NullNode(); functionBody.Body.Add(AstFactory.BuildReturnStatement(returnValue)); } Type allTypes = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeVar); //Create a new function definition var functionDef = new FunctionDefinitionNode { Name = def.FunctionName.Replace("-", string.Empty), Signature = new ArgumentSignatureNode { Arguments = parameters.Select(param => AstFactory.BuildParamNode(param, allTypes)).ToList() }, FunctionBody = functionBody, ReturnType = allTypes }; OnAstNodeBuilt(def.FunctionId, new[] { functionDef }); }
private ProtoCore.AST.AssociativeAST.AssociativeNode ParseMethod(MethodInfo method) { ProtoCore.Type retype = CLRModuleType.GetProtoCoreType(method.ReturnType, Module); bool propaccessor = isPropertyAccessor(method); bool isOperator = isOverloadedOperator(method); FFIMethodAttributes mattrs = new FFIMethodAttributes(method); if (method.IsStatic && method.DeclaringType == method.ReturnType && !propaccessor && !isOperator) { //case for named constructor. Must return a pointer type if (!Object.Equals(method.ReturnType, CLRType)) throw new InvalidOperationException("Unexpected type for constructor {0D28FC00-F8F4-4049-AD1F-BBC34A68073F}"); retype = ProtoCoreType; ConstructorDefinitionNode node = ParsedNamedConstructor(method, method.Name, retype); node.MethodAttributes = mattrs; return node; } //Need to hide property accessor from design script users, prefix with % string prefix = (isOperator || propaccessor) ? "%" : ""; var func = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); if (isOperator) { func.Name = string.Format("{0}{1}", prefix, GetDSOperatorName(method.Name)); } else { func.Name = string.Format("{0}{1}", prefix, method.Name); } func.Pattern = null; func.Signature = ParseArgumentSignature(method); if ((retype.IsIndexable && mattrs.AllowRankReduction) || (typeof(object).Equals(method.ReturnType))) { retype.rank = Constants.kArbitraryRank; } func.ReturnType = retype; func.FunctionBody = null; func.access = ProtoCore.Compiler.AccessSpecifier.kPublic; func.IsDNI = false; func.IsExternLib = true; func.ExternLibName = Module.Name; func.IsStatic = method.IsStatic; func.MethodAttributes = mattrs; return func; }
// The following methods are used to insert methods to the bottom of the AST and convert operator to these method calls // to support replication on operators private static void InsertUnaryOperationMethod(Core core, CodeBlockNode root, UnaryOperator op, PrimitiveType r, PrimitiveType operand) { FunctionDefinitionNode funcDefNode = new FunctionDefinitionNode(); funcDefNode.access = CompilerDefinitions.AccessModifier.kPublic; funcDefNode.IsAssocOperator = true; funcDefNode.IsBuiltIn = true; funcDefNode.Name = Op.GetUnaryOpFunction(op); funcDefNode.ReturnType = new Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r }; ArgumentSignatureNode args = new ArgumentSignatureNode(); args.AddArgument(new VarDeclNode() { Access = CompilerDefinitions.AccessModifier.kPublic, NameNode = AstFactory.BuildIdentifier("%param"), ArgumentType = new Type { Name = core.TypeSystem.GetType((int)operand), UID = (int)operand } }); funcDefNode.Signature = args; CodeBlockNode body = new CodeBlockNode(); IdentifierNode param = AstFactory.BuildIdentifier("%param"); body.Body.Add(AstFactory.BuildReturnStatement(new UnaryExpressionNode() { Expression = param, Operator = op })); funcDefNode.FunctionBody = body; root.Body.Add(funcDefNode); }
public ThisPointerProcOverload() { classIndex = Constants.kInvalidIndex; procNode = null; }
private void EmitClassDeclNode(AssociativeNode node, ref ProtoCore.Type inferedType, ProtoCore.CompilerDefinitions.SubCompilePass subPass = ProtoCore.CompilerDefinitions.SubCompilePass.None, GraphNode graphNode = null) { ClassDeclNode classDecl = node as ClassDeclNode; // Handling n-pass on class declaration if (ProtoCore.CompilerDefinitions.CompilePass.ClassName == compilePass) { // Class name pass // Populating the class tables with the class names if (null != codeBlock.parent) { buildStatus.LogSemanticError(Resources.ClassCannotBeDefinedInsideLanguageBlock, core.CurrentDSFileName, classDecl.line, classDecl.col); } ProtoCore.DSASM.ClassNode thisClass = new ProtoCore.DSASM.ClassNode(); thisClass.Name = classDecl.ClassName; thisClass.Size = classDecl.Variables.Count; thisClass.IsImportedClass = classDecl.IsImportedClass; thisClass.TypeSystem = core.TypeSystem; thisClass.ClassAttributes = classDecl.ClassAttributes; if (classDecl.ExternLibName != null) thisClass.ExternLib = classDecl.ExternLibName; else thisClass.ExternLib = Path.GetFileName(core.CurrentDSFileName); globalClassIndex = core.ClassTable.Append(thisClass); if (ProtoCore.DSASM.Constants.kInvalidIndex == globalClassIndex) { string message = string.Format("Class redefinition '{0}' (BE1C3285).\n", classDecl.ClassName); buildStatus.LogSemanticError(message, core.CurrentDSFileName, classDecl.line, classDecl.col); throw new BuildHaltException(message); } unPopulatedClasses.Add(globalClassIndex, classDecl); //Always allow us to convert a class to a bool thisClass.CoerceTypes.Add((int)PrimitiveType.Bool, (int)ProtoCore.DSASM.ProcedureDistance.CoerceScore); } else if (ProtoCore.CompilerDefinitions.CompilePass.ClassBaseClass == compilePass) { // Base class pass // Populating each class entry with their immediate baseclass globalClassIndex = core.ClassTable.GetClassId(classDecl.ClassName); ProtoCore.DSASM.ClassNode thisClass = core.ClassTable.ClassNodes[globalClassIndex]; // Verify and store the list of classes it inherits from if (!string.IsNullOrEmpty(classDecl.BaseClass)) { int baseClass = core.ClassTable.GetClassId(classDecl.BaseClass); if (baseClass == globalClassIndex) { string message = string.Format("Class '{0}' cannot derive from itself (DED0A61F).\n", classDecl.ClassName); buildStatus.LogSemanticError(message, core.CurrentDSFileName, classDecl.line, classDecl.col); throw new BuildHaltException(message); } if (ProtoCore.DSASM.Constants.kInvalidIndex != baseClass) { if (core.ClassTable.ClassNodes[baseClass].IsImportedClass && !thisClass.IsImportedClass) { string message = string.Format("Cannot derive from FFI class {0} (DA87AC4D).\n", core.ClassTable.ClassNodes[baseClass].Name); buildStatus.LogSemanticError(message, core.CurrentDSFileName, classDecl.line, classDecl.col); throw new BuildHaltException(message); } thisClass.Base = baseClass; thisClass.CoerceTypes.Add(baseClass, (int)ProtoCore.DSASM.ProcedureDistance.CoerceBaseClass); } else { string message = string.Format("Unknown base class '{0}' (9E44FFB3).\n", classDecl.BaseClass); buildStatus.LogSemanticError(message, core.CurrentDSFileName, classDecl.line, classDecl.col); throw new BuildHaltException(message); } } } else if (ProtoCore.CompilerDefinitions.CompilePass.ClassHierarchy == compilePass) { // Class hierarchy pass // Populating each class entry with all sub classes in the hierarchy globalClassIndex = core.ClassTable.GetClassId(classDecl.ClassName); ProtoCore.DSASM.ClassNode thisClass = core.ClassTable.ClassNodes[globalClassIndex]; // Verify and store the list of classes it inherits from if (!string.IsNullOrEmpty(classDecl.BaseClass)) { int baseClass = core.ClassTable.GetClassId(classDecl.BaseClass); // Iterate through all the base classes until the the root class // For every base class, add the coercion score ProtoCore.DSASM.ClassNode tmpCNode = core.ClassTable.ClassNodes[baseClass]; if (tmpCNode.Base != Constants.kInvalidIndex) { baseClass = tmpCNode.Base; while (ProtoCore.DSASM.Constants.kInvalidIndex != baseClass) { thisClass.CoerceTypes.Add(baseClass, (int)ProtoCore.DSASM.ProcedureDistance.CoerceBaseClass); tmpCNode = core.ClassTable.ClassNodes[baseClass]; baseClass = ProtoCore.DSASM.Constants.kInvalidIndex; if (tmpCNode.Base != Constants.kInvalidIndex) { baseClass = tmpCNode.Base; } } } } } else if (ProtoCore.CompilerDefinitions.CompilePass.ClassMemVar == compilePass) { EmitMemberVariables(classDecl, graphNode); } else if (ProtoCore.CompilerDefinitions.CompilePass.ClassMemFuncSig == compilePass) { // Class member variable pass // Populating each class entry vtables with their respective // member variables signatures globalClassIndex = core.ClassTable.GetClassId(classDecl.ClassName); List<AssociativeNode> thisPtrOverloadList = new List<AssociativeNode>(); foreach (AssociativeNode funcdecl in classDecl.Procedures) { DfsTraverse(funcdecl, ref inferedType); var funcDef = funcdecl as FunctionDefinitionNode; if (funcDef == null || funcDef.IsStatic || funcDef.Name == ProtoCore.DSDefinitions.Keyword.Dispose) continue; bool isGetterSetter = CoreUtils.IsGetterSetter(funcDef.Name); var thisPtrArgName = Constants.kThisPointerArgName; if (!isGetterSetter) { var classsShortName = classDecl.ClassName.Split('.').Last(); var typeDepName = classsShortName.ToLower(); if (typeDepName != classsShortName && funcDef.Signature.Arguments.All(a => a.NameNode.Name != typeDepName)) thisPtrArgName = typeDepName; } // This is a function, create its parameterized this pointer overload var procNode = new FunctionDefinitionNode(funcDef); var thisPtrArg = new VarDeclNode() { Access = ProtoCore.CompilerDefinitions.AccessModifier.Public, NameNode = AstFactory.BuildIdentifier(thisPtrArgName), ArgumentType = new ProtoCore.Type { Name = classDecl.ClassName, UID = globalClassIndex, rank = 0 } }; procNode.Signature.Arguments.Insert(0, thisPtrArg); procNode.IsAutoGeneratedThisProc = true; if (CoreUtils.IsGetterSetter(funcDef.Name)) { for (int n = 0; n < procNode.FunctionBody.Body.Count; ++n) { if (procNode.FunctionBody.Body[n] is BinaryExpressionNode) { var assocNode = procNode.FunctionBody.Body[n] as BinaryExpressionNode; AssociativeNode outLNode = null; AssociativeNode outRNode = null; // This is the first traversal of this statement and is therefore the assignment op Validity.Assert(Operator.assign == assocNode.Optr); TraverseAndAppendThisPtrArg(assocNode.LeftNode, ref outLNode); TraverseAndAppendThisPtrArg(assocNode.RightNode, ref outRNode); assocNode.LeftNode = outLNode; assocNode.RightNode = outRNode; } } } else { // Generate a static function for member function f(): // satic def f(a: A) // { // return = a.f() // } procNode.IsStatic = true; var args = procNode.Signature.Arguments.Select(a => a.NameNode).ToList(); var fcall = AstFactory.BuildFunctionCall(procNode.Name, args) as FunctionCallNode; // Build the dotcall node var lhs = procNode.Signature.Arguments[0].NameNode; var right = CoreUtils.GenerateCallDotNode(lhs, fcall, core); var body = AstFactory.BuildReturnStatement(right); procNode.FunctionBody.Body = new List<AssociativeNode> { body }; } thisPtrOverloadList.Add(procNode); } foreach (var overloadFunc in thisPtrOverloadList) { // Emit the newly defined overloads DfsTraverse(overloadFunc, ref inferedType); } classDecl.Procedures.AddRange(thisPtrOverloadList); if (!classDecl.IsExternLib) { ProtoCore.DSASM.ProcedureTable vtable = core.ClassTable.ClassNodes[globalClassIndex].ProcTable; if (vtable.GetFunctionBySignature(classDecl.ClassName, new List<ProtoCore.Type>()) == null) { ConstructorDefinitionNode defaultConstructor = new ConstructorDefinitionNode(); defaultConstructor.Name = classDecl.ClassName; defaultConstructor.LocalVariableCount = 0; defaultConstructor.Signature = new ArgumentSignatureNode(); defaultConstructor.ReturnType = new ProtoCore.Type { Name = "var", UID = 0 }; defaultConstructor.FunctionBody = new CodeBlockNode(); defaultConstructor.BaseConstructor = null; defaultConstructor.Access = ProtoCore.CompilerDefinitions.AccessModifier.Public; defaultConstructor.IsExternLib = false; defaultConstructor.ExternLibName = null; DfsTraverse(defaultConstructor, ref inferedType); classDecl.Procedures.Add(defaultConstructor); } } } else if (ProtoCore.CompilerDefinitions.CompilePass.GlobalScope == compilePass) { // before populate the attributes, we must know the attribute class constructor signatures // in order to check the parameter // populate the attributes for the class and class member variable globalClassIndex = core.ClassTable.GetClassId(classDecl.ClassName); if (globalClassIndex != ProtoCore.DSASM.Constants.kInvalidIndex) { ProtoCore.DSASM.ClassNode thisClass = core.ClassTable.ClassNodes[globalClassIndex]; // class if (classDecl.Attributes != null) { thisClass.Attributes = PopulateAttributes(classDecl.Attributes); } // member variable int ix = -1; int currentClassScope = -1; foreach (ProtoCore.DSASM.SymbolNode sn in thisClass.Symbols.symbolList.Values) { // only populate the attributes for member variabls if (sn.functionIndex != ProtoCore.DSASM.Constants.kInvalidIndex) continue; if (sn.classScope != globalClassIndex) { if (currentClassScope != sn.classScope) { currentClassScope = sn.classScope; ix = 0; } } else { if (currentClassScope != globalClassIndex) { currentClassScope = globalClassIndex; ix = 0; } } } } } else if (ProtoCore.CompilerDefinitions.CompilePass.ClassMemFuncBody == compilePass) { // Class member variable pass // Populating the function body of each member function defined in the class vtables globalClassIndex = core.ClassTable.GetClassId(classDecl.ClassName); // Initialize the global function table for this class // 'classIndexAtCallsite' is the class index as it is stored at the callsite function tables int classIndexAtCallsite = globalClassIndex + 1; core.FunctionTable.InitGlobalFunctionEntry(classIndexAtCallsite); foreach (AssociativeNode funcdecl in classDecl.Procedures) { // reset the inferedtype between functions inferedType = new ProtoCore.Type(); DfsTraverse(funcdecl, ref inferedType, false, null, subPass); } } // Reset the class index core.ClassIndex = globalClassIndex = ProtoCore.DSASM.Constants.kGlobalScope; }
private FunctionDefinitionNode EmitSetterFunction(ProtoCore.DSASM.SymbolNode prop, ProtoCore.Type argType) { var argument = new ProtoCore.AST.AssociativeAST.VarDeclNode() { Access = ProtoCore.CompilerDefinitions.AccessModifier.kPublic, NameNode =AstFactory.BuildIdentifier(Constants.kTempArg), ArgumentType = argType }; var argumentSingature = new ArgumentSignatureNode(); argumentSingature.AddArgument(argument); FunctionDefinitionNode setter = new FunctionDefinitionNode { Name = ProtoCore.DSASM.Constants.kSetterPrefix + prop.name, Signature = argumentSingature, Pattern = null, ReturnType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeNull, 0), FunctionBody = new CodeBlockNode(), IsExternLib = false, IsDNI = false, ExternLibName = null, Access = prop.access, IsStatic = prop.isStatic, IsAutoGenerated = true }; // property = %tmpArg var propIdent = new TypedIdentifierNode(); propIdent.Name = propIdent.Value = prop.name; propIdent.datatype = prop.datatype; var tmpArg =AstFactory.BuildIdentifier(Constants.kTempArg); var assignment = AstFactory.BuildBinaryExpression(propIdent, tmpArg, Operator.assign); setter.FunctionBody.Body.Add(assignment); // return = null; var returnNull = AstFactory.BuildReturnStatement(new NullNode()); setter.FunctionBody.Body.Add(returnNull); return setter; }
// The following methods are used to insert methods to the bottom of the AST and convert operator to these method calls // to support replication on operators private static void InsertUnaryOperationMethod(Core core, ProtoCore.AST.Node root, UnaryOperator op, PrimitiveType r, PrimitiveType operand) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); funcDefNode.access = ProtoCore.CompilerDefinitions.AccessModifier.kPublic; funcDefNode.IsAssocOperator = true; funcDefNode.IsBuiltIn = true; funcDefNode.Name = Op.GetUnaryOpFunction(op); funcDefNode.ReturnType = new ProtoCore.Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r }; ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.CompilerDefinitions.AccessModifier.kPublic, NameNode = BuildAssocIdentifier(core, "%param"), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)operand), UID = (int)operand } }); funcDefNode.Signature = args; ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Keyword.Return, ProtoCore.PrimitiveType.kTypeReturn); ProtoCore.AST.AssociativeAST.IdentifierNode param = BuildAssocIdentifier(core, "%param"); body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = _return, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new ProtoCore.AST.AssociativeAST.UnaryExpressionNode() { Expression = param, Operator = op } }); funcDefNode.FunctionBody = body; (root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode); }
private static void InsertInlineConditionOperationMethod(Core core, ProtoCore.AST.Node root, PrimitiveType condition, PrimitiveType r) { ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode(); funcDefNode.access = ProtoCore.DSASM.AccessSpecifier.kPublic; funcDefNode.Name = ProtoCore.DSASM.Constants.kInlineCondition; funcDefNode.ReturnType = new ProtoCore.Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r }; ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode(); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, "%condition"), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)condition), UID = (int)condition } }); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, "%trueExp"), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)r), UID = (int)r } }); args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode() { memregion = ProtoCore.DSASM.MemoryRegion.kMemStack, access = ProtoCore.DSASM.AccessSpecifier.kPublic, NameNode = BuildAssocIdentifier(core, "%falseExp"), ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)r), UID = (int)r } }); funcDefNode.Signature = args; ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode(); ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Keyword.Return, ProtoCore.PrimitiveType.kTypeReturn); ProtoCore.AST.AssociativeAST.IdentifierNode con = BuildAssocIdentifier(core, "%condition"); ProtoCore.AST.AssociativeAST.IdentifierNode t = BuildAssocIdentifier(core, "%trueExp"); ProtoCore.AST.AssociativeAST.IdentifierNode f = BuildAssocIdentifier(core, "%falseExp"); body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = _return, Optr = Operator.assign, RightNode = new ProtoCore.AST.AssociativeAST.InlineConditionalNode() { ConditionExpression = con, TrueExpression = t, FalseExpression = f } }); funcDefNode.FunctionBody = body; (root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode); }
public FunctionDefinitionNode(FunctionDefinitionNode rhs) { this.Name = rhs.Name; if (null != rhs.FunctionBody) { this.FunctionBody = new CodeBlockNode(rhs.FunctionBody); } else { this.FunctionBody = new CodeBlockNode(); } this.ReturnType = rhs.ReturnType; this.Attributes = rhs.Attributes; this.Singnature = new ArgumentSignatureNode(rhs.Singnature); this.Pattern = rhs.Pattern; this.IsExternLib = rhs.IsExternLib; this.BuiltInMethodId = rhs.BuiltInMethodId; this.IsDNI = rhs.IsDNI; this.ExternLibName = rhs.ExternLibName; this.access = rhs.access; this.IsStatic = rhs.IsStatic; this.IsAutoGenerated = rhs.IsAutoGenerated; this.IsAssocOperator = rhs.IsAssocOperator; this.IsAutoGeneratedThisProc = IsAutoGeneratedThisProc; this.IsBuiltIn = rhs.IsBuiltIn; }
public void DFSTraverse(ref AST.AssociativeAST.AssociativeNode node) { if (node is AST.AssociativeAST.IdentifierNode) { EmitIdentifierNode(ref node); } else if (node is ProtoCore.AST.AssociativeAST.IdentifierListNode) { AST.AssociativeAST.IdentifierListNode identList = node as ProtoCore.AST.AssociativeAST.IdentifierListNode; EmitIdentifierListNode(ref identList); } else if (node is ProtoCore.AST.AssociativeAST.IntNode) { AST.AssociativeAST.IntNode intNode = node as ProtoCore.AST.AssociativeAST.IntNode; EmitIntNode(ref intNode); } else if (node is ProtoCore.AST.AssociativeAST.DoubleNode) { AST.AssociativeAST.DoubleNode doubleNode = node as ProtoCore.AST.AssociativeAST.DoubleNode; EmitDoubleNode(ref doubleNode); } else if (node is ProtoCore.AST.AssociativeAST.FunctionCallNode) { AST.AssociativeAST.FunctionCallNode funcCallNode = node as ProtoCore.AST.AssociativeAST.FunctionCallNode; EmitFunctionCallNode(ref funcCallNode); } else if (node is ProtoCore.AST.AssociativeAST.FunctionDotCallNode) { AST.AssociativeAST.FunctionDotCallNode funcDotCall = node as ProtoCore.AST.AssociativeAST.FunctionDotCallNode; EmitFunctionDotCallNode(ref funcDotCall); } else if (node is ProtoCore.AST.AssociativeAST.BinaryExpressionNode) { ProtoCore.AST.AssociativeAST.BinaryExpressionNode binaryExpr = node as ProtoCore.AST.AssociativeAST.BinaryExpressionNode; if (binaryExpr.Optr != DSASM.Operator.assign) { ; } //EmitCode("("); EmitBinaryNode(ref binaryExpr); if (binaryExpr.Optr == DSASM.Operator.assign) { //EmitCode(ProtoCore.DSASM.Constants.termline); } if (binaryExpr.Optr != DSASM.Operator.assign) { ; } //EmitCode(")"); } else if (node is ProtoCore.AST.AssociativeAST.FunctionDefinitionNode) { AST.AssociativeAST.FunctionDefinitionNode funcDefNode = node as ProtoCore.AST.AssociativeAST.FunctionDefinitionNode; EmitFunctionDefNode(ref funcDefNode); } else if (node is ProtoCore.AST.AssociativeAST.ClassDeclNode) { AST.AssociativeAST.ClassDeclNode classDeclNode = node as ProtoCore.AST.AssociativeAST.ClassDeclNode; EmitClassDeclNode(ref classDeclNode); } else if (node is ProtoCore.AST.AssociativeAST.NullNode) { AST.AssociativeAST.NullNode nullNode = node as ProtoCore.AST.AssociativeAST.NullNode; EmitNullNode(ref nullNode); } else if (node is ProtoCore.AST.AssociativeAST.ArrayIndexerNode) { AST.AssociativeAST.ArrayIndexerNode arrIdxNode = node as ProtoCore.AST.AssociativeAST.ArrayIndexerNode; EmitArrayIndexerNode(ref arrIdxNode); } else if (node is ProtoCore.AST.AssociativeAST.ExprListNode) { AST.AssociativeAST.ExprListNode exprListNode = node as ProtoCore.AST.AssociativeAST.ExprListNode; EmitExprListNode(ref exprListNode); } }
/// <summary> /// Gets the has id of a function signature given the name and argument types /// </summary> /// <param name="functionDef"></param> /// <returns></returns> public static int GetFunctionHash(FunctionDefinitionNode functionDef) { Validity.Assert(null != functionDef); string functionDescription = functionDef.Name; foreach (VarDeclNode argNode in functionDef.Signature.Arguments) { functionDescription += argNode.ArgumentType.ToString(); } return functionDescription.GetHashCode(); }