yyc12345/libcmo21
1
0
Fork 0
Code Activity

feat: update flag enum and enum underlying type decision rules for codegen

Browse Source
This commit is contained in:
yyc12345
2026-02-11 22:49:54 +08:00
parent 3310cac100
commit 4619cb5d1a
10 changed files with 211 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
Assets/CodeGen/EnumsMigration/EnumsAnalyzer/ClassidWalker.java
View File

@@ -72,9 +72,13 @@ public class ClassidWalker extends CKDefinesParserBaseListener {
mLevel = 0;
mLevelStack = null;
// classid is signed int and do not have flags feature.
mCurrentEnum.mCanUnsigned = false;
mCurrentEnum.mUseFlags = false;
// update self
mCurrentEnum.updateByEntries();
// we forcely set classid is signed and do not have flags feature.
mCurrentEnum.mIsFlag = false;
mCurrentEnum.mIsUnsigned = false;
// and return
mResult = mCurrentEnum;
mCurrentEnum = null;
}
@@ -90,6 +94,11 @@ public class ClassidWalker extends CKDefinesParserBaseListener {
mCurrentEntry.mEntryName = ctx.CKGENERIC_ID(0).getText();
mCurrentEntry.mEntryValue = ctx.CKGENERIC_NUM().getText();
// All classid number is positive.
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Positive;
// And all in ordinary number style so it doesn't have flag feature.
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.NotFlag;
// fill entry level info
int this_level = getClassidLevel(ctx.getStart());
if (this_level > mLevel) {

20
Assets/CodeGen/EnumsMigration/EnumsAnalyzer/DefinesWalker.java
View File

@@ -30,6 +30,9 @@ public class DefinesWalker extends CKDefinesParserBaseListener {
@Override
public void exitProg(CKDefinesParser.ProgContext ctx) {
// update enum
mCurrentEnum.updateByEntries();
// and return
mResult = mCurrentEnum;
mCurrentEnum = null;
}
@@ -48,19 +51,26 @@ public class DefinesWalker extends CKDefinesParserBaseListener {
if (ctx.CKGENERIC_NUM() == null) {
// define with id
mCurrentEntry.mEntryValue = ctx.CKGENERIC_ID(1).getText();
// it refers other memeber, so its sign is unknown
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Unknown;
// it refers other memeber, so it may flag.
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.MayFlag;
} else {
// define with number
String num = ctx.CKGENERIC_NUM().getText();
mCurrentEntry.mEntryValue = num;
// check whether this enum can be unsigned
// check the sign of this number
if (CommonHelper.isNegativeNumber(num)) {
mCurrentEnum.mCanUnsigned = false;
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Negative;
} else {
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Positive;
}
// if the number is in hex form, this enum MIGHT have flags feature
// if the number is in hex form, it may belong to flag enum
if (CommonHelper.isHexNumber(num)) {
mCurrentEnum.mUseFlags = true;
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.MayFlag;
} else {
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.NotFlag;
}
}

93
Assets/CodeGen/EnumsMigration/EnumsAnalyzer/EnumsHelper.java
View File

@@ -1,6 +1,45 @@
import java.util.Vector;
public class EnumsHelper {
/**
* The kind of enum entry value.
* This kind indicates whether this enum entry belong to a flag enum.
*/
public enum BEnumEntryFlagKind {
/**
* This enum entry can not belong to a flag enum.
* Because its value is ordinary.
*/
NotFlag,
/**
* This enum entry may belong to a flag enum.
* Because its value is in HEX format, and refering other members.
*/
MayFlag,
/**
* This enum entry must belong to a flag enum.
* Because its value use bitwise operation.
*/
MustFlag,
}
/**
* The kind of enum entry value.
* This kind indicates the sign of this enum entry value.
*/
public enum BEnumEntrySignKind {
/** The value of this enum entry is positive number or zero. */
Positive,
/** The value of this enum entry is negative. */
Negative,
/**
* The value of this enum entry is unknown.
* This is may be caused by that it refer other memeber.
*/
Unknown,
}
/**
* The struct to describe the entry of an enum.
*/
@@ -8,6 +47,8 @@ public class EnumsHelper {
public BEnumEntry() {
mEntryName = null;
mEntryValue = null;
mEntryFlagKind = null;
mEntrySignKind = null;
mEntryComment = null;
}
@@ -15,6 +56,10 @@ public class EnumsHelper {
public String mEntryName;
/** The value of this entry. null if this entry do not have explicit value. */
public String mEntryValue;
/** The flag kind of this entry value. */
public BEnumEntryFlagKind mEntryFlagKind;
/** The sign kind of this entry value. */
public BEnumEntrySignKind mEntrySignKind;
/** The comment of this entry. null if no comment. */
public String mEntryComment;
}
@@ -44,8 +89,8 @@ public class EnumsHelper {
public BEnum() {
mEnumName = null;
mEnumComment = null;
mCanUnsigned = true;
mUseFlags = false;
mIsUnsigned = true;
mIsFlag = false;
mEntries = new Vector<BEnumEntry>();
}
@@ -53,12 +98,48 @@ public class EnumsHelper {
public String mEnumName;
/** The comment of this enum. null if no comment. */
public String mEnumComment;
/** True if this enum can use unsigned integer as its underlying type. */
public boolean mCanUnsigned;
/** True if this enum will use flags feature (supporting OR, AND, operators). */
public boolean mUseFlags;
/** True if this enum should use unsigned integer as its underlying type, otherwise false. */
public boolean mIsUnsigned;
/** True if this enum shoule have flags feature (supporting OR, AND, operators), otherwise false. */
public boolean mIsFlag;
/** The list to store entries of this enum. */
public Vector<BEnumEntry> mEntries;
/**
* Update some properties located in this class according to existing entries.
*/
public void updateByEntries() {
// If there is at least one negative entry, the enum should be signed,
// Otherwise, it is unsigned.
// For unknown entries, ignore them.
boolean has_negative = false;
for (BEnumEntry entry : this.mEntries) {
if (entry.mEntrySignKind == BEnumEntrySignKind.Negative) {
has_negative = true;
}
}
this.mIsUnsigned = !has_negative;
// For flag kind, if there is "Must Flag" entry, the enum should be a flag enum.
// Then, if "May Flag" entry is more than "Not Flag", the enum would be a flag enum.
// Otherwise, it is not flag.
boolean has_must_flag = false;
int cnt_may_flag = 0, cnt_not_flag = 0;
for (BEnumEntry entry : this.mEntries) {
switch (entry.mEntryFlagKind) {
case NotFlag -> ++cnt_not_flag;
case MayFlag -> ++cnt_may_flag;
case MustFlag -> has_must_flag = true;
}
}
if (has_must_flag) {
this.mIsFlag = true;
} else if (cnt_may_flag > cnt_not_flag) {
this.mIsFlag = true;
} else {
this.mIsFlag = false;
}
}
}
/**

84
Assets/CodeGen/EnumsMigration/EnumsAnalyzer/EnumsWalker.java
View File

@@ -59,6 +59,8 @@ public class EnumsWalker extends CKEnumsParserBaseListener {
List<TerminalNode> allNames = ctx.CKGENERIC_ID();
mCurrentEnum.mEnumName = allNames.get(allNames.size() - 1).getText();
// update self and add into list
mCurrentEnum.updateByEntries();
mCurrentProg.mEnums.add(mCurrentEnum);
mCurrentEnum = null;
}
@@ -75,6 +77,14 @@ public class EnumsWalker extends CKEnumsParserBaseListener {
// get entry name
mCurrentEntry.mEntryName = ctx.CKGENERIC_ID().getText();
// if its value is null, we manually fill 2 kinds
if (mCurrentEntry.mEntryValue == null) {
// the sign kind is unknown because it relys on other value (+1)
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Unknown;
// because it just adds one from previous member, it should not belong to a flag enum
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.NotFlag;
}
mCurrentEnum.mEntries.add(mCurrentEntry);
mCurrentEntry = null;
}
@@ -85,34 +95,42 @@ public class EnumsWalker extends CKEnumsParserBaseListener {
List<TerminalNode> nums = ctx.CKGENERIC_NUM();
switch (nums.size()) {
case 1: {
// set value
TerminalNode node = nums.get(0);
mCurrentEntry.mEntryValue = node.getText();
case 1: {
// value is immediate number
TerminalNode node = nums.get(0);
String num = node.getText();
mCurrentEntry.mEntryValue = num;
// check whether this enum can be unsigned
if (CommonHelper.isNegativeNumber(node.getText())) {
mCurrentEnum.mCanUnsigned = false;
// check whether this enum can be unsigned
if (CommonHelper.isNegativeNumber(num)) {
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Negative;
} else {
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Positive;
}
// if the number is in hex form, this entry may belong to flag enum
if (CommonHelper.isHexNumber(num)) {
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.MayFlag;
} else {
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.NotFlag;
}
break;
}
// if the number is in hex form, this enum MIGHT have flags feature
if (CommonHelper.isHexNumber(node.getText())) {
mCurrentEnum.mUseFlags = true;
case 2: {
// value is bitwise operation
TerminalNode num = nums.get(0), offset = nums.get(1);
mCurrentEntry.mEntryValue = String.format("%s << %s", num.getText(), offset.getText());
// << operator appears.
// it shoud be unsigned.
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Positive;
// and it must belong to flag enum
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.MustFlag;
break;
}
break;
}
case 2: {
// set value
TerminalNode num = nums.get(0), offset = nums.get(1);
mCurrentEntry.mEntryValue = String.format("%s << %s", num.getText(), offset.getText());
// << operator appears. this enum must have flags feature
mCurrentEnum.mUseFlags = true;
break;
}
default:
throw new IllegalArgumentException("Unexpected value: " + nums.size());
default:
throw new IllegalArgumentException("Unexpected value: " + nums.size());
}
}
@@ -123,9 +141,19 @@ public class EnumsWalker extends CKEnumsParserBaseListener {
mCurrentEntry.mEntryValue = ctx.CKGENERIC_ID().stream().map(value -> value.getText())
.collect(Collectors.joining(" | "));
// | operator appears. this enum must have flags feature
mCurrentEnum.mUseFlags = true;
if (ctx.CKGENERIC_ID().size() > 1) {
// If there is more than one ID, it means | operator appears.
// It should be unsigned.
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Positive;
// And it must belong to flag enum.
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.MustFlag;
} else {
// Otherwise it just refer other member.
// The sign of its value is unclear.
mCurrentEntry.mEntrySignKind = EnumsHelper.BEnumEntrySignKind.Unknown;
// And it may belong to flag enum because it refers other memeber.
mCurrentEntry.mEntryFlagKind = EnumsHelper.BEnumEntryFlagKind.MayFlag;
}
}
}

23
Assets/CodeGen/EnumsMigration/EnumsAnalyzer/JsonWriter.java
View File

@@ -6,10 +6,28 @@ import com.google.gson.GsonBuilder;
public class JsonWriter {
private static String writeBEnumEntryFlagKind(EnumsHelper.BEnumEntryFlagKind kind) {
return switch (kind) {
case NotFlag -> "not-flag";
case MayFlag -> "may-flag";
case MustFlag -> "must-flag";
};
}
private static String writeBEnumEntrySignKind(EnumsHelper.BEnumEntrySignKind kind) {
return switch (kind) {
case Positive -> "positive";
case Negative -> "negative";
case Unknown -> "unknown";
};
}
private static JsonObject writeBEnumEntry(EnumsHelper.BEnumEntry enumEntry) {
JsonObject data = new JsonObject();
data.addProperty("name", enumEntry.mEntryName);
data.addProperty("value", enumEntry.mEntryValue);
data.addProperty("flag_kind", writeBEnumEntryFlagKind(enumEntry.mEntryFlagKind));
data.addProperty("sign_kind", writeBEnumEntrySignKind(enumEntry.mEntrySignKind));
data.addProperty("comment", enumEntry.mEntryComment);
// Export hierarchy if possible
@@ -30,9 +48,8 @@ public class JsonWriter {
JsonObject data = new JsonObject();
data.addProperty("name", benum.mEnumName);
data.addProperty("comment", benum.mEnumComment);
data.addProperty("can_unsigned", benum.mCanUnsigned);
data.addProperty("use_flags", benum.mUseFlags);
data.addProperty("use_flags", benum.mUseFlags);
data.addProperty("is_unsigned", benum.mIsUnsigned);
data.addProperty("is_flag", benum.mIsFlag);
JsonArray entries = new JsonArray();
for (EnumsHelper.BEnumEntry enumEntry : benum.mEntries) {