instruction.h

Go to the documentation of this file.

 
#ifndef NSBACI_COMPILER_INSTRUCTION_H
#define NSBACI_COMPILER_INSTRUCTION_H
 
#include <cstdint>
#include <string>
#include <variant>
#include <vector>

namespace nsbaci::compiler {

enum class Opcode : uint8_t {
  // ============== Stack/Memory Operations ==============
  LoadValue,      // Load value from address onto stack
  LoadAddress,    // Load address onto stack
  LoadIndirect,   // Load value from address pointed to by top of stack
  StoreIndirect,  // Store value to address on stack (pops addr, pops value)
  LoadBlock,      // Load block of memory onto stack
  Store,          // Store top of stack to address
  StoreKeep,      // Store and keep value on stack
  PushLiteral,    // Push literal value onto stack
  Swap,           // Swap top two stack elements
  RotateDown3,    // Rotate top 3: [a,b,c] -> [b,c,a]
  Index,          // Array indexing
  CopyBlock,      // Copy block of memory
  ValueAt,        // Get value at address on stack
  MarkStack,      // Mark stack for procedure call
  UpdateDisplay,  // Update display register
 
  // ============== Arithmetic Operations ==============
  Add,         // Addition
  Sub,         // Subtraction
  Mult,        // Multiplication
  Div,         // Integer division
  Mod,         // Modulo
  Negate,      // Unary negation
  Complement,  // Bitwise complement
 
  // ============== Logical Operations ==============
  And,  // Logical AND
  Or,   // Logical OR
 
  // ============== Comparison Operations ==============
  TestEQ,         // Test equal
  TestNE,         // Test not equal
  TestLT,         // Test less than
  TestLE,         // Test less or equal
  TestGT,         // Test greater than
  TestGE,         // Test greater or equal
  TestEqualKeep,  // Test equal, keep operands
 
  // ============== Control Flow ==============
  Jump,          // Unconditional jump
  JumpZero,      // Jump if top of stack is zero
  Call,          // Call procedure
  ShortCall,     // Short call (no display update)
  ShortReturn,   // Short return
  ExitProc,      // Exit procedure
  ExitFunction,  // Exit function (with return value)
  EnterFrame,    // Enter function frame (save locals) - operand1 = start addr,
                 // operand2 = count
  LeaveFrame,  // Leave function frame (restore locals) - operand1 = start addr,
               // operand2 = count
  Halt,        // Halt execution
 
  // ============== Loop Control ==============
  BeginFor,  // Begin for loop
  EndFor,    // End for loop
 
  // ============== Concurrency - Process ==============
  Cobegin,    // Begin concurrent block
  Coend,      // End concurrent block (operand1 = expected thread count)
  Create,     // Create new process (operand1 = start PC)
  ThreadEnd,  // Terminate current thread
  Suspend,    // Suspend current process
  Revive,     // Revive suspended process
  WhichProc,  // Get current process ID
 
  // ============== Concurrency - Semaphores ==============
  Wait,            // Wait on semaphore (P operation)
  Signal,          // Signal semaphore (V operation)
  StoreSemaphore,  // Initialize semaphore
 
  // ============== Concurrency - Monitors ==============
  EnterMonitor,       // Enter monitor
  ExitMonitor,        // Exit monitor
  CallMonitorInit,    // Call monitor initialization
  ReturnMonitorInit,  // Return from monitor init
  WaitCondition,      // Wait on condition variable
  SignalCondition,    // Signal condition variable
  Empty,              // Check if condition queue is empty
 
  // ============== I/O Operations ==============
  Read,            // Read integer
  Readln,          // Read line
  Write,           // Write value
  Writeln,         // Write newline
  WriteString,     // Write string
  WriteRawString,  // Write raw string literal
  EolEof,          // Check end of line/file
  Sprintf,         // Format string
  Sscanf,          // Scan string
 
  // ============== String Operations ==============
  CopyString,        // Copy string
  CopyRawString,     // Copy raw string
  ConcatString,      // Concatenate strings
  ConcatRawString,   // Concatenate raw string
  CompareString,     // Compare strings
  CompareRawString,  // Compare raw strings
  LengthString,      // Get string length
 
  // ============== Graphics/Drawing Operations ==============
  // Canvas operations
  DrawClear,    // Clear the canvas (optional: r, g, b on stack)
  DrawRefresh,  // Force canvas refresh
 
  // Color/state operations
  DrawSetColor,       // Set drawing color (r, g, b on stack)
  DrawSetColorAlpha,  // Set drawing color with alpha (r, g, b, a on stack)
  DrawSetLineWidth,   // Set line width (width on stack)
  DrawSetPosition,    // Set current position (x, y on stack)
 
  // Shape drawing operations (outline only)
  DrawCircle,     // Draw circle outline (x, y, radius on stack)
  DrawRectangle,  // Draw rectangle outline (x, y, width, height on stack)
  DrawTriangle,   // Draw triangle outline (x1, y1, x2, y2, x3, y3 on stack)
  DrawLine,       // Draw line (x1, y1, x2, y2 on stack)
  DrawEllipse,    // Draw ellipse outline (x, y, radiusX, radiusY on stack)
  DrawPixel,      // Draw pixel (x, y on stack)
  DrawText,       // Draw text (x, y, fontSize on stack, string in operand)
 
  // Shape fill operations (filled shapes)
  FillCircle,     // Fill circle (x, y, radius on stack)
  FillRectangle,  // Fill rectangle (x, y, width, height on stack)
  FillTriangle,   // Fill triangle (x1, y1, x2, y2, x3, y3 on stack)
  FillEllipse,    // Fill ellipse (x, y, radiusX, radiusY on stack)
 
  // Legacy graphics (keeping for compatibility)
  MoveTo,       // Move to absolute position
  MoveBy,       // Move by relative offset
  ChangeColor,  // Change drawing color
  MakeVisible,  // Make object visible
  Remove,       // Remove object
 
  // ============== Miscellaneous ==============
  Random,  // Generate random number
  Test,    // Generic test instruction
 
  // ============== Total count ==============
  _Count  // Number of opcodes (keep last)
};

using Operand = std::variant<std::monostate,  // No operand
                             int32_t,         // Integer literal or offset
                             uint32_t,        // Unsigned value or address
                             std::string      // String literal
                             >;

struct Instruction {
  Opcode opcode;
  Operand operand1;
  Operand operand2;
 
  // Convenience constructors
  Instruction() : opcode(Opcode::Halt), operand1(), operand2() {}
 
  explicit Instruction(Opcode op) : opcode(op), operand1(), operand2() {}
 
  Instruction(Opcode op, int32_t op1) : opcode(op), operand1(op1), operand2() {}
 
  Instruction(Opcode op, uint32_t op1)
      : opcode(op), operand1(op1), operand2() {}
 
  Instruction(Opcode op, std::string op1)
      : opcode(op), operand1(std::move(op1)), operand2() {}
 
  Instruction(Opcode op, int32_t op1, int32_t op2)
      : opcode(op), operand1(op1), operand2(op2) {}
 
  Instruction(Opcode op, uint32_t op1, int32_t op2)
      : opcode(op), operand1(op1), operand2(op2) {}
};

using InstructionStream = std::vector<Instruction>;

const char* opcodeName(Opcode op);
 
}  // namespace nsbaci::compiler
 
#endif  // NSBACI_COMPILER_INSTRUCTION_H