268 lines
9.5 KiB
Haxe
268 lines
9.5 KiB
Haxe
package engine.macros;
|
|
|
|
#if macro
|
|
import haxe.macro.Expr;
|
|
import haxe.macro.Context;
|
|
import haxe.macro.Type;
|
|
import haxe.macro.Expr.Field;
|
|
import haxe.macro.Expr.Function;
|
|
import haxe.macro.Expr.Access;
|
|
|
|
private typedef CVarMetadata = {
|
|
name:Expr,
|
|
type:String,
|
|
value:Expr,
|
|
flags:Expr,
|
|
help:Expr,
|
|
?callback:Expr
|
|
}
|
|
|
|
class ConVarDecorators {
|
|
static function extractCVarMetadata(params:Array<Expr>):CVarMetadata {
|
|
if (params == null || params.length == 0) return null;
|
|
|
|
var metadata:CVarMetadata = {
|
|
name: macro "",
|
|
type: "CString",
|
|
value: macro 0,
|
|
flags: macro "FCVAR_NONE",
|
|
help: macro "",
|
|
callback: macro null
|
|
};
|
|
|
|
switch (params[0].expr) {
|
|
case EObjectDecl(fields):
|
|
var fieldMap = [
|
|
"name" => function(expr) metadata.name = expr,
|
|
"type" => function(expr) metadata.type = switch (expr.expr) {
|
|
case EConst(CString(s)): s;
|
|
case _: "CString";
|
|
},
|
|
"value" => function(expr) metadata.value = expr,
|
|
"flags" => function(expr) metadata.flags = expr,
|
|
"help" => function(expr) metadata.help = expr,
|
|
"callback" => function(expr) metadata.callback = expr
|
|
];
|
|
|
|
for (field in fields) {
|
|
if (fieldMap.exists(field.field)) {
|
|
fieldMap[field.field](field.expr);
|
|
} else {
|
|
Context.error("Unexpected field: " + field.field, field.expr.pos);
|
|
}
|
|
}
|
|
case _:
|
|
}
|
|
return metadata;
|
|
}
|
|
|
|
// Process command fields
|
|
private static function processCommandField(field:Field, cmdMeta:MetadataEntry, extraFields:Array<Field>):Void {
|
|
if (!isFieldKind(field, "FFun")) {
|
|
Context.error("The @:concmd metadata can only be applied to functions", field.pos);
|
|
return;
|
|
}
|
|
|
|
var pos = Context.currentPos();
|
|
var functionReference = getFunctionFromField(field);
|
|
if (functionReference == null) return;
|
|
|
|
var name = cmdMeta.params.length > 0 ? getStringFromExpr(cmdMeta.params[0]) ?? field.name : field.name;
|
|
var functionExpression = macro function(args:Array<String>) ${functionReference.expr};
|
|
|
|
var initExpr = macro {
|
|
var cmd = engine.ConVar.registerCCmd($v{name}, $functionExpression);
|
|
cmd;
|
|
};
|
|
|
|
var initName = "__init__cmd_" + name;
|
|
extraFields.push(createStaticInitField(initName, initExpr, pos));
|
|
}
|
|
|
|
// Process convar fields
|
|
private static function processConVarField(field:Field, cvarMeta:MetadataEntry, extraFields:Array<Field>):Void {
|
|
if (!isFieldKind(field, "FVar")) {
|
|
Context.error("The @:convar metadata can only be applied to variables", field.pos);
|
|
return;
|
|
}
|
|
|
|
var pos = Context.currentPos();
|
|
var meta = extractCVarMetadata(cvarMeta.params);
|
|
if (meta == null) {
|
|
Context.error("Metadata extraction failed for field: " + field.name, field.pos);
|
|
return;
|
|
}
|
|
|
|
var cvarName = getStringFromMetaExpr(meta.name) ?? field.name;
|
|
var fieldName = field.name;
|
|
var isStatic = hasAccess(field, AStatic);
|
|
|
|
var varType = getVarType(field);
|
|
|
|
if (isStatic) {
|
|
// Handle static fields
|
|
var staticInitExpr = macro {
|
|
var cvar = $i{fieldName} = engine.ConVar.registerCVar(
|
|
${meta.name},
|
|
${Context.parse('engine.enums.console.CVarType.' + meta.type, pos)},
|
|
${meta.value},
|
|
${Context.parse('engine.enums.console.CVarFlag.' + switch (meta.flags.expr) {
|
|
case EConst(CString(s)): s;
|
|
case _: "FCVAR_NONE";
|
|
}, pos)},
|
|
${meta.help},
|
|
${meta.callback ?? macro null}
|
|
);
|
|
trace($v{"Registered CVar: "} + $e{meta.name});
|
|
cvar;
|
|
};
|
|
|
|
extraFields.push(createStaticInitField("__init__" + cvarName, staticInitExpr, pos));
|
|
} else {
|
|
// Handle instance fields
|
|
updateFieldInitialValue(field, macro null);
|
|
|
|
var instanceInitializerExpression = macro {
|
|
if (Reflect.field(this, $v{fieldName}) == null) {
|
|
Reflect.setField(this, $v{fieldName}, engine.ConVar.registerCVar(
|
|
${meta.name},
|
|
${Context.parse('engine.enums.console.CVarType.' + meta.type, pos)},
|
|
${meta.value},
|
|
${Context.parse('engine.enums.console.CVarFlag.' + switch (meta.flags.expr) {
|
|
case EConst(CString(s)): s;
|
|
case _: "FCVAR_NONE";
|
|
}, pos)},
|
|
${meta.help},
|
|
${meta.callback ?? macro null}
|
|
));
|
|
trace($v{"Registered CVar: "} + $e{meta.name});
|
|
}
|
|
};
|
|
|
|
ensureConstructorWithInit(extraFields, instanceInitializerExpression, pos);
|
|
}
|
|
}
|
|
|
|
// Map to check field kinds
|
|
private static final fieldKindMap:Map<String, haxe.macro.FieldType->Bool> = [
|
|
"FFun" => function(ft) return switch(ft) { case FFun(_): true; case _: false; },
|
|
"FVar" => function(ft) return switch(ft) { case FVar(_, _): true; case _: false; },
|
|
"FProp" => function(ft) return switch(ft) { case FProp(_, _, _, _): true; case _: false; }
|
|
];
|
|
|
|
// Utility functions
|
|
private static function isFieldKind(field:Field, kind:String):Bool {
|
|
return fieldKindMap.exists(kind) ? fieldKindMap.get(kind)(field.kind) : false;
|
|
}
|
|
|
|
private static function getFunctionFromField(field:Field):Function {
|
|
return switch (field.kind) {
|
|
case FFun(f): f;
|
|
case _: null;
|
|
}
|
|
}
|
|
|
|
private static function getVarType(field:Field):ComplexType {
|
|
return switch (field.kind) {
|
|
case FVar(t, _): t;
|
|
case _: null;
|
|
}
|
|
}
|
|
|
|
private static function updateFieldInitialValue(field:Field, expr:Expr):Void {
|
|
switch (field.kind) {
|
|
case FVar(t, _): field.kind = FVar(t, expr);
|
|
case _:
|
|
}
|
|
}
|
|
|
|
private static function getStringFromExpr(expr:Expr):String {
|
|
return switch (expr.expr) {
|
|
case EConst(CString(s)): s;
|
|
case _: null;
|
|
}
|
|
}
|
|
|
|
private static function getStringFromMetaExpr(expr:Expr):String {
|
|
return switch (expr.expr) {
|
|
case EConst(CString(s)): s;
|
|
case _: null;
|
|
}
|
|
}
|
|
|
|
private static function hasAccess(field:Field, access:Access):Bool {
|
|
return field.access != null && field.access.indexOf(access) >= 0;
|
|
}
|
|
|
|
private static function createStaticInitField(name:String, initExpr:Expr, pos:Position):Field {
|
|
return {
|
|
name: name,
|
|
access: [AStatic],
|
|
kind: FVar(null, initExpr),
|
|
pos: pos,
|
|
doc: null,
|
|
meta: [{ name: ":keep", params: [], pos: pos }]
|
|
};
|
|
}
|
|
|
|
private static function ensureConstructorWithInit(fields:Array<Field>, initExpr:Expr, pos:Position):Void {
|
|
var cls = Context.getLocalClass().get();
|
|
var hasSuperClass = cls.superClass != null;
|
|
|
|
var constructor = Lambda.find(fields, function(f) return f.name == "new");
|
|
if (constructor == null) {
|
|
constructor = {
|
|
name: "new",
|
|
access: [APublic],
|
|
kind: FFun({
|
|
args: [],
|
|
expr: if (hasSuperClass) macro {
|
|
super();
|
|
$initExpr;
|
|
} else macro {
|
|
$initExpr;
|
|
},
|
|
ret: null
|
|
}),
|
|
pos: pos,
|
|
meta: []
|
|
};
|
|
fields.push(constructor);
|
|
} else {
|
|
switch (constructor.kind) {
|
|
case FFun(f):
|
|
switch(f.expr.expr) {
|
|
case EBlock(exprs):
|
|
exprs.push(initExpr);
|
|
case _:
|
|
f.expr = macro {
|
|
${f.expr};
|
|
$initExpr;
|
|
}
|
|
}
|
|
case _:
|
|
}
|
|
}
|
|
}
|
|
|
|
public static macro function build():Array<Field> {
|
|
var fields = Context.getBuildFields();
|
|
var extraFields:Array<Field> = [];
|
|
|
|
for (field in fields) {
|
|
if (field.meta == null) continue;
|
|
|
|
var cmdMeta = Lambda.find(field.meta, function(m) return m.name == ":concmd");
|
|
var cvarMeta = Lambda.find(field.meta, function(m) return m.name == ":convar");
|
|
|
|
if (cmdMeta != null) {
|
|
processCommandField(field, cmdMeta, extraFields);
|
|
} else if (cvarMeta != null && cvarMeta.params.length > 0) {
|
|
processConVarField(field, cvarMeta, extraFields);
|
|
}
|
|
}
|
|
|
|
return fields.concat(extraFields);
|
|
}
|
|
}
|
|
#end |