method() public method

public method ( string name ) : Method
name string
return Method
Exemplo n.º 1
0
        int executeType(string target)
        {
            if (target.IndexOf("::") < 0)
            {
                target += "::Main.main";
            }
            else if (target.IndexOf('.') < 0)
            {
                target += ".main";
            }

            try
            {
                int    dot  = target.IndexOf('.');
                Type   type = Type.find(target.Substring(0, dot), true);
                Method main = type.method(target.Substring(dot + 1), true);
                return(callMain(type, main));
            }
            catch (Exception e)
            {
                if (e is Err.Val)
                {
                    ((Err.Val)e).err().trace();
                }
                else
                {
                    Err.dumpStack(e);
                }
                return(-1);
            }
        }
Exemplo n.º 2
0
        public int executeFile(FileInfo file)
        {
            LocalFile f = (LocalFile)(new LocalFile(file).normalize());

            // use Fantom reflection to run compiler::Main.compileScript(File)
            Pod pod = null;

            try
            {
                pod = Env.cur().compileScript(f).pod();
            }
            catch (Err.Val e)
            {
                System.Console.WriteLine("ERROR: cannot compile script");
                e.err().trace();
                return(-1);
            }
            catch (Exception e)
            {
                System.Console.WriteLine("ERROR: cannot compile script");
                System.Console.WriteLine(e);
                return(-1);
            }

            List   types = pod.types();
            Type   type  = null;
            Method main  = null;

            for (int i = 0; i < types.sz(); ++i)
            {
                type = (Type)types.get(i);
                main = type.method("main", false);
                if (main != null)
                {
                    break;
                }
            }

            if (main == null)
            {
                System.Console.WriteLine("ERROR: missing main method: " + ((Type)types.get(0)).name() + ".main()");
                return(-1);
            }

            return(callMain(type, main));
        }
Exemplo n.º 3
0
Arquivo: Fant.cs Projeto: nomit007/f4
        private int runTest(Type type, Method method)
        {
            Method setup    = type.method("setup", true);
              Method teardown = type.method("teardown", true);

              FanSysTest test = null;
              List args = null;
              try
              {
            test = (FanSysTest)type.make();
            args = new List(Sys.ObjType, new object[] {test});
              }
              catch (System.Exception e)
              {
            System.Console.WriteLine();
            System.Console.WriteLine("ERROR: Cannot make test " + type);
            if (e is Err.Val)
              ((Err.Val)e).err().trace();
            else
              Err.dumpStack(e);
            return -1;
              }

              try
              {
            test.m_curTestMethod = method;
            setup.callList(args);
            method.callList(args);
            return test.verifyCount;
              }
              catch (System.Exception e)
              {
            //System.Console.WriteLine(" -- " + e.GetType() + " -- ");
            System.Console.WriteLine();
            System.Console.WriteLine("TEST FAILED");
            if (e is Err.Val)
              ((Err.Val)e).err().trace();
            else
              Err.dumpStack(e);
            return -1;
              }
              finally
              {
            try
            {
              if (args != null) teardown.callList(args);
            }
            catch (System.Exception e)
            {
              Err.dumpStack(e);
            }
            test.m_curTestMethod = null;
              }
        }
Exemplo n.º 4
0
Arquivo: Fant.cs Projeto: nomit007/f4
        private Method[] methods(Type type, string methodName)
        {
            // named test
              if (methodName != "*") return new Method[] { type.method(methodName, true) };

              // all methods which start with "test"
              List all = type.methods();
              ArrayList acc = new ArrayList();
              for (int i=0; i<all.sz(); i++)
              {
            Method m = (Method)all.get(i);
            if (m.name().StartsWith("test") && !m.isAbstract()) acc.Add(m);
              }
              return (Method[])acc.ToArray(System.Type.GetType("Fan.Sys.Method"));
        }
Exemplo n.º 5
0
        /// <summary>
        /// simple := type "(" str ")"
        /// </summary>
        private object readSimple(int line, Type t)
        {
            // parse: type(str)
              consume(Token.LPAREN, "Expected ( in simple");
              string str = consumeStr("Expected string literal for simple");
              consume(Token.RPAREN, "Expected ) in simple");

              // lookup the fromStr method
              t.finish();
              Method m = t.method("fromStr", false);
              if (m == null)
            throw err("Missing method: " + t.qname() + ".fromStr", line);

              // invoke parse method to translate into instance
              try
              {
            return m.invoke(null, new object[] { str });
              }
              catch (ParseErr.Val e)
              {
            throw ParseErr.make(e.err().msg() + " [Line " + line + "]").val;
              }
              catch (System.Exception e)
              {
            throw ParseErr.make(e.ToString() + " [Line " + line + "]", e).val;
              }
        }
Exemplo n.º 6
0
        //////////////////////////////////////////////////////////////////////////
        // Complex
        //////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// complex := type [fields]
        /// fields  := "{" field (eos field)* "}"
        /// field   := name "=" obj
        /// </summary>
        private object readComplex(int line, Type t, bool root)
        {
            Map toSet = new Map(Sys.FieldType, Sys.ObjType.toNullable());
              List toAdd = new List(Sys.ObjType.toNullable());

              // read fields/collection into toSet/toAdd
              readComplexFields(t, toSet, toAdd);

              // get the make constructor
              Method makeCtor = t.method("make", false);
              if (makeCtor == null || !makeCtor.isPublic())
            throw err("Missing public constructor " + t.qname() + ".make", line);

              // get argument lists
              List args = null;
              if (root && options != null)
            args = (List)options.get("makeArgs");

              // construct object
              object obj = null;
              bool setAfterCtor = true;
              try
              {
            // if first parameter is an function then pass toSet
            // as an it-block for setting the fields
            Param p = (Param)makeCtor.@params().first();
            if (args == null && p != null && p.type().fits(Sys.FuncType))
            {
              args = new List(Sys.ObjType).add(Field.makeSetFunc(toSet));
              setAfterCtor = false;
            }

            // invoke make to construct object
            obj = makeCtor.callList(args);
              }
              catch (System.Exception e)
              {
            throw err("Cannot make " + t + ": " + e, line, e);
              }

              // set fields (if not passed to ctor as it-block)
              if (setAfterCtor && toSet.size() > 0)
              {
            IDictionaryEnumerator en = toSet.pairsIterator();
            while (en.MoveNext())
            {
              complexSet(obj, (Field)en.Key, en.Value, line);
            }
              }

              // add
              if (toAdd.size() > 0)
              {
            Method addMethod = t.method("add", false);
            if (addMethod == null) throw err("Method not found: " + t.qname() + ".add", line);
            for (int i=0; i<toAdd.sz(); ++i)
              complexAdd(t, obj, addMethod, toAdd.get(i), line);
              }

              return obj;
        }
Exemplo n.º 7
0
        //////////////////////////////////////////////////////////////////////////
        // Collection (@collection)
        //////////////////////////////////////////////////////////////////////////
        private bool writeCollectionItems(Type type, object obj, bool first)
        {
            // lookup each method
              Method m = type.method("each", false);
              if (m == null) throw IOErr.make("Missing " + type.qname() + ".each").val;

              // call each(it)
              EachIterator it = new EachIterator(this, first);
              m.invoke(obj, new object[] { it });
              return it.first;
        }