Trang Language

1. Biến & Biểu thức số nguyên

Trang hỗ trợ biến số nguyên với cú pháp gán đơn giản và các toán tử số học, logic cơ bản.

Khả năng:

• Toán tử số học: +, -, *, /
• Toán tử so sánh: <, >, ==
• Biến tự động khởi tạo = 0
• Hỗ trợ biểu thức lồng nhau với dấu ngoặc

# Biến và biểu thức
x = 10
y = x * 2 + 5
result = (x + y) / 3

# So sánh
isGreater = x > 5  # 1 (true) hoặc 0 (false)
isEqual = x == 10  # 1

in x        # In: 10
in y        # In: 25
in result   # In: 11

2. Cấu trúc điều khiển

Hỗ trợ rẽ nhánh neu...thi...het và vòng lặp khi...thi...het với cú pháp tiếng Việt tự nhiên.

Rẽ nhánh (neu-thi-het):

x = 15

neu x > 10 thi
    in x
    in 1
het

# Nested conditions
neu x > 5 thi
    neu x < 20 thi
        in 999
    het
het

Vòng lặp (khi-thi-het):

# Fibonacci(20)
n = 20
a = 0
b = 1
i = 0

khi i < n thi
    t = a + b
    a = b
    b = t
    i = i + 1
het

in a  # 6765

3. Khối sandbox (trang...het)

Tính năng độc đáo: tạo môi trường cô lập để thực thi code, trả về giá trị mà không ảnh hưởng đến state bên ngoài.

Cơ chế hoạt động:

• Backup toàn bộ stack và biến hiện tại
• Reset môi trường sandbox (biến = 0, stack rỗng)
• Thực thi code trong sandbox
• Lấy giá trị top-of-stack làm return value
• Restore state bên ngoài
• Push return value lên stack ngoài

x = 10
in x  # 10

# Sandbox thay đổi x bên trong
y = trang
    x = 999  # x local trong sandbox
    123      # return value
het

in y  # 123 (return value từ sandbox)
in x  # 10 (x ngoài không đổi!)

# Factorial trong sandbox
fact10 = trang
    n = 10
    acc = 1
    i = 1
    khi i < n + 1 thi
        acc = acc * i
        i = i + 1
    het
    acc  # return value
het

in fact10  # 3628800

4. Tích hợp lệnh shell

Gọi trực tiếp các lệnh Linux từ script Trang, kết hợp scripting với automation.

Lệnh builtin hỗ trợ:

• date - Hiển thị thời gian hệ thống
• pwd - Thư mục hiện tại
• whoami - Tên user
• ls, dir - Liệt kê files
• ps - Danh sách processes
• cd, exit, help, history

i = 0
khi i < 5 thi
    date  # In timestamp
    pwd   # In working directory
    in i
    i = i + 1
het

whoami  # In username
ls      # List files

5. Quản lý jobs (Background/Foreground)

Shell hỗ trợ chạy processes ở background và quản lý jobs như bash.

Chức năng:

• Chạy nền: command &
• Foreground: fg <job_id>
• Kill, stop, resume processes
• Xử lý SIGINT (Ctrl+C) cho child process
• Job table tracking

# Trong thinsh
thinsh> sleep 100 &
[1] Running: sleep 100

thinsh> ps
# Xem processes

thinsh> fg 1
# Đưa job 1 lên foreground

# Ctrl+C để kill process

6. Biến môi trường riêng

Quản lý biến môi trường độc lập với bash, lưu persistent trong env.txt.

Commands:

• set <key> <value> - Đặt biến
• get <key> - Xem giá trị
• Lưu vào env.txt dạng KEY=VALUE

thinsh> set API_KEY abc123
thinsh> set PORT 8080
thinsh> get API_KEY
abc123
thinsh> get PORT
8080

Stack Virtual Machine

Trang sử dụng stack-based VM để thực thi bytecode, tương tự JVM hoặc Python bytecode interpreter.

Cấu trúc VM (MAY_AO):

Triển khai (C source):

typedef struct {
  CHUONG_TRINH *program;
  int pc;
  int stack[1024];
  int sp;
  int backup_stack[1024];
  int backup_sp;
  int vars[1024];
  int backup_vars[1024];
  int is_in_trang;
} MAY_AO;

void push(MAY_AO *vm, int value) {
  if (vm->sp >= 1024) {
    printf("Loi: Tran ngan xep (Stack Overflow)!\n");
    exit(1);
  }
  vm->stack[vm->sp++] = value;
}

int pop(MAY_AO *vm) {
  if (vm->sp <= 0) {
    printf("Loi: Ngan xep rong (Stack Underflow)!\n");
    exit(1);
  }
  return vm->stack[--vm->sp];
}

Compiler (Lexer + Parser)

Compiler phân tích source code Trang thành bytecode, thực hiện lexical analysis và parsing one-pass.

Các giai đoạn:

1. Lexer: Tokenize source thành tokens (keywords, operators, identifiers, numbers)
2. Parser: Phân tích cú pháp và sinh bytecode
3. Emission: Ghi opcodes vào program->code[]

Keywords được hỗ trợ:

typedef enum {
  TOKEN_NEU,      // if
  TOKEN_THI,      // then
  TOKEN_HET,      // end
  TOKEN_KHI,      // while
  TOKEN_TRANG,    // sandbox
  TOKEN_IN,       // print
  TOKEN_EQUAL,    // =
  TOKEN_SEMICOLON,
  TOKEN_PLUS, TOKEN_MINUS, TOKEN_STAR, TOKEN_SLASH,
  TOKEN_LESS, TOKEN_GREATER, TOKEN_EQUAL_EQUAL,
  TOKEN_LPAREN, TOKEN_RPAREN,
  TOKEN_VAR, TOKEN_NUMBER,
  TOKEN_EOF, TOKEN_ERROR, TOKEN_NEWLINE
} TU_KHOA;

static const char *keyword_names[] = {
  "neu", "thi", "het", "khi", "trang", "in"
};

Symbol table:

• Mảng 1023 slots cho biến user
• Slot 1023 dành riêng cho return value của trang
• Hash table đơn giản: key → slot index

Opcodes (Instruction Set)

VM định nghĩa 17 opcodes cơ bản cho arithmetic, logic, control flow và sandbox.

Implementation (VM dispatch loop):

void run(MAY_AO *vm) {
  while (vm->pc < vm->program->code_size) {
    CHI_DAN instr = vm->program->code[vm->pc];
    vm->pc++;
    
    switch (instr.opcode) {
      case CONG: OP_CONG(vm); break;
      case TRU: OP_TRU(vm); break;
      case NHAN: OP_NHAN(vm); break;
      case CHIA: OP_CHIA(vm); break;
      case BANG: OP_BANG(vm); break;
      case LON: OP_LON(vm); break;
      case NHO: OP_NHO(vm); break;
      case NHAY: OP_NHAY(vm, instr.operand); break;
      case NNS: OP_NNS(vm, instr.operand); break;
      case CAT: OP_CAT(vm, instr.operand); break;
      case LAY: OP_LAY(vm, instr.operand); break;
      case NAP: OP_NAP(vm, instr.operand); break;
      case BO: OP_BO(vm, instr.operand); break;
      case IN: OP_IN_WITH_OPERAND(vm, instr.operand); break;
      case VAO_TRANG: OP_VAO_TRANG(vm); break;
      case RA_TRANG: OP_RA_TRANG(vm); break;
      case DUNG: return;
      default:
        printf("Loi: Opcode khong hop le!\n");
        exit(1);
    }
  }
}

Sandbox Mechanism (trang...het)

Cơ chế sandbox được triển khai thông qua 2 opcodes: VAO_TRANG và RA_TRANG.

Luồng thực thi:

1. Compile time: Emit VAO_TRANG → sandbox_code → RA_TRANG
2. Runtime (VAO_TRANG):
   • Check nested trang (forbidden)
   • Backup sp, stack[0..sp], vars[0..1024]
   • Reset sp=0, vars[]=0
   • Set is_in_trang=1
3. Runtime (RA_TRANG):
   • Capture result = stack[sp-1] (if sp > 0)
   • Restore sp, stack[], vars[]
   • Set is_in_trang=0
   • Push result onto restored stack

void OP_VAO_TRANG(MAY_AO *vm) {
  if (vm->is_in_trang) {
    printf("Loi: Khong ho tro 'trang' long nhau!\n");
    exit(1);
  }
  vm->is_in_trang = 1;

  // Backup outer state
  vm->backup_sp = vm->sp;
  for (int i = 0; i < vm->backup_sp; i++) {
    vm->backup_stack[i] = vm->stack[i];
  }
  for (int i = 0; i < 1024; i++) {
    vm->backup_vars[i] = vm->vars[i];
  }

  // Fresh sandbox state
  vm->sp = 0;
  for (int i = 0; i < 1024; i++) {
    vm->vars[i] = 0;
  }
}

void OP_RA_TRANG(MAY_AO *vm) {
  if (!vm->is_in_trang) {
    printf("Loi: 'ra_trang' khi khong o trong 'trang'!\n");
    exit(1);
  }

  // Capture return value
  int has_result = (vm->sp > 0);
  int result = has_result ? vm->stack[vm->sp - 1] : 0;

  // Restore outer state
  vm->sp = vm->backup_sp;
  for (int i = 0; i < vm->backup_sp; i++) {
    vm->stack[i] = vm->backup_stack[i];
  }
  for (int i = 0; i < 1024; i++) {
    vm->vars[i] = vm->backup_vars[i];
  }

  vm->is_in_trang = 0;

  // Push return value onto restored stack
  push(vm, result);
}