public void VisitNode(ArgList node) { // Arg list for which method call? String owningMethod = null; // Find sibling with the method call info AbstractNode tempNode; tempNode = node.First; while (tempNode != null) { // Find qualified name sibling and leave if (tempNode.GetType() == typeof(QualifiedName)) { owningMethod = Utilities.FilterOutKeywords(tempNode.Name); break; } tempNode = tempNode.Sib; } Utilities.TypeVisitAllChildren(node); Attributes a = new Attributes("ArgList"); ArgListTypeDescriptor ATD = new ArgListTypeDescriptor(); a.typeInfo = ATD; node.attrRef = a; // Error type if problem with assignment if (IsValidArgList(node) == false) { Error(String.Format("Warning! Invalid Argument List when calling method {0}", owningMethod)); node.attrRef.typeInfo = new ErrorTypeDescriptor(); } // Also add the parameters to the typeInfo for printing later List <AbstractNode> listOfParams = new List <AbstractNode>(); ATD.Params = listOfParams; ATD.OwningMethod = owningMethod; //Add every child to the parameters tempNode = node.Child; while (tempNode != null) { listOfParams.Add(tempNode); // Find qualified name sibling and leave if (tempNode.GetType() == typeof(QualifiedName)) { owningMethod = Utilities.FilterOutKeywords(tempNode.Name); break; } tempNode = tempNode.Sib; } }
protected void VisitNode(MethodCall node) { // deal with arguments first // Arguments are in the arglist node's type descriptor. // If arguments were provided // We'll need one of these to understand what we're looking at MethodCallTypeDescriptor mtd = null; ArgListTypeDescriptor atd = null; ArgList proposedArgs = null; // "If the arg list for this has errors" is what we're trying to get at with this block // If we aren't error type descriptor try to get the args root if (Utilities.attrToType(node.attrRef) != "ErrorTypeDescriptor") { proposedArgs = node.attrRef.typeInfo.argsRoot; // If arguments are invalid if (proposedArgs != null && proposedArgs.attrRef.typeInfo.GetType() == typeof(ErrorTypeDescriptor)) { Console.WriteLine("Error in code generator. ErrorTypeDescriptor encountered."); } // If arguments are valid mtd = node.attrRef.typeInfo; string paramResult = ""; if (proposedArgs != null) { atd = mtd.argsRoot.attrRef.typeInfo; } // Keep track of how many arguments we're loading onto the stack prior to a function call if (atd != null) { foreach (var element in atd.Params) { if (Utilities.attrToType(element.attrRef).Contains("String")) { paramResult += "string"; // Overhead of pushing string to the stack InsertIntoFile(String.Format("ldstr\t\t \"{0}\"\n", element.Name)); } else if (Utilities.attrToType(element.attrRef).Contains("Integer")) { paramResult += "int32"; // If Identifier, use the number directly if (element.NodeType.Name == "Identifier") { InsertIntoFile(String.Format("ldc.i4\t\t {0}\n", element.Name)); } // If Qualified Name use variable name else if (element.NodeType.Name == "QualifiedName") { int varNumber = 0; // Either this is coming from function args (see here). Dictionary <string, int> localArgs = new Dictionary <string, int>(); localArgNumber.TryGetValue(methodName, out localArgs); if (localArgs.ContainsKey(element.Name)) { varNumber = GetArgPosit(element.Name); InsertIntoFile(String.Format("ldarg {0}\t\t //{1}\n", varNumber, element.Name)); } else { varNumber = GetStackPosit(element.Name); InsertIntoFile(String.Format("ldloc {0}\t\t //{1}\n", varNumber, element.Name)); } // Or this is coming from function local vars (see here) } // If Expr, generate instructions to evaluate expr else if (element.NodeType.Name == "Expr") { // Visit all expr nodes and have them generate the code. The other way to do this // would be as defined in this comment block which I was told not to do in class // (But works!) /* * Expr e = element as Expr; * int expressionEval = e.eval(); * InsertIntoFile(String.Format("ldc.i4\t\t {0}\n", expressionEval)); */ element.Accept(this); } } else { paramResult += "DEFAULT uh oh"; } } } // call method String nameSpaceString = mtd.nameSpaceVar; InsertIntoFile(String.Format("call {0} {1} :: {2}({3})\n", mtd.returnType.ToLower(), mtd.nameSpaceVar, mtd.name, paramResult)); } #if false // Get a type descriptor for this method dcl MethodDclTypeDescp m = node.attrRef.typeInfo as MethodDclTypeDescp; StringBuilder sb = new StringBuilder(); Byte[] info; // Build modifier list string modList = ""; foreach (string modifier in m.Modifiers) { modList += modifier + " "; } modList = modList.ToLower(); // Build parameter list string theFunctArgs = ""; int numberOfParams = 0; if (m.paramList != null) { foreach (string name in m.paramList.Names) { string entry = name + " " + m.paramList.Types; if (numberOfParams++ > 0) { entry += ","; } theFunctArgs += entry + "\n"; } } sb.AppendLine(String.Format(".method {0}{1} \n {2} ({3}) cil managed", modList, m.returnType, m.Name, theFunctArgs)); info = new UTF8Encoding(true).GetBytes(sb.ToString()); TCCLParser.currentFileStream.Write(info, 0, info.Length); InsertIntoFile("{\n"); if (m.Name.Contains("main") || m.Name.Contains("Main")) { InsertIntoFile(".entrypoint\n"); } InsertIntoFile(".maxstack 1000\n"); // for now // If field decls, do them here too // Visit children Utilities.CodeGenVisitAllChildren(node, this); #endif }