Luke/snow
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

!45 feat: 编译器补齐对 取模运算符 % 的完整支持

Browse Source 
Merge pull request !45 from Luke/feature/add-mod-operator
This commit is contained in:
Luke 2025-07-29 01:17:32 +00:00 committed by Gitee
commit 5b15b2d170
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
6 changed files with 124 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.run/Demo16.run.xml Normal file
View File

@ -0,0 +1,10 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Demo16" type="Application" factoryName="Application" folderName="Demo">
<option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
<module name="Snow" />
<option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo/Demo16 -o target/Demo16" />
<method v="2">
<option name="Make" enabled="true" />
</method>
</configuration>
</component>

22
playground/Demo/Demo16/Main.snow Normal file
View File

@ -0,0 +1,22 @@
module: Main
import: os
function: main
return_type: int
body:
loop:
init:
declare i:int = 1
cond:
i <= 10
step:
i = i + 1
body:
if i % 2 == 0 then
print(i)
end if
end body
end loop
return 0
end body
end function
end module

11
playground/Demo/Demo16/OS.snow Normal file
View File

@ -0,0 +1,11 @@
module: os
import: os
function: print
parameter:
declare i1: int
return_type: void
body:
syscall("PRINT",i1)
end body
end function
end module

6
src/main/java/org/jcnc/snow/compiler/backend/utils/IROpCodeMapper.java
View File

@ -44,6 +44,7 @@ public final class IROpCodeMapper {
opcodeMap.put(IROpCode.MUL_B8, "B_MUL"); opcodeMap.put(IROpCode.MUL_B8, "B_MUL");
opcodeMap.put(IROpCode.DIV_B8, "B_DIV"); opcodeMap.put(IROpCode.DIV_B8, "B_DIV");
opcodeMap.put(IROpCode.NEG_B8, "B_NEG"); opcodeMap.put(IROpCode.NEG_B8, "B_NEG");
opcodeMap.put(IROpCode.MOD_B8, "B_MOD");
// 整形16位算术运算映射 // 整形16位算术运算映射
opcodeMap.put(IROpCode.ADD_S16, "S_ADD"); opcodeMap.put(IROpCode.ADD_S16, "S_ADD");
@ -51,6 +52,7 @@ public final class IROpCodeMapper {
opcodeMap.put(IROpCode.MUL_S16, "S_MUL"); opcodeMap.put(IROpCode.MUL_S16, "S_MUL");
opcodeMap.put(IROpCode.DIV_S16, "S_DIV"); opcodeMap.put(IROpCode.DIV_S16, "S_DIV");
opcodeMap.put(IROpCode.NEG_S16, "S_NEG"); opcodeMap.put(IROpCode.NEG_S16, "S_NEG");
opcodeMap.put(IROpCode.MOD_S16, "S_MOD");
// 整形32位算术运算映射 // 整形32位算术运算映射
opcodeMap.put(IROpCode.ADD_I32, "I_ADD"); opcodeMap.put(IROpCode.ADD_I32, "I_ADD");
@ -58,6 +60,7 @@ public final class IROpCodeMapper {
opcodeMap.put(IROpCode.MUL_I32, "I_MUL"); opcodeMap.put(IROpCode.MUL_I32, "I_MUL");
opcodeMap.put(IROpCode.DIV_I32, "I_DIV"); opcodeMap.put(IROpCode.DIV_I32, "I_DIV");
opcodeMap.put(IROpCode.NEG_I32, "I_NEG"); opcodeMap.put(IROpCode.NEG_I32, "I_NEG");
opcodeMap.put(IROpCode.MOD_I32, "I_MOD");
// 整形64位算术运算映射 // 整形64位算术运算映射
opcodeMap.put(IROpCode.ADD_L64, "L_ADD"); opcodeMap.put(IROpCode.ADD_L64, "L_ADD");
@ -65,6 +68,7 @@ public final class IROpCodeMapper {
opcodeMap.put(IROpCode.MUL_L64, "L_MUL"); opcodeMap.put(IROpCode.MUL_L64, "L_MUL");
opcodeMap.put(IROpCode.DIV_L64, "L_DIV"); opcodeMap.put(IROpCode.DIV_L64, "L_DIV");
opcodeMap.put(IROpCode.NEG_L64, "L_NEG"); opcodeMap.put(IROpCode.NEG_L64, "L_NEG");
opcodeMap.put(IROpCode.MOD_L64, "L_MOD");
// --- 32-bit floating point --- // --- 32-bit floating point ---
@ -73,6 +77,7 @@ public final class IROpCodeMapper {
opcodeMap.put(IROpCode.MUL_F32, "F_MUL"); opcodeMap.put(IROpCode.MUL_F32, "F_MUL");
opcodeMap.put(IROpCode.DIV_F32, "F_DIV"); opcodeMap.put(IROpCode.DIV_F32, "F_DIV");
opcodeMap.put(IROpCode.NEG_F32, "F_NEG"); opcodeMap.put(IROpCode.NEG_F32, "F_NEG");
opcodeMap.put(IROpCode.MOD_F32, "F_MOD");
// --- 64-bit floating point --- // --- 64-bit floating point ---
opcodeMap.put(IROpCode.ADD_D64, "D_ADD"); opcodeMap.put(IROpCode.ADD_D64, "D_ADD");
@ -80,6 +85,7 @@ public final class IROpCodeMapper {
opcodeMap.put(IROpCode.MUL_D64, "D_MUL"); opcodeMap.put(IROpCode.MUL_D64, "D_MUL");
opcodeMap.put(IROpCode.DIV_D64, "D_DIV"); opcodeMap.put(IROpCode.DIV_D64, "D_DIV");
opcodeMap.put(IROpCode.NEG_D64, "D_NEG"); opcodeMap.put(IROpCode.NEG_D64, "D_NEG");
opcodeMap.put(IROpCode.MOD_D64, "D_MOD");
// 比较运算映射 // 比较运算映射
// 8位整数比较运算映射 // 8位整数比较运算映射

16
src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java
View File

@ -25,11 +25,12 @@ public enum IROpCode {
/* ───── 算术运算（8位整数: byte）───── */ /* ───── 算术运算（8位整数: byte）───── */
ADD_B8, // 8位整型加法: a = b + c ADD_B8, // 8位整型加法:
SUB_B8, // 8位整型减法: a = b - c SUB_B8, // 8位整型减法:
MUL_B8, // 8位整型乘法: a = b * c MUL_B8, // 8位整型乘法:
DIV_B8, // 8位整型除法: a = b / c DIV_B8, // 8位整型除法:
NEG_B8, // 8位整型取负: a = -b NEG_B8, // 8位整型取负:
MOD_B8, // 8位整型取余
/* ───── 算术运算（16位整数: short）───── */ /* ───── 算术运算（16位整数: short）───── */
ADD_S16, // 16位整型加法 ADD_S16, // 16位整型加法
@ -37,6 +38,7 @@ public enum IROpCode {
MUL_S16, // 16位整型乘法 MUL_S16, // 16位整型乘法
DIV_S16, // 16位整型除法 DIV_S16, // 16位整型除法
NEG_S16, // 16位整型取负 NEG_S16, // 16位整型取负
MOD_S16, // 16位整型取余
/* ───── 算术运算（32位整数: int）───── */ /* ───── 算术运算（32位整数: int）───── */
ADD_I32, // 32位整型加法 ADD_I32, // 32位整型加法
@ -44,6 +46,7 @@ public enum IROpCode {
MUL_I32, // 32位整型乘法 MUL_I32, // 32位整型乘法
DIV_I32, // 32位整型除法 DIV_I32, // 32位整型除法
NEG_I32, // 32位整型取负 NEG_I32, // 32位整型取负
MOD_I32, // 32位整型取余
/* ───── 算术运算（64位整数: long）───── */ /* ───── 算术运算（64位整数: long）───── */
ADD_L64, // 64位整型加法 ADD_L64, // 64位整型加法
@ -51,6 +54,7 @@ public enum IROpCode {
MUL_L64, // 64位整型乘法 MUL_L64, // 64位整型乘法
DIV_L64, // 64位整型除法 DIV_L64, // 64位整型除法
NEG_L64, // 64位整型取负 NEG_L64, // 64位整型取负
MOD_L64, // 64位整型取余
/* ───── 算术运算（32位浮点数: float）───── */ /* ───── 算术运算（32位浮点数: float）───── */
ADD_F32, // 32位浮点加法 ADD_F32, // 32位浮点加法
@ -58,6 +62,7 @@ public enum IROpCode {
MUL_F32, // 32位浮点乘法 MUL_F32, // 32位浮点乘法
DIV_F32, // 32位浮点除法 DIV_F32, // 32位浮点除法
NEG_F32, // 32位浮点取负 NEG_F32, // 32位浮点取负
MOD_F32, // 32位浮点取余
/* ───── 算术运算（64位浮点数: double）───── */ /* ───── 算术运算（64位浮点数: double）───── */
ADD_D64, // 64位浮点加法 ADD_D64, // 64位浮点加法
@ -65,6 +70,7 @@ public enum IROpCode {
MUL_D64, // 64位浮点乘法 MUL_D64, // 64位浮点乘法
DIV_D64, // 64位浮点除法 DIV_D64, // 64位浮点除法
NEG_D64, // 64位浮点取负 NEG_D64, // 64位浮点取负
MOD_D64, // 64位浮点取余
/* ───── 逻辑与比较运算指令（8位整数: byte） ───── */ /* ───── 逻辑与比较运算指令（8位整数: byte） ───── */
CMP_BEQ, // 8位整数相等比较: a == b CMP_BEQ, // 8位整数相等比较: a == b

102
src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java
View File

@ -6,97 +6,123 @@ import java.util.Map;
* 操作符与IR操作码映射表，统一管理所有类型的算术和比较操作映射。 * 操作符与IR操作码映射表，统一管理所有类型的算术和比较操作映射。
*/ */
public final class IROpCodeMappings { public final class IROpCodeMappings {
private IROpCodeMappings() {} // 禁止实例化
// 8位整型运算符映射 // 8位整型运算符映射
public static final Map<String, IROpCode> OP_B8 = Map.of( public static final Map<String, IROpCode> OP_B8 = Map.of(
"+", IROpCode.ADD_B8, "-", IROpCode.SUB_B8, "+", IROpCode.ADD_B8,
"*", IROpCode.MUL_B8, "/", IROpCode.DIV_B8 "-", IROpCode.SUB_B8,
"*", IROpCode.MUL_B8,
"/", IROpCode.DIV_B8,
"%", IROpCode.MOD_B8
); );
// 16位整型 // 16位整型
public static final Map<String, IROpCode> OP_S16 = Map.of( public static final Map<String, IROpCode> OP_S16 = Map.of(
"+", IROpCode.ADD_S16, "-", IROpCode.SUB_S16, "+", IROpCode.ADD_S16,
"*", IROpCode.MUL_S16, "/", IROpCode.DIV_S16 "-", IROpCode.SUB_S16,
"*", IROpCode.MUL_S16,
"/", IROpCode.DIV_S16,
"%", IROpCode.MOD_S16
); );
// 32位整型 // 32位整型
public static final Map<String, IROpCode> OP_I32 = Map.of( public static final Map<String, IROpCode> OP_I32 = Map.of(
"+", IROpCode.ADD_I32, "-", IROpCode.SUB_I32, "+", IROpCode.ADD_I32,
"*", IROpCode.MUL_I32, "/", IROpCode.DIV_I32 "-", IROpCode.SUB_I32,
"*", IROpCode.MUL_I32,
"/", IROpCode.DIV_I32,
"%", IROpCode.MOD_I32
); );
// 64位长整型 // 64位长整型
public static final Map<String, IROpCode> OP_L64 = Map.of( public static final Map<String, IROpCode> OP_L64 = Map.of(
"+", IROpCode.ADD_L64, "-", IROpCode.SUB_L64, "+", IROpCode.ADD_L64,
"*", IROpCode.MUL_L64, "/", IROpCode.DIV_L64 "-", IROpCode.SUB_L64,
"*", IROpCode.MUL_L64,
"/", IROpCode.DIV_L64,
"%", IROpCode.MOD_L64
); );
// 32位浮点型 // 32位浮点型
public static final Map<String, IROpCode> OP_F32 = Map.of( public static final Map<String, IROpCode> OP_F32 = Map.of(
"+", IROpCode.ADD_F32, "-", IROpCode.SUB_F32, "+", IROpCode.ADD_F32,
"*", IROpCode.MUL_F32, "/", IROpCode.DIV_F32 "-", IROpCode.SUB_F32,
"*", IROpCode.MUL_F32,
"/", IROpCode.DIV_F32,
"%", IROpCode.MOD_F32
); );
// 64位双精度浮点型 // 64位双精度浮点型
public static final Map<String, IROpCode> OP_D64 = Map.of( public static final Map<String, IROpCode> OP_D64 = Map.of(
"+", IROpCode.ADD_D64, "-", IROpCode.SUB_D64, "+", IROpCode.ADD_D64,
"*", IROpCode.MUL_D64, "/", IROpCode.DIV_D64 "-", IROpCode.SUB_D64,
"*", IROpCode.MUL_D64,
"/", IROpCode.DIV_D64,
"%", IROpCode.MOD_D64
); );
/**
/* ────── 比较运算符映射 ────── */ * 8-bit（byte）比较
/** 8-bit（byte）比较 */ */
public static final Map<String, IROpCode> CMP_B8 = Map.of( public static final Map<String, IROpCode> CMP_B8 = Map.of(
"==", IROpCode.CMP_BEQ, "==", IROpCode.CMP_BEQ,
"!=", IROpCode.CMP_BNE, "!=", IROpCode.CMP_BNE,
"<", IROpCode.CMP_BLT, "<", IROpCode.CMP_BLT,
">", IROpCode.CMP_BGT, ">", IROpCode.CMP_BGT,
"<=", IROpCode.CMP_BLE, "<=", IROpCode.CMP_BLE,
">=", IROpCode.CMP_BGE ">=", IROpCode.CMP_BGE
); );
/** 16-bit（short）比较 */ /* ────── 比较运算符映射 ────── */
/**
* 16-bit（short）比较
*/
public static final Map<String, IROpCode> CMP_S16 = Map.of( public static final Map<String, IROpCode> CMP_S16 = Map.of(
"==", IROpCode.CMP_SEQ, "==", IROpCode.CMP_SEQ,
"!=", IROpCode.CMP_SNE, "!=", IROpCode.CMP_SNE,
"<", IROpCode.CMP_SLT, "<", IROpCode.CMP_SLT,
">", IROpCode.CMP_SGT, ">", IROpCode.CMP_SGT,
"<=", IROpCode.CMP_SLE, "<=", IROpCode.CMP_SLE,
">=", IROpCode.CMP_SGE ">=", IROpCode.CMP_SGE
); );
/**
/** 32-bit（int）比较 */ * 32-bit（int）比较
*/
public static final Map<String, IROpCode> CMP_I32 = Map.of( public static final Map<String, IROpCode> CMP_I32 = Map.of(
"==", IROpCode.CMP_IEQ, "==", IROpCode.CMP_IEQ,
"!=", IROpCode.CMP_INE, "!=", IROpCode.CMP_INE,
"<", IROpCode.CMP_ILT, "<", IROpCode.CMP_ILT,
">", IROpCode.CMP_IGT, ">", IROpCode.CMP_IGT,
"<=", IROpCode.CMP_ILE, "<=", IROpCode.CMP_ILE,
">=", IROpCode.CMP_IGE ">=", IROpCode.CMP_IGE
); );
/**
/** 64-bit（long）比较 */ * 64-bit（long）比较
*/
public static final Map<String, IROpCode> CMP_L64 = Map.of( public static final Map<String, IROpCode> CMP_L64 = Map.of(
"==", IROpCode.CMP_LEQ, "==", IROpCode.CMP_LEQ,
"!=", IROpCode.CMP_LNE, "!=", IROpCode.CMP_LNE,
"<", IROpCode.CMP_LLT, "<", IROpCode.CMP_LLT,
">", IROpCode.CMP_LGT, ">", IROpCode.CMP_LGT,
"<=", IROpCode.CMP_LLE, "<=", IROpCode.CMP_LLE,
">=", IROpCode.CMP_LGE ">=", IROpCode.CMP_LGE
); );
/**
/** 32-bit（float）比较 */ * 32-bit（float）比较
*/
public static final Map<String, IROpCode> CMP_F32 = Map.of( public static final Map<String, IROpCode> CMP_F32 = Map.of(
"==", IROpCode.CMP_FEQ, "==", IROpCode.CMP_FEQ,
"!=", IROpCode.CMP_FNE, "!=", IROpCode.CMP_FNE,
"<", IROpCode.CMP_FLT, "<", IROpCode.CMP_FLT,
">", IROpCode.CMP_FGT, ">", IROpCode.CMP_FGT,
"<=", IROpCode.CMP_FLE, "<=", IROpCode.CMP_FLE,
">=", IROpCode.CMP_FGE ">=", IROpCode.CMP_FGE
); );
/**
/** 64-bit（double）比较 */ * 64-bit（double）比较
*/
public static final Map<String, IROpCode> CMP_D64 = Map.of( public static final Map<String, IROpCode> CMP_D64 = Map.of(
"==", IROpCode.CMP_DEQ, "==", IROpCode.CMP_DEQ,
"!=", IROpCode.CMP_DNE, "!=", IROpCode.CMP_DNE,
"<", IROpCode.CMP_DLT, "<", IROpCode.CMP_DLT,
">", IROpCode.CMP_DGT, ">", IROpCode.CMP_DGT,
"<=", IROpCode.CMP_DLE, "<=", IROpCode.CMP_DLE,
">=", IROpCode.CMP_DGE ">=", IROpCode.CMP_DGE
); );
private IROpCodeMappings() {
} // 禁止实例化
} }