spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "xvm.c"

/* ... */

// Read byte code from file
xvm_bytecode byte_code;
xvm_bytecode_init(&byte_code);

if (xvm_bytecode_read_from_file(&byte_code, filename) == 0)
{
    log_readfile_error(filename);
    return 0;
}

// Create stack
size_t stack_size = 512;
xvm_stack stack;
xvm_stack_init(&stack);
xvm_stack_create(&stack, stack_size);

// Execute program
const xvm_exit_codes exit_code = xvm_execute_program(&byte_code, &stack, NULL);

if (exit_code != EXITCODE_SUCCESS)
    log_exitcode_error(exit_code);
else if (verbose != 0)
    log_println("Program terminated successful");

// Clean up
xvm_bytecode_free(&byte_code);
xvm_stack_free(&stack);

Quellcode

; Test
; 07/07/2014

        call    Main
        stop                    ; quit
Main:   mov     $r1, @lng0      ; load value of 'lng0'
        add     $sp, 4          ; increase stack for local scope (4 bytes)
        stw     $r1, ($lb) 8    ; store value of $r1 in local scope (after dynamic-link)
        ldw     $r2, str0       ; load address of 'str0'
        xor     $r0, $r0        ; i := 0
        mov     $r1, 10         ; n := 10
.for0:  cmp     $r0, $r1        ; while i < 10
        jge     .end0
        push    $r2
        call    Intr.PrintLn    ; print str0 with new-line
        inc     $r0             ; i++
        jmp     .for0
.end0:  ret     (0) 0           ; return

str0:   .ascii  "Hello, World!"
lng0:   .word   999

Quellcode

; Reflective XASM code
; Program cycle:
;   call main
;   overwrite 4 instructions from 'func' to 'main'
;   push arguments on stack
;   call main again -> this time the code from 'func' will be executed

        call    main
        stop
main:   lda     $r1, @main      ; load address of 'main'
        lda     $r2, @func      ; load address of 'func'
        ldw     $r3, ($r2) 0    ; load first instruction from func[0]
        stw     $r3, ($r1) 0    ; write first instruction to main[0]
        ldw     $r3, ($r2) 4    ; load second instruction from func[1]
        stw     $r3, ($r1) 4    ; ...
        ldw     $r3, ($r2) 8
        stw     $r3, ($r1) 8
        ldw     $r3, ($r2) 12
        stw     $r3, ($r1) 12
        push    10
        call    main
func:   ldw     $r0, ($lb) -4   ; get argument0
        add     $r0, $r0        ; r0 := r0 + r0 (r0 *= 2)
        stw     $r0, ($lb) -4   ; write result back to argument0
        ret     (0) 0

; After execution the code looks like this:

        call    main
        stop
main:   ldw     $r0, ($lb) -4   ; get argument0
        add     $r0, $r0        ; r0 := r0 + r0 (r0 *= 2)
        stw     $r0, ($lb) -4   ; write result back to argument0
        ret     (0) 0           ; return to 'stop' instruction
        ldw     $r3, ($r2) 4    ; ...
        stw     $r3, ($r1) 4
        ldw     $r3, ($r2) 8
        stw     $r3, ($r1) 8
        ldw     $r3, ($r2) 12
        stw     $r3, ($r1) 12
        push    10
        call    main
func:   ldw     $r0, ($lb) -4   ; get argument0
        add     $r0, $r0        ; r0 := r0 + r0 (r0 *= 2)
        stw     $r0, ($lb) -4   ; write result back to argument0
        ret     (0) 0