Module: MilkTea::Lowering::StrBuffer

Included in:
MilkTea::Lowerer
Defined in:
lib/milk_tea/core/lowering/str_buffer.rb

Instance Method Summary collapse

Instance Method Details

#lower_char_array_data_pointer(expression, env:) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 57

def lower_char_array_data_pointer(expression, env:)
  lowered_receiver = lower_expression(expression, env:)
  IR::AddressOf.new(
    expression: IR::Index.new(
      receiver: lowered_receiver,
      index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
      type: @ctx.types.fetch("char"),
    ),
    type: pointer_to(@ctx.types.fetch("char")),
  )
end

#lower_str_buffer_data_pointer(expression, env:) ⇒ Object 



69
70
71
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 69

def lower_str_buffer_data_pointer(expression, env:)
  lower_str_buffer_data_pointer_from_lowered(lower_expression(expression, env:))
end

#lower_str_buffer_data_pointer_from_lowered(lowered_receiver) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 73

def lower_str_buffer_data_pointer_from_lowered(lowered_receiver)
  IR::AddressOf.new(
    expression: IR::Index.new(
      receiver: IR::Member.new(
        receiver: lowered_receiver,
        member: "data",
        type: Types::Registry.generic_instance(
          "array",
          [@ctx.types.fetch("char"), Types::LiteralTypeArg.new(str_buffer_storage_capacity(lowered_receiver.type))],
        ),
      ),
      index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
      type: @ctx.types.fetch("char"),
    ),
    type: pointer_to(@ctx.types.fetch("char")),
  )
end

#lower_str_buffer_dirty_pointer(expression, env:) ⇒ Object 



102
103
104
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 102

def lower_str_buffer_dirty_pointer(expression, env:)
  lower_str_buffer_dirty_pointer_from_lowered(lower_expression(expression, env:))
end

#lower_str_buffer_dirty_pointer_from_lowered(lowered_receiver) ⇒ Object 



106
107
108
109
110
111
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 106

def lower_str_buffer_dirty_pointer_from_lowered(lowered_receiver)
  IR::AddressOf.new(
    expression: IR::Member.new(receiver: lowered_receiver, member: "dirty", type: @ctx.types.fetch("bool")),
    type: pointer_to(@ctx.types.fetch("bool")),
  )
end

#lower_str_buffer_len_pointer(expression, env:) ⇒ Object 



91
92
93
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 91

def lower_str_buffer_len_pointer(expression, env:)
  lower_str_buffer_len_pointer_from_lowered(lower_expression(expression, env:))
end

#lower_str_buffer_len_pointer_from_lowered(lowered_receiver) ⇒ Object 



95
96
97
98
99
100
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 95

def lower_str_buffer_len_pointer_from_lowered(lowered_receiver)
  IR::AddressOf.new(
    expression: IR::Member.new(receiver: lowered_receiver, member: "len", type: @ctx.types.fetch("ptr_uint")),
    type: pointer_to(@ctx.types.fetch("ptr_uint")),
  )
end

#str_buffer_args(receiver, env:) ⇒ Object 



113
114
115
116
117
118
119
120
121
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 113

def str_buffer_args(receiver, env:)
  receiver_type = infer_expression_type(receiver, env:)
  [
    lower_str_buffer_data_pointer(receiver, env:),
    IR::IntegerLiteral.new(value: str_buffer_capacity(receiver_type), type: @ctx.types.fetch("ptr_uint")),
    lower_str_buffer_len_pointer(receiver, env:),
    lower_str_buffer_dirty_pointer(receiver, env:),
  ]
end

#str_buffer_method_kind(receiver_type, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 6

def str_buffer_method_kind(receiver_type, name)
  return unless str_buffer_type?(receiver_type)

  case name
  when "clear"
    :str_buffer_clear
  when "assign"
    :str_buffer_assign
  when "append"
    :str_buffer_append
  when "assign_format"
    :str_buffer_assign_format
  when "append_format"
    :str_buffer_append_format
  when "len"
    :str_buffer_len
  when "capacity"
    :str_buffer_capacity
  when "as_str"
    :str_buffer_as_str
  when "as_cstr"
    :str_buffer_as_cstr
  end
end

#str_buffer_method_type(kind, receiver_type) ⇒ Object 



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
 
# File 'lib/milk_tea/core/lowering/str_buffer.rb', line 31

def str_buffer_method_type(kind, receiver_type)
  return_type, params = case kind
                        when :str_buffer_clear
                          [@ctx.types.fetch("void"), []]
                        when :str_buffer_assign, :str_buffer_append, :str_buffer_assign_format, :str_buffer_append_format
                          [@ctx.types.fetch("void"), [Types::Registry.parameter("value", @ctx.types.fetch("str"))]]
                        when :str_buffer_len, :str_buffer_capacity
                          [@ctx.types.fetch("ptr_uint"), []]
                        when :str_buffer_as_str
                          [@ctx.types.fetch("str"), []]
                        when :str_buffer_as_cstr
                          [@ctx.types.fetch("cstr"), []]
                        else
                          raise LoweringError.new("unsupported str_buffer method #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
                        end

  Types::Registry.function(
    kind.to_s,
    params:,
    return_type:,
    receiver_type:,
    receiver_editable: %i[str_buffer_clear str_buffer_assign str_buffer_append str_buffer_assign_format str_buffer_append_format].include?(kind),
    external: false,
  )
end