L1VM - pointers
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)