import dan200.computercraft.api.lua.ILuaObject; //导入依赖的package包/类
public static Object toLua(Object obj) throws LuaException {
    if (obj == null || obj instanceof ILuaObject) {
        return obj;
    }

    for (ITypeConverter converter : CONVERTERS) {
        Object response = converter.toLua(obj);
        if (response != null) {
            return response;
        }
    }

    // a catch-all of a catch-all? sure :P
    throw new IllegalStateException("Conversion failed on " + obj);
}
 

import dan200.computercraft.api.lua.ILuaObject; //导入依赖的package包/类
public static void init() {
	final MethodSelector peripheralSelector = new MethodSelector(Constants.ARCH_COMPUTER_CRAFT)
			.allowReturnSignal()
			.addDefaultEnv()
			.addProvidedEnv(Constants.ARG_ACCESS, IArchitectureAccess.class)
			.addProvidedEnv(Constants.ARG_COMPUTER, IComputerAccess.class)
			.addProvidedEnv(Constants.ARG_CONTEXT, ILuaContext.class);

	PERIPHERAL_METHODS_FACTORY = new ComposedMethodsFactory<IndexedMethodMap>(AdapterRegistry.PERIPHERAL_ADAPTERS, peripheralSelector) {
		@Override
		protected IndexedMethodMap wrapMethods(Class<?> targetCls, Map<String, IMethodExecutor> methods) {
			return new IndexedMethodMap(methods);
		}
	};

	// can't push events, so not allowing return signals
	final MethodSelector objectSelector = new MethodSelector(Constants.ARCH_COMPUTER_CRAFT)
			.addDefaultEnv()
			.addProvidedEnv(Constants.ARG_CONTEXT, ILuaContext.class);

	OBJECT_METHODS_FACTORY = new ComposedMethodsFactory<IndexedMethodMap>(AdapterRegistry.OBJECT_ADAPTERS, objectSelector) {
		@Override
		protected IndexedMethodMap wrapMethods(Class<?> targetCls, Map<String, IMethodExecutor> methods) {
			return new IndexedMethodMap(methods);
		}
	};

	CommandDump.addArchSerializer("ComputerCraft", "peripheral", DocBuilder.TILE_ENTITY_DECORATOR, PERIPHERAL_METHODS_FACTORY);
	CommandDump.addArchSerializer("ComputerCraft", "object", DocBuilder.SCRIPT_OBJECT_DECORATOR, OBJECT_METHODS_FACTORY);

	final IConverter converter = new TypeConversionRegistryCC();
	// CC converter is default one (legacy behaviour)
	TypeConvertersProvider.INSTANCE.registerConverter(Constants.ARCH_COMPUTER_CRAFT, converter);

	TypeClassifier.INSTANCE.registerType(ILuaObject.class, SingleArgType.OBJECT);

	ENV = new ComputerCraftEnv(converter);
}
 

import dan200.computercraft.api.lua.ILuaObject; //导入依赖的package包/类
public static ILuaObject wrap(Object target) {
	Preconditions.checkNotNull(target, "Can't wrap null");

	try {
		IndexedMethodMap methods = ModuleComputerCraft.OBJECT_METHODS_FACTORY.getAdaptedClass(target.getClass());
		return methods.isEmpty()? null : new WrappedLuaObject(methods, target);
	} catch (Throwable t) {
		throw new GenerationFailedException(String.format("%s (%s)", target, target.getClass()), t);
	}
}
 

import dan200.computercraft.api.lua.ILuaObject; //导入依赖的package包/类
@Override
public ILuaObject wrapObject(Object target) {
	return LuaObjectWrapper.wrap(target);
}
 

import dan200.computercraft.api.lua.ILuaObject; //导入依赖的package包/类
public TypeConversionRegistryCC() {
	super(LUA_OFFSET);
	registerIgnored(ILuaObject.class, true);
	outbound.addFirst(new ConverterCallableCC());
}
 

import dan200.computercraft.api.lua.ILuaObject; //导入依赖的package包/类
/**
 * @throws GenerationFailedException
 */
public ILuaObject wrapObject(Object target);