Exemple #1
0
        //////////////////////////////////////////////////////////////////////////
        // Bind
        //////////////////////////////////////////////////////////////////////////
        public Func bind(List args)
        {
            if (args.sz() == 0) return this;
              if (args.sz() > @params().sz()) throw ArgErr.make("args.size > params.size").val;

              Type[] newParams = new Type[@params().sz()-args.sz()];
              for (int i=0; i<newParams.Length; ++i)
            newParams[i] = ((Param)@params().get(args.sz()+i)).m_type;

              FuncType newType = new FuncType(newParams, this.returns());
              return new BindFunc(newType, this, args);
        }
Exemple #2
0
        //////////////////////////////////////////////////////////////////////////
        // List
        //////////////////////////////////////////////////////////////////////////

        public void writeList(List list)
        {
            // get of type
            Type of = list.of();

            // decide if we're going output as single or multi-line format
            bool nl = isMultiLine(of);

            // figure out if we can use an inferred type
            bool inferred = false;

            if (curFieldType != null && curFieldType.fits(Sys.ListType))
            {
                inferred = true;
            }

            // clear field type, so it doesn't get used for inference again
            curFieldType = null;

            // if we don't have an inferred type, then prefix of type
            if (!inferred)
            {
                wType(of);
            }

            // handle empty list
            int size = list.sz();

            if (size == 0)
            {
                w("[,]"); return;
            }

            // items
            if (nl)
            {
                w('\n').wIndent();
            }
            w('[');
            level++;
            for (int i = 0; i < size; ++i)
            {
                if (i > 0)
                {
                    w(',');
                }
                if (nl)
                {
                    w('\n').wIndent();
                }
                writeObj(list.get(i));
            }
            level--;
            if (nl)
            {
                w('\n').wIndent();
            }
            w(']');
        }
Exemple #3
0
        public void test(string pattern, bool verbose)
        {
            if (pattern == "*")
            {
                List pods = Pod.list();
                for (int i = 0; i < pods.sz(); i++)
                {
                    Pod p = (Pod)pods.get(i);
                    test(p.name(), verbose);
                }
                return;
            }

            if (pattern == "sys" || pattern.StartsWith("sys::"))
            {
                writeLine("");
                //if (pattern == "sys")
                //  pattern = "";
                //else
                //  pattern = pattern.Substring(5);
                if (!Fanx.Test.Test.RunTests(null))
                {
                    failures++;
                }
                totalVerifyCount += Fanx.Test.Test.totalVerified;
                return;
            }

            string[] s          = pattern.Split(new char[] { ':', '.' });
            string   podName    = s[0];
            string   testName   = (s.Length > 2) ? s[2] : "*";
            string   methodName = (s.Length > 3) ? s[3] : "*";

            writeLine("");

            Pod pod = Pod.doFind(podName, true, null);

            Type[] t = tests(pod, testName);
            for (int i = 0; i < t.Length; i++)
            {
                Method[] m = methods(t[i], methodName);
                for (int j = 0; j < m.Length; j++)
                {
                    writeLine("-- Run:  " + m[j] + "...");
                    int verifyCount = runTest(t[i], m[j]);
                    if (verifyCount < 0)
                    {
                        failures++; failedMethods.Add(m[j]); continue;
                    }
                    writeLine("   Pass: "******" [" + verifyCount + "]");
                    methodCount++;
                    totalVerifyCount += verifyCount;
                }
                testCount++;
            }
        }
Exemple #4
0
        /// <summary>
        /// Emit a mixin router from a class to the mixin body methods.
        /// </summary>
        public void emitMixinRouter(Method m)
        {
            string parent = FanUtil.toDotnetTypeName(m.parent());
            string name   = FanUtil.toDotnetMethodName(m.name());
            string ret    = FanUtil.toDotnetTypeName(m.inheritedReturns());

            string[] parTypes   = new string[] { parent };
            List     pars       = m.@params();
            int      paramCount = pars.sz();

            // find first param with default value
            int firstDefault = paramCount;

            for (int i = 0; i < paramCount; i++)
            {
                if (((Param)pars.get(i)).hasDefault())
                {
                    firstDefault = i; break;
                }
            }

            // generate routers
            for (int i = firstDefault; i <= paramCount; i++)
            {
                string[] myParams     = new string[i];
                string[] myParamNames = new string[i];
                string[] implParams   = new string[i + 1];
                implParams[0] = parent;

                for (int j = 0; j < i; j++)
                {
                    Param  param = (Param)m.@params().get(j);
                    Type   pt    = param.type();
                    string s     = FanUtil.toDotnetTypeName(pt);
                    myParams[j]       = s;
                    myParamNames[j]   = param.name();
                    implParams[j + 1] = s;
                }

                // CLR requires public virtual
                PERWAPI.MethAttr attr = PERWAPI.MethAttr.Public | PERWAPI.MethAttr.Virtual;

                PERWAPI.CILInstructions code = emitter.emitMethod(name, ret, myParamNames, myParams,
                                                                  attr, new string[0], new string[0]);
                code.Inst(PERWAPI.Op.ldarg_0); // push this
                for (int p = 0; p < i; p++)
                {
                    // push args
                    Param param = (Param)m.@params().get(p);
                    FCodeEmit.loadVar(code, FanUtil.toDotnetStackType(param.type()), p + 1);
                }
                PERWAPI.Method meth = emitter.findMethod(parent + "_", name, implParams, ret);
                code.MethInst(PERWAPI.MethodOp.call, meth);
                code.Inst(PERWAPI.Op.ret);
            }
        }
Exemple #5
0
 public virtual void walk(Func c)
 {
     c.call(this);
     if (isDir())
     {
         List x = list();
         for (int i = 0; i < x.sz(); ++i)
         {
             ((File)x.get(i)).walk(c);
         }
     }
 }
Exemple #6
0
        //////////////////////////////////////////////////////////////////////////
        // Bind
        //////////////////////////////////////////////////////////////////////////

        public Func bind(List args)
        {
            if (args.sz() == 0)
            {
                return(this);
            }
            if (args.sz() > @params().sz())
            {
                throw ArgErr.make("args.size > params.size").val;
            }

            Type[] newParams = new Type[@params().sz() - args.sz()];
            for (int i = 0; i < newParams.Length; ++i)
            {
                newParams[i] = ((Param)@params().get(args.sz() + i)).m_type;
            }

            FuncType newType = new FuncType(newParams, this.returns());

            return(new BindFunc(newType, this, args));
        }
Exemple #7
0
        static int callMain(Type t, Method m)
        {
            // check parameter type and build main arguments
            List args;
            List pars = m.@params();

            if (pars.sz() == 0)
            {
                args = null;
            }
            else if (((Param)pars.get(0)).type().@is(Sys.StrType.toListOf()) &&
                     (pars.sz() == 1 || ((Param)pars.get(1)).hasDefault()))
            {
                args = new List(Sys.ObjType, new object[] { Env.cur().args() });
            }
            else
            {
                System.Console.WriteLine("ERROR: Invalid parameters for main: " + m.signature());
                return(-1);
            }

            // invoke
            try
            {
                if (m.isStatic())
                {
                    return(toResult(m.callList(args)));
                }
                else
                {
                    return(toResult(m.callOn(t.make(), args)));
                }
            }
            catch (Err.Val ex)
            {
                ex.err().trace();
                return(-1);
            }
        }
Exemple #8
0
        public virtual List listFiles(Regex pattern)
        {
            List x = list(pattern);

            for (int i = x.sz() - 1; i >= 0; --i)
            {
                if (((File)x.get(i)).isDir())
                {
                    x.removeAt(i);
                }
            }
            return(x);
        }
Exemple #9
0
        //////////////////////////////////////////////////////////////////////////
        // Public
        //////////////////////////////////////////////////////////////////////////

        public Type compile(File file, Map options)
        {
            // normalize the file path as our cache key
            file = file.normalize();

            // unless force=true, check the cache
            if (!getOption(options, m_strForce, false))
            {
                CachedScript c = getCache(file);

                // if cached, try to lookup type (it might have been GCed)
                if (c != null)
                {
                    Type t1 = Type.find(c.typeName, false);
                    if (t1 != null)
                    {
                        return(t1);
                    }
                }
            }

            // generate a unique pod name
            string podName = generatePodName(file);

            // compile the script
            Pod pod = compile(podName, file, options);

            // get the primary type
            List types = pod.types();
            Type t     = null;

            for (int i = 0; i < types.sz(); ++i)
            {
                t = (Type)types.get(i);
                if (t.isPublic())
                {
                    break;
                }
            }
            if (t == null)
            {
                throw Err.make("Script file defines no public classes: " + file).val;
            }

            // put it into the cache
            putCache(file, t);

            return(t);
        }
Exemple #10
0
        //////////////////////////////////////////////////////////////////////////
        // Load
        //////////////////////////////////////////////////////////////////////////

        private void load()
        {
            Log log = Log.get("podindex");

            // load all the props
            List      podNames = m_env.findAllPodNames();
            Hashtable mutable  = new Hashtable(podNames.sz() * 11);

            for (int i = 0; i < podNames.sz(); ++i)
            {
                string n = (string)podNames.get(i);
                try
                {
                    FileSystemInfo f = ((LocalFile)m_env.findPodFile(n)).toDotnet();
                    loadPod(mutable, n, f);
                }
                catch (System.Exception e)
                {
                    log.err("Cannot load " + n, e);
                }
            }

            // now make all the lists immutable
            List                  keys      = new List(Sys.StrType);
            Hashtable             immutable = new Hashtable(mutable.Count * 3);
            IDictionaryEnumerator en        = mutable.GetEnumerator();

            while (en.MoveNext())
            {
                immutable[en.Key] = ((List)en.Value).toImmutable();
                keys.add(en.Key);
            }

            this.m_index = immutable;
            this.m_keys  = (List)keys.sort().toImmutable();
        }
Exemple #11
0
        static Map read(Map defProps, Key key, List files)
        {
            if (files.isEmpty())
            {
                return(defProps);
            }
            Map acc = defProps.dup();

            for (int i = files.sz() - 1; i >= 0; --i)
            {
                InStream input = ((File)files.get(i)).@in();
                try { acc.setAll(input.readProps()); }
                finally { input.close(); }
            }
            return((Map)acc.toImmutable());
        }
Exemple #12
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));
        }
Exemple #13
0
        private void emitMixinRouters(Type type)
        {
            // generate router method for each concrete instance method
            List methods = type.methods();

            for (int i = 0; i < methods.sz(); i++)
            {
                Method m    = (Method)methods.get(i);
                string name = m.name();

                // only emit router for non-abstract instance methods
                if (m.isStatic())
                {
                    continue;
                }
                if (m.isAbstract())
                {
                    // however if abstract, check if a base class
                    // has already implemented this method
                    if (m.parent() == type && parent.slot(name, true).parent() == type)
                    {
                        Type b = parent.@base();
                        while (b != null)
                        {
                            Slot s = b.slot(name, false);
                            if (s != null && s.parent() == b)
                            {
                                new FMethodEmit(this).emitInterfaceRouter(b, m);
                                break;
                            }
                            b = b.@base();
                        }
                    }
                    continue;
                }

                // only emit the router unless this is the exact one I inherit
                if (parent.slot(name, true).parent() != type)
                {
                    continue;
                }

                // do it
                new FMethodEmit(this).emitMixinRouter(m);
            }
        }
Exemple #14
0
        static void pods(String progName)
        {
            version(progName);

            long t1   = Duration.nowTicks();
            List pods = Pod.list();
            long t2   = Duration.nowTicks();

            writeLine("");
            writeLine("Fantom Pods [" + (t2 - t1) / 1000000L + "ms]:");

            writeLine("  Pod                 Version");
            writeLine("  ---                 -------");
            for (int i = 0; i < pods.sz(); ++i)
            {
                Pod pod = (Pod)pods.get(i);
                writeLine("  " +
                          FanStr.justl(pod.name(), 18L) + "  " +
                          FanStr.justl(pod.version().toStr(), 8));
            }
        }
Exemple #15
0
        internal void attachTo(Control control)
        {
            // sync with native control
            this.m_control = control;
            if (m_pos != Fan.Fwt.Point.m_def)
            {
                pos(m_self, m_pos);
            }
            if (m_size != Fan.Fwt.Size.m_def)
            {
                size(m_self, m_size);
            }
            sync(null);

            // recursively attach my children
            List kids = m_self.m_kids;

            for (int i = 0; i < kids.sz(); ++i)
            {
                Widget kid = (Widget)kids.get(i);
                kid.m_peer.attach(kid);
            }
        }
Exemple #16
0
        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")));
        }
Exemple #17
0
        private Type[] tests(Pod pod, string testName)
        {
            // named test
            if (testName != "*")
            {
                return new Type[] { pod.type(testName, true) }
            }
            ;

            // all types which subclass Test
            List      all = pod.types();
            ArrayList acc = new ArrayList();

            for (int i = 0; i < all.sz(); i++)
            {
                Type x = (Type)all.get(i);
                if (x.@is(Sys.TestType) && !x.isAbstract())
                {
                    acc.Add(x);
                }
            }
            return((Type[])acc.ToArray(System.Type.GetType("Fan.Sys.Type")));
        }
Exemple #18
0
            public override object callList(List args)
            {
                int    origReq  = m_orig.@params().sz();
                int    haveSize = m_bound.sz() + args.sz();
                Method m        = m_orig.method();

                if (m != null)
                {
                    origReq = m.minParams();
                    if (haveSize > origReq)
                    {
                        origReq = haveSize;
                    }
                }
                if (origReq <= m_bound.sz())
                {
                    return(m_orig.callList(m_bound));
                }

                object[] temp = new object[haveSize];
                m_bound.copyInto(temp, 0, m_bound.sz());
                args.copyInto(temp, m_bound.sz(), temp.Length - m_bound.sz());
                return(m_orig.callList(new List(Sys.ObjType, temp)));
            }
Exemple #19
0
        //////////////////////////////////////////////////////////////////////////
        // Complex
        //////////////////////////////////////////////////////////////////////////

        private void writeComplex(Type type, object obj, Serializable ser)
        {
            wType(type);

            bool   first  = true;
            object defObj = null;

            if (skipDefaults)
            {
                defObj = FanObj.@typeof(obj).make();
            }

            List fields = type.fields();

            for (int i = 0; i < fields.sz(); ++i)
            {
                Field f = (Field)fields.get(i);

                // skip static, transient, and synthetic (once) fields
                if (f.isStatic() || f.isSynthetic() || f.hasFacet(Sys.TransientType))
                {
                    continue;
                }

                // get the value
                object val = f.get(obj);

                // if skipping defaults
                if (defObj != null)
                {
                    object defVal = f.get(defObj);
                    if (OpUtil.compareEQ(val, defVal))
                    {
                        continue;
                    }
                }

                // if first then open braces
                if (first)
                {
                    w('\n').wIndent().w('{').w('\n'); level++; first = false;
                }

                // field name =
                wIndent().w(f.name()).w('=');

                // field value
                curFieldType = f.type().toNonNullable();
                writeObj(val);
                curFieldType = null;

                w('\n');
            }

            // if collection
            if (ser.m_collection)
            {
                first = writeCollectionItems(type, obj, first);
            }

            // if we output fields, then close braces
            if (!first)
            {
                level--; wIndent().w('}');
            }
        }
Exemple #20
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);
        }
Exemple #21
0
            public override object callList(List args)
            {
                int origReq  = m_orig.@params().sz();
                int haveSize = m_bound.sz() + args.sz();
                Method m = m_orig.method();
                if (m != null)
                {
                  origReq = m.minParams();
                  if (haveSize > origReq) origReq = haveSize;
                }
                if (origReq <= m_bound.sz()) return m_orig.callList(m_bound);

                object[] temp = new object[haveSize];
                m_bound.copyInto(temp, 0, m_bound.sz());
                args.copyInto(temp, m_bound.sz(), temp.Length-m_bound.sz());
                return m_orig.callList(new List(Sys.ObjType, temp));
            }
Exemple #22
0
        private void doCopyTo(File to, object exclude, object overwrite)
        {
            // check exclude
            if (exclude is Regex)
            {
                if (((Regex)exclude).matches(m_uri.toStr()))
                {
                    return;
                }
            }
            else if (exclude is Func)
            {
                if (((Func)exclude).call(this) == Boolean.True)
                {
                    return;
                }
            }

            // check for overwrite
            if (to.exists())
            {
                if (overwrite is Boolean)
                {
                    if (overwrite == Boolean.False)
                    {
                        return;
                    }
                }
                else if (overwrite is Func)
                {
                    if (((Func)overwrite).call(this) == Boolean.False)
                    {
                        return;
                    }
                }
                else
                {
                    throw IOErr.make("No overwrite policy for `" + to + "`").val;
                }
            }

            // copy directory
            if (isDir())
            {
                to.create();
                List kids = list();
                for (int i = 0; i < kids.sz(); ++i)
                {
                    File kid = (File)kids.get(i);
                    kid.doCopyTo(to.plusNameOf(kid), exclude, overwrite);
                }
            }

            // copy file contents
            else
            {
                OutStream @out = to.@out();
                try
                {
                    @in().pipe(@out);
                }
                finally
                {
                    @out.close();
                }
            }
        }