L1VM pointers

I did add a new feature to my L1VM interrupts: check_pointer

     // set pointers, use new check_pointer interrupt for pointer type checks
    (person.first_name~ Pfirst_name~ pointer)
    check_pointer (Pfirst_name~, byte_ptr)

This checks if a pointer has the given variable type. In this case if it is a “byte_ptr” (string type). If it is not a byte type, then a runtime error will happen!

UPDATE I did add a new interrupt: pointer_type It returns the pointer variable type.

The type definitions are in: vars.l1h.

I did update my “people-object.l1com” example:

// people-object.l1com
// use . variable names to build something like a pseudo data structure like in other
// programming languages
//
#include <intr.l1h>
#include <vars.l1h>
(main func)
    (set int64 1 zero 0)
    (set int64 1 one  1)
    // person data with person. names
    (set string 256 person.first_name "Jane")
    (set string 256 person.last_name "Doe")
    (set string 256 person.gender "female")
    (set int64 1 person.age 30)
    (set double 1 person.height 1.80)
    (set string 256 person.eye_color "brown")
    (set string s meminitstr "ERROR can't init memory!")
    (set string s memerrstr "ERROR can't allocate memory!")
    (set string s saveerrstr "ERROR can't save to memory object!")
    (set int64 1 memaddr 0)
    (set int64 1 memind 0)
    (set int64 1 memsize 1)
    (set int64 1 variables 6)
    (set int64 1 ret 0)
    (set int64 1 f 0)
    // include memory object variable types
    #include <mem-obj-lib-types.l1h>
    (zero one :mem_obj_init call)
    (ret stpopi)
    (((ret zero !=) f =) f if)
        // ERROR can't allocate memory
        print_s (meminitstr)
        print_n
        exit (one)
    (endif)
    // allocate memory for the 6 variables
    (variables memsize :alloc_obj_memobj call)
    (memaddr stpopi)
    (loadreg)
    (((memaddr zero <) f =) f if)
        // ERROR can't allocate memory
        print_s (memerrstr)
        print_n
        exit (one)
    (endif)

    // store person data in mem object using memory variable types: s_type, i_type and d_type
    // going from right to left with variable types first before variable
    (person.eye_color s_type person.height d_type person.age i_type person.gender s_type person.last_name s_type person.first_name s_type variables zero memaddr :save_obj_memobj !)
    (ret stpopi)
    (((ret zero !=) f =) f if)
        // ERROR can't allocate memory
        print_s (saveerrstr)
        print_n
        exit (one)
    (endif)
    (memaddr :person_list_data !)
    free_mod (zero)
    exit (zero)
(funcend)

// get person data from mem object
(person_list_data func)
    #var ~ person_list_data
    (set int64 1 f~)
    (set int64 1 zero~ 0)
    (set int64 1 variables~ 6)
    (set int64 1 memaddr~ 0)
    (set int64 1 ret~ 0)
    (set string s height_format~ "%.2lf")
    (set string 256 person.first_name~ "")
    (set string 256 person.last_name~ "")
    (set string 256 person.gender~ "")
    (set int64 1 person.age~ 0)
    (set double 1 person.height~ 0.0)
    (set string 256 person.eye_color~ "")
    // data pointer, make only changeable by "pointer" function to avoid memory errors
    (set const-int64 1 Pfirst_name~ 0)
    (set const-int64 1 Plast_name~ 0)
    (set const-int64 1 Pgender~ 0)
    (set const-int64 1 Page~ 0)
    (set const-int64 1 Pheight~ 0)
    (set const-int64 1 Peye_color~ 0)
    // get mem address of person data
    (memaddr~ stpopi)

     // set pointers, use new check_pointer interrupt for pointer type checks
    (person.first_name~ Pfirst_name~ pointer)
    check_pointer (Pfirst_name~, byte_ptr)

    (person.last_name~ Plast_name~ pointer)
    check_pointer (Plast_name~, byte_ptr)

    (person.gender~ Pgender~ pointer)
    check_pointer (Pgender~, byte_ptr)

    (person.age~ Page~ pointer)
    check_pointer (Page~, int64_ptr)

    (person.height~ Pheight~ pointer)
    check_pointer (Pheight~, double_ptr)

    (person.eye_color~ Peye_color~ pointer)
    check_pointer (Peye_color~, byte_ptr)

    (Peye_color~ Pheight~ Page~ Pgender~ Plast_name~ Pfirst_name~ variables~ zero~ memaddr~ :load_obj_array_memobj !)
    (ret stpopi)

    print_s (person.first_name~)
    print_n
    print_s (person.last_name~)
    print_n
    print_s (person.gender~)
    print_n
    print_i (person.age~)
    print_n
    printf_d (height_format~, person.height~)
    print_n
    print_s (person.eye_color~)
    print_n
(funcend)
#include <mem-obj-lib.l1h>


I did write a new example: hello-print.l1com. It uses the new pointer_type interrupt to get the variable type the pointer points at.

// hello-print.l1com
// This shows how to use the pointer_type interrupt to get the pointer array variable type.
//
#include <intr.l1h>
#include <vars.l1h>
#include <misc-macros.l1h>
(main func)
    (set const-int64 1 zero 0)
    (set int64 1 x 23)
    (set int64 1 y 42)
    (set int64 1 a 0)
    (set string 13 hello "Hello world!")
    (set double 1 d 123.456)
    (set int64 1 Pvar 0)

    // get string pointer
    (hello Pvar pointer)
    (Pvar :print_var !)
    print_n

    ((x y *) a =)
    // get int64 pointer
    (a Pvar pointer)
    (Pvar :print_var !)
    print_n

    // get double pointer
    (d Pvar pointer)
    (Pvar :print_var !)
    print_n

    exit (zero)
(funcend)

(print_var func)
    // Print variable the pointer points at.
    #var ~ print_var
    (set const-int64 1 zero~ 0)
    (set int64 1 Pvar~ 0)
    (set int64 1 vartype~ 0)
    (set int64 1 f~ 0)
    (set int64 1 int_var~)
    (set double 1 double_var~)
    (Pvar~ stpop)
    // get pointer type
    pointer_type (Pvar~, vartype~)
    // pull vartype~ to variable
    pull_int64_var (vartype~)

    // Check pointer type and print the variable.
    (switch)
        (vartype~ byte_ptr ?)
            print_s (Pvar~)
            (break)

        (vartype~ int64_ptr ?)
            (Pvar~ [ zero~ ] int_var~ =)
            print_i (int_var~)
            (break)

        (vartype~ double_ptr ?)
            (Pvar~ [ zero~ ] double_var~ =)
            print_d (double_var~)
            (break)
    (switchend)
(funcend)