858f5658-b835-4f01-86b4-3a69cebd0b86

Committed 16 Oct 2023 06:23PM UTC coverage: 91.625% (+0.004%) from 91.621%

Build # 858f5658-b835-4f01-86b4-3a69cebd0b86

Build Type

push

circleci

Committed by Mirella de Medeiros

Commit Message

Bump version: 1.0.1 → 1.1.0

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

19988 of 21815 relevant lines covered (91.63%)

0.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.5

/boa3/internal/model/builtin/classmethod/uppermethod.py

from typing import Any, Dict, Optional

from boa3.internal.model.builtin.method.builtinmethod import IBuiltinMethod
from boa3.internal.model.type.primitive.ibytestringtype import IByteStringType
from boa3.internal.model.variable import Variable
from boa3.internal.neo.vm.opcode.Opcode import Opcode


class UpperMethod(IBuiltinMethod):
    def __init__(self, self_type: IByteStringType = None):

        if not isinstance(self_type, IByteStringType):
            from boa3.internal.model.type.type import Type
            self_type = Type.bytes

        identifier = 'upper'
        args: Dict[str, Variable] = {'self': Variable(self_type)}

        super().__init__(identifier, args, return_type=self_type)

    @property
    def _arg_self(self) -> Variable:
        return self.args['self']

    def generate_internal_opcodes(self, code_generator):
        from boa3.internal.model.builtin.builtin import Builtin
        from boa3.internal.model.operation.binaryop import BinaryOp
        from boa3.internal.neo.vm.type.Integer import Integer

        lower_a = Integer(ord('a')).to_byte_array()
        lower_z = Integer(ord('z')).to_byte_array()

        # string = arg
        code_generator.duplicate_stack_top_item()
        # max_index = len(arg)
        code_generator.convert_builtin_method_call(Builtin.Len, is_internal=True)

        # index = 0
        code_generator.convert_literal(0)

        # while index < max_index
        while_begin = code_generator.convert_begin_while()

        #   substr_left = string[:index]
        code_generator.swap_reverse_stack_items(3)
        code_generator.duplicate_stack_top_item()
        code_generator.duplicate_stack_item(4)
        code_generator.duplicate_stack_item(2)
        code_generator.duplicate_stack_item(2)
        code_generator.convert_get_sequence_beginning()
        code_generator.swap_reverse_stack_items(3, rotate=True)
        code_generator.swap_reverse_stack_items(3, rotate=True)

        #   modifier = 1, since using upper is only supported with ASCII for now
        code_generator.duplicate_stack_item(2)  # TODO: verify if string[index] < c0 when other values are implemented
        code_generator.duplicate_stack_item(2)
        code_generator.convert_literal(1)

        #   substr_middle = string[index:index+modifier]
        code_generator.convert_get_substring(is_internal=True)

        #   if 'a' <= substr_middle <= 'z':
        code_generator.duplicate_stack_top_item()
        code_generator.convert_literal(lower_a)
        if_lower_than_a = code_generator.convert_begin_if()
        code_generator.change_jump(if_lower_than_a, Opcode.JMPLT)

        code_generator.duplicate_stack_top_item()
        code_generator.convert_literal(lower_z)
        if_greater_than_z = code_generator.convert_begin_if()
        code_generator.change_jump(if_greater_than_z, Opcode.JMPGT)

        #       substr_middle = lower(substr_middle)
        code_generator.convert_literal(ord('a') - ord('A'))
        code_generator.convert_operation(BinaryOp.Sub, is_internal=True)
        code_generator.convert_cast(self.type)

        code_generator.convert_end_if(if_greater_than_z)
        code_generator.convert_end_if(if_lower_than_a)

        #   substr_right = string[index+modifier:]
        code_generator.swap_reverse_stack_items(3, rotate=True)
        code_generator.swap_reverse_stack_items(3, rotate=True)
        code_generator.insert_opcode(Opcode.INC)
        code_generator.convert_get_sequence_ending()

        concat = BinaryOp.Concat.build(self.type, self.type)  # ensure the correct type on generator stack
        #   string = substr_left + substr_middle + substr_right
        code_generator.convert_operation(concat, is_internal=True)
        code_generator.convert_operation(concat)
        code_generator.remove_stack_item(2)
        code_generator.swap_reverse_stack_items(3)

        #   index += 1
        code_generator.insert_opcode(Opcode.INC)

        while_condition = code_generator.bytecode_size
        code_generator.duplicate_stack_item(2)
        code_generator.duplicate_stack_item(2)
        code_generator.convert_operation(BinaryOp.Gt, is_internal=True)

        code_generator.convert_end_while(while_begin, while_condition, is_internal=True)

        # clean stack
        code_generator.remove_stack_top_item()
        code_generator.remove_stack_top_item()

    def push_self_first(self) -> bool:
        return self.has_self_argument

    @property
    def _args_on_stack(self) -> int:
        return len(self.args)

    @property
    def _body(self) -> Optional[str]:
        return None

    def build(self, value: Any) -> IBuiltinMethod:
        if isinstance(value, IByteStringType):
            return UpperMethod(value)
        return super().build(value)

1	from typing import Any, Dict, Optional	1✔
2
3	from boa3.internal.model.builtin.method.builtinmethod import IBuiltinMethod	1✔
4	from boa3.internal.model.type.primitive.ibytestringtype import IByteStringType	1✔
5	from boa3.internal.model.variable import Variable	1✔
6	from boa3.internal.neo.vm.opcode.Opcode import Opcode	1✔
7
8
9	class UpperMethod(IBuiltinMethod):	1✔
10	def __init__(self, self_type: IByteStringType = None):	1✔
11
12	if not isinstance(self_type, IByteStringType):	1✔
13	from boa3.internal.model.type.type import Type	1✔
14	self_type = Type.bytes	1✔
15
16	identifier = 'upper'	1✔
17	args: Dict[str, Variable] = {'self': Variable(self_type)}	1✔
18
19	super().__init__(identifier, args, return_type=self_type)	1✔
20
21	@property	1✔
22	def _arg_self(self) -> Variable:	1✔
23	return self.args['self']	×
24
25	def generate_internal_opcodes(self, code_generator):	1✔
26	from boa3.internal.model.builtin.builtin import Builtin	1✔
27	from boa3.internal.model.operation.binaryop import BinaryOp	1✔
28	from boa3.internal.neo.vm.type.Integer import Integer	1✔
29
30	lower_a = Integer(ord('a')).to_byte_array()	1✔
31	lower_z = Integer(ord('z')).to_byte_array()	1✔
32
33	# string = arg
34	code_generator.duplicate_stack_top_item()	1✔
35	# max_index = len(arg)
36	code_generator.convert_builtin_method_call(Builtin.Len, is_internal=True)	1✔
37
38	# index = 0
39	code_generator.convert_literal(0)	1✔
40
41	# while index < max_index
42	while_begin = code_generator.convert_begin_while()	1✔
43
44	# substr_left = string[:index]
45	code_generator.swap_reverse_stack_items(3)	1✔
46	code_generator.duplicate_stack_top_item()	1✔
47	code_generator.duplicate_stack_item(4)	1✔
48	code_generator.duplicate_stack_item(2)	1✔
49	code_generator.duplicate_stack_item(2)	1✔
50	code_generator.convert_get_sequence_beginning()	1✔
51	code_generator.swap_reverse_stack_items(3, rotate=True)	1✔
52	code_generator.swap_reverse_stack_items(3, rotate=True)	1✔
53
54	# modifier = 1, since using upper is only supported with ASCII for now
55	code_generator.duplicate_stack_item(2) # TODO: verify if string[index] < c0 when other values are implemented	1✔
56	code_generator.duplicate_stack_item(2)	1✔
57	code_generator.convert_literal(1)	1✔
58
59	# substr_middle = string[index:index+modifier]
60	code_generator.convert_get_substring(is_internal=True)	1✔
61
62	# if 'a' <= substr_middle <= 'z':
63	code_generator.duplicate_stack_top_item()	1✔
64	code_generator.convert_literal(lower_a)	1✔
65	if_lower_than_a = code_generator.convert_begin_if()	1✔
66	code_generator.change_jump(if_lower_than_a, Opcode.JMPLT)	1✔
67
68	code_generator.duplicate_stack_top_item()	1✔
69	code_generator.convert_literal(lower_z)	1✔
70	if_greater_than_z = code_generator.convert_begin_if()	1✔
71	code_generator.change_jump(if_greater_than_z, Opcode.JMPGT)	1✔
72
73	# substr_middle = lower(substr_middle)
74	code_generator.convert_literal(ord('a') - ord('A'))	1✔
75	code_generator.convert_operation(BinaryOp.Sub, is_internal=True)	1✔
76	code_generator.convert_cast(self.type)	1✔
77
78	code_generator.convert_end_if(if_greater_than_z)	1✔
79	code_generator.convert_end_if(if_lower_than_a)	1✔
80
81	# substr_right = string[index+modifier:]
82	code_generator.swap_reverse_stack_items(3, rotate=True)	1✔
83	code_generator.swap_reverse_stack_items(3, rotate=True)	1✔
84	code_generator.insert_opcode(Opcode.INC)	1✔
85	code_generator.convert_get_sequence_ending()	1✔
86
87	concat = BinaryOp.Concat.build(self.type, self.type) # ensure the correct type on generator stack	1✔
88	# string = substr_left + substr_middle + substr_right
89	code_generator.convert_operation(concat, is_internal=True)	1✔
90	code_generator.convert_operation(concat)	1✔
91	code_generator.remove_stack_item(2)	1✔
92	code_generator.swap_reverse_stack_items(3)	1✔
93
94	# index += 1
95	code_generator.insert_opcode(Opcode.INC)	1✔
96
97	while_condition = code_generator.bytecode_size	1✔
98	code_generator.duplicate_stack_item(2)	1✔
99	code_generator.duplicate_stack_item(2)	1✔
100	code_generator.convert_operation(BinaryOp.Gt, is_internal=True)	1✔
101
102	code_generator.convert_end_while(while_begin, while_condition, is_internal=True)	1✔
103
104	# clean stack
105	code_generator.remove_stack_top_item()	1✔
106	code_generator.remove_stack_top_item()	1✔
107
108	def push_self_first(self) -> bool:	1✔
109	return self.has_self_argument	1✔
110
111	@property	1✔
112	def _args_on_stack(self) -> int:	1✔
113	return len(self.args)	1✔
114
115	@property	1✔
116	def _body(self) -> Optional[str]:	1✔
117	return None	×
118
119	def build(self, value: Any) -> IBuiltinMethod:	1✔
120	if isinstance(value, IByteStringType):	1✔
121	return UpperMethod(value)	1✔
122	return super().build(value)	1✔

CityOfZion / neo3-boa / 858f5658-b835-4f01-86b4-3a69cebd0b86

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous