feat：vm 增加 byte8 比较指令
This commit is contained in:
parent
b882050f24
commit
a0fad7f642
@ -0,0 +1,76 @@
|
||||
package org.jcnc.snow.vm.commands.control.byte8;
|
||||
|
||||
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;
|
||||
import org.jcnc.snow.vm.utils.LoggingUtils;
|
||||
|
||||
/**
|
||||
* The BCECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
|
||||
* This class compares two values from the stack, and if they are equal, it jumps to the specified target command.
|
||||
*
|
||||
* <p>Specific behavior:</p>
|
||||
* <ul>
|
||||
* <li>Pops two byte8 from the virtual machine stack.</li>
|
||||
* <li>If the two byte8 are equal, jumps to the target command.</li>
|
||||
* <li>Otherwise, the program continues with the next command.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class BCECommand implements Command {
|
||||
/**
|
||||
* Default constructor for creating an instance of BCECommand.
|
||||
* This constructor is empty as no specific initialization is required.
|
||||
*/
|
||||
public BCECommand() {
|
||||
// Empty constructor
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the virtual machine instruction's operation.
|
||||
*
|
||||
* <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
|
||||
* specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
|
||||
* to be executed.</p>
|
||||
*
|
||||
* <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
|
||||
* of execution by updating the program counter.</p>
|
||||
*
|
||||
* <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
|
||||
* function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
|
||||
* while a `POP` instruction will remove an item from the operand stack.</p>
|
||||
*
|
||||
* @param parts The array of instruction parameters, which usually includes the operator and related arguments
|
||||
* (such as target addresses, values, or function names). These parameters may vary based on
|
||||
* the instruction being executed.
|
||||
* @param currentPC The current program counter-value, indicating the address of the instruction being executed.
|
||||
* This value is typically incremented after the execution of each instruction to point to the next one.
|
||||
* @param operandStack The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
|
||||
* such as pushing, popping, and peeking values.
|
||||
* @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
|
||||
* The store may not be used in every command but can be leveraged by instructions that require access
|
||||
* to local variables.
|
||||
* @param callStack The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
|
||||
* instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
|
||||
* @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
|
||||
* instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
|
||||
* corresponding to the target of the jump or the subroutine to call.
|
||||
*/
|
||||
@Override
|
||||
public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
|
||||
// Parse the target command address
|
||||
int target = Integer.parseInt(parts[1]);
|
||||
|
||||
// Pop the two operands from the stack
|
||||
byte b = (byte) operandStack.pop();
|
||||
byte a = (byte) operandStack.pop();
|
||||
|
||||
// If the operands are equal, jump to the target command
|
||||
if (a == b) {
|
||||
LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
|
||||
return target;
|
||||
}
|
||||
|
||||
return currentPC + 1;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
package org.jcnc.snow.vm.commands.control.byte8;
|
||||
|
||||
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;
|
||||
import org.jcnc.snow.vm.utils.LoggingUtils;
|
||||
|
||||
/**
|
||||
* The BCGCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
|
||||
* This class compares two values from the stack, and if the first value is greater than the second, it jumps to the specified target command.
|
||||
*
|
||||
* <p>Specific behavior:</p>
|
||||
* <ul>
|
||||
* <li>Pops two byte8 from the virtual machine stack.</li>
|
||||
* <li>If the first byte8 is greater than the second, jumps to the target command.</li>
|
||||
* <li>Otherwise, the program continues with the next command.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class BCGCommand implements Command {
|
||||
/**
|
||||
* Default constructor for creating an instance of BCGCommand.
|
||||
* This constructor is empty as no specific initialization is required.
|
||||
*/
|
||||
public BCGCommand() {
|
||||
// Empty constructor
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the virtual machine instruction's operation.
|
||||
*
|
||||
* <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
|
||||
* specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
|
||||
* to be executed.</p>
|
||||
*
|
||||
* <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
|
||||
* of execution by updating the program counter.</p>
|
||||
*
|
||||
* <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
|
||||
* function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
|
||||
* while a `POP` instruction will remove an item from the operand stack.</p>
|
||||
*
|
||||
* @param parts The array of instruction parameters, which usually includes the operator and related arguments
|
||||
* (such as target addresses, values, or function names). These parameters may vary based on
|
||||
* the instruction being executed.
|
||||
* @param currentPC The current program counter-value, indicating the address of the instruction being executed.
|
||||
* This value is typically incremented after the execution of each instruction to point to the next one.
|
||||
* @param operandStack The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
|
||||
* such as pushing, popping, and peeking values.
|
||||
* @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
|
||||
* The store may not be used in every command but can be leveraged by instructions that require access
|
||||
* to local variables.
|
||||
* @param callStack The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
|
||||
* instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
|
||||
* @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
|
||||
* instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
|
||||
* corresponding to the target of the jump or the subroutine to call.
|
||||
*/
|
||||
@Override
|
||||
public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
|
||||
// Parse the target command address
|
||||
int target = Integer.parseInt(parts[1]);
|
||||
|
||||
// Pop the two operands from the stack
|
||||
byte b = (byte) operandStack.pop();
|
||||
byte a = (byte) operandStack.pop();
|
||||
|
||||
// If the first operand is greater than the second, jump to the target command
|
||||
if (a > b) {
|
||||
LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
|
||||
return target;
|
||||
}
|
||||
|
||||
return currentPC + 1;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
package org.jcnc.snow.vm.commands.control.byte8;
|
||||
|
||||
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;
|
||||
import org.jcnc.snow.vm.utils.LoggingUtils;
|
||||
|
||||
/**
|
||||
* The BCGECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
|
||||
* This class compares two values from the stack, and if the first value is greater than or equal to the second, it jumps to the specified target command.
|
||||
*
|
||||
* <p>Specific behavior:</p>
|
||||
* <ul>
|
||||
* <li>Pops two byte8 from the virtual machine stack.</li>
|
||||
* <li>If the first byte8 is greater than or equal to the second, jumps to the target command.</li>
|
||||
* <li>Otherwise, the program continues with the next command.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class BCGECommand implements Command {
|
||||
/**
|
||||
* Default constructor for creating an instance of BCGECommand.
|
||||
* This constructor is empty as no specific initialization is required.
|
||||
*/
|
||||
public BCGECommand() {
|
||||
// Empty constructor
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the virtual machine instruction's operation.
|
||||
*
|
||||
* <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
|
||||
* specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
|
||||
* to be executed.</p>
|
||||
*
|
||||
* <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
|
||||
* of execution by updating the program counter.</p>
|
||||
*
|
||||
* <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
|
||||
* function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
|
||||
* while a `POP` instruction will remove an item from the operand stack.</p>
|
||||
*
|
||||
* @param parts The array of instruction parameters, which usually includes the operator and related arguments
|
||||
* (such as target addresses, values, or function names). These parameters may vary based on
|
||||
* the instruction being executed.
|
||||
* @param currentPC The current program counter-value, indicating the address of the instruction being executed.
|
||||
* This value is typically incremented after the execution of each instruction to point to the next one.
|
||||
* @param operandStack The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
|
||||
* such as pushing, popping, and peeking values.
|
||||
* @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
|
||||
* The store may not be used in every command but can be leveraged by instructions that require access
|
||||
* to local variables.
|
||||
* @param callStack The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
|
||||
* instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
|
||||
* @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
|
||||
* instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
|
||||
* corresponding to the target of the jump or the subroutine to call.
|
||||
*/
|
||||
@Override
|
||||
public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
|
||||
// Parse the target command address
|
||||
int target = Integer.parseInt(parts[1]);
|
||||
|
||||
// Pop the two operands from the stack
|
||||
byte b = (byte) operandStack.pop();
|
||||
byte a = (byte) operandStack.pop();
|
||||
|
||||
// If the first operand is greater than or equal to the second, jump to the target command
|
||||
if (a >= b) {
|
||||
LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
|
||||
return target;
|
||||
}
|
||||
|
||||
return currentPC + 1;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
package org.jcnc.snow.vm.commands.control.byte8;
|
||||
|
||||
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;
|
||||
import org.jcnc.snow.vm.utils.LoggingUtils;
|
||||
|
||||
/**
|
||||
* The BCLCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
|
||||
* This class compares two values from the stack, and if the first value is less than the second, it jumps to the specified target command.
|
||||
*
|
||||
* <p>Specific behavior:</p>
|
||||
* <ul>
|
||||
* <li>Pops two byte8 from the virtual machine stack.</li>
|
||||
* <li>If the first byte8 is less than the second, jumps to the target command.</li>
|
||||
* <li>Otherwise, the program continues with the next command.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class BCLCommand implements Command {
|
||||
/**
|
||||
* Default constructor for creating an instance of BCLCommand.
|
||||
* This constructor is empty as no specific initialization is required.
|
||||
*/
|
||||
public BCLCommand() {
|
||||
// Empty constructor
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the virtual machine instruction's operation.
|
||||
*
|
||||
* <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
|
||||
* specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
|
||||
* to be executed.</p>
|
||||
*
|
||||
* <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
|
||||
* of execution by updating the program counter.</p>
|
||||
*
|
||||
* <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
|
||||
* function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
|
||||
* while a `POP` instruction will remove an item from the operand stack.</p>
|
||||
*
|
||||
* @param parts The array of instruction parameters, which usually includes the operator and related arguments
|
||||
* (such as target addresses, values, or function names). These parameters may vary based on
|
||||
* the instruction being executed.
|
||||
* @param currentPC The current program counter-value, indicating the address of the instruction being executed.
|
||||
* This value is typically incremented after the execution of each instruction to point to the next one.
|
||||
* @param operandStack The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
|
||||
* such as pushing, popping, and peeking values.
|
||||
* @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
|
||||
* The store may not be used in every command but can be leveraged by instructions that require access
|
||||
* to local variables.
|
||||
* @param callStack The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
|
||||
* instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
|
||||
* @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
|
||||
* instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
|
||||
* corresponding to the target of the jump or the subroutine to call.
|
||||
*/
|
||||
@Override
|
||||
public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
|
||||
// Parse the target command address
|
||||
int target = Integer.parseInt(parts[1]);
|
||||
|
||||
// Pop the two operands from the stack
|
||||
byte b = (byte) operandStack.pop();
|
||||
byte a = (byte) operandStack.pop();
|
||||
|
||||
// If the first operand is less than the second, jump to the target command
|
||||
if (a < b) {
|
||||
LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
|
||||
return target;
|
||||
}
|
||||
|
||||
return currentPC + 1;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
package org.jcnc.snow.vm.commands.control.byte8;
|
||||
|
||||
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;
|
||||
import org.jcnc.snow.vm.utils.LoggingUtils;
|
||||
|
||||
/**
|
||||
* The BCLECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
|
||||
* This class compares two values from the stack, and if the first value is less than or equal to the second, it jumps to the specified target command.
|
||||
*
|
||||
* <p>Specific behavior:</p>
|
||||
* <ul>
|
||||
* <li>Pops two byte8 from the virtual machine stack.</li>
|
||||
* <li>If the first byte8 is less than or equal to the second, jumps to the target command.</li>
|
||||
* <li>Otherwise, the program continues with the next command.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class BCLECommand implements Command {
|
||||
/**
|
||||
* Default constructor for creating an instance of BCLECommand.
|
||||
* This constructor is empty as no specific initialization is required.
|
||||
*/
|
||||
public BCLECommand() {
|
||||
// Empty constructor
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the virtual machine instruction's operation.
|
||||
*
|
||||
* <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
|
||||
* specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
|
||||
* to be executed.</p>
|
||||
*
|
||||
* <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
|
||||
* of execution by updating the program counter.</p>
|
||||
*
|
||||
* <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
|
||||
* function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
|
||||
* while a `POP` instruction will remove an item from the operand stack.</p>
|
||||
*
|
||||
* @param parts The array of instruction parameters, which usually includes the operator and related arguments
|
||||
* (such as target addresses, values, or function names). These parameters may vary based on
|
||||
* the instruction being executed.
|
||||
* @param currentPC The current program counter-value, indicating the address of the instruction being executed.
|
||||
* This value is typically incremented after the execution of each instruction to point to the next one.
|
||||
* @param operandStack The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
|
||||
* such as pushing, popping, and peeking values.
|
||||
* @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
|
||||
* The store may not be used in every command but can be leveraged by instructions that require access
|
||||
* to local variables.
|
||||
* @param callStack The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
|
||||
* instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
|
||||
* @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
|
||||
* instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
|
||||
* corresponding to the target of the jump or the subroutine to call.
|
||||
*/
|
||||
@Override
|
||||
public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
|
||||
// Parse the target command address
|
||||
int target = Integer.parseInt(parts[1]);
|
||||
|
||||
// Pop the two operands from the stack
|
||||
byte b = (byte) operandStack.pop();
|
||||
byte a = (byte) operandStack.pop();
|
||||
|
||||
// If the first operand is less than or equal to the second, jump to the target command
|
||||
if (a <= b) {
|
||||
LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
|
||||
return target;
|
||||
}
|
||||
|
||||
return currentPC + 1;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,77 @@
|
||||
package org.jcnc.snow.vm.commands.control.byte8;
|
||||
|
||||
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;
|
||||
import org.jcnc.snow.vm.utils.LoggingUtils;
|
||||
|
||||
/**
|
||||
* The BCNECommand class implements the {@link Command} interface and represents a conditional jump command
|
||||
* in the virtual machine that triggers if two values are not equal.
|
||||
*
|
||||
* <p>Specific behavior:</p>
|
||||
* <ul>
|
||||
* <li>Pops two byte8 from the virtual machine stack.</li>
|
||||
* <li>If the two byte8 are not equal, jumps to the target command.</li>
|
||||
* <li>Otherwise, the program continues with the next command.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class BCNECommand implements Command {
|
||||
/**
|
||||
* Default constructor for creating an instance of BCNECommand.
|
||||
* This constructor is empty as no specific initialization is required.
|
||||
*/
|
||||
public BCNECommand() {
|
||||
|
||||
// Empty constructor
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the virtual machine instruction's operation.
|
||||
*
|
||||
* <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
|
||||
* specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
|
||||
* to be executed.</p>
|
||||
*
|
||||
* <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
|
||||
* of execution by updating the program counter.</p>
|
||||
*
|
||||
* <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
|
||||
* function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
|
||||
* while a `POP` instruction will remove an item from the operand stack.</p>
|
||||
*
|
||||
* @param parts The array of instruction parameters, which usually includes the operator and related arguments
|
||||
* (such as target addresses, values, or function names). These parameters may vary based on
|
||||
* the instruction being executed.
|
||||
* @param currentPC The current program counter-value, indicating the address of the instruction being executed.
|
||||
* This value is typically incremented after the execution of each instruction to point to the next one.
|
||||
* @param operandStack The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
|
||||
* such as pushing, popping, and peeking values.
|
||||
* @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
|
||||
* The store may not be used in every command but can be leveraged by instructions that require access
|
||||
* to local variables.
|
||||
* @param callStack The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
|
||||
* instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
|
||||
* @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
|
||||
* instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
|
||||
* corresponding to the target of the jump or the subroutine to call.
|
||||
*/
|
||||
@Override
|
||||
public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
|
||||
// Parse the target command address
|
||||
int target = Integer.parseInt(parts[1]);
|
||||
|
||||
// Pop the two operands from the stack
|
||||
byte b = (byte) operandStack.pop();
|
||||
byte a = (byte) operandStack.pop();
|
||||
|
||||
// If the operands are not equal, jump to the target command
|
||||
if (a != b) {
|
||||
LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
|
||||
return target;
|
||||
}
|
||||
|
||||
return currentPC + 1;
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user