static public Handle Add (uint t, GLib.TimeoutHandler timeout_handler)
		{
			Closure c;
			c = new Closure (timeout_handler);
			c.Id = GLib.Timeout.Add (t, new GLib.TimeoutHandler (c.Handler));
			return c;
		}

 /**
  * Constructor that performs no validation.
  * Use <code>getInstance</code> if you want that.
  *
  * @param predicate  predicate to switch on, not null
  * @param trueClosure  closure used if true, not null
  * @param falseClosure  closure used if false, not null
  */
 public IfClosure(Predicate predicate, Closure trueClosure, Closure falseClosure)
     : base()
 {
     iPredicate = predicate;
     iTrueClosure = trueClosure;
     iFalseClosure = falseClosure;
 }

 /**
  * Constructor that performs no validation.
  * Use <code>getInstance</code> if you want that.
  *
  * @param predicates  array of predicates, not cloned, no nulls
  * @param closures  matching array of closures, not cloned, no nulls
  * @param defaultClosure  the closure to use if no match, null means nop
  */
 public SwitchClosure(Predicate[] predicates, Closure[] closures, Closure defaultClosure)
     : base()
 {
     iPredicates = predicates;
     iClosures = closures;
     iDefault = (defaultClosure == null ? NOPClosure.INSTANCE : defaultClosure);
 }

 // we have a gc, so nothing to do
 public static void LuaFFreeClosure(LuaState L, Closure c)
 {
     int size = (c.c.isC != 0) ? SizeCclosure(c.c.nupvalues) :
                             SizeLclosure(c.l.nupvalues);
     //luaM_freemem(L, c, size);
     SubtractTotalBytes(L, size);
 }

 /**
  * Constructor that performs no validation.
  * Use <code>getInstance</code> if you want that.
  *
  * @param predicate  the predicate used to evaluate when the loop terminates, not null
  * @param closure  the closure the execute, not null
  * @param doLoop  true to act as a do-while loop, always executing the closure once
  */
 public WhileClosure(Predicate predicate, Closure closure, bool doLoop)
     : base()
 {
     iPredicate = predicate;
     iClosure = closure;
     iDoLoop = doLoop;
 }

 public StronglyTypedAstBuilder(Closure externalClosure)
 {
     foreach (var pair in externalClosure)
     {
         _closure.Add(pair.Key, pair.Value);
     }
 }

 public void Generate()
 {
     indensionStack.Clear();
     indensionStack.Push(-1);
     if (app == null) app = new Application();
     thisPresentation = app.Presentations.Add(MsoTriState.msoFalse);
     var cl = new DocumentClosure(null, thisPresentation, app);
     CurrentClosure = cl;
     ChangeTheme();
     cl.Initialize();
     cl.WorkPath = DefaultWorkPath;
     var module = thisPresentation.VBProject.VBComponents.Add(vbext_ComponentType.vbext_ct_StdModule);
     module.CodeModule.AddFromString(Resources.VBAModule);
     while (true)
     {
         var thisLine = ScriptReader.ReadLine();
         if (thisLine == null) break;
         Console.WriteLine(thisLine);
         if (!string.IsNullOrWhiteSpace(thisLine) && thisLine.TrimStart()[0] != '#')
             ParseLine(thisLine);
     }
     while (CurrentClosure != null) ExitClosure();
     app.Run("PAG_PostProcess", thisPresentation);
     var wnd = thisPresentation.NewWindow();
     thisPresentation.VBProject.VBComponents.Remove(module);
     wnd.Activate();
     //thisPresentation.Close();
 }

 // we have a gc, so nothing to do
 public static void luaF_freeclosure(lua_State L, Closure c)
 {
     int size = (c.c.isC != 0) ? sizeCclosure(c.c.nupvalues) :
                           sizeLclosure(c.l.nupvalues);
       //luaM_freemem(L, c, size);
       SubtractTotalBytes(L, size);
 }

        public void ShouldBeAbleToNestClosures()
        {
            MathOperation add = delegate(int a, int b) { return a + b; };
            Closure doMath = new Closure(add, new Closure(add, new Closure(add, 1, 1), 1), 1);

            int result = (int) doMath.Invoke();
            Assert.IsTrue(result == 4);
        }

 protected IEnumerator CallLuaClosure(LuaEnvironment luaEnv, Closure callback)
 {
     yield return new WaitForEndOfFrame();
     if (callback != null)
     {
         luaEnv.RunLuaFunction(callback, true);
     }
 }

 /**
  * Factory method that performs validation.
  *
  * @param closure  the closure to call, not null
  * @return the <code>closure</code> transformer
  * @throws IllegalArgumentException if the closure is null
  */
 public static Transformer getInstance(Closure closure)
 {
     if (closure == null)
     {
         throw new java.lang.IllegalArgumentException("Closure must not be null");
     }
     return new ClosureTransformer(closure);
 }

 /**
  * Clone the closures to ensure that the internal reference can't be messed with.
  *
  * @param closures  the closures to copy
  * @return the cloned closures
  */
 internal static Closure[] copy(Closure[] closures)
 {
     if (closures == null)
     {
         return null;
     }
     return (Closure[])closures.clone();
 }

 /**
  * Factory method that performs validation and copies the parameter array.
  *
  * @param closures  the closures to chain, copied, no nulls
  * @return the <code>chained</code> closure
  * @throws IllegalArgumentException if the closures array is null
  * @throws IllegalArgumentException if any closure in the array is null
  */
 public static Closure getInstance(Closure[] closures)
 {
     FunctorUtils.validate(closures);
     if (closures.Length == 0)
     {
         return NOPClosure.INSTANCE;
     }
     closures = FunctorUtils.copy(closures);
     return new ChainedClosure(closures);
 }

		public DynValue Coroutine_Create(Closure closure)
		{
			// create a processor instance
			Processor P = new Processor(this);

			// Put the closure as first value on the stack, for future reference
			P.m_ValueStack.Push(DynValue.NewClosure(closure));

			// Return the coroutine handle
			return DynValue.NewCoroutine(new Coroutine(P));
		}

        public void CurriedClosureShouldBeAbleToBindToAStronglyTypedDelegate()
        {
            MathOperation add = delegate(int a, int b) { return a + b; };
            Closure doMath = new Closure(add, Args.Lambda, 1);
            SingleOperatorMathOperation mathOp = doMath.AdaptTo<SingleOperatorMathOperation>();

            // return 5 + 1
            int result = mathOp(5);
            // The result should be 6
            Assert.AreEqual(6, result);
        }

 /**
  * Factory method that performs validation.
  *
  * @param predicate  the predicate used to evaluate when the loop terminates, not null
  * @param closure  the closure the execute, not null
  * @param doLoop  true to act as a do-while loop, always executing the closure once
  * @return the <code>while</code> closure
  * @throws IllegalArgumentException if the predicate or closure is null
  */
 public static Closure getInstance(Predicate predicate, Closure closure, bool doLoop)
 {
     if (predicate == null)
     {
         throw new java.lang.IllegalArgumentException("Predicate must not be null");
     }
     if (closure == null)
     {
         throw new java.lang.IllegalArgumentException("Closure must not be null");
     }
     return new WhileClosure(predicate, closure, doLoop);
 }

 /**
  * Factory method that performs validation.
  * <p>
  * A null closure or zero count returns the <code>NOPClosure</code>.
  * A count of one returns the specified closure.
  *
  * @param count  the number of times to execute the closure
  * @param closure  the closure to execute, not null
  * @return the <code>for</code> closure
  */
 public static Closure getInstance(int count, Closure closure)
 {
     if (count <= 0 || closure == null)
     {
         return NOPClosure.INSTANCE;
     }
     if (count == 1)
     {
         return closure;
     }
     return new ForClosure(count, closure);
 }

        public MethodResolution(MethodInfo methodInfo, Closure closure, InvokeExpression callAst)
        {
            MethodInfo = methodInfo;
            Closure = closure;
            CallAst = callAst;
            Result = null;

            PassesComplete = null;
            Target = new StronglyTypedAstBuilder(closure).Visit(callAst.Target);
            FormalArgs = new List<Type>(MethodInfo.GetParameters().Select(p => p.ParameterType));
            RealArgs = new List<Expression>(callAst.Args.Select(ast => ast is LambdaExpression ?
                new StronglyTypedAstBuilder(closure).VisitLambda((LambdaExpression)ast, null, true) :
                new StronglyTypedAstBuilder(closure).Visit(ast)));
            InferenceCache = new Dictionary<Type, Type>();
            Array.ForEach(MethodInfo.GetGenericArguments(), t => InferenceCache.Add(t, null));
        }

        /// <summary>
        /// Extension for MenuDialog that allows AddOption to call a Lua function when an option is selected.
        /// </summary>
        public static bool AddOption(this MenuDialog menuDialog, string text, bool interactable, LuaEnvironment luaEnvironment, Closure callBack)
        {
            if (!menuDialog.gameObject.activeSelf)
            {
                menuDialog.gameObject.SetActive(true);
            }

            bool addedOption = false;
            foreach (Button button in menuDialog.cachedButtons)
            {
                if (!button.gameObject.activeSelf)
                {
                    button.gameObject.SetActive(true);

                    button.interactable = interactable;

                    Text textComponent = button.GetComponentInChildren<Text>();
                    if (textComponent != null)
                    {
                        textComponent.text = text;
                    }

                    button.onClick.AddListener(delegate {

                        menuDialog.StopAllCoroutines(); // Stop timeout
                        menuDialog.Clear();
                        menuDialog.HideSayDialog();

                        if (callBack != null)
                        {
                            luaEnvironment.RunLuaFunction(callBack, true);
                        }
                    });

                    addedOption = true;
                    break;
                }
            }

            return addedOption;
        }

        public void ShouldBeAbleToCurryArguments()
        {
            object source = new object();
            EventArgs args = new EventArgs();

            ITestCounter counter = mock.NewMock<ITestCounter>();
            Expect.Once.On(counter).Method("Increment").WithAnyArguments();

            EventHandler dummyHandler = delegate(object eventSource, EventArgs e)
                                            {
                                                // The arguments passed to the
                                                // delegate should match the ones
                                                // given
                                                Assert.AreSame(eventSource, source);
                                                Assert.AreSame(e, args);
                                                counter.Increment();
                                            };

            Closure closure = new Closure(dummyHandler, source);
            Assert.IsTrue(closure.Arguments.Contains(source));
            closure.Invoke(args);
        }