The Perl Toolchain Summit 2025 Needs You: You can help 🙏 Learn more

KIMOTO / SPVM-0.990046 / lib / SPVM / Native / Runtime.spvm 

            

              
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

              
# Copyright (c) 2023 Yuki Kimoto
# MIT License
class Native::Runtime : pointer {
  version_from SPVM;
  allow Native;
  allow Native::Compiler;
   
  use Native::Compiler;
  use Native::Env;
  use Native::Stack;
  use Native::BasicType;
  use Native::Method;
  use Native::Arg;
  use Native::ClassVar;
  use Native::Field;
   
  use Fn;
   
  # Fields
  has compiler : Native::Compiler;
   
  has env : Native::Env;
   
  # Class Methods
  private static method new_with_pointer : Native::Runtime ($pointer : Address, $options : object[] = undef) {
     
    my $self = new Native::Runtime;
     
    Fn->set_pointer($self, $pointer);
     
    return $self;
  }
   
  # Instance Methods
  native method get_basic_types_length : int ();
   
  native method get_basic_type_by_id : Native::BasicType ($id : int);
   
  native method get_basic_type_by_name : Native::BasicType ($name : string);
   
  native method build_precompile_class_source : string ($basic_type : Native::BasicType);
   
  native method build_precompile_method_source : string ($method : Native::Method);
   
  native method get_compiler : Native::Compiler ();
   
  method get_method_by_name : Native::Method ($class_name : string, $method_name : string) {
     
    my $basic_type = $self->get_basic_type_by_name($class_name);
     
    my $method = $basic_type->get_method_by_name($method_name);
     
    return $method;
  }
   
  method get_field_by_name : Native::Field ($class_name : string, $field_name : string) {
     
    my $basic_type = $self->get_basic_type_by_name($class_name);
     
    my $field = $basic_type->get_field_by_name($field_name);
     
    return $field;
  }
   
  method get_class_var_by_name : Native::ClassVar ($class_name : string, $class_var_name : string) {
     
    my $basic_type = $self->get_basic_type_by_name($class_name);
     
    my $class_var = $basic_type->get_class_var_by_name($class_var_name);
     
    return $class_var;
  }
   
  method get_basic_types : Native::BasicType[] ($options : object[] = undef) {
     
    my $options_h = Hash->new($options);
     
    my $basic_types_length = $self->get_basic_types_length;
     
    my $basic_types_list = List->new(new Native::BasicType[0]);
     
    my $match = 1;
     
    for (my $id = 0; $id < $basic_types_length; $id++) {
      my $basic_type = $self->get_basic_type_by_id($id);
       
      if ($options_h->exists("category")) {
        my $categories = (int[])$options_h->get("category");
         
        my $category_match = 0;
        for my $category (@$categories) {
          if ($basic_type->get_category == $category) {
            $category_match = 1;
            last;
          }
        }
         
        unless ($category_match) {
          next;
        }
      }
       
      if ($options_h->exists("is_anon")) {
        my $is_anon = $options_h->get_int("is_anon");
         
        my $basic_type_name = $basic_type->get_name;
        my $basic_type_is_anon = $basic_type->is_anon;
         
        my $is_anon_match = !!$basic_type->is_anon == !!$is_anon;
         
        unless ($is_anon_match) {
          next;
        }
      }
       
      $basic_types_list->push($basic_type);
    }
     
    my $basic_types = (Native::BasicType[])$basic_types_list->to_array;
     
    return $basic_types;
  }
   
  method get_env : Native::Env () {
    return $self->{env};
  }
}