-
- 
+
+ 
@@ -69,6 +69,7 @@ Snow 语言受到 LLM 驱动代码生成趋势的启发,强调简单而清晰的
[https://gitee.com/jcnc-org/snow/releases](https://gitee.com/jcnc-org/snow/releases)
## 相关文档
+[Snow-Lang 语法](docs/Snow-Lang-Syntax/Snow-Lang-Syntax.md)
[Git 管理规范](docs/Snow-Lang-Git-Management/Snow-Lang-Git-Management.md)
diff --git a/docs/Snow-Lang-Syntax/Snow-Lang-Syntax.md b/docs/Snow-Lang-Syntax/Snow-Lang-Syntax.md
new file mode 100644
index 0000000..265b4b1
--- /dev/null
+++ b/docs/Snow-Lang-Syntax/Snow-Lang-Syntax.md
@@ -0,0 +1,260 @@
+# Snow-Lang 语法
+
+## 快速入门
+
+一个简单的 snow 程序
+
+```snow
+module: Main
+ function: main
+ return_type: int
+ body:
+
+ return 1 + 1
+ end body
+ end function
+end module
+```
+
+## 基础
+
+### 注释
+```snow
+// 单行注释
+
+/*
+ 多行注释
+ 多行注释
+ 多行注释
+*/
+```
+
+### 数据类型
+
+bool 类型：
+
+两种值：`true` 和 `false`
+
+
+
+
+数值类型：
+
+| Number | keyword |
+|----------|---------|
+| byte8 | byte |
+| short16 | short |
+| int32 | int |
+| long64 | long |
+| float32 | float |
+| double64 | double |
+
+默认整数的类型为 int，浮点数的类型为 double。
+
+数值字面量后缀：
+
+| 数值字面量后缀 | 例子 |
+|---------|----|
+| b、B | 7b |
+| s、S | 7s |
+| i、I | 7i |
+| l、L | 7l |
+| f、F | 7f |
+| d、D | 7d |
+
+
+### 变量
+定义变量的形式如下，中括号表示可选：
+
+```snow
+declare name: type [= initial_value]
+```
+
+其中 `name` 是变量名，`type` 是变量类型，`initial_value` 是初始值
+
+例：
+
+```snow
+declare x: int
+declare y: long = 123456789
+```
+
+读取变量值的方法，直接写变量的名字即可：
+```snow
+x
+```
+
+设置变量值的方法，先写变量名，后面接 `=`，最后写一个表达式即可：
+```snow
+x = 10
+```
+
+于是可以通过这种方式让变量参与计算并保存结果：
+```snow
+x = y + 1
+```
+读取 `y` 的值加 1 并保存到变量 `x`。
+
+变量只能定义在函数体中、函数参数列表、loop 初始化器中。
+
+## 流程控制
+### if
+if 语句的形式如下，else 是可选的：
+
+```snow
+if condition then
+ // 条件成立执行的代码
+else
+ // 以上条件不成立执行的代码
+end if
+```
+
+condition 可以是表达式（结果为 bool 类型）或者 bool 字面量
+
+例：
+
+```snow
+module: Main
+ function: main
+ return_type: int
+ body:
+ if 5 > 7 then
+ return 5
+ else
+ return 7
+ end if
+
+ return 0
+ end body
+ end function
+end module
+```
+
+### loop
+loop 语句的形式如下：
+```snow
+loop:
+ initializer:
+ // 循环开始前可声明循环变量，有且只能声明一个
+ declare i: int = 1
+ condition:
+ // 循环条件，成立则执行 body 的代码，
+ // 不成立则退出循环，有且只能写一条
+ i <= 100
+ update:
+ // 循环体执行完后执行的代码，有且只能写一条
+ i = i + 1
+ body:
+ // 每次执行的代码写这里
+ end body
+end loop
+```
+
+例子（求 1 ~ 100 的和）：
+```snow
+module: Main
+ function: main
+ return_type: int
+ body:
+ declare sum: int = 0
+ loop:
+ initializer:
+ declare i: int = 1
+ condition:
+ i <= 100
+ update:
+ i = i + 1
+ body:
+ sum = sum + i
+ end body
+ end loop
+
+ return sum
+ end body
+ end function
+end module
+```
+
+## 函数
+函数的形式如下：
+```snow
+function: add
+ parameter:
+ declare a: int
+ declare b: int
+ return_type: int
+ body:
+ return a + b
+ end body
+end function
+```
+其中 add 是函数名，parameter 下面是参数列表（可省略），与变量的定义类似，但是不允许赋初值，
+接着 return_type 设置返回值类型，最后的 body 为函数体。
+
+## 模块
+
+一个模块可以包含多个函数，
+通过 import 语句导入模块，
+snow 会自动将同名模块的函数合并。
+
+在我们最初的例子中，就用了 module 这个关键字。让我们回忆一下：
+
+```snow
+module: Main
+ function: main
+ return_type: int
+ body:
+
+ return 1 + 1
+ end body
+ end function
+end module
+```
+
+可以看到模块名是 Main，里面有函数 main。
+
+假如现在有一个模块 Math，代码如下：
+```snow
+// Math.snow
+module: Math
+ function: add
+ parameter:
+ declare a: int
+ declare b: int
+ return_type: int
+ body:
+ return a + b
+ end body
+ end function
+end module
+```
+
+可以使用 import 来导入 Math 模块：
+```snow
+// main.snow
+module: Main
+ import: Math
+ function: main
+ return_type: int
+ body:
+
+ return Math.add(5, 7)
+ end body
+ end function
+end module
+```
+
+可以同时导入多个模块，用逗号（半角）分隔模块名即可：
+```snow
+// main.snow
+module: Main
+ import: Math, Time
+ function: main
+ return_type: int
+ body:
+
+ return Math.add(5, 7)
+ end body
+ end function
+end module
+```
diff --git a/playground/BugFarm/Bug1/Main.snow b/playground/BugFarm/Bug1/Main.snow
index 4a13b7d..cc9117d 100644
--- a/playground/BugFarm/Bug1/Main.snow
+++ b/playground/BugFarm/Bug1/Main.snow
@@ -1,17 +1,17 @@
module: Main
function: main
- parameter:
return_type: int
body:
- declare n1: int =1
- declare n2: int =2
- declare n3: int =1
- if n1 ==1 then
- if n2 ==2 then
- n3 =3
- end if
- end if
- return n3
+ foo()
+
+ return 0
+ end body
+ end function
+
+ function: foo
+ return_type: void
+ body:
+
end body
end function
end module
\ No newline at end of file
diff --git a/playground/BugFarm/Bug1/README.md b/playground/BugFarm/Bug1/README.md
deleted file mode 100644
index b34d14d..0000000
--- a/playground/BugFarm/Bug1/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-## 编译器输出
-### Snow 源代码
-#### Main.snow
-```snow
-function: main
- return_type: int
- body:
- 3 L
- return 65537
- end body
-end function
-```
\ No newline at end of file
diff --git a/playground/Demo1/Main.snow b/playground/Demo/Demo1/Main.snow
similarity index 100%
rename from playground/Demo1/Main.snow
rename to playground/Demo/Demo1/Main.snow
diff --git a/playground/Demo1/Math.snow b/playground/Demo/Demo1/Math.snow
similarity index 100%
rename from playground/Demo1/Math.snow
rename to playground/Demo/Demo1/Math.snow
diff --git a/playground/Demo10/Main.snow b/playground/Demo/Demo10/Main.snow
similarity index 100%
rename from playground/Demo10/Main.snow
rename to playground/Demo/Demo10/Main.snow
diff --git a/playground/Demo11/Main.snow b/playground/Demo/Demo11/Main.snow
similarity index 100%
rename from playground/Demo11/Main.snow
rename to playground/Demo/Demo11/Main.snow
diff --git a/playground/Demo/Demo12/Main.snow b/playground/Demo/Demo12/Main.snow
new file mode 100644
index 0000000..134096c
--- /dev/null
+++ b/playground/Demo/Demo12/Main.snow
@@ -0,0 +1,21 @@
+module: Main
+ function: main
+ return_type: int
+ body:
+ foo()
+
+ return 0
+ end body
+ end function
+
+ function: foo
+ return_type: int
+ body:
+ if false then
+ return 1
+ end if
+
+ return 0
+ end body
+ end function
+end module
\ No newline at end of file
diff --git a/playground/Demo/Demo13/Main.snow b/playground/Demo/Demo13/Main.snow
new file mode 100644
index 0000000..dee7b5b
--- /dev/null
+++ b/playground/Demo/Demo13/Main.snow
@@ -0,0 +1,69 @@
+module: Main
+ function: main
+ return_type: int
+ body:
+ 5 == 7
+ 5 == 7s
+ 5 == 7b
+ 5 == 7l
+ 5 == 7f
+ 5 == 7d
+
+ 5b == 5b
+ 5b == 5s
+ 5b == 5l
+ 5b == 5f
+ 5b == 5d
+
+ 5s == 5s
+ 5s == 5l
+ 5s == 5f
+ 5s == 5d
+
+ 5l == 5l
+ 5l == 5f
+ 5l == 5d
+
+ 5f == 5f
+ 5f == 5d
+
+ 5d == 5d
+
+ declare b: byte = 8b
+ declare s: short = 8s
+ declare i: int = 8
+ declare l: long = 8l
+ declare f: float = 8f
+ declare d: double = 8d
+
+ b == b
+ b == s
+ b == i
+ b == l
+ b == f
+ b == d
+
+ s == s
+ s == i
+ s == l
+ s == f
+ s == d
+
+ i == i
+ i == l
+ i == f
+ i == d
+
+ l == l
+ l == f
+ l == d
+
+ f == f
+ f == d
+
+ d == d
+
+ return 65537
+ end body
+ end function
+end module
\ No newline at end of file
diff --git a/playground/Demo2/Main.snow b/playground/Demo/Demo2/Main.snow
similarity index 100%
rename from playground/Demo2/Main.snow
rename to playground/Demo/Demo2/Main.snow
diff --git a/playground/Demo3/Main.snow b/playground/Demo/Demo3/Main.snow
similarity index 100%
rename from playground/Demo3/Main.snow
rename to playground/Demo/Demo3/Main.snow
diff --git a/playground/Demo4/Main.snow b/playground/Demo/Demo4/Main.snow
similarity index 100%
rename from playground/Demo4/Main.snow
rename to playground/Demo/Demo4/Main.snow
diff --git a/playground/Demo5/Main.snow b/playground/Demo/Demo5/Main.snow
similarity index 100%
rename from playground/Demo5/Main.snow
rename to playground/Demo/Demo5/Main.snow
diff --git a/playground/Demo6/Main.snow b/playground/Demo/Demo6/Main.snow
similarity index 100%
rename from playground/Demo6/Main.snow
rename to playground/Demo/Demo6/Main.snow
diff --git a/playground/Demo7/Main.snow b/playground/Demo/Demo7/Main.snow
similarity index 100%
rename from playground/Demo7/Main.snow
rename to playground/Demo/Demo7/Main.snow
diff --git a/playground/Demo8/Main.snow b/playground/Demo/Demo8/Main.snow
similarity index 100%
rename from playground/Demo8/Main.snow
rename to playground/Demo/Demo8/Main.snow
diff --git a/playground/Demo9/Main.snow b/playground/Demo/Demo9/Main.snow
similarity index 100%
rename from playground/Demo9/Main.snow
rename to playground/Demo/Demo9/Main.snow
diff --git a/pom.xml b/pom.xml
index 285cc54..2d33298 100644
--- a/pom.xml
+++ b/pom.xml
@@ -7,7 +7,7 @@
- * 步骤如下： - *
-
- *
- 预测返回值类型（采用首个实参槽的类型作为近似） - *
- 为每个参数根据实际类型发出加载指令 - *
- 生成 CALL 调用指令 - *
- 将返回值存储到目标槽，并记录类型信息 - *
* 该类实现了 {@link InstructionGenerator} 接口， * 负责将 IR 中的 {@link IRCompareJumpInstruction}（条件比较并跳转指令） * 转换为目标虚拟机（VM）可执行的指令序列。 *
* - * 主要功能 + * 主要功能 *-
*
- 根据 IR 比较指令左右操作数的类型，自动进行类型提升与转换 *
- 生成相应的 VM 加载、类型转换、比较与跳转指令 @@ -36,85 +37,6 @@ public class CmpJumpGenerator implements InstructionGenerator
- D（double）：6 - *
- F（float）：5 - *
- L（long）：4 - *
- I（int）：3 - *
- S（short）：2 - *
- B（byte）：1 - *
- 未识别类型：0 - *
- 维护在当前作用域中已声明变量的寄存器分配信息； *
- 支持将已有虚拟寄存器与变量名重新绑定； - *
- 根据变量名查找对应的虚拟寄存器实例。 + *
- 根据变量名查找对应的虚拟寄存器实例或类型。 *
- 在函数 IR 构建阶段，调用 {@link #register(String, String)} 方法登记函数名与返回类型。 + *
- 在生成调用指令阶段，通过 {@link #getReturnType(String)} 查询函数的返回类型。 + *
- 返回类型统一为小写；若调用 {@code register} 时传入的返回类型为 {@code null}，则登记为 {@code "void"}。 + *
- Key：函数名（不含模块限定） + *
- Value：返回类型，统一转换为小写字符串；若无返回值则为 {@code "void"} + *
- 字面量后缀：支持 B/S/I/L/F/D（大小写均可） + *
- 浮点数支持：如无后缀但有小数点，视为 double + *
- 变量类型：根据传入变量表推断类型，未识别则默认 int + *
- 字面量常量的解析与类型推断 - *
- 自动匹配算术/比较操作码 - *
- 表达式类型合并与提升 - *
- Pop the top byte8 value from the operand stack. + *
- Convert the byte8 value to a long64 value. + *
- Push the converted long64 value back onto the operand stack for subsequent operations. + *
- Pop the top byte8 value from the operand stack. + *
- Convert the byte8 value to a short16 value. + *
- Push the converted short16 value back onto the operand stack for subsequent operations. + *
- Pop the top double64 value from the operand stack. + *
- Convert the double64 value to a byte8 value (this may involve truncation). + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. + *
- Push the converted float32 value back onto the operand stack for subsequent operations. * * - *
- Push the converted int32 value back onto the operand stack for subsequent operations. * * - *
- Push the converted long64 value back onto the operand stack for subsequent operations. * * - *
- Pop the top double64 value from the operand stack. + *
- Convert the double64 value to a short16 value (this may involve truncation). + *
- Push the converted short16 value back onto the operand stack for subsequent operations. + *
- Pop the top float32 value from the operand stack. + *
- Convert the float32 value to a byte8 value (this may involve truncation). + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. + *
- Push the converted double64 value back onto the operand stack for subsequent operations. * * - *
- Push the converted int32 value back onto the operand stack for subsequent operations. * * - *
- Push the converted long64 value back onto the operand stack for subsequent operations. * * - *
- Pop the top float32 value from the operand stack. + *
- Convert the float32 value to a short16 value (this may involve truncation). + *
- Push the converted short16 value back onto the operand stack for subsequent operations. + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. * * - *
- Push the converted double64 value back onto the operand stack for subsequent operations. * * - *
- Push the converted float32 value back onto the operand stack for subsequent operations. * * - *
- Push the converted long64 value back onto the operand stack for subsequent operations. * * - *
- Push the converted short16 value back onto the operand stack for subsequent operations. * * - *
- Pop the top long64 value from the operand stack. + *
- Convert the long64 value to a byte8 value. + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. + *
- Push the converted double64 value back onto the operand stack for subsequent operations. * * - *
- Push the converted float32 value back onto the operand stack for subsequent operations. * * - *
- Push the converted int32 value back onto the operand stack for subsequent operations. * * - *
- Pop the top long64 value from the operand stack. + *
- Convert the long64 value to a short16 value. + *
- Push the converted short16 value back onto the operand stack for subsequent operations. + *
- Pop the top short16 value from the operand stack. + *
- Convert the short16 value to a byte8 value. + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. + *
- Pop the top short16 value from the operand stack. + *
- Convert the short16 value to a double64 value. + *
- Push the converted double64 value back onto the operand stack for subsequent operations. + *
- Pop the top short16 value from the operand stack. + *
- Convert the short16 value to a float32 value. + *
- Push the converted float32 value back onto the operand stack for subsequent operations. + *
- Push the converted int32 value back onto the operand stack for subsequent operations. * * - *
- Pop the top short16 value from the operand stack. + *
- Convert the short16 value to a long64 value. + *
- Push the converted long64 value back onto the operand stack for subsequent operations. + *
- Pop the top int32 value from the operand stack. - *
- Convert the int32 value to a long64 value. - *
- Push the converted long64 value back onto the operand stack for subsequent operations. - *
- Pop the top int32 value from the operand stack. - *
- Convert the int32 value to a short16 value (this may involve truncation). + *
- Pop the top byte8 value from the operand stack. + *
- Convert the byte8 value to a short16 value. *
- Push the converted short16 value back onto the operand stack for subsequent operations. *
- Pop the top int32 value from the operand stack. - *
- Convert the int32 value to a byte8 value (this may involve truncation). - *
- Push the converted byte8 value back onto the operand stack for subsequent operations. - *
- Pop the top int32 value from the operand stack. - *
- Convert the int32 value to a double64 value. - *
- Push the converted double64 value back onto the operand stack for subsequent operations. - *
- Pop the top int32 value from the operand stack. - *
- Convert the int32 value to a float32 value. - *
- Push the converted float32 value back onto the operand stack for subsequent operations. - *
- Pop the top long64 value from the operand stack. - *
- Convert the long64 value to an int32 value (this may involve truncation). - *
- Push the converted int32 value back onto the operand stack for subsequent operations. - *
- Pop the top long64 value from the operand stack. - *
- Convert the long64 value to a double64 value. - *
- Push the converted double64 value back onto the operand stack for subsequent operations. - *
- Pop the top long64 value from the operand stack. - *
- Convert the long64 value to a float32 value. - *
- Push the converted float32 value back onto the operand stack for subsequent operations. - *
- Pop the top float32 value from the operand stack. - *
- Convert the float32 value to an int32 value (this may involve truncation). - *
- Push the converted int32 value back onto the operand stack for subsequent operations. - *
- Pop the top float32 value from the operand stack. - *
- Convert the float32 value to a long64 value. - *
- Push the converted long64 value back onto the operand stack for subsequent operations. - *
- Pop the top float32 value from the operand stack. - *
- Convert the float32 value to a double64 value. - *
- Push the converted double64 value back onto the operand stack for subsequent operations. - *
- Pop the top double64 value from the operand stack. - *
- Convert the double64 value to an int32 value (this may involve truncation). - *
- Push the converted int32 value back onto the operand stack for subsequent operations. - *
- Pop the top double64 value from the operand stack. - *
- Convert the double64 value to a long64 value (this may involve truncation). - *
- Push the converted long64 value back onto the operand stack for subsequent operations. - *
- Pop the top double64 value from the operand stack. - *
- Convert the double64 value to a float32 value. - *
- Push the converted float32 value back onto the operand stack for subsequent operations. - *
- Pop the top short16 value from the operand stack. - *
- Convert the short16 value to an int32 value. - *
- Push the converted int32 value back onto the operand stack for subsequent operations. - *
- Push the converted int32 value back onto the operand stack for subsequent operations. * * - *
- Pop the top byte8 value from the operand stack. + *
- Convert the byte8 value to a long64 value. + *
- Push the converted long64 value back onto the operand stack for subsequent operations. + *
- Pop the top byte8 value from the operand stack. + *
- Convert the byte8 value to a float32 value. + *
- Push the converted float32 value back onto the operand stack for subsequent operations. + *
- Pop the top byte8 value from the operand stack. + *
- Convert the byte8 value to a double64 value. + *
- Push the converted double64 value back onto the operand stack for subsequent operations. + *
- Pop the top short16 value from the operand stack. + *
- Convert the short16 value to a byte8 value (this may involve truncation). + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. + *
- Pop the top short16 value from the operand stack. + *
- Convert the short16 value to an int32 value. + *
- Push the converted int32 value back onto the operand stack for subsequent operations. + *
- Pop the top short16 value from the operand stack. + *
- Convert the short16 value to a long64 value. + *
- Push the converted long64 value back onto the operand stack for subsequent operations. + *
- Pop the top short16 value from the operand stack. + *
- Convert the short16 value to a float32 value. + *
- Push the converted float32 value back onto the operand stack for subsequent operations. + *
- Pop the top short16 value from the operand stack. + *
- Convert the short16 value to a double64 value. + *
- Push the converted double64 value back onto the operand stack for subsequent operations. + *
- Pop the top int32 value from the operand stack. + *
- Convert the int32 value to a byte8 value (this may involve truncation). + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. + *
- Pop the top int32 value from the operand stack. + *
- Convert the int32 value to a short16 value (this may involve truncation). + *
- Push the converted short16 value back onto the operand stack for subsequent operations. + *
- Pop the top int32 value from the operand stack. + *
- Convert the int32 value to a long64 value. + *
- Push the converted long64 value back onto the operand stack for subsequent operations. + *
- Pop the top int32 value from the operand stack. + *
- Convert the int32 value to a float32 value. + *
- Push the converted float32 value back onto the operand stack for subsequent operations. + *
- Pop the top int32 value from the operand stack. + *
- Convert the int32 value to a double64 value. + *
- Push the converted double64 value back onto the operand stack for subsequent operations. + *
- Pop the top long64 value from the operand stack. + *
- Convert the long64 value to a byte8 value (this may involve truncation). + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. + *
- Pop the top long64 value from the operand stack. + *
- Convert the long64 value to a short16 value (this may involve truncation). + *
- Push the converted short16 value back onto the operand stack for subsequent operations. + *
- Pop the top long64 value from the operand stack. + *
- Convert the long64 value to an int32 value (this may involve truncation). + *
- Push the converted int32 value back onto the operand stack for subsequent operations. + *
- Pop the top long64 value from the operand stack. + *
- Convert the long64 value to a float32 value. + *
- Push the converted float32 value back onto the operand stack for subsequent operations. + *
- Pop the top long64 value from the operand stack. + *
- Convert the long64 value to a double64 value. + *
- Push the converted double64 value back onto the operand stack for subsequent operations. + *
- Pop the top float32 value from the operand stack. + *
- Convert the float32 value to a byte8 value (this may involve truncation). + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. + *
- Pop the top float32 value from the operand stack. + *
- Convert the float32 value to a short16 value (this may involve truncation). + *
- Push the converted short16 value back onto the operand stack for subsequent operations. + *
- Pop the top float32 value from the operand stack. + *
- Convert the float32 value to an int32 value (this may involve truncation). + *
- Push the converted int32 value back onto the operand stack for subsequent operations. + *
- Pop the top float32 value from the operand stack. + *
- Convert the float32 value to a long64 value. + *
- Push the converted long64 value back onto the operand stack for subsequent operations. + *
- Pop the top float32 value from the operand stack. + *
- Convert the float32 value to a double64 value. + *
- Push the converted double64 value back onto the operand stack for subsequent operations. + *
- Pop the top double64 value from the operand stack. + *
- Convert the double64 value to a byte8 value (this may involve truncation). + *
- Push the converted byte8 value back onto the operand stack for subsequent operations. + *
- Pop the top double64 value from the operand stack. + *
- Convert the double64 value to a short16 value (this may involve truncation). + *
- Push the converted short16 value back onto the operand stack for subsequent operations. + *
- Pop the top double64 value from the operand stack. + *
- Convert the double64 value to an int32 value (this may involve truncation). + *
- Push the converted int32 value back onto the operand stack for subsequent operations. + *
- Pop the top double64 value from the operand stack. + *
- Convert the double64 value to a long64 value (this may involve truncation). + *
- Push the converted long64 value back onto the operand stack for subsequent operations. + *
- Pop the top double64 value from the operand stack. + *
- Convert the double64 value to a float32 value. + *
- Push the converted float32 value back onto the operand stack for subsequent operations. + *
-
- *
- * 仅覆盖目前常见的整数与浮点类型提升与转换，后续有新类型可补充。 - *
- * - * @param from 源类型标记字符 - * @param to 目标类型标记字符 - * @return 转换指令名，如“L2I”；无转换返回 {@code null} - */ - private static String convert(char from, char to) { - if (from == to) return null; - return switch ("" + from + to) { - case "IL" -> "I2L"; - case "ID" -> "I2D"; - case "IF" -> "I2F"; - case "LI" -> "L2I"; - case "LD" -> "L2D"; - case "LF" -> "L2F"; - case "FI" -> "F2I"; - case "FL" -> "F2L"; - case "FD" -> "F2D"; - case "DI" -> "D2I"; - case "DL" -> "D2L"; - case "DF" -> "D2F"; - case "SI" -> "S2I"; - case "BI" -> "B2I"; - default -> null; - }; - } - /** * 生成 IR 条件比较跳转指令的 VM 指令序列。 *-
@@ -138,21 +60,21 @@ public class CmpJumpGenerator implements InstructionGenerator
+ * 在进行数值类型运算、比较等操作时，低优先级的类型会被提升为高优先级类型参与运算。 + * 例如 int + long 运算，int 会被提升为 long，最终运算结果类型为 long。 + *
+ * 类型优先级从高到低依次为： + * D（double）：6 + * F（float） ：5 + * L（long） ：4 + * I（int） ：3 + * S（short） ：2 + * B（byte） ：1 + * 未识别类型 ：0 + */ +public class TypePromoteUtils { + + /** + * 返回数值类型的宽度优先级，数值越大类型越宽。 + * 类型及优先级映射如下： + * D（double）: 6 + * F（float） : 5 + * L（long） : 4 + * I（int） : 3 + * S（short） : 2 + * B（byte） : 1 + * 未知类型 : 0 + * + * @param p 类型标记字符（B/S/I/L/F/D） + * @return 优先级数值（0 表示未知类型） + */ + private static int rank(char p) { + return switch (p) { + case 'D' -> 6; + case 'F' -> 5; + case 'L' -> 4; + case 'I' -> 3; + case 'S' -> 2; + case 'B' -> 1; + default -> 0; + }; + } + + /** + * 返回两个类型中较“宽”的公共类型（即优先级较高的类型）。 + * 若优先级相等，返回第一个参数的类型。 + * + * @param a 类型标记字符1 + * @param b 类型标记字符2 + * @return 优先级较高的类型标记字符 + */ + public static char promote(char a, char b) { + return rank(a) >= rank(b) ? a : b; + } + + /** + * 将单个字符的类型标记转为字符串。 + * + * @param p 类型标记字符 + * @return 类型标记的字符串形式 + */ + public static String str(char p) { + return String.valueOf(p); + } + + /** + * 获取类型转换指令名（例如 "I2L", "F2D"），表示从源类型到目标类型的转换操作。 + * 如果源类型和目标类型相同，则返回 null，表示无需转换。 + *
+ * 支持的类型标记字符包括：B（byte）、S（short）、I（int）、L（long）、F（float）、D（double）。 + * 所有可能的类型转换均已覆盖，如下所示： + * B → S/I/L/F/D + * S → B/I/L/F/D + * I → B/S/L/F/D + * L → B/S/I/F/D + * F → B/S/I/L/D + * D → B/S/I/L/F + * + * @param from 源类型标记字符 + * @param to 目标类型标记字符 + * @return 类型转换指令名（如 "L2I"），如无须转换则返回 null + */ + public static String convert(char from, char to) { + if (from == to) return null; + return switch ("" + from + to) { + case "BS" -> "B2S"; + case "BI" -> "B2I"; + case "BL" -> "B2L"; + case "BF" -> "B2F"; + case "BD" -> "B2D"; + + case "SB" -> "S2B"; + case "SI" -> "S2I"; + case "SL" -> "S2L"; + case "SF" -> "S2F"; + case "SD" -> "S2D"; + + case "IB" -> "I2B"; + case "IS" -> "I2S"; + case "IL" -> "I2L"; + case "IF" -> "I2F"; + case "ID" -> "I2D"; + + case "LB" -> "L2B"; + case "LS" -> "L2S"; + case "LI" -> "L2I"; + case "LF" -> "L2F"; + case "LD" -> "L2D"; + + case "FB" -> "F2B"; + case "FS" -> "F2S"; + case "FI" -> "F2I"; + case "FL" -> "F2L"; + case "FD" -> "F2D"; + + case "DB" -> "D2B"; + case "DS" -> "D2S"; + case "DI" -> "D2I"; + case "DL" -> "D2L"; + case "DF" -> "D2F"; + default -> null; + }; + } +} diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java index f53d8cc..bb8c32e 100644 --- a/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java +++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java @@ -145,7 +145,7 @@ public record ExpressionBuilder(IRContext ctx) { if (ComparisonUtils.isComparisonOperator(op)) { return InstructionFactory.binOp( ctx, - ComparisonUtils.cmpOp(op, bin.left(), bin.right()), + ComparisonUtils.cmpOp(ctx.getScope().getVarTypes(), op, bin.left(), bin.right()), left, right); } @@ -171,7 +171,7 @@ public record ExpressionBuilder(IRContext ctx) { if (ComparisonUtils.isComparisonOperator(op)) { InstructionFactory.binOpInto( ctx, - ComparisonUtils.cmpOp(op, bin.left(), bin.right()), + ComparisonUtils.cmpOp(ctx.getScope().getVarTypes(), op, bin.left(), bin.right()), a, b, dest); } else { IROpCode code = ExpressionUtils.resolveOpCode(op, bin.left(), bin.right()); diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java index 48b10e7..c9f4fd5 100644 --- a/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java +++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java @@ -1,5 +1,6 @@ package org.jcnc.snow.compiler.ir.builder; +import org.jcnc.snow.compiler.ir.common.GlobalFunctionTable; import org.jcnc.snow.compiler.ir.core.IRFunction; import org.jcnc.snow.compiler.ir.utils.ExpressionUtils; import org.jcnc.snow.compiler.ir.value.IRVirtualRegister; @@ -32,6 +33,10 @@ public class FunctionBuilder { */ public IRFunction build(FunctionNode functionNode) { + // 在全局函数表中注册函数信息 + GlobalFunctionTable.register(functionNode.name(), functionNode.returnType()); + + // 0) 基本初始化：创建 IRFunction 实例与对应上下文 IRFunction irFunction = new IRFunction(functionNode.name()); IRContext irContext = new IRContext(irFunction); diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java index e0fd4cf..3cd5deb 100644 --- a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java +++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java @@ -13,7 +13,7 @@ import java.util.Map; *
-
*
+ * 此工具类用于在编译前端构建每个函数 IR（中间表示）时登记函数的返回类型， + * 以便后端在生成 {@code CALL} 指令时判断是否需要保存返回值。 + *
+ * + * 使用说明 + *-
+ *
-
+ *
若传入的 {@code returnType} 为 {@code null}，则登记为 {@code "void"}。 + * 否则将去除前后空白并转换为小写后登记。
+ * + * @param name 函数名（不含模块限定） + * @param returnType 函数返回类型字符串，如 {@code "int"}、{@code "String"}。 + * 如果为 {@code null}，则登记类型为 {@code "void"}。 + * @throws IllegalArgumentException 如果 {@code name} 为空或 {@code null} + */ + public static void register(String name, String returnType) { + if (name == null || name.trim().isEmpty()) { + throw new IllegalArgumentException("函数名不能为空或 null"); + } + RETURN_TYPES.put( + name, + returnType == null + ? "void" + : returnType.trim().toLowerCase() + ); + } + + /** + * 查询指定函数的返回类型。 + * + *返回类型为登记时的值（小写），如果函数未登记过，则返回 {@code null}。
+ * + * @param name 函数名（不含模块限定） + * @return 已登记的返回类型（小写），或 {@code null} 表示未知 + * @throws IllegalArgumentException 如果 {@code name} 为空或 {@code null} + */ + public static String getReturnType(String name) { + if (name == null || name.trim().isEmpty()) { + throw new IllegalArgumentException("函数名不能为空或 null"); + } + return RETURN_TYPES.get(name); + } +} diff --git a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java index c45a454..1e6b3e7 100644 --- a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java +++ b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java @@ -66,21 +66,53 @@ public enum IROpCode { DIV_D64, // 64位浮点除法 NEG_D64, // 64位浮点取负 + /* ───── 逻辑与比较运算指令（8位整数：byte） ───── */ + CMP_BEQ, // 8位整数相等比较：a == b + CMP_BNE, // 8位整数不等比较：a != b + CMP_BLT, // 8位整数小于比较：a < b + CMP_BGT, // 8位整数大于比较：a > b + CMP_BLE, // 8位整数小于等于：a <= b + CMP_BGE, // 8位整数大于等于：a >= b + + /* ───── 逻辑与比较运算指令（16位整数：int） ───── */ + CMP_SEQ, // 16位整数相等比较：a == b + CMP_SNE, // 16位整数不等比较：a != b + CMP_SLT, // 16位整数小于比较：a < b + CMP_SGT, // 16位整数大于比较：a > b + CMP_SLE, // 16位整数小于等于：a <= b + CMP_SGE, // 16位整数大于等于：a >= b + /* ───── 逻辑与比较运算指令（32位整数：int） ───── */ - CMP_IEQ, // 32位相等比较：a == b - CMP_INE, // 32位不等比较：a != b - CMP_ILT, // 32位小于比较：a < b - CMP_IGT, // 32位大于比较：a > b - CMP_ILE, // 32位小于等于：a <= b - CMP_IGE, // 32位大于等于：a >= b + CMP_IEQ, // 32位整数相等比较：a == b + CMP_INE, // 32位整数不等比较：a != b + CMP_ILT, // 32位整数小于比较：a < b + CMP_IGT, // 32位整数大于比较：a > b + CMP_ILE, // 32位整数小于等于：a <= b + CMP_IGE, // 32位整数大于等于：a >= b /* ───── 逻辑与比较运算指令（64位整数：long） ───── */ - CMP_LEQ, // 64位相等比较：a == b - CMP_LNE, // 64位不等比较：a != b - CMP_LLT, // 64位小于比较：a < b - CMP_LGT, // 64位大于比较：a > b - CMP_LLE, // 64位小于等于：a <= b - CMP_LGE, // 64位大于等于：a >= b + CMP_LEQ, // 64位整数相等比较：a == b + CMP_LNE, // 64位整数不等比较：a != b + CMP_LLT, // 64位整数小于比较：a < b + CMP_LGT, // 64位整数大于比较：a > b + CMP_LLE, // 64位整数小于等于：a <= b + CMP_LGE, // 64位整数大于等于：a >= b + + /* ───── 逻辑与比较运算指令（32位浮点数：float） ───── */ + CMP_FEQ, // 32位浮点相等比较：a == b + CMP_FNE, // 32位浮点不等比较：a != b + CMP_FLT, // 32位浮点小于比较：a < b + CMP_FGT, // 32位浮点大于比较：a > b + CMP_FLE, // 32位浮点小于等于：a <= b + CMP_FGE, // 32位浮点大于等于：a >= b + + /* ───── 逻辑与比较运算指令（64位浮点数：double） ───── */ + CMP_DEQ, // 64位浮点相等比较：a == b + CMP_DNE, // 64位浮点不等比较：a != b + CMP_DLT, // 64位浮点小于比较：a < b + CMP_DGT, // 64位浮点大于比较：a > b + CMP_DLE, // 64位浮点小于等于：a <= b + CMP_DGE, // 64位浮点大于等于：a >= b /* ───── 数据访问与常量操作 ───── */ LOAD, // 从内存加载数据至寄存器 diff --git a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java index 32593d9..92677a6 100644 --- a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java +++ b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java @@ -40,6 +40,26 @@ public final class IROpCodeMappings { ); /* ────── 比较运算符映射 ────── */ + /** 8-bit（byte）比较 */ + public static final Map+ * dest = CALL foo, arg1, arg2, ... + *+ * 若被调函数返回 void，则 {@code dest} 可以为 {@code null}， + * 并且不会参与寄存器分配。 */ public class CallInstruction extends IRInstruction { + /** 调用结果目标寄存器；void 返回时可为 null */ private final IRVirtualRegister dest; + /** 被调用的函数名（含模块限定） */ private final String functionName; + /** 实参列表 */ private final List
L/l 判定）选择
- * 正确的 IR 比较指令，保证 int/long 均能正常运行。
+ * 工具类，用于比较运算相关的类型推断和指令选择。
+ * + * 该类主要用于根据左右操作数的静态类型，自动选择正确的 IR 层比较操作码。 + * 支持自动类型提升，保证 int、long、float、double 等类型的比较均能得到正确的 IR 指令。 + *
+ * + * 类型判定支持： + *-
+ *
主要功能：
- *-
- *
+ * 主要功能：
+ * - 解析字面量常量，自动推断类型
+ * - 自动匹配并选择适合的算术/比较操作码
+ * - 表达式类型的合并与类型提升
+ * - 支持线程隔离的函数级默认类型后缀
*/
public final class ExpressionUtils {
private ExpressionUtils() {}
- /* ────────────────── 线程级默认类型后缀 ────────────────── */
+ // ───────────── 线程级默认类型后缀 ─────────────
- /** 默认类型后缀（如当前函数返回类型），线程隔离。 */
+ /**
+ * 当前线程的默认类型后缀（如当前函数返回类型等），用于类型推断兜底。
+ */
private static final ThreadLocal
+ * 支持的字面量后缀有 b/s/l/f/d（大小写均可）。
+ * 无后缀时，优先参考 IRContext 当前变量类型，否则根据字面量格式（含'.'或'e'等）判断为 double，否则为 int。
+ *
+ * @param ctx IRContext，允许参考变量声明类型
+ * @param value 数字字面量字符串
+ * @return 对应类型的 IRConstant 常量
*/
public static IRConstant buildNumberConstant(IRContext ctx, String value) {
char suffix = value.isEmpty() ? '\0'
@@ -55,7 +75,7 @@ public final class ExpressionUtils {
String digits = switch (suffix) {
case 'b','s','l','f','d' -> value.substring(0, value.length() - 1);
default -> {
- /* 如果字面量本身没有后缀，则回退到变量目标类型（如声明语句左值） */
+ // 无后缀，优先参考变量类型
if (ctx.getVarType() != null) {
String t = ctx.getVarType();
suffix = switch (t) {
@@ -72,7 +92,7 @@ public final class ExpressionUtils {
}
};
- /* 创建常量 */
+ // 生成常量对象
return switch (suffix) {
case 'b' -> new IRConstant(Byte.parseByte(digits));
case 's' -> new IRConstant(Short.parseShort(digits));
@@ -85,10 +105,13 @@ public final class ExpressionUtils {
};
}
- /* ────────────────────── 一元运算 ────────────────────── */
+ // ───────────── 一元运算指令匹配 ─────────────
/**
- * 推断一元取负（-）运算应使用的 {@link IROpCode}。
+ * 根据表达式节点的类型后缀，选择对应的取负（-）运算操作码。
+ *
+ * @param operand 操作数表达式
+ * @return 匹配类型的 IROpCode
*/
public static IROpCode negOp(ExpressionNode operand) {
char t = typeChar(operand);
@@ -98,36 +121,56 @@ public final class ExpressionUtils {
case 'l' -> IROpCode.NEG_L64;
case 'f' -> IROpCode.NEG_F32;
case 'd' -> IROpCode.NEG_D64;
- default -> IROpCode.NEG_I32; // '\0' 或 'i'
+ default -> IROpCode.NEG_I32; // 无法推断或为 int
};
}
- /* ────────────────── 比较运算（已适配 long） ────────────────── */
+ // ───────────── 比较运算相关 ─────────────
- /** 判断给定字符串是否是比较运算符（==, !=, <, >, <=, >=）。 */
+ /**
+ * 判断给定字符串是否为支持的比较运算符（==, !=, <, >, <=, >=）。
+ *
+ * @param op 操作符字符串
+ * @return 若为比较运算符返回 true，否则返回 false
+ */
public static boolean isComparisonOperator(String op) {
return ComparisonUtils.isComparisonOperator(op);
}
/**
- * 兼容旧调用：仅凭操作符返回 int32 比较指令。
+ * 兼容旧逻辑：仅凭操作符直接返回 int32 比较指令。
+ *
+ * @param op 比较操作符
+ * @return int32 类型的比较操作码
*/
public static IROpCode cmpOp(String op) {
- return IROpCodeMappings.CMP_I32.get(op); // 旧逻辑：一律 i32
+ return IROpCodeMappings.CMP_I32.get(op);
}
/**
- * 推荐调用：根据左右表达式类型自动选择 int / long 比较指令。
+ * 推荐调用：根据左右表达式类型自动选择 int/long/float/double 等合适的比较操作码。
+ *
+ * @param variables 变量名到类型的映射
+ * @param op 比较符号
+ * @param left 左操作数表达式
+ * @param right 右操作数表达式
+ * @return 匹配类型的比较操作码
*/
- public static IROpCode cmpOp(String op, ExpressionNode left, ExpressionNode right) {
- return ComparisonUtils.cmpOp(op, left, right);
+ public static IROpCode cmpOp(Map
+ * 类型推断优先使用左右表达式的类型后缀，推断失败时回退为线程级默认类型后缀，再失败则默认为 int32。
+ *
+ * @param op 算术操作符
+ * @param left 左表达式
+ * @param right 右表达式
+ * @return 匹配类型的 IROpCode
*/
public static IROpCode resolveOpCode(String op,
ExpressionNode left,
ExpressionNode right) {
-
- /* 1. 尝试根据字面量推断 */
+ // 1. 优先根据表达式类型推断
char suffix = resolveSuffix(left, right);
-
- /* 2. 若失败则使用函数级默认类型 */
+ // 2. 推断失败则使用线程默认类型
if (suffix == '\0') suffix = DEFAULT_SUFFIX.get();
-
- /* 3. 仍失败则默认为 int32 */
+ // 3. 仍失败则默认为 int32
Map
- * 示例语法结构： - *
- *{@code
- * if (x > 0) {
- * print("Positive");
- * } else {
- * print("Negative");
- * }
- * }
*
* @param condition 控制分支执行的条件表达式
* @param thenBranch 条件为 true 时执行的语句块
* @param elseBranch 条件为 false 时执行的语句块（可为空）
- * @param line 当前节点所在的行号
- * @param column 当前节点所在的列号
- * @param file 当前节点所在的文件
+ * @param context 节点上下文信息（包含行号、列号等）
*/
public record IfNode(
ExpressionNode condition,
ListThis opcode is used to widen a byte8 value to an int32 type to ensure compatibility with integer-based operations.
+ *This opcode is used to widen a byte8 value to an int32 type.
*/ public class B2ICommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/B2LCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/B2LCommand.java new file mode 100644 index 0000000..3bcff86 --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/B2LCommand.java @@ -0,0 +1,47 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * B2LCommand Opcode: Represents the type conversion operation from byte8 to long64 in the virtual machine. + *This opcode is implemented by the {@link B2LCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a byte8 value to a long64 type.
+ */ +public class B2LCommand implements Command { + + /** + * Default constructor for creating an instance of B2LCommand. + */ + public B2LCommand() { + // Empty constructor + } + + /** + * Executes the byte8 to long64 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + long convertedValue = (byte) operandStack.pop(); + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/B2SCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/B2SCommand.java new file mode 100644 index 0000000..167d318 --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/B2SCommand.java @@ -0,0 +1,47 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * B2SCommand Opcode: Represents the type conversion operation from byte8 to short16 in the virtual machine. + *This opcode is implemented by the {@link B2SCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a byte8 value to a short16 type.
+ */ +public class B2SCommand implements Command { + + /** + * Default constructor for creating an instance of B2SCommand. + */ + public B2SCommand() { + // Empty constructor + } + + /** + * Executes the byte8 to short16 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + short convertedValue = (byte) operandStack.pop(); + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2BCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2BCommand.java new file mode 100644 index 0000000..8106ae8 --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2BCommand.java @@ -0,0 +1,48 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * D2BCommand Opcode: Represents the type conversion operation from double64 to byte8 in the virtual machine. + *This opcode is implemented by the {@link D2BCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a double64 value to a byte8 type.
+ */ +public class D2BCommand implements Command { + + /** + * Default constructor for creating an instance of D2BCommand. + */ + public D2BCommand() { + // Empty constructor + } + + /** + * Executes the double64 to byte8 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + double value = (double) operandStack.pop(); + byte convertedValue = (byte) value; + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2FCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2FCommand.java index 7f4bcc0..49d14eb 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2FCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2FCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to narrow a double64 value to a float32 type when lower precision floating-point arithmetic is acceptable.
+ *This opcode is used to narrow a double64 value to a float32 type.
*/ public class D2FCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2ICommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2ICommand.java index 903f6dc..b99dd0a 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2ICommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2ICommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to narrow a double64 value to an int32 type for further integer-based operations.
+ *This opcode is used to narrow a double64 value to an int32 type.
*/ public class D2ICommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2LCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2LCommand.java index 78d558a..c825d09 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2LCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2LCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to narrow a double64 value to a long64 type, which can then be used for integer operations.
+ *This opcode is used to narrow a double64 value to a long64 type.
*/ public class D2LCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2SCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2SCommand.java new file mode 100644 index 0000000..49da2f1 --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2SCommand.java @@ -0,0 +1,48 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * D2SCommand Opcode: Represents the type conversion operation from double64 to short16 in the virtual machine. + *This opcode is implemented by the {@link D2SCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a double64 value to a short16 type.
+ */ +public class D2SCommand implements Command { + + /** + * Default constructor for creating an instance of D2SCommand. + */ + public D2SCommand() { + // Empty constructor + } + + /** + * Executes the double64 to short16 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + double value = (double) operandStack.pop(); + short convertedValue = (short) value; + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2BCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2BCommand.java new file mode 100644 index 0000000..3277271 --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2BCommand.java @@ -0,0 +1,48 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * F2BCommand Opcode: Represents the type conversion operation from float32 to byte8 in the virtual machine. + *This opcode is implemented by the {@link F2BCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to convert a float32 value to a byte8 type.
+ */ +public class F2BCommand implements Command { + + /** + * Default constructor for creating an instance of F2BCommand. + */ + public F2BCommand() { + // Empty constructor + } + + /** + * Executes the float32 to byte8 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + float value = (float) operandStack.pop(); + byte convertedValue = (byte) value; + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2DCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2DCommand.java index 7f4dba7..88c1075 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2DCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2DCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to promote a float32 value to a double64 type, thereby increasing precision for floating-point computations.
+ *This opcode is used to promote a float32 value to a double64 type.
*/ public class F2DCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2ICommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2ICommand.java index 24f9192..ced0b27 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2ICommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2ICommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to convert a float32 value to an int32 type for further integer operations or comparisons.
+ *This opcode is used to convert a float32 value to an int32 type.
*/ public class F2ICommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2LCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2LCommand.java index b4bcb6b..5471c14 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2LCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2LCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to widen a float32 value to a long64 type for operations requiring a larger numeric range.
+ *This opcode is used to widen a float32 value to a long64 type.
*/ public class F2LCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2SCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2SCommand.java new file mode 100644 index 0000000..312c828 --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2SCommand.java @@ -0,0 +1,48 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * F2SCommand Opcode: Represents the type conversion operation from float32 to short16 in the virtual machine. + *This opcode is implemented by the {@link F2SCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to convert a float32 value to a short16 type.
+ */ +public class F2SCommand implements Command { + + /** + * Default constructor for creating an instance of F2SCommand. + */ + public F2SCommand() { + // Empty constructor + } + + /** + * Executes the float32 to short16 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + float value = (float) operandStack.pop(); + short convertedValue = (short) value; + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2BCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2BCommand.java index 76ef29c..3ab1503 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2BCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2BCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to narrow an int32 value to a byte8 type when a smaller numeric representation is required.
+ *This opcode is used to narrow an int32 value to a byte8 type.
*/ public class I2BCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2DCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2DCommand.java index 0147f5b..07a3c9b 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2DCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2DCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to widen an int32 value to a double64 type, providing high-precision floating-point calculations.
+ *This opcode is used to widen an int32 value to a double64 type.
*/ public class I2DCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2FCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2FCommand.java index 22182dc..6b85e06 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2FCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2FCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to convert an int32 value to a float32 type when floating-point arithmetic is required.
+ *This opcode is used to convert an int32 value to a float32 type.
*/ public class I2FCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2LCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2LCommand.java index a9d1aae..069fc52 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2LCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2LCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is commonly used to widen an int32 value to a long64 type to accommodate larger numeric ranges.
+ *This opcode is commonly used to widen an int32 value to a long64 type.
*/ public class I2LCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2SCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2SCommand.java index ca5987a..b948a8d 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2SCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2SCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is typically used to narrow an int32 value to a short16 type when a smaller data representation is required.
+ *This opcode is typically used to narrow an int32 value to a short16 type.
*/ public class I2SCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2BCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2BCommand.java new file mode 100644 index 0000000..b005ca2 --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2BCommand.java @@ -0,0 +1,48 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * L2BCommand Opcode: Represents the type conversion operation from long64 to byte8 in the virtual machine. + *This opcode is implemented by the {@link L2BCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a long64 value to a byte8 type.
+ */ +public class L2BCommand implements Command { + + /** + * Default constructor for creating an instance of L2BCommand. + */ + public L2BCommand() { + // Empty constructor + } + + /** + * Executes the long64 to byte8 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + long value = (long) operandStack.pop(); + byte convertedValue = (byte) value; + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2DCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2DCommand.java index 06426ae..2fd9a21 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2DCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2DCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to widen a long64 value to a double64 type for high-precision floating-point computations.
+ *This opcode is used to widen a long64 value to a double64 type.
*/ public class L2DCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2FCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2FCommand.java index 5cf6a67..b790255 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2FCommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2FCommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to convert a long64 value to a float32 type, typically for floating-point arithmetic involving long values.
+ *This opcode is used to convert a long64 value to a float32 type.
*/ public class L2FCommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2ICommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2ICommand.java index f4f4b41..b96442d 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2ICommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2ICommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is typically used to narrow a long64 value to an int32 type for further integer operations.
+ *This opcode is typically used to narrow a long64 value to an int32 typ.
*/ public class L2ICommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2SCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2SCommand.java new file mode 100644 index 0000000..70c5e2a --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2SCommand.java @@ -0,0 +1,48 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * L2SCommand Opcode: Represents the type conversion operation from long64 to short16 in the virtual machine. + *This opcode is implemented by the {@link L2SCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a long64 value to a short16 type.
+ */ +public class L2SCommand implements Command { + + /** + * Default constructor for creating an instance of L2SCommand. + */ + public L2SCommand() { + // Empty constructor + } + + /** + * Executes the long64 to short16 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + long value = (long) operandStack.pop(); + short convertedValue = (short) value; + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2BCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2BCommand.java new file mode 100644 index 0000000..159504f --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2BCommand.java @@ -0,0 +1,48 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * S2BCommand Opcode: Represents the type conversion operation from short16 to byte8 in the virtual machine. + *This opcode is implemented by the {@link S2BCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a short16 value to a byte8 type.
+ */ +public class S2BCommand implements Command { + + /** + * Default constructor for creating an instance of S2BCommand. + */ + public S2BCommand() { + // Empty constructor + } + + /** + * Executes the short16 to byte8 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + short value = (short) operandStack.pop(); + byte convertedValue = (byte) value; + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2DCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2DCommand.java new file mode 100644 index 0000000..50c6e4e --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2DCommand.java @@ -0,0 +1,47 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * S2DCommand Opcode: Represents the type conversion operation from short16 to double64 in the virtual machine. + *This opcode is implemented by the {@link S2DCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a short16 value to a double64 type.
+ */ +public class S2DCommand implements Command { + + /** + * Default constructor for creating an instance of S2DCommand. + */ + public S2DCommand() { + // Empty constructor + } + + /** + * Executes the short16 to double64 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + double convertedValue = (short) operandStack.pop(); + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2FCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2FCommand.java new file mode 100644 index 0000000..9493a55 --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2FCommand.java @@ -0,0 +1,47 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * S2FCommand Opcode: Represents the type conversion operation from short16 to float32 in the virtual machine. + *This opcode is implemented by the {@link S2FCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a short16 value to a float32 type.
+ */ +public class S2FCommand implements Command { + + /** + * Default constructor for creating an instance of S2FCommand. + */ + public S2FCommand() { + // Empty constructor + } + + /** + * Executes the short16 to float32 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + float convertedValue = (short) operandStack.pop(); + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2ICommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2ICommand.java index fa3ee74..c980d3b 100644 --- a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2ICommand.java +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2ICommand.java @@ -16,7 +16,7 @@ import org.jcnc.snow.vm.module.OperandStack; *This opcode is used to widen a short16 value to an int32 type, facilitating subsequent integer arithmetic or comparison operations.
+ *This opcode is used to widen a short16 value to an int32 type.
*/ public class S2ICommand implements Command { diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2LCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2LCommand.java new file mode 100644 index 0000000..194344f --- /dev/null +++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2LCommand.java @@ -0,0 +1,47 @@ +package org.jcnc.snow.vm.commands.type.conversion; + +import org.jcnc.snow.vm.interfaces.Command; +import org.jcnc.snow.vm.module.CallStack; +import org.jcnc.snow.vm.module.LocalVariableStore; +import org.jcnc.snow.vm.module.OperandStack; + +/** + * S2LCommand Opcode: Represents the type conversion operation from short16 to long64 in the virtual machine. + *This opcode is implemented by the {@link S2LCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a short16 value to a long64 type.
+ */ +public class S2LCommand implements Command { + + /** + * Default constructor for creating an instance of S2LCommand. + */ + public S2LCommand() { + // Empty constructor + } + + /** + * Executes the short16 to long64 conversion operation. + * + * @param parts The array of instruction parameters, which is not used in this operation. + * @param currentPC The current program counter, representing the instruction address. + * @param operandStack The operand stack of the virtual machine. + * @param localVariableStore The local variable store for managing method-local variables. + * @param callStack The call stack of the virtual machine. + * @return The updated program counter after execution. + */ + @Override + public int execute(String[] parts, int currentPC, OperandStack operandStack, + LocalVariableStore localVariableStore, CallStack callStack) { + long convertedValue = (short) operandStack.pop(); + operandStack.push(convertedValue); + return currentPC + 1; + } +} diff --git a/src/main/java/org/jcnc/snow/vm/engine/VMOpCode.java b/src/main/java/org/jcnc/snow/vm/engine/VMOpCode.java index c53f511..73d8ed5 100644 --- a/src/main/java/org/jcnc/snow/vm/engine/VMOpCode.java +++ b/src/main/java/org/jcnc/snow/vm/engine/VMOpCode.java @@ -2043,216 +2043,21 @@ public class VMOpCode { // endregion // region Type Conversion (0x00C0-0x00DF) + // region Byte8 (0x00C0-0xC4) /** - * I2L Opcode: Represents the type conversion operation from int32 to long64 in the virtual machine. - *This opcode is implemented by the {@link I2LCommand} class, which defines its specific execution logic.
+ * B2S Opcode: Represents the type conversion operation from byte8 to short16 in the virtual machine. + *This opcode is implemented by the {@link B2SCommand} class, which defines its specific execution logic.
* *Execution Steps:
*-
- *
This opcode is commonly used to widen an int32 value to a long64 type to accommodate larger numeric ranges.
- */ - public static final int I2L = 0x00C0; - /** - * I2S Opcode: Represents the type conversion operation from int32 to short16 in the virtual machine. - *This opcode is implemented by the {@link I2SCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is typically used to narrow an int32 value to a short16 type when a smaller data representation is needed.
+ *This opcode is commonly used to widen a byte8 value to a short16 type.
*/ - public static final int I2S = 0x00C1; - /** - * I2B Opcode: Represents the type conversion operation from int32 to byte8 in the virtual machine. - *This opcode is implemented by the {@link I2BCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to narrow an int32 value to a byte8 type, suitable when a smaller numeric type is required.
- */ - public static final int I2B = 0x00C2; - /** - * I2D Opcode: Represents the type conversion operation from int32 to double64 in the virtual machine. - *This opcode is implemented by the {@link I2DCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to widen an int32 value to a double64 type, providing high-precision floating-point calculations.
- */ - public static final int I2D = 0x00C3; - /** - * I2F Opcode: Represents the type conversion operation from int32 to float32 in the virtual machine. - *This opcode is implemented by the {@link I2FCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to convert an int32 value to a float32 type when floating-point arithmetic is required.
- */ - public static final int I2F = 0x00C4; - /** - * L2I Opcode: Represents the type conversion operation from long64 to int32 in the virtual machine. - *This opcode is implemented by the {@link L2ICommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is typically used to narrow a long64 value to an int32 type for further integer operations.
- */ - public static final int L2I = 0x00C5; - /** - * L2D Opcode: Represents the type conversion operation from long64 to double64 in the virtual machine. - *This opcode is implemented by the {@link L2DCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to widen a long64 value to a double64 type for high-precision floating-point computations.
- */ - public static final int L2D = 0x00C6; - /** - * L2F Opcode: Represents the type conversion operation from long64 to float32 in the virtual machine. - *This opcode is implemented by the {@link L2FCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to convert a long64 value to a float32 type, typically for floating-point arithmetic involving long values.
- */ - public static final int L2F = 0x00C7; - /** - * F2I Opcode: Represents the type conversion operation from float32 to int32 in the virtual machine. - *This opcode is implemented by the {@link F2ICommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to convert a float32 value to an int32 type for further integer-based operations or comparisons.
- */ - public static final int F2I = 0x00C8; - /** - * F2L Opcode: Represents the type conversion operation from float32 to long64 in the virtual machine. - *This opcode is implemented by the {@link F2LCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to widen a float32 value to a long64 type, which is useful when operations require a larger numeric range.
- */ - public static final int F2L = 0x00C9; - /** - * F2D Opcode: Represents the type conversion operation from float32 to double64 in the virtual machine. - *This opcode is implemented by the {@link F2DCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to promote a float32 value to a double64 type, thereby increasing precision for floating-point computations.
- */ - public static final int F2D = 0x00CA; - /** - * D2I Opcode: Represents the type conversion operation from double64 to int32 in the virtual machine. - *This opcode is implemented by the {@link D2ICommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to narrow a double64 value to an int32 type for further integer-based processing.
- */ - public static final int D2I = 0x00CB; - /** - * D2L Opcode: Represents the type conversion operation from double64 to long64 in the virtual machine. - *This opcode is implemented by the {@link D2LCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to narrow a double64 value to a long64 type, which can then be used for integer operations.
- */ - public static final int D2L = 0x00CC; - /** - * D2F Opcode: Represents the type conversion operation from double64 to float32 in the virtual machine. - *This opcode is implemented by the {@link D2FCommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to narrow a double64 value to a float32 type when lower precision floating-point arithmetic is acceptable.
- */ - public static final int D2F = 0x00CD; - /** - * S2I Opcode: Represents the type conversion operation from short16 to int32 in the virtual machine. - *This opcode is implemented by the {@link S2ICommand} class, which defines its specific execution logic.
- * - *Execution Steps:
- *-
- *
This opcode is used to widen a short16 value to an int32 type, facilitating subsequent integer arithmetic or comparison operations.
- */ - public static final int S2I = 0x00CE; + public static final int B2S = 0x00C0; /** * B2I Opcode: Represents the type conversion operation from byte8 to int32 in the virtual machine. *This opcode is implemented by the {@link B2ICommand} class, which defines its specific execution logic.
@@ -2264,10 +2069,418 @@ public class VMOpCode { *This opcode is used to widen a byte8 value to an int32 type to ensure compatibility with integer-based operations.
+ *This opcode is commonly used to widen a byte8 value to an int32 type.
*/ - public static final int B2I = 0x00CF; - // endregion + public static final int B2I = 0x00C1; + /** + * B2L Opcode: Represents the type conversion operation from byte8 to long64 in the virtual machine. + *This opcode is implemented by the {@link B2LCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is commonly used to widen a byte8 value to a long64 type.
+ */ + public static final int B2L = 0x00C2; + /** + * B2F Opcode: Represents the type conversion operation from byte8 to float32 in the virtual machine. + *This opcode is implemented by the {@link B2FCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to convert a byte8 value to a float32 type.
+ */ + public static final int B2F = 0x00C3; + /** + * B2D Opcode: Represents the type conversion operation from byte8 to double64 in the virtual machine. + *This opcode is implemented by the {@link B2DCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a byte8 value to a double64 type.
+ */ + public static final int B2D = 0x00C4; + // endregion Byte8 + + // region Short16 (0x00C5-0xC9) + /** + * S2B Opcode: Represents the type conversion operation from short16 to byte8 in the virtual machine. + *This opcode is implemented by the {@link S2BCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a short16 value to a byte8 type.
+ */ + public static final int S2B = 0x00C5; + /** + * S2I Opcode: Represents the type conversion operation from short16 to int32 in the virtual machine. + *This opcode is implemented by the {@link S2ICommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is commonly used to widen a short16 value to an int32 type.
+ */ + public static final int S2I = 0x00C6; + /** + * S2L Opcode: Represents the type conversion operation from short16 to long64 in the virtual machine. + *This opcode is implemented by the {@link S2LCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is commonly used to widen a short16 value to a long64 type.
+ */ + public static final int S2L = 0x00C7; + /** + * S2F Opcode: Represents the type conversion operation from short16 to float32 in the virtual machine. + *This opcode is implemented by the {@link S2FCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to convert a short16 value to a float32 type.
+ */ + public static final int S2F = 0x00C8; + /** + * S2D Opcode: Represents the type conversion operation from short16 to double64 in the virtual machine. + *This opcode is implemented by the {@link S2DCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a short16 value to a double64 type.
+ */ + public static final int S2D = 0x00C9; + // endregion Short16 + + // region Int32 (0x00CA-0xCE) + /** + * I2B Opcode: Represents the type conversion operation from int32 to byte8 in the virtual machine. + *This opcode is implemented by the {@link I2BCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow an int32 value to a byte8 type.
+ */ + public static final int I2B = 0x00CA; + /** + * I2S Opcode: Represents the type conversion operation from int32 to short16 in the virtual machine. + *This opcode is implemented by the {@link I2SCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is typically used to narrow an int32 value to a short16 type.
+ */ + public static final int I2S = 0x00CB; + /** + * I2L Opcode: Represents the type conversion operation from int32 to long64 in the virtual machine. + *This opcode is implemented by the {@link I2LCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is commonly used to widen an int32 value to a long64 type.
+ */ + public static final int I2L = 0x00CC; + /** + * I2F Opcode: Represents the type conversion operation from int32 to float32 in the virtual machine. + *This opcode is implemented by the {@link I2FCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to convert an int32 value to a float32 type.
+ */ + public static final int I2F = 0x00CD; + /** + * I2D Opcode: Represents the type conversion operation from int32 to double64 in the virtual machine. + *This opcode is implemented by the {@link I2DCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen an int32 value to a double64 type.
+ */ + public static final int I2D = 0x00CE; + // endregion Int32 + + // region Long64 (0x00CF-0xD3) + /** + * L2B Opcode: Represents the type conversion operation from long64 to byte8 in the virtual machine. + *This opcode is implemented by the {@link L2BCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a long64 value to a byte8 type.
+ */ + public static final int L2B = 0x00CF; + /** + * L2S Opcode: Represents the type conversion operation from long64 to short16 in the virtual machine. + *This opcode is implemented by the {@link L2SCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a long64 value to a short16 type.
+ */ + public static final int L2S = 0x00D0; + /** + * L2I Opcode: Represents the type conversion operation from long64 to int32 in the virtual machine. + *This opcode is implemented by the {@link L2ICommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is typically used to narrow a long64 value to an int32 type .
+ */ + public static final int L2I = 0x00D1; + /** + * L2F Opcode: Represents the type conversion operation from long64 to float32 in the virtual machine. + *This opcode is implemented by the {@link L2FCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to convert a long64 value to a float32 type.
+ */ + public static final int L2F = 0x00D2; + /** + * L2D Opcode: Represents the type conversion operation from long64 to double64 in the virtual machine. + *This opcode is implemented by the {@link L2DCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a long64 value to a double64 type.
+ */ + public static final int L2D = 0x00D3; + // endregion Long64 + + // region Float32 (0x00D4-0xD8) + /** + * F2B Opcode: Represents the type conversion operation from float32 to byte8 in the virtual machine. + *This opcode is implemented by the {@link F2BCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to convert a float32 value to a byte8 type.
+ */ + public static final int F2B = 0x00D4; + /** + * F2S Opcode: Represents the type conversion operation from float32 to short16 in the virtual machine. + *This opcode is implemented by the {@link F2SCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to convert a float32 value to a short16 type.
+ */ + public static final int F2S = 0x00D5; + /** + * F2I Opcode: Represents the type conversion operation from float32 to int32 in the virtual machine. + *This opcode is implemented by the {@link F2ICommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to convert a float32 value to an int32 type.
+ */ + public static final int F2I = 0x00D6; + /** + * F2L Opcode: Represents the type conversion operation from float32 to long64 in the virtual machine. + *This opcode is implemented by the {@link F2LCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to widen a float32 value to a long64 type.
+ */ + public static final int F2L = 0x00D7; + /** + * F2D Opcode: Represents the type conversion operation from float32 to double64 in the virtual machine. + *This opcode is implemented by the {@link F2DCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to promote a float32 value to a double64 type.
+ */ + public static final int F2D = 0x00D8; + // endregion Float32 + + // region Double64 (0x00D9-0xDD) + /** + * D2B Opcode: Represents the type conversion operation from double64 to byte8 in the virtual machine. + *This opcode is implemented by the {@link D2BCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a double64 value to a byte8 type.
+ */ + public static final int D2B = 0x00D9; + /** + * D2S Opcode: Represents the type conversion operation from double64 to short16 in the virtual machine. + *This opcode is implemented by the {@link D2SCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a double64 value to a short16 type.
+ */ + public static final int D2S = 0x00DA; + /** + * D2I Opcode: Represents the type conversion operation from double64 to int32 in the virtual machine. + *This opcode is implemented by the {@link D2ICommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a double64 value to an int32 type.
+ */ + public static final int D2I = 0x00DB; + /** + * D2L Opcode: Represents the type conversion operation from double64 to long64 in the virtual machine. + *This opcode is implemented by the {@link D2LCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a double64 value to a long64 type.
+ */ + public static final int D2L = 0x00DC; + /** + * D2F Opcode: Represents the type conversion operation from double64 to float32 in the virtual machine. + *This opcode is implemented by the {@link D2FCommand} class, which defines its specific execution logic.
+ * + *Execution Steps:
+ *-
+ *
This opcode is used to narrow a double64 value to a float32 type.
+ */ + public static final int D2F = 0x00DD; + // endregion Double64 + // endregion Conversion // region Stack Control (0x0100-0x01FF) /** diff --git a/src/main/java/org/jcnc/snow/vm/factories/CommandFactory.java b/src/main/java/org/jcnc/snow/vm/factories/CommandFactory.java index a5af00b..4054a11 100644 --- a/src/main/java/org/jcnc/snow/vm/factories/CommandFactory.java +++ b/src/main/java/org/jcnc/snow/vm/factories/CommandFactory.java @@ -207,26 +207,41 @@ public class CommandFactory { // endregion // region Type Conversion (0x00C0-0x00DF) - COMMANDS[VMOpCode.I2L] = new I2LCommand(); - COMMANDS[VMOpCode.I2S] = new I2SCommand(); + COMMANDS[VMOpCode.B2S] = new B2SCommand(); + COMMANDS[VMOpCode.B2I] = new B2ICommand(); + COMMANDS[VMOpCode.B2L] = new B2LCommand(); + COMMANDS[VMOpCode.B2F] = new B2FCommand(); + COMMANDS[VMOpCode.B2D] = new B2DCommand(); + + COMMANDS[VMOpCode.S2B] = new S2BCommand(); + COMMANDS[VMOpCode.S2I] = new S2ICommand(); + COMMANDS[VMOpCode.S2L] = new S2LCommand(); + COMMANDS[VMOpCode.S2F] = new S2FCommand(); + COMMANDS[VMOpCode.S2D] = new S2DCommand(); + COMMANDS[VMOpCode.I2B] = new I2BCommand(); - COMMANDS[VMOpCode.I2D] = new I2DCommand(); + COMMANDS[VMOpCode.I2S] = new I2SCommand(); + COMMANDS[VMOpCode.I2L] = new I2LCommand(); COMMANDS[VMOpCode.I2F] = new I2FCommand(); + COMMANDS[VMOpCode.I2D] = new I2DCommand(); + COMMANDS[VMOpCode.L2B] = new L2BCommand(); + COMMANDS[VMOpCode.L2S] = new L2SCommand(); COMMANDS[VMOpCode.L2I] = new L2ICommand(); - COMMANDS[VMOpCode.L2D] = new L2DCommand(); COMMANDS[VMOpCode.L2F] = new L2FCommand(); + COMMANDS[VMOpCode.L2D] = new L2DCommand(); + COMMANDS[VMOpCode.F2B] = new F2BCommand(); + COMMANDS[VMOpCode.F2S] = new F2SCommand(); COMMANDS[VMOpCode.F2I] = new F2ICommand(); COMMANDS[VMOpCode.F2L] = new F2LCommand(); COMMANDS[VMOpCode.F2D] = new F2DCommand(); + COMMANDS[VMOpCode.D2B] = new D2BCommand(); + COMMANDS[VMOpCode.D2S] = new D2SCommand(); COMMANDS[VMOpCode.D2I] = new D2ICommand(); COMMANDS[VMOpCode.D2L] = new D2LCommand(); COMMANDS[VMOpCode.D2F] = new D2FCommand(); - - COMMANDS[VMOpCode.S2I] = new S2ICommand(); - COMMANDS[VMOpCode.B2I] = new B2ICommand(); // endregion // region Stack Control (0x0100-0x01FF)