xlang 语言提供完整的反射体系(语言级别, VM支持)

四大类:

• Class ,  类
• Field, 字段
• Method, 方法
• Object, 万物基类

1.Class 类:

class Class : public Object{
		public Object newInstance();
		public Object newInstance(Method ctor);
		public Object newInstance(Method ctor, Object [] args);
		public bool hasAnnotation();
		public Class getSuperClass();
		public Method[] getMethods();
		public Method[] getMethods(String name, int flags);
		public Field[] getFields();
		public static Class getClass();
		public JsonObject getAnnotations();
		public bool extendsOf(Object c);
};

class Method : public Object{
		public static int FLAG_STATIC;
		public static int FLAG_FINAL;
		public static int FLAG_CONSTRUCTOR;

		public static int FLAG_GLOBAL;
		public static int FLAG_OVERRIDE;
		public static int FLAG_ABSTRACT;
		public static int FLAG_ENUM;
		public static int FLAG_EXCEPTIONLIST;
		public static int FLAG_PUBLIC;
		public static int FLAG_PROTECTED;
		public static int FLAG_ANNOTATE;
		public static int FLAG_ALL;

		public long toNative();
		public Object invoke(Object own);
		public Object invoke(Object own, Object [] args);
		public bool hasAnnotation();
		public Object getType();
		public Object getParameterType(int n);
		public int getParameterFlags(int n);
		public int getParameterFlag(int n);
		public int getParameterCount();
		public String getName();
		public int getFlags();
		public int getThrowExceptionCount();
		public Object getThrowExceptionItem(int n);
};

class Field : public Object{
		public static int FLAG_STATIC;
		public static int FLAG_CONST;
		public static int FLAG_NOTNILPTR;
		public static int FLAG_ALL;

		public long toNative();
		public Object getValue(Object own);
		public bool setValue(Object own, Object args);
		public bool hasAnnotation();
		public bool isStatic();
		public bool isConst();

		public Object getType();
		public String getName();
};

class Object {
	public void wait();
	public void wait(int ms);
	public String toString();
	public void notify();
	public void notifyAll();
	public bool isArrayObject();
	public bool instanceOf(Class c);
	public long hash();
	public long getPtr();
	public long getObjectPtr();
	public Class getComponentType();
	public Class getClass();
	public static Object fromHash();
};

代码示例:

class TestClass{
    String text;
    static int a;
    char c;
    TestClass(){}
    @Annotate(Name="user")
    public int add(){
        return 123;
    }
    static void Add(int n){return ;}
    TestClass(String s){text =s ;}
};



void testReflex(){
    /** 获取名为 TestClass 的类*/
    Class clazz = Class.getClass("TestClass");
    /** 从默认构造函数 构造一个实例, 注意, 如无默认构造函数, 则可能构造失败*/
    Object st = clazz.newInstance();
    /** 获取类的所有方法, 含静态*/
    Method [] mm = clazz.getMethods();
    /** 打印方法名*/
    System.out.print(mm[1].getName());
    
    /** 调用第一个方法, 参数为实例对象*/
    int i = (int)mm[1].invoke(st);
    
    /** 获取对象的注解*/
    JsonObject json = mm[1].getAnnotations();
    
    if (json != nilptr){
        /** 遍历注解*/
        JsonNode sub = json.child();
        while (sub != nilptr){
            System.out.print(sub.getName());
            if (sub.getType() == JsonNode.JSONTYPE_OBJECT){
                JsonObject jobj = (JsonObject)sub;
                System.out.print(jobj.getString("Name"));
                break;
            }
            sub = sub.next();
        }
    }
    
    /*** 从第一个造函数构造类实例*/
    st = clazz.newInstance((clazz.getMethods("TestClass", Method.FLAG_CONSTRUCTOR))[0]);
    
    /*** 给第0个字段赋值为字符串 hello */
    clazz.getFields()[0].setValue(st, "hello");
    
    /** 获取第0个字段的值**/
    String fv = (String)clazz.getFields()[0].getValue(st);
    
    /***打印值 */
    System.out.print("get is " + fv + "\n");
    
    /** 打印第二个方法的名称*/
    System.out.print(mm[2].getName());
    
    /** 从带参数的构造函数构造类实例*/
    st = clazz.newInstance(mm[2], "value seted");
    
    /*** 调用第二个方法, 静态方法*/
    mm[3].invoke(clazz, 2);
}

xnl / cxnl 接口中反射相关定义

#define REFLEX_FLAG_CONST	0x2
#define REFLEX_FLAG_STATIC	0x4
#define REFLEX_FLAG_NONNIL	0x8
#define REFLEX_FLAG_OVRRID	0x10
#define REFLEX_FLAG_ABSTRT	0x20
#define REFLEX_FLAG_ENUM	0x40
#define REFLEX_FLAG_CTOR	0x40
#define REFLEX_FLAG_EXCEPT	0x80
#define INVOKE_ONLY					0
#define INVOKE_CHECKARGS			1
#define INVOKE_PUSHARGS				2
#define INVOKE_SECURE				3


// 将异常设置为默认行为
#define EXCEPTION_DEFAULT	0

// 保留异常, 调用结束后恢复现场, 保留异常状态并由native进行处理
#define EXCEPTION_RESEVER	0x8

// 向上传递, 调用结束后不恢复现场, 向上传递至外层xlang代码中的 try catch 进行回复
#define EXCEPTION_UPWRAD	0x10

// 就地直接报告异常
#define EXCEPTION_REPORT	0x20
#define EXCEPTION_SKIP_MASK		(EXCEPTION_RESEVER | EXCEPTION_UPWRAD)
#define EXCEPTION_MASK		(EXCEPTION_RESEVER | EXCEPTION_UPWRAD | EXCEPTION_REPORT)

virtual XObject* getClass(const char* classname) = 0;
virtual XObject* getMethod(XContext* context, XObject* pclass, const char* methodname) = 0;
virtual XObject* getFields(XContext* context, XObject* object, const char* fieldname) = 0;
virtual int getMethodFlags(XObject*) = 0;
virtual int getFieldFlags(XObject* a) = 0;
virtual const char* getMethodName(XObject*, size_t* size) = 0;
virtual const char* getFieldName(XObject* o, size_t* size) = 0;
virtual const char* getClassName(XObject*, size_t* size) = 0;

virtual XObject* getReturnType(XContext* context, XObject*) = 0;
virtual int getParameterCount(XObject*) = 0;
virtual XObject* getParameterType(XContext* context, XObject*, int n) = 0;
virtual bool ref_checkParameterType(XContext* context, XObject* method, XObject* paramsPack) = 0;
virtual bool ref_pushParameter(XContext* context, XObject* method, XObject* paramsPack) = 0;
virtual bool ref_invoke(XContext* context, XObject* pthis, XObject* method, XObject* paramsPack, XObject* out, int callFlags) = 0;
virtual bool isClass(XObject* object) = 0;
virtual bool isInstanceOf(XObject* object, XObject* _class, bool allowExtends) = 0;
virtual XDataType getObjectType(XObject* object) = 0;
virtual XObject* getObjectClass(XObject* object) = 0;
virtual void* getClassObject(XObject* object) = 0;
virtual XObject* getBaseClass(XObject* _classobject) = 0;
virtual xlong getHash(XObject * object) = 0;
virtual XObject* fromHash(xlong) = 0;
virtual const char * toString(XContext* context, XObject* object) = 0;

virtual XObject* getFieldType(XContext* context, XObject*) = 0;
virtual XObject* getFieldValue(XObject*, XObject*) = 0;
virtual bool setFieldValue(XContext* context, XObject*, XObject* field, XObject* value) = 0;

virtual int getFieldId(const char* path) = 0;
virtual XObject* getDynamicField(XObject* object, int id) = 0;
virtual XObject* getStaticField(XObject* object, int id) = 0;
virtual bool isExtendsOf(XObject* eclass, XObject* bclass) = 0;

标志位定义（Method / Field 特性）

类型与类操作

方法操作（Method 元对象相关）

字段操作（Field 元对象相关）

用途说明:

xnl / cxnl 是为底层程序与xlang vm沟通的接口, 通过此接口, 可以使底层模块更好的与xlang vm交互, 以下以 quickjs 引擎为例:

在 quickjs 引擎模块中, 为了在 js 中调用上层的xlang代码, 实现js <-> 无障碍调用, 使用xnl中的反射功能, 将vm 中需要用到的类通过反射全部解析出来, 然后构造 js 中的桥接对象, 以达到设计目的.

例如 MyClass 类在 js 中被使用时:

1. js 引擎通过 gs_env->getClassName("MyClass") 查询虚拟机中的类对象 object, 并构造对应的内部对象.
2. 通过 gs_env->getMethod(ctx.getThread(), object, 0) 遍历类对象的方法, 在 quickjs 中使用 JSCFunctionListEntry 构造对应的函数列表.
3. 通过 gs_env->getFields(ctx.getThread(), object, 0) 遍历对象的字段及其信息, 通过 JS_DefinePropertyValueStr 关联相应的操作方法.
4. 将内部对象与前两步构造的函数列表和字段操作进行关联, 并注册到 quickjs 的系统中.

完成以上4步以后, 就可以在 js 代码中使用 Myclass 类, 该套方法具有完全自动化, 无需特化处理的处理特点, 可将 xlang vm中的任意对象构造对应的 js 对象并实现上下层的无障碍调用.

反射限制说明

核心规则

1. 四大类不被反射 (可以查询到对象,但无法进一步查询到他们的成员和方法)

   • Class

   • Method

   • Field

   • Object

2. 含义

   • 无法通过反射 API（Class.getClass(), getMethods(), getFields() 等）获取它们自身的类信息、方法或字段

   • 即使在 xnl/cxnl 中，也无法像普通类那样遍历或操作这四大类.

3. 原因

   • 这四大类是 反射体系的基础元对象

   • 允许反射查询其他类，如果允许反射自身，会引入无限递归或自引用问题

   • 保护底层元对象结构，保证反射机制的稳定性

4. 注意事项

   • 对普通类（用户定义类、系统类）可以完全反射

   • 对四大类本身，只能通过 底层接口或原生指针 进行操作

   • 调用 getClass("Class") 或 getMethods() 不能获取 Class 的方法列表

5. 结构固定性
   • 不能动态修改成员方法或者字段
   • 不能在运行期间动态生成类对象以及方法/字段

总结：
四大类是 反射体系的底层基础，它们自身无法被反射，但它们定义的接口和方法支撑了对其它类的完整反射操作。这是 xlang VM 设计上的安全和稳定策略。