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
|
# Copyright 2021 The Meson development team
# SPDX-license-identifier: Apache-2.0
import typing as T
from ...interpreterbase import (
ObjectHolder,
IterableObject,
MesonOperator,
typed_operator,
noKwargs,
noPosargs,
noArgsFlattening,
typed_pos_args,
TYPE_var,
TYPE_kwargs,
InvalidArguments,
)
if T.TYPE_CHECKING:
# Object holders need the actual interpreter
from ...interpreter import Interpreter
class ArrayHolder(ObjectHolder[T.List[TYPE_var]], IterableObject):
def __init__(self, obj: T.List[TYPE_var], interpreter: 'Interpreter') -> None:
super().__init__(obj, interpreter)
self.methods.update({
'contains': self.contains_method,
'length': self.length_method,
'get': self.get_method,
})
self.trivial_operators.update({
MesonOperator.EQUALS: (list, lambda x: self.held_object == x),
MesonOperator.NOT_EQUALS: (list, lambda x: self.held_object != x),
MesonOperator.IN: (object, lambda x: x in self.held_object),
MesonOperator.NOT_IN: (object, lambda x: x not in self.held_object),
})
# Use actual methods for functions that require additional checks
self.operators.update({
MesonOperator.PLUS: self.op_plus,
MesonOperator.INDEX: self.op_index,
})
def display_name(self) -> str:
return 'array'
def iter_tuple_size(self) -> None:
return None
def iter_self(self) -> T.Iterator[TYPE_var]:
return iter(self.held_object)
def size(self) -> int:
return len(self.held_object)
@noArgsFlattening
@noKwargs
@typed_pos_args('array.contains', object)
def contains_method(self, args: T.Tuple[object], kwargs: TYPE_kwargs) -> bool:
def check_contains(el: T.List[TYPE_var]) -> bool:
for element in el:
if isinstance(element, list):
found = check_contains(element)
if found:
return True
if element == args[0]:
return True
return False
return check_contains(self.held_object)
@noKwargs
@noPosargs
def length_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> int:
return len(self.held_object)
@noArgsFlattening
@noKwargs
@typed_pos_args('array.get', int, optargs=[object])
def get_method(self, args: T.Tuple[int, T.Optional[TYPE_var]], kwargs: TYPE_kwargs) -> TYPE_var:
index = args[0]
if index < -len(self.held_object) or index >= len(self.held_object):
if args[1] is None:
raise InvalidArguments(f'Array index {index} is out of bounds for array of size {len(self.held_object)}.')
return args[1]
return self.held_object[index]
@typed_operator(MesonOperator.PLUS, object)
def op_plus(self, other: TYPE_var) -> T.List[TYPE_var]:
if not isinstance(other, list):
other = [other]
return self.held_object + other
@typed_operator(MesonOperator.INDEX, int)
def op_index(self, other: int) -> TYPE_var:
try:
return self.held_object[other]
except IndexError:
raise InvalidArguments(f'Index {other} out of bounds of array of size {len(self.held_object)}.')
|
