public static LuaNativeFunction LuaAtPanic(LuaState L, LuaNativeFunction panicf)
 {
     LuaNativeFunction old;
     LuaLock(L);
     old = G(L).panic;
     G(L).panic = panicf;
     LuaUnlock(L);
     return old;
 }

        /// <summary>
        /// Registers the given function to the current table on the stack top.
        /// </summary>
        /// <param name="state"></param>
        /// <param name="name"></param>
        /// <param name="func"></param>
        public static void RegisterTableFunction(this NLua.Lua state, string name, LuaNativeFunction func)
        {
            // Do not continue if we are not a table..
            var isTable = NLua.LuaLib.LuaType(state.GetState(), -1) == LuaTypes.Table;
            if (!isTable)
                return;

            // Push the name, function, and set the table..
            NLua.LuaLib.LuaPushString(state.GetState(), name);
            NLua.LuaLib.LuaPushStdCallCFunction(state.GetState(), func);
            NLua.LuaLib.LuaRawSet(state.GetState(), -3);
        }

		public MetaFunctions (ObjectTranslator translator)
		{
			this.translator = translator;
			gcFunction = new LuaNativeFunction (MetaFunctions.CollectObject);
			toStringFunction = new LuaNativeFunction (MetaFunctions.ToStringLua);
			indexFunction = new LuaNativeFunction (MetaFunctions.GetMethod);
			newindexFunction = new LuaNativeFunction (MetaFunctions.SetFieldOrProperty);
			baseIndexFunction = new LuaNativeFunction (MetaFunctions.GetBaseMethod);
			callConstructorFunction = new LuaNativeFunction (MetaFunctions.CallConstructor);
			classIndexFunction = new LuaNativeFunction (MetaFunctions.GetClassMethod);
			classNewindexFunction = new LuaNativeFunction (MetaFunctions.SetClassFieldOrProperty);
			execDelegateFunction = new LuaNativeFunction (MetaFunctions.RunFunctionDelegate);
		}

		/*
		 * Constructs the wrapper for a known MethodBase instance
		 */
		public LuaMethodWrapper (ObjectTranslator translator, object target, ProxyType targetType, MethodBase method)
		{
			invokeFunction = new LuaNativeFunction (this.Call);
			_Translator = translator;
			_Target = target;

			if (targetType != null)
				_ExtractTarget = translator.typeChecker.GetExtractor (targetType);

			_Method = method;
			_MethodName = method.Name;
			_IsStatic = method.IsStatic;
		}

        /// <summary>
        /// Constructs the wrapper for a known method name
        /// </summary>
        /// <param name="translator"></param>
        /// <param name="targetType"></param>
        /// <param name="methodName"></param>
        /// <param name="bindingType"></param>
        public LuaMethodWrapper(ObjectTranslator translator, IReflect targetType, string methodName, BindingFlags bindingType)
        {
            invokeFunction = new LuaNativeFunction(this.Call);

            _Translator = translator;
            _MethodName = methodName;

            if (targetType != null)
                _ExtractTarget = translator.typeChecker.GetExtractor(targetType);

            _BindingType = bindingType;
            //CP: Removed NonPublic binding search and added IgnoreCase
            _Members = targetType.UnderlyingSystemType.GetMember(methodName, MemberTypes.Method, bindingType | BindingFlags.Public | BindingFlags.IgnoreCase/*|BindingFlags.NonPublic*/);
        }

		/*
		 * Constructs the wrapper for a known MethodBase instance
		 */
		public LuaMethodWrapper (ObjectTranslator translator, object target, IReflect targetType, MethodBase method)
		{
			invokeFunction = new LuaNativeFunction (this.Call);
			_Translator = translator;
			_Target = target;

			if (targetType != null)
				_ExtractTarget = translator.typeChecker.GetExtractor (targetType);

			_Method = method;
			_MethodName = method.Name;

			if (method.IsStatic)
				_BindingType = BindingFlags.Static;
			else
				_BindingType = BindingFlags.Instance;
		}

        public ObjectTranslator(Lua interpreter, LuaState luaState)
        {
            this.interpreter = interpreter;
            typeChecker = new CheckType(this);
            metaFunctions = new MetaFunctions(this);
            assemblies = new List<Assembly>();

            importTypeFunction = new LuaNativeFunction(ObjectTranslator.ImportType);
            loadAssemblyFunction = new LuaNativeFunction(ObjectTranslator.LoadAssembly);
            registerTableFunction = new LuaNativeFunction(ObjectTranslator.RegisterTable);
            unregisterTableFunction = new LuaNativeFunction(ObjectTranslator.UnregisterTable);
            getMethodSigFunction = new LuaNativeFunction(ObjectTranslator.GetMethodSignature);
            getConstructorSigFunction = new LuaNativeFunction(ObjectTranslator.GetConstructorSignature);
            ctypeFunction = new LuaNativeFunction(ObjectTranslator.CType);
            enumFromIntFunction = new LuaNativeFunction(ObjectTranslator.EnumFromInt);

            CreateLuaObjectList(luaState);
            CreateIndexingMetaFunction(luaState);
            CreateBaseClassMetatable(luaState);
            CreateClassMetatable(luaState);
            CreateFunctionMetatable(luaState);
            SetGlobalFunctions(luaState);
        }

 private static void NewFEnv(LuaState L, LuaNativeFunction cls)
 {
     LuaCreateTable(L, 0, 1);
     LuaPushCFunction(L, cls);
     LuaSetField(L, -2, "__close");
 }

 public static void LuaPushCFunction(LuaState L, LuaNativeFunction f)
 {
     LuaPushCClosure(L, f, 0);
 }

 public static void LuaRegister(LuaState L, CharPtr n, LuaNativeFunction f)
 {
     LuaPushCFunction(L, f);
     LuaSetGlobal(L, n);
 }

		  public LuaLReg(CharPtr name, LuaNativeFunction func) {
			  this.name = name;
			  this.func = func;
		  }

		public MetaFunctions (ObjectTranslator translator)
		{
			this.translator = translator;
			GcFunction = new LuaNativeFunction (MetaFunctions.CollectObject);
			ToStringFunction = new LuaNativeFunction (MetaFunctions.ToStringLua);
			IndexFunction = new LuaNativeFunction (MetaFunctions.GetMethod);
			NewIndexFunction = new LuaNativeFunction (MetaFunctions.SetFieldOrProperty);
			BaseIndexFunction = new LuaNativeFunction (MetaFunctions.GetBaseMethod);
			CallConstructorFunction = new LuaNativeFunction (MetaFunctions.CallConstructor);
			ClassIndexFunction = new LuaNativeFunction (MetaFunctions.GetClassMethod);
			ClassNewindexFunction = new LuaNativeFunction (MetaFunctions.SetClassFieldOrProperty);
			ExecuteDelegateFunction = new LuaNativeFunction (MetaFunctions.RunFunctionDelegate);
			AddFunction = new LuaNativeFunction (MetaFunctions.AddLua);
			SubtractFunction = new LuaNativeFunction (MetaFunctions.SubtractLua);
			MultiplyFunction = new LuaNativeFunction (MetaFunctions.MultiplyLua);
			DivisionFunction = new LuaNativeFunction (MetaFunctions.DivideLua);
			ModulosFunction = new LuaNativeFunction (MetaFunctions.ModLua);
			UnaryNegationFunction = new LuaNativeFunction (MetaFunctions.UnaryNegationLua);
			EqualFunction = new LuaNativeFunction (MetaFunctions.EqualLua);
			LessThanFunction = new LuaNativeFunction (MetaFunctions.LessThanLua);
			LessThanOrEqualFunction = new LuaNativeFunction (MetaFunctions.LessThanOrEqualLua);
		}

		public Lua ()
		{
			luaState = LuaLib.LuaLNewState ();	// steffenj: Lua 5.1.1 API change (lua_open is gone)
			LuaLib.LuaLOpenLibs (luaState);		// steffenj: Lua 5.1.1 API change (luaopen_base is gone, just open all libs right here)
			Init ();
			// We need to keep this in a managed reference so the delegate doesn't get garbage collected
			panicCallback = new LuaNativeFunction (PanicCallback);
			LuaLib.LuaAtPanic (luaState, panicCallback);
		}

		public static void LuaAtPanic (IntPtr luaState, LuaNativeFunction panicf)
		{
			IntPtr fnpanic = Marshal.GetFunctionPointerForDelegate (panicf);
			NativeMethods.LuaAtPanic (luaState, fnpanic);
		}

		public Lua ()
		{
			luaState = LuaLib.LuaLNewState ();
			LuaLib.LuaLOpenLibs (luaState);
			Init ();
			// We need to keep this in a managed reference so the delegate doesn't get garbage collected
			panicCallback = new LuaNativeFunction (PanicCallback);
			LuaLib.LuaAtPanic (luaState, panicCallback);
		}

 public static void LuaPushCClosure(LuaState L, LuaNativeFunction fn, int n)
 {
     Closure cl;
     LuaLock(L);
     LuaCCheckGC(L);
     CheckNElements(L, n);
     cl = LuaFNewCclosure(L, n, GetCurrentEnv(L));
     cl.c.f = fn;
     L.top -= n;
     while (n-- != 0)
         SetObj2N(L, cl.c.upvalue[n], L.top + n);
     SetCLValue(L, L.top, cl);
     LuaAssert(IsWhite(obj2gco(cl)));
     IncrementTop(L);
     LuaUnlock(L);
 }

 public static int LuaCPCall(LuaState L, LuaNativeFunction func, object ud)
 {
     CCallS c = new CCallS();
     int status;
     LuaLock(L);
     c.func = func;
     c.ud = ud;
     status = LuaDPCall(L, FunctionCCall, c, SaveStack(L, L.top), 0);
     LuaUnlock(L);
     return status;
 }

		public static void LuaAtPanic (LuaState luaState, LuaNativeFunction panicf)
		{
			LuaCore.LuaAtPanic (luaState, (LuaNativeFunction)panicf);
		}

 public static void LuaPushStdCallCFunction(LuaState luaState, LuaNativeFunction function)
 {
     LuaPushCFunction (luaState, function);
 }

		internal void PushCSFunction (LuaNativeFunction function)
		{
			translator.PushFunction (luaState, function);
		}