Exemplo n.º 1
0
 public Statement(Parser yyp, FunctionCall fc) : base((yyp))
 {
     kids.Add(fc);
 }
        /// <summary>
        ///     Generates the code for a FunctionCall node.
        /// </summary>
        /// <param name="fc">The FunctionCall node.</param>
        /// <param name="NeedRetVal"></param>
        /// <returns>String containing C# code for FunctionCall fc.</returns>
        string GenerateFunctionCall(FunctionCall fc, bool NeedRetVal)
        {
            StringBuilder retVal = new StringBuilder(), tmpVal = new StringBuilder();
            bool marc = FuncCallsMarc();

            string Mname = "";
            bool isEnumerable = false;

            //int NeedCloseParent = 0;

            foreach (SYMBOL kid in fc.kids)
            {
                //                if (kid is ArgumentList && m_SLCompatabilityMode)
                if (kid is ArgumentList)
                {
                    ArgumentList al = kid as ArgumentList;
                    int comma = al.kids.Count - 1; // tells us whether to print a comma

                    foreach (SYMBOL s in al.kids)
                    {
                        if (s is BinaryExpression)
                        {
                            BinaryExpression be = s as BinaryExpression;
                            //FunctionCalls += GenerateNode(s);
                            if (be.ExpressionSymbol.Equals("&&") || be.ExpressionSymbol.Equals("||"))
                            {
                                // special case handling for logical and/or, see Mantis 3174
                                tmpVal.Append("((bool)(");
                                tmpVal.Append(GenerateNode((SYMBOL) be.kids.Pop()));
                                tmpVal.Append("))");
                                tmpVal.Append(Generate(string.Format(" {0} ", be.ExpressionSymbol.Substring(0, 1)), be));
                                tmpVal.Append("((bool)(");
                                foreach (SYMBOL kidb in be.kids)
                                    retVal.Append(GenerateNode(kidb));
                                tmpVal.Append("))");
                            }
                            else
                            {
                                tmpVal.Append(GenerateNode((SYMBOL) be.kids.Pop()));
                                tmpVal.Append(Generate(string.Format(" {0} ", be.ExpressionSymbol), be));
                                foreach (SYMBOL kidb in be.kids)
                                {
                                    if (kidb is FunctionCallExpression)
                                    {
                                        tmpVal.Append(GenerateNode(kidb));
                                    }
                                    else if (kidb is TypecastExpression)
                                    {
                                        tmpVal.Append(Generate(string.Format("({0}) (", ((TypecastExpression) kidb).TypecastType)));
                                        tmpVal.Append(GenerateNode((SYMBOL) kidb.kids.Pop()));
                                        tmpVal.Append(Generate(")"));
                                    }

                                    else
                                        tmpVal.Append(GenerateNode(kidb));
                                }
                            }
                        }
                        else if (s is TypecastExpression)
                        {
                            tmpVal.Append(Generate(string.Format("({0}) (", ((TypecastExpression) s).TypecastType)));
                            tmpVal.Append(GenerateNode((SYMBOL) s.kids.Pop()));
                            tmpVal.Append(Generate(")"));
                        }
                        else
                        {
                            tmpVal.Append(GenerateNode(s));
                        }

                        if (0 < comma--)
                            tmpVal.Append(Generate(", "));
                    }
                }
                else
                {
                    tmpVal.Append(GenerateNode(kid));
                }
            }

            isEnumerable = false;
            bool DTFunction = false;

            string rettype = "void";
            if (LocalMethods.TryGetValue(fc.Id, out rettype))
                isEnumerable = true;
                /* suspended.. API fails with IEnums
                        else if (IenFunctions.TryGetValue(fc.Id, out rettype))
                            isEnumerable = true;
            */
            else if (DTFunctions.Contains(fc.Id))
            {
                DTFunction = true;
            }

            //Check whether this function is an API function
            if (m_apiFunctions.ContainsKey(CheckName(fc.Id)))
            {
                //Add the m_apis link
                fc.Id = string.Format("((dynamic)m_apis[\"{0}\"]).{1}",
                                      m_apiFunctions[CheckName(fc.Id)].Name, fc.Id);
            }

            if (DTFunction)
            {
                retVal.Append(Generate("yield return "));
                retVal.Append(Generate(string.Format("{0}(", CheckName(fc.Id)), fc));
                retVal.Append(tmpVal.ToString());
                retVal.Append(Generate(")"));
            }
            else if (isEnumerable)
            {
                if (m_isInEnumeratedDeclaration && NeedRetVal) //Got to have a retVal for do/while
                {
                    //This is for things like the do/while statement, where a function is in the 
                    // while() part and can't be dumped in front of the do/while
                    string MethodName = StringUtils.RandomString(10, true);
                    string typeDefs = "";
                    ObjectList arguements = null;
                    if (LocalMethodArguements.TryGetValue(fc.Id, out arguements))
                    {
                        // print the state arguments, if any
                        foreach (SYMBOL kid in arguements)
                        {
                            if (kid is ArgumentDeclarationList)
                            {
                                ArgumentDeclarationList ADL = (ArgumentDeclarationList) kid;
                                typeDefs += (GenerateArgumentDeclarationList(ADL)) + ",";
                            }
                        }
                    }
                    if (typeDefs.Length != 0)
                        typeDefs = typeDefs.Remove(typeDefs.Length - 1);

                    string newMethod = string.Format("private {0} {1}({2}, out bool ahwowuerogng)", rettype, MethodName,
                                                     typeDefs);
                    newMethod += (Generate("{"));
                    newMethod += (Generate("ahwowuerogng = true;"));
                    Mname = StringUtils.RandomString(10, true);
                    newMethod += (Generate("System.Collections.IEnumerator " + Mname + " = "));
                    newMethod += (Generate(string.Format("{0}(", CheckName(fc.Id)), fc));
                    newMethod += (tmpVal.ToString());
                    newMethod += (Generate(");"));

                    newMethod += (Generate(" try {"));
                    newMethod += (Generate(Mname + ".MoveNext();"));
                    newMethod += (Generate("  if(" + Mname + ".Current != null)"));
                    newMethod += (Generate("   return (" + rettype + ")" + Mname + ".Current;"));
                    newMethod += (Generate("  }")); //End of try
                    newMethod += (Generate(" catch(Exception ex) "));
                    newMethod += (Generate("  {"));
                    newMethod += (Generate("  }")); //End of catch
                    newMethod += (Generate("ahwowuerogng = true;"));
                    newMethod += (Generate("return default(" + rettype + ");")); //End while
                    newMethod += "}";
                    MethodsToAdd.Add(newMethod);

                    List<string> fCalls = new List<string>();
                    string boolname = StringUtils.RandomString(10, true);
                    fCalls.Add(Generate("bool " + boolname + " = true;"));
                    retVal.Append(MethodName + "(" + tmpVal + ", out " + boolname + ")");
                    lock (FuncCalls)
                        FuncCalls.AddRange(fCalls);
                }
                else
                {
                    //Function calls are added to the DumpFunc command, and will be dumped safely before the
                    // statement that occurs here, so we don't have to deal with the issues behind having 
                    // { and } in this area.
                    Mname = StringUtils.RandomString(10, true);
                    string Exname = StringUtils.RandomString(10, true);
                    List<string> fCalls = new List<string>
                                              {
                                                  Generate("string " + Exname + " =  \"\";"),
                                                  Generate("System.Collections.IEnumerator " + Mname + " = "),
                                                  Generate(string.Format("{0}(", CheckName(fc.Id)), fc),
                                                  tmpVal.ToString(),
                                                  Generate(");"),
                                                  Generate("while (true) {"),
                                                  Generate(" try {"),
                                                  Generate("  if(!" + Mname + ".MoveNext())"),
                                                  Generate("   break;"),
                                                  Generate("  }"),
                                                  Generate(" catch(Exception ex) "),
                                                  Generate("  {"),
                                                  Generate("  " + Exname + " = ex.Message;"),
                                                  Generate("  }"),
                                                  Generate(" if(" + Exname + " != \"\")"),
                                                  Generate("   yield return " + Exname + ";"),
                                                  Generate(" else if(" + Mname + ".Current == null || " + Mname +
                                                           ".Current is DateTime)"),
                                                  Generate("   yield return " + Mname + ".Current;"),
                                                  Generate(" else break;"),
                                                  Generate(" }")
                                              };

                    //Let the other things process for a bit here at the end of each enumeration
                    //Let the other things process for a bit here at the end of each enumeration
                    if (NeedRetVal && rettype != "void")
                    {
                        retVal.Append(" (" + rettype + ") " + Mname + ".Current");
                    }
                    lock (FuncCalls)
                        FuncCalls.AddRange(fCalls);
                }
            }
            else
            {
                retVal.Append(Generate(string.Format("{0}(", CheckName(fc.Id)), fc));
                retVal.Append(tmpVal.ToString());

                retVal.Append(Generate(")"));
            }

            //Function calls are first if needed
            return DumpFunc(marc) + retVal + DumpAfterFunc(marc);
        }
Exemplo n.º 3
0
 public FunctionCallExpression(Parser yyp, FunctionCall fc) : base((yyp))
 {
     kids.Add(fc);
 }