# This file is part of Metasm, the Ruby assembly manipulation suite
# Copyright (C) 2006-2009 Yoann GUILLOT
#
# Licence is LGPL, see LICENCE in the top-level directory
require 'metasm/main'
require 'metasm/parse_c'
module Metasm
module C
class Parser
def precompile
@toplevel.precompile(Compiler.new(self))
self
end
end
# each CPU defines a subclass of this one
class Compiler
# an ExeFormat (mostly used for unique label creation)
attr_accessor :exeformat
# the C Parser (destroyed by compilation)
attr_accessor :parser
# an array of assembler statements (strings)
attr_accessor :source
# list of unique labels generated (to recognize user-defined ones)
attr_accessor :auto_label_list
# map asm name -> original C name (for exports etc)
attr_accessor :label_oldname
attr_accessor :curexpr
# allows 'raise self' (eg struct.offsetof)
def exception(msg='EOF unexpected')
ParseError.new "near #@curexpr: #{msg}"
end
# creates a new CCompiler from an ExeFormat and a C Parser
def initialize(parser, exeformat=ExeFormat.new, source=[])
@parser, @exeformat, @source = parser, exeformat, source
@auto_label_list = {}
@label_oldname = {}
end
def new_label(base='')
lbl = @exeformat.new_label base
@auto_label_list[lbl] = true
lbl
end
def toplevel ; @parser.toplevel end
def typesize ; @parser.typesize end
def sizeof(*a) @parser.sizeof(*a) end
# compiles the c parser toplevel to assembler statements in self.source (::Array of ::String)
#
# starts by precompiling parser.toplevel (destructively):
# static symbols are converted to toplevel ones, as nested functions
# uses an ExeFormat (the argument) to create unique label/variable names
#
# remove typedefs/enums
# CExpressions: all expr types are converted to __int8/__int16/__int32/__int64 (sign kept) (incl. ptr), + void
# struct member dereference/array indexes are converted to *(ptr + off)
# coma are converted to 2 statements, ?: are converted to If
# :|| and :&& are converted to If + assignment to temporary
# immediate quotedstrings/floats are converted to references to const static toplevel
# postincrements are replaced by a temporary (XXX arglist)
# compound statements are unnested
# Asm are kept (TODO precompile clobber types)
# Declarations: initializers are converted to separate assignment CExpressions
# Blocks are kept unless empty
# structure dereferences/array indexing are converted to *(ptr + offset)
# While/For/DoWhile/Switch are converted to If/Goto
# Continue/Break are converted to Goto
# Cases are converted to Labels during Switch conversion
# Label statements are removed
# Return: 'return <foo>;' => 'return <foo>; goto <end_of_func>;', 'return;' => 'goto <eof>;'
# If: 'if (a) b; else c;' => 'if (a) goto l1; { c; }; goto l2; l1: { b; } l2:'
# && and || in condition are expanded to multiple If
# functions returning struct are precompiled (in Declaration/CExpression/Return)
#
# in a second phase, unused labels are removed from functions, as noop goto (goto x; x:)
# dead code is removed ('goto foo; bar; baz:' => 'goto foo; baz:') (TODO)
#
# after that, toplevel is no longer valid C (bad types, blocks moved...)
#
# then toplevel statements are sorted (.text, .data, .rodata, .bss) and compiled into asm statements in self.source
#
# returns the asm source in a single string
def compile
cf = @exeformat.unique_labels_cache.keys & @auto_label_list.keys
raise "compile_c name conflict: #{cf.inspect}" if not cf.empty?
@exeformat.unique_labels_cache.update @auto_label_list
@parser.toplevel.precompile(self)
# reorder statements (arrays of Variables) following exe section typical order
funcs, rwdata, rodata, udata = [], [], [], []
@parser.toplevel.statements.each { |st|
if st.kind_of? Asm
@source << st.body
next
end
raise 'non-declaration at toplevel! ' + st.inspect if not st.kind_of? Declaration
v = st.var
if v.type.kind_of? Function
funcs << v if v.initializer # no initializer == storage :extern
elsif v.storage == :extern
elsif v.initializer
if v.type.qualifier.to_a.include?(:const) or
(v.type.kind_of? Array and v.type.type.qualifier.to_a.include?(:const))
rodata << v
else
rwdata << v
end
else
udata << v
end
}
if not funcs.empty?
@exeformat.compile_setsection @source, '.text'
funcs.each { |func| c_function(func) }
c_program_epilog
end
align = 1
if not rwdata.empty?
@exeformat.compile_setsection @source, '.data'
rwdata.each { |data| align = c_idata(data, align) }
end
if not rodata.empty?
@exeformat.compile_setsection @source, '.rodata'
rodata.each { |data| align = c_idata(data, align) }
end
if not udata.empty?
@exeformat.compile_setsection @source, '.bss'
udata.each { |data| align = c_udata(data, align) }
end
# needed to allow asm parser to use our autogenerated label names
@exeformat.unique_labels_cache.delete_if { |k, v| @auto_label_list[k] }
@source.join("\n")
end
# compiles a C function +func+ to asm source into the array of strings +str+
# in a first pass the stack variable offsets are computed,
# then each statement is compiled in turn
def c_function(func)
# must wait the Declaration to run the CExpr for dynamic auto offsets,
# and must run those statements once only
# TODO alloc a stack variable to maintain the size for each dynamic array
# TODO offset of arguments
# TODO nested function
c_init_state(func)
# hide the full @source while compiling, then add prolog/epilog (saves 1 pass)
@source << ''
@source << "#{@label_oldname[func.name]}:" if @label_oldname[func.name]
@source << "#{func.name}:"
presource, @source = @source, []
c_block(func.initializer)
tmpsource, @source = @source, presource
c_prolog
@source.concat tmpsource
c_epilog
@source << ''
end
def c_block(blk)
c_block_enter(blk)
blk.statements.each { |stmt|
case stmt
when CExpression; c_cexpr(stmt)
when Declaration; c_decl(stmt.var)
when If; c_ifgoto(stmt.test, stmt.bthen.target)
when Goto; c_goto(stmt.target)
when Label; c_label(stmt.name)
when Return; c_return(stmt.value)
when Asm; c_asm(stmt)
when Block; c_block(stmt)
else raise
end
}
c_block_exit(blk)
end
def c_block_enter(blk)
end
def c_block_exit(blk)
end
def c_label(name)
@source << "#{name}:"
end
# fills @state.offset (empty hash)
# automatic variable => stack offset, (recursive)
# offset is an ::Integer or a CExpression (dynamic array)
# assumes offset 0 is a ptr-size-aligned address
# TODO registerize automatic variables
def c_reserve_stack(block, off = 0)
block.statements.each { |stmt|
case stmt
when Declaration
next if stmt.var.type.kind_of? Function
off = c_reserve_stack_var(stmt.var, off)
@state.offset[stmt.var] = off
when Block
c_reserve_stack(stmt, off)
# do not update off, not nested subblocks can overlap
end
}
end
# computes the new stack offset for var
# off is either an offset from stack start (:ptr-size-aligned) or
# a CExpression [[[expr, +, 7], &, -7], +, off]
def c_reserve_stack_var(var, off)
if (arr_type = var.type).kind_of? Array and (arr_sz = arr_type.length).kind_of? CExpression
# dynamic array !
arr_sz = CExpression.new(arr_sz, :*, sizeof(nil, arr_type.type),
BaseType.new(:long, :unsigned)).precompile_inner(@parser, nil)
off = CExpression.new(arr_sz, :+, off, arr_sz.type)
off = CExpression.new(off, :+, 7, off.type)
off = CExpression.new(off, :&, -7, off.type)
CExpression.new(off, :+, 0, off.type)
else
al = var.type.align(@parser)
sz = sizeof(var)
case off
when CExpression; CExpression.new(off.lexpr, :+, ((off.rexpr + sz + al - 1) / al * al), off.type)
else (off + sz + al - 1) / al * al
end
end
end
# here you can add thing like stubs for PIC code
def c_program_epilog
end
# compiles a C static data definition into an asm string
# returns the new alignment value
def c_idata(data, align)
w = data.type.align(@parser)
@source << ".align #{align = w}" if w > align
@source << "#{@label_oldname[data.name]}:" if @label_oldname[data.name]
@source << data.name.dup
len = c_idata_inner(data.type, data.initializer)
len %= w
len == 0 ? w : len
end
# dumps an anonymous variable definition, appending to the last line of source
# source.last is a label name or is empty before calling here
# return the length of the data written
def c_idata_inner(type, value)
case type
when BaseType
value ||= 0
if type.name == :void
@source.last << ':' if not @source.last.empty?
return 0
end
@source.last <<
case type.name
when :__int8; ' db '
when :__int16; ' dw '
when :__int32; ' dd '
when :__int64; ' dq '
when :ptr; " d#{%w[x b w x d x x x q][@parser.typesize[type.name]]} "
when :float; ' db ' + [value].pack(@parser.endianness == :little ? 'e' : 'g').unpack('C*').join(', ') + ' // '
when :double; ' db ' + [value].pack(@parser.endianness == :little ? 'E' : 'G').unpack('C*').join(', ') + ' // '
when :longdouble; ' db ' + [value].pack(@parser.endianness == :little ? 'E' : 'G').unpack('C*').join(', ') + ' // ' # XXX same as :double
else raise "unknown idata type #{type.inspect} #{value.inspect}"
end
@source.last << c_idata_inner_cexpr(value)
@parser.typesize[type.name]
when Struct
value ||= []
@source.last << ':' if not @source.last.empty?
# could .align here, but if there is our label name just before, it should have been .aligned too..
raise "unknown struct initializer #{value.inspect}" if not value.kind_of? ::Array
sz = 0
type.members.zip(value).each { |m, v|
if m.name and wsz = type.offsetof(@parser, m.name) and sz < wsz
@source << "db #{wsz-sz} dup(?)"
end
@source << ''
flen = c_idata_inner(m.type, v)
sz += flen
}
sz
when Union
value ||= []
@source.last << ':' if not @source.last.empty?
len = sizeof(nil, type)
raise "unknown union initializer #{value.inspect}" if not value.kind_of? ::Array
idx = value.rindex(value.compact.last) || 0
raise "empty union initializer" if not idx
wlen = c_idata_inner(type.members[idx].type, value[idx])
@source << "db #{'0' * (len - wlen) * ', '}" if wlen < len
len
when Array
value ||= []
if value.kind_of? CExpression and not value.op and value.rexpr.kind_of? ::String
elen = sizeof(nil, value.type.type)
@source.last <<
case elen
when 1; ' db '
when 2; ' dw '
else raise 'bad char* type ' + value.inspect
end << value.rexpr.inspect
len = type.length || (value.rexpr.length+1)
if len > value.rexpr.length
@source.last << (', 0' * (len - value.rexpr.length))
end
elen * len
elsif value.kind_of? ::Array
@source.last << ':' if not @source.last.empty?
len = type.length || value.length
value.each { |v|
@source << ''
c_idata_inner(type.type, v)
}
len -= value.length
if len > 0
@source << " db #{len * sizeof(nil, type.type)} dup(0)"
end
sizeof(nil, type.type) * len
else raise "unknown static array initializer #{value.inspect}"
end
end
end
def c_idata_inner_cexpr(expr)
expr = expr.reduce(@parser) if expr.kind_of? CExpression
case expr
when ::Integer; (expr >= 4096) ? ('0x%X' % expr) : expr.to_s
when ::Numeric; expr.to_s
when Variable
case expr.type
when Array; expr.name
else c_idata_inner_cexpr(expr.initializer)
end
when CExpression
if not expr.lexpr
case expr.op
when :&
case expr.rexpr
when Variable; expr.rexpr.name
else raise 'unhandled addrof in initializer ' + expr.rexpr.inspect
end
#when :*
when :+; c_idata_inner_cexpr(expr.rexpr)
when :-; ' -' << c_idata_inner_cexpr(expr.rexpr)
when nil
e = c_idata_inner_cexpr(expr.rexpr)
if expr.rexpr.kind_of? CExpression
e = '(' << e << " & 0#{'ff'*sizeof(expr)}h)"
end
e
else raise 'unhandled initializer expr ' + expr.inspect
end
else
case expr.op
when :+, :-, :*, :/, :%, :<<, :>>, :&, :|, :^
e = '(' << c_idata_inner_cexpr(expr.lexpr) <<
expr.op.to_s << c_idata_inner_cexpr(expr.rexpr) << ')'
if expr.type.integral?
# db are unsigned
e = '(' << e << " & 0#{'ff'*sizeof(expr)}h)"
end
e
#when :'.'
#when :'->'
#when :'[]'
else raise 'unhandled initializer expr ' + expr.inspect
end
end
else raise 'unhandled initializer ' + expr.inspect
end
end
def c_udata(data, align)
@source << "#{@label_oldname[data.name]}:" if @label_oldname[data.name]
@source << "#{data.name} "
@source.last <<
case data.type
when BaseType
len = @parser.typesize[data.type.name]
case data.type.name
when :__int8; 'db ?'
when :__int16; 'dw ?'
when :__int32; 'dd ?'
when :__int64; 'dq ?'
else "db #{len} dup(?)"
end
else
len = sizeof(data)
"db #{len} dup(?)"
end
len %= align
len == 0 ? align : len
end
# return non-nil if the variable name is unsuitable to appear as is in the asm listing
# eg filter out asm instruction names
def check_reserved_name(var)
%w[db dw dd dq].include?(var.name)
end
end
class Statement
# all Statements/Declaration must define a precompile(compiler, scope) method
# it must append itself to scope.statements
# turns a statement into a new block
def precompile_make_block(scope)
b = Block.new scope
b.statements << self
b
end
end
class Block
# precompile all statements, then simplifies symbols/structs types
def precompile(compiler, scope=nil)
stmts = @statements.dup
@statements.clear
stmts.each { |st|
compiler.curexpr = st
st.precompile(compiler, self)
}
# cleanup declarations
@symbol.delete_if { |n, s| not s.kind_of? Variable }
@struct.delete_if { |n, s| not s.kind_of? Union }
@symbol.each_value { |var|
CExpression.precompile_type(compiler, self, var, true)
}
@struct.each_value { |var|
next if not var.members
var.members.each { |m|
CExpression.precompile_type(compiler, self, m, true)
}
}
scope.statements << self if scope and not @statements.empty?
end
# removes unused labels, and in-place goto (goto toto; toto:)
def precompile_optimize
list = []
precompile_optimize_inner(list, 1)
precompile_optimize_inner(list, 2)
end
# step 1: list used labels/unused goto
# step 2: remove unused labels
def precompile_optimize_inner(list, step)
lastgoto = nil
hadref = false
walk = lambda { |expr|
next if not expr.kind_of? CExpression
# gcc's unary && support
if not expr.op and not expr.lexpr and expr.rexpr.kind_of? Label
list << expr.rexpr.name
else
walk[expr.lexpr]
if expr.rexpr.kind_of? ::Array
expr.rexpr.each { |r| walk[r] }
else
walk[expr.rexpr]
end
end
}
@statements.dup.each { |s|
lastgoto = nil if not s.kind_of? Label
case s
when Block
s.precompile_optimize_inner(list, step)
@statements.delete s if step == 2 and s.statements.empty?
when CExpression; walk[s] if step == 1
when Label
case step
when 1
if lastgoto and lastgoto.target == s.name
list << lastgoto
list.delete s.name if not hadref
end
when 2; @statements.delete s if not list.include? s.name
end
when Goto, If
s.kind_of?(If) ? g = s.bthen : g = s
case step
when 1
hadref = list.include? g.target
lastgoto = g
list << g.target
when 2
if list.include? g
idx = @statements.index s
@statements.delete s
@statements[idx, 0] = s.test if s != g and not s.test.constant?
end
end
end
}
list
end
# noop
def precompile_make_block(scope) self end
def continue_label ; defined?(@continue_label) ? @continue_label : @outer.continue_label end
def continue_label=(l) @continue_label = l end
def break_label ; defined?(@break_label) ? @break_label : @outer.break_label end
def break_label=(l) @break_label = l end
def return_label ; defined?(@return_label) ? @return_label : @outer.return_label end
def return_label=(l) @return_label = l end
def nonauto_label=(l) @nonauto_label = l end
def nonauto_label ; defined?(@nonauto_label) ? @nonauto_label : @outer.nonauto_label end
def function ; defined?(@function) ? @function : @outer.function end
def function=(f) @function = f end
end
class Declaration
def precompile(compiler, scope)
if (@var.type.kind_of? Function and @var.initializer and scope != compiler.toplevel) or @var.storage == :static or compiler.check_reserved_name(@var)
old = @var.name
ref = scope.symbol.delete old
if scope == compiler.toplevel or (@var.type.kind_of?(Function) and not @var.initializer)
if n = compiler.label_oldname.index(old)
# reuse same name as predeclarations
@var.name = n
else
@var.name = compiler.new_label @var.name until @var.name != old
compiler.label_oldname[@var.name] = old
end
ref ||= scope.symbol[@var.name] || @var
# append only one actual declaration for all predecls (the one with init, or the last uninit)
scope.statements << self if ref.eql?(@var)
else
@var.name = compiler.new_label @var.name until @var.name != old
compiler.toplevel.statements << self
end
compiler.toplevel.symbol[@var.name] = ref
else
scope.symbol[@var.name] ||= @var
appendme = true if scope.symbol[@var.name].eql?(@var)
end
if i = @var.initializer
if @var.type.kind_of? Function
if @var.type.type.kind_of? Union
s = @var.type.type
v = Variable.new
v.name = compiler.new_label('return_struct_ptr')
v.type = Pointer.new(s)
CExpression.precompile_type(compiler, scope, v)
@var.type.args.unshift v
@var.type.type = v.type
end
i.function = @var
i.return_label = compiler.new_label('epilog')
i.nonauto_label = {}
i.precompile(compiler)
Label.new(i.return_label).precompile(compiler, i)
i.precompile_optimize
# append now so that static dependencies are declared before us
# TODO no pure inline if addrof(func) needed
scope.statements << self if appendme and not @var.attributes.to_a.include? 'inline'
elsif scope != compiler.toplevel and @var.storage != :static
scope.statements << self if appendme
Declaration.precompile_dyn_initializer(compiler, scope, @var, @var.type, i)
@var.initializer = nil
else
scope.statements << self if appendme
@var.initializer = Declaration.precompile_static_initializer(compiler, @var.type, i)
end
else
scope.statements << self if appendme
end
end
# turns an initializer to CExpressions in scope.statements
def self.precompile_dyn_initializer(compiler, scope, var, type, init)
case type = type.untypedef
when Array
# XXX TODO type.length may be dynamic !!
case init
when CExpression
# char toto[] = "42"
if not init.kind_of? CExpression or init.op or init.lexpr or not init.rexpr.kind_of? ::String
raise "unknown initializer #{init.inspect} for #{var.inspect}"
end
init = init.rexpr.unpack('C*') + [0]
init.map! { |chr| CExpression.new(nil, nil, chr, type.type) }
precompile_dyn_initializer(compiler, scope, var, type, init)
when ::Array
type.length ||= init.length
# len is an Integer
init.each_with_index { |it, idx|
next if not it
break if idx >= type.length
idx = CExpression.new(nil, nil, idx, BaseType.new(:long, :unsigned))
v = CExpression.new(var, :'[]', idx, type.type)
precompile_dyn_initializer(compiler, scope, v, type.type, it)
}
else raise "unknown initializer #{init.inspect} for #{var.inspect}"
end
when Union
case init
when CExpression, Variable
if init.type.untypedef.kind_of? BaseType
# works for struct foo bar[] = {0}; ...
type.members.each { |m|
v = CExpression.new(var, :'.', m.name, m.type)
precompile_dyn_initializer(compiler, scope, v, v.type, init)
}
elsif init.type.untypedef.kind_of? type.class
CExpression.new(var, :'=', init, type).precompile(compiler, scope)
else
raise "bad initializer #{init.inspect} for #{var.inspect}"
end
when ::Array
init.each_with_index{ |it, idx|
next if not it
m = type.members[idx]
v = CExpression.new(var, :'.', m.name, m.type)
precompile_dyn_initializer(compiler, scope, v, m.type, it)
}
else raise "unknown initializer #{init.inspect} for #{var.inspect}"
end
else
case init
when CExpression
CExpression.new(var, :'=', init, type).precompile(compiler, scope)
else raise "unknown initializer #{init.inspect} for #{var.inspect}"
end
end
end
# returns a precompiled static initializer (eg string constants)
def self.precompile_static_initializer(compiler, type, init)
# TODO
case type = type.untypedef
when Array
if init.kind_of? ::Array
init.map { |i| precompile_static_initializer(compiler, type.type, i) }
else
init
end
when Union
if init.kind_of? ::Array
init.zip(type.members).map { |i, m| precompile_static_initializer(compiler, m.type, i) }
else
init
end
else
if init.kind_of? CExpression and init = init.reduce(compiler) and init.kind_of? CExpression
if not init.op and init.rexpr.kind_of? ::String
v = Variable.new
v.storage = :static
v.name = 'char_' + init.rexpr.tr('^a-zA-Z', '')[0, 8]
v.type = Array.new(type.type)
v.type.length = init.rexpr.length + 1
v.type.type.qualifier = [:const]
v.initializer = CExpression.new(nil, nil, init.rexpr, type)
Declaration.new(v).precompile(compiler, compiler.toplevel)
init.rexpr = v
end
init.rexpr = precompile_static_initializer(compiler, init.rexpr.type, init.rexpr) if init.rexpr.kind_of? CExpression
init.lexpr = precompile_static_initializer(compiler, init.lexpr.type, init.lexpr) if init.lexpr.kind_of? CExpression
end
init
end
end
end
class If
def precompile(compiler, scope)
expr = lambda { |e| e.kind_of?(CExpression) ? e : CExpression.new(nil, nil, e, e.type) }
if @bthen.kind_of? Goto or @bthen.kind_of? Break or @bthen.kind_of? Continue
# if () goto l; else b; => if () goto l; b;
if belse
t1 = @belse
@belse = nil
end
# need to convert user-defined Goto target !
@bthen.precompile(compiler, scope)
@bthen = scope.statements.pop # break => goto break_label
elsif belse
# if () a; else b; => if () goto then; b; goto end; then: a; end:
t1 = @belse
t2 = @bthen
l2 = compiler.new_label('if_then')
@bthen = Goto.new(l2)
@belse = nil
l3 = compiler.new_label('if_end')
else
# if () a; => if (!) goto end; a; end:
t1 = @bthen
l2 = compiler.new_label('if_end')
@bthen = Goto.new(l2)
@test = CExpression.negate(@test)
end
@test = expr[@test]
case @test.op
when :'&&'
# if (c1 && c2) goto a; => if (!c1) goto b; if (c2) goto a; b:
l1 = compiler.new_label('if_nand')
If.new(CExpression.negate(@test.lexpr), Goto.new(l1)).precompile(compiler, scope)
@test = expr[@test.rexpr]
precompile(compiler, scope)
when :'||'
l1 = compiler.new_label('if_or')
If.new(expr[@test.lexpr], Goto.new(@bthen.target)).precompile(compiler, scope)
@test = expr[@test.rexpr]
precompile(compiler, scope)
else
@test = CExpression.precompile_inner(compiler, scope, @test)
t = @test.reduce(compiler)
if t.kind_of? ::Integer
if t == 0
Label.new(l1, nil).precompile(compiler, scope) if l1
t1.precompile(compiler, scope) if t1
Label.new(l2, nil).precompile(compiler, scope) if l2
Label.new(l3, nil).precompile(compiler, scope) if l3
else
scope.statements << @bthen
Label.new(l1, nil).precompile(compiler, scope) if l1
Label.new(l2, nil).precompile(compiler, scope) if l2
t2.precompile(compiler, scope) if t2
Label.new(l3, nil).precompile(compiler, scope) if l3
end
return
end
scope.statements << self
end
Label.new(l1, nil).precompile(compiler, scope) if l1
t1.precompile(compiler, scope) if t1
Goto.new(l3).precompile(compiler, scope) if l3
Label.new(l2, nil).precompile(compiler, scope) if l2
t2.precompile(compiler, scope) if t2
Label.new(l3, nil).precompile(compiler, scope) if l3
end
end
class For
def precompile(compiler, scope)
if init
@init.precompile(compiler, scope)
scope = @init if @init.kind_of? Block
end
@body = @body.precompile_make_block scope
@body.continue_label = compiler.new_label 'for_continue'
@body.break_label = compiler.new_label 'for_break'
label_test = compiler.new_label 'for_test'
Label.new(label_test).precompile(compiler, scope)
if test
If.new(CExpression.negate(@test), Goto.new(@body.break_label)).precompile(compiler, scope)
end
@body.precompile(compiler, scope)
Label.new(@body.continue_label).precompile(compiler, scope)
if iter
@iter.precompile(compiler, scope)
end
Goto.new(label_test).precompile(compiler, scope)
Label.new(@body.break_label).precompile(compiler, scope)
end
end
class While
def precompile(compiler, scope)
@body = @body.precompile_make_block scope
@body.continue_label = compiler.new_label('while_continue')
@body.break_label = compiler.new_label('while_break')
Label.new(@body.continue_label).precompile(compiler, scope)
If.new(CExpression.negate(@test), Goto.new(@body.break_label)).precompile(compiler, scope)
@body.precompile(compiler, scope)
Goto.new(@body.continue_label).precompile(compiler, scope)
Label.new(@body.break_label).precompile(compiler, scope)
end
end
class DoWhile
def precompile(compiler, scope)
@body = @body.precompile_make_block scope
@body.continue_label = compiler.new_label('dowhile_continue')
@body.break_label = compiler.new_label('dowhile_break')
loop_start = compiler.new_label('dowhile_start')
Label.new(loop_start).precompile(compiler, scope)
@body.precompile(compiler, scope)
Label.new(@body.continue_label).precompile(compiler, scope)
If.new(@test, Goto.new(loop_start)).precompile(compiler, scope)
Label.new(@body.break_label).precompile(compiler, scope)
end
end
class Switch
def precompile(compiler, scope)
var = Variable.new
var.storage = :register
var.name = compiler.new_label('switch')
var.type = @test.type
var.initializer = @test
CExpression.precompile_type(compiler, scope, var)
Declaration.new(var).precompile(compiler, scope)
@body = @body.precompile_make_block scope
@body.break_label = compiler.new_label('switch_break')
@body.precompile(compiler)
default = @body.break_label
# recursive lambda to change Case to Labels
# dynamically creates the If sequence
walk = lambda { |blk|
blk.statements.each_with_index { |s, i|
case s
when Case
label = compiler.new_label('case')
if s.expr == 'default'
default = label
elsif s.exprup
If.new(CExpression.new(CExpression.new(var, :'>=', s.expr, BaseType.new(:int)), :'&&',
CExpression.new(var, :'<=', s.exprup, BaseType.new(:int)),
BaseType.new(:int)), Goto.new(label)).precompile(compiler, scope)
else
If.new(CExpression.new(var, :'==', s.expr, BaseType.new(:int)),
Goto.new(label)).precompile(compiler, scope)
end
blk.statements[i] = Label.new(label)
when Block
walk[s]
end
}
}
walk[@body]
Goto.new(default).precompile(compiler, scope)
scope.statements << @body
Label.new(@body.break_label).precompile(compiler, scope)
end
end
class Continue
def precompile(compiler, scope)
Goto.new(scope.continue_label).precompile(compiler, scope)
end
end
class Break
def precompile(compiler, scope)
Goto.new(scope.break_label).precompile(compiler, scope)
end
end
class Return
def precompile(compiler, scope)
if @value
@value = CExpression.new(nil, nil, @value, @value.type) if not @value.kind_of? CExpression
if @value.type.untypedef.kind_of? Union
@value = @value.precompile_inner(compiler, scope)
func = scope.function.type
CExpression.new(CExpression.new(nil, :*, func.args.first, @value.type), :'=', @value, @value.type).precompile(compiler, scope)
@value = func.args.first
else
# cast to function return type
@value = CExpression.new(nil, nil, @value, scope.function.type.type).precompile_inner(compiler, scope)
end
scope.statements << self
end
Goto.new(scope.return_label).precompile(compiler, scope)
end
end
class Label
def precompile(compiler, scope)
if name and (not compiler.auto_label_list[@name])
@name = scope.nonauto_label[@name] ||= compiler.new_label(@name)
end
scope.statements << self
if statement
@statement.precompile(compiler, scope)
@statement = nil
end
end
end
class Case
def precompile(compiler, scope)
@expr = CExpression.precompile_inner(compiler, scope, @expr)
@exprup = CExpression.precompile_inner(compiler, scope, @exprup) if exprup
super(compiler, scope)
end
end
class Goto
def precompile(compiler, scope)
if not compiler.auto_label_list[@target]
@target = scope.nonauto_label[@target] ||= compiler.new_label(@target)
end
scope.statements << self
end
end
class Asm
def precompile(compiler, scope)
scope.statements << self
# TODO CExpr.precompile_type(clobbers)
end
end
class CExpression
def precompile(compiler, scope)
i = precompile_inner(compiler, scope, false)
scope.statements << i if i
end
# changes obj.type to a precompiled type
# keeps struct/union, change everything else to __int\d
# except Arrays if declaration is true (need to know variable allocation sizes etc)
# returns the type
def self.precompile_type(compiler, scope, obj, declaration = false)
case t = obj.type.untypedef
when BaseType
case t.name
when :void
when :float, :double, :longdouble
else t = BaseType.new("__int#{compiler.typesize[t.name]*8}".to_sym, t.specifier)
end
when Array
if declaration; precompile_type(compiler, scope, t, declaration)
else t = BaseType.new("__int#{compiler.typesize[:ptr]*8}".to_sym, :unsigned)
end
when Pointer
if t.type.untypedef.kind_of? Function
precompile_type(compiler, scope, t, declaration)
else
t = BaseType.new("__int#{compiler.typesize[:ptr]*8}".to_sym, :unsigned)
end
when Enum; t = BaseType.new("__int#{compiler.typesize[:int]*8}".to_sym)
when Function
precompile_type(compiler, scope, t)
t.args ||= []
t.args.each { |a| precompile_type(compiler, scope, a) }
when Union
if declaration and t.members and not t.name # anonymous struct
t.members.each { |a| precompile_type(compiler, scope, a, true) }
end
else raise 'bad type ' + t.inspect
end
(t.qualifier ||= []).concat obj.type.qualifier if obj.type.qualifier and t != obj.type
(t.attributes ||= []).concat obj.type.attributes if obj.type.attributes and t != obj.type
while obj.type.kind_of? TypeDef
obj.type = obj.type.type
(t.qualifier ||= []).concat obj.type.qualifier if obj.type.qualifier and t != obj.type
(t.attributes ||= []).concat obj.type.attributes if obj.type.attributes and t != obj.type
end
obj.type = t
end
def self.precompile_inner(compiler, scope, expr, nested = true)
case expr
when CExpression; expr.precompile_inner(compiler, scope, nested)
else expr
end
end
# returns a new CExpression with simplified self.type, computes structure offsets
# turns char[]/float immediates to reference to anonymised const
# TODO 'a = b += c' => 'b += c; a = b' (use nested argument)
# TODO handle precompile_inner return nil
# TODO struct.bits
def precompile_inner(compiler, scope, nested = true)
case @op
when :'.'
# a.b => (&a)->b
lexpr = CExpression.precompile_inner(compiler, scope, @lexpr)
ll = lexpr
ll = lexpr.rexpr while ll.kind_of? CExpression and not ll.op
if ll.kind_of? CExpression and ll.op == :'*' and not ll.lexpr
# do not change lexpr.rexpr.type directly to a pointer, might retrigger (ptr+imm) => (ptr + imm*sizeof(*ptr))
@lexpr = CExpression.new(nil, nil, ll.rexpr, Pointer.new(lexpr.type))
else
@lexpr = CExpression.new(nil, :'&', lexpr, Pointer.new(lexpr.type))
end
@op = :'->'
precompile_inner(compiler, scope)
when :'->'
# a->b => *(a + off(b))
struct = @lexpr.type.untypedef.type.untypedef
lexpr = CExpression.precompile_inner(compiler, scope, @lexpr)
@lexpr = nil
@op = nil
if struct.kind_of? Union and (off = struct.offsetof(compiler, @rexpr)) != 0
off = CExpression.new(nil, nil, off, BaseType.new(:int, :unsigned))
@rexpr = CExpression.new(lexpr, :'+', off, lexpr.type)
# ensure the (ptr + value) is not expanded to (ptr + value * sizeof(*ptr))
CExpression.precompile_type(compiler, scope, @rexpr)
else
# union or 1st struct member
@rexpr = lexpr
end
if @type.kind_of? Array # Array member type is already an address
else
@rexpr = CExpression.new(nil, :*, @rexpr, @rexpr.type)
end
precompile_inner(compiler, scope)
when :'[]'
rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
if rexpr.kind_of? CExpression and not rexpr.op and rexpr.rexpr == 0
@rexpr = @lexpr
else
@rexpr = CExpression.new(@lexpr, :'+', rexpr, @lexpr.type)
end
@op = :'*'
@lexpr = nil
precompile_inner(compiler, scope)
when :'?:'
# cannot precompile in place, a conditionnal expression may have a coma: must turn into If
if @lexpr.kind_of? CExpression
@lexpr = @lexpr.precompile_inner(compiler, scope)
if not @lexpr.lexpr and not @lexpr.op and @lexpr.rexpr.kind_of? ::Numeric
if @lexpr.rexpr == 0
e = @rexpr[1]
else
e = @rexpr[0]
end
e = CExpression.new(nil, nil, e, e.type) if not e.kind_of? CExpression
return e.precompile_inner(compiler, scope)
end
end
raise 'conditional in toplevel' if scope == compiler.toplevel # just in case
var = Variable.new
var.storage = :register
var.name = compiler.new_label('ternary')
var.type = @rexpr[0].type
CExpression.precompile_type(compiler, scope, var)
Declaration.new(var).precompile(compiler, scope)
If.new(@lexpr, CExpression.new(var, :'=', @rexpr[0], var.type), CExpression.new(var, :'=', @rexpr[1], var.type)).precompile(compiler, scope)
@lexpr = nil
@op = nil
@rexpr = var
precompile_inner(compiler, scope)
when :'&&'
if scope == compiler.toplevel
@lexpr = CExpression.precompile_inner(compiler, scope, @lexpr)
@rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
CExpression.precompile_type(compiler, scope, self)
self
else
var = Variable.new
var.storage = :register
var.name = compiler.new_label('and')
var.type = @type
CExpression.precompile_type(compiler, scope, var)
var.initializer = CExpression.new(nil, nil, 0, var.type)
Declaration.new(var).precompile(compiler, scope)
l = @lexpr.kind_of?(CExpression) ? @lexpr : CExpression.new(nil, nil, @lexpr, @lexpr.type)
r = @rexpr.kind_of?(CExpression) ? @rexpr : CExpression.new(nil, nil, @rexpr, @rexpr.type)
If.new(l, If.new(r, CExpression.new(var, :'=', CExpression.new(nil, nil, 1, var.type), var.type))).precompile(compiler, scope)
@lexpr = nil
@op = nil
@rexpr = var
precompile_inner(compiler, scope)
end
when :'||'
if scope == compiler.toplevel
@lexpr = CExpression.precompile_inner(compiler, scope, @lexpr)
@rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
CExpression.precompile_type(compiler, scope, self)
self
else
var = Variable.new
var.storage = :register
var.name = compiler.new_label('or')
var.type = @type
CExpression.precompile_type(compiler, scope, var)
var.initializer = CExpression.new(nil, nil, 1, var.type)
Declaration.new(var).precompile(compiler, scope)
l = @lexpr.kind_of?(CExpression) ? @lexpr : CExpression.new(nil, nil, @lexpr, @lexpr.type)
l = CExpression.new(nil, :'!', l, var.type)
r = @rexpr.kind_of?(CExpression) ? @rexpr : CExpression.new(nil, nil, @rexpr, @rexpr.type)
r = CExpression.new(nil, :'!', r, var.type)
If.new(l, If.new(r, CExpression.new(var, :'=', CExpression.new(nil, nil, 0, var.type), var.type))).precompile(compiler, scope)
@lexpr = nil
@op = nil
@rexpr = var
precompile_inner(compiler, scope)
end
when :funcall
if @lexpr.kind_of? Variable and @lexpr.type.kind_of? Function and @lexpr.attributes and @lexpr.attributes.include? 'inline' and @lexpr.initializer
# TODO check recursive call (direct or indirect)
raise 'inline varargs unsupported' if @lexpr.type.varargs
rtype = @lexpr.type.type.untypedef
if not rtype.kind_of? BaseType or rtype.name != :void
rval = Variable.new
rval.name = compiler.new_label('inline_return')
rval.type = @lexpr.type.type
Declaration.new(rval).precompile(compiler, scope)
end
inline_label = {}
locals = @lexpr.type.args.zip(@rexpr).inject({}) { |h, (fa, a)|
h.update fa => CExpression.new(nil, nil, a, fa.type).precompile_inner(compiler, scope)
}
copy_inline_ce = lambda { |ce|
case ce
when CExpression; CExpression.new(copy_inline_ce[ce.lexpr], ce.op, copy_inline_ce[ce.rexpr], ce.type)
when Variable; locals[ce] || ce
when ::Array; ce.map { |e_| copy_inline_ce[e_] }
else ce
end
}
copy_inline = lambda { |stmt, scp|
case stmt
when Block
b = Block.new(scp)
stmt.statements.each { |s|
s = copy_inline[s, b]
b.statements << s if s
}
b
when If; If.new(copy_inline_ce[stmt.test], copy_inline[stmt.bthen, scp]) # re-precompile ?
when Label; Label.new(inline_label[stmt.name] ||= compiler.new_label('inline_'+stmt.name))
when Goto; Goto.new(inline_label[stmt.target] ||= compiler.new_label('inline_'+stmt.target))
when Return; CExpression.new(rval, :'=', copy_inline_ce[stmt.value], rval.type).precompile_inner(compiler, scp) if stmt.value
when CExpression; copy_inline_ce[stmt]
when Declaration
nv = stmt.var.dup
if nv.type.kind_of? Array and nv.type.length.kind_of? CExpression
nv.type = Array.new(nv.type.type, copy_inline_ce[nv.type.length]) # XXX nested dynamic?
end
locals[stmt.var] = nv
scp.symbol[nv.name] = nv
Declaration.new(nv)
else raise 'unexpected inline statement ' + stmt.inspect
end
}
scope.statements << copy_inline[@lexpr.initializer, scope] # body already precompiled
CExpression.new(nil, nil, rval, rval.type).precompile_inner(compiler, scope)
elsif @type.kind_of? Union
var = Variable.new
var.name = compiler.new_label('return_struct')
var.type = @type
Declaration.new(var).precompile(compiler, scope)
@rexpr.unshift CExpression.new(nil, :&, var, Pointer.new(var.type))
var2 = Variable.new
var2.name = compiler.new_label('return_struct_ptr')
var2.type = Pointer.new(@type)
var2.storage = :register
CExpression.precompile_type(compiler, scope, var2)
Declaration.new(var2).precompile(compiler, scope)
@type = var2.type
CExpression.new(var2, :'=', self, var2.type).precompile(compiler, scope)
CExpression.new(nil, :'*', var2, var.type).precompile_inner(compiler, scope)
else
t = @lexpr.type.untypedef
t = t.type.untypedef if t.pointer?
@lexpr = CExpression.precompile_inner(compiler, scope, @lexpr)
types = t.args.map { |a| a.type }
# cast args to func prototype
@rexpr.map! { |e_| (types.empty? ? e_ : CExpression.new(nil, nil, e_, types.shift)).precompile_inner(compiler, scope) }
CExpression.precompile_type(compiler, scope, self)
self
end
when :','
lexpr = @lexpr.kind_of?(CExpression) ? @lexpr : CExpression.new(nil, nil, @lexpr, @lexpr.type)
rexpr = @rexpr.kind_of?(CExpression) ? @rexpr : CExpression.new(nil, nil, @rexpr, @rexpr.type)
lexpr.precompile(compiler, scope)
rexpr.precompile_inner(compiler, scope)
when :'!'
CExpression.precompile_type(compiler, scope, self)
if @rexpr.kind_of?(CExpression)
case @rexpr.op
when :'<', :'>', :'<=', :'>=', :'==', :'!='
@op = { :'<' => :'>=', :'>' => :'<=', :'<=' => :'>', :'>=' => :'<',
:'==' => :'!=', :'!=' => :'==' }[@rexpr.op]
@lexpr = @rexpr.lexpr
@rexpr = @rexpr.rexpr
precompile_inner(compiler, scope)
when :'&&', :'||'
@op = { :'&&' => :'||', :'||' => :'&&' }[@rexpr.op]
@lexpr = CExpression.new(nil, :'!', @rexpr.lexpr, @type)
@rexpr = CExpression.new(nil, :'!', @rexpr.rexpr, @type)
precompile_inner(compiler, scope)
when :'!'
if @rexpr.rexpr.kind_of? CExpression
@op = nil
@rexpr = @rexpr.rexpr
else
@op = :'!='
@lexpr = @rexpr.rexpr
@rexpr = CExpression.new(nil, nil, 0, @lexpr.type)
end
precompile_inner(compiler, scope)
else
@rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
self
end
else
@rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
self
end
when :'++', :'--'
if not @rexpr
var = Variable.new
var.storage = :register
var.name = compiler.new_label('postincrement')
var.type = @type
Declaration.new(var).precompile(compiler, scope)
CExpression.new(var, :'=', @lexpr, @type).precompile(compiler, scope)
CExpression.new(nil, @op, @lexpr, @type).precompile(compiler, scope)
@lexpr = nil
@op = nil
@rexpr = var
precompile_inner(compiler, scope)
elsif @type.pointer? and compiler.sizeof(nil, @type.untypedef.type.untypedef) != 1
# ++ptr => ptr += sizeof(*ptr) (done in += precompiler)
@op = { :'++' => :'+=', :'--' => :'-=' }[@op]
@lexpr = @rexpr
@rexpr = CExpression.new(nil, nil, 1, BaseType.new(:ptr, :unsigned))
precompile_inner(compiler, scope)
else
CExpression.precompile_type(compiler, scope, self)
@rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
self
end
when :'='
# handle structure assignment/array assignment
case @lexpr.type.untypedef
when Union
# rexpr may be a :funcall
@rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
@lexpr.type.untypedef.members.zip(@rexpr.type.untypedef.members) { |m1, m2|
# assume m1 and m2 are compatible
v1 = CExpression.new(@lexpr, :'.', m1.name, m1.type)
v2 = CExpression.new(@rexpr, :'.', m2.name, m1.type)
CExpression.new(v1, :'=', v2, v1.type).precompile(compiler, scope)
}
# (foo = bar).toto
@op = nil
@rexpr = @lexpr
@lexpr = nil
@type = @rexpr.type
precompile_inner(compiler, scope) if nested
when Array
if not len = @lexpr.type.untypedef.length
@rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
# char toto[] = "bla"
if @rexpr.kind_of? CExpression and not @rexpr.lexpr and not @rexpr.op and
@rexpr.rexpr.kind_of? Variable and @rexpr.rexpr.type.kind_of? Array
len = @rexpr.rexpr.type.length
end
end
raise 'array initializer with no length !' if not len
# TODO optimize...
len.times { |i|
i = CExpression.new(nil, nil, i, BaseType.new(:long, :unsigned))
v1 = CExpression.new(@lexpr, :'[]', i, @lexpr.type.untypedef.type)
v2 = CExpression.new(@rexpr, :'[]', i, v1.type)
CExpression.new(v1, :'=', v2, v1.type).precompile(compiler, scope)
}
@op = nil
@rexpr = @lexpr
@lexpr = nil
@type = @rexpr.type
precompile_inner(compiler, scope) if nested
else
@lexpr = CExpression.precompile_inner(compiler, scope, @lexpr)
@rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
CExpression.precompile_type(compiler, scope, self)
self
end
when nil
case @rexpr
when Block
# compound statements
raise 'compound statement in toplevel' if scope == compiler.toplevel # just in case
var = Variable.new
var.storage = :register
var.name = compiler.new_label('compoundstatement')
var.type = @type
CExpression.precompile_type(compiler, scope, var)
Declaration.new(var).precompile(compiler, scope)
if @rexpr.statements.last.kind_of? CExpression
@rexpr.statements[-1] = CExpression.new(var, :'=', @rexpr.statements[-1], var.type)
@rexpr.precompile(compiler, scope)
end
@rexpr = var
precompile_inner(compiler, scope)
when ::String
# char[] immediate
v = Variable.new
v.storage = :static
v.name = 'char_' + @rexpr.tr('^a-zA-Z', '')[0, 8]
v.type = Array.new(@type.type)
v.type.length = @rexpr.length + 1
v.type.type.qualifier = [:const]
v.initializer = CExpression.new(nil, nil, @rexpr, @type)
Declaration.new(v).precompile(compiler, scope)
@rexpr = v
precompile_inner(compiler, scope)
when ::Float
# float immediate
v = Variable.new
v.storage = :static
v.name = @type.untypedef.name.to_s
v.type = @type
v.type.qualifier = [:const]
v.initializer = CExpression.new(nil, nil, @rexpr, @type)
Declaration.new(v).precompile(compiler, scope)
@rexpr = CExpression.new(nil, :'*', v, v.type)
precompile_inner(compiler, scope)
when CExpression
# simplify casts
CExpression.precompile_type(compiler, scope, self)
# propagate type first so that __uint64 foo() { return -1 } => 0xffffffffffffffff
@rexpr.type = @type if @rexpr.kind_of? CExpression and @rexpr.op == :- and not @rexpr.lexpr and @type.kind_of? BaseType and @type.name == :__int64 # XXX kill me
@rexpr = @rexpr.precompile_inner(compiler, scope)
if @type.kind_of? BaseType and @rexpr.type.kind_of? BaseType
if @rexpr.type == @type
# noop cast
@lexpr, @op, @rexpr = @rexpr.lexpr, @rexpr.op, @rexpr.rexpr
elsif not @rexpr.op and @type.integral? and @rexpr.type.integral?
if @rexpr.rexpr.kind_of? ::Numeric and (val = reduce(compiler)).kind_of? ::Numeric
@rexpr = val
elsif compiler.typesize[@type.name] < compiler.typesize[@rexpr.type.name]
# (char)(short)(int)(long)foo => (char)foo
@rexpr = @rexpr.rexpr
end
end
end
self
else
CExpression.precompile_type(compiler, scope, self)
self
end
else
# int+ptr => ptr+int
if @op == :+ and @lexpr and @lexpr.type.integral? and @rexpr.type.pointer?
@rexpr, @lexpr = @lexpr, @rexpr
end
# handle pointer + 2 == ((char *)pointer) + 2*sizeof(*pointer)
if @rexpr and [:'+', :'+=', :'-', :'-='].include? @op and
@type.pointer? and @rexpr.type.integral?
sz = compiler.sizeof(nil, @type.untypedef.type.untypedef)
if sz != 1
sz = CExpression.new(nil, nil, sz, @rexpr.type)
@rexpr = CExpression.new(@rexpr, :'*', sz, @rexpr.type)
end
end
# type promotion => cast
case @op
when :+, :-, :*, :/, :&, :|, :^, :%
if @lexpr
if @lexpr.type != @type
@lexpr = CExpression.new(nil, nil, @lexpr, @lexpr.type) if not @lexpr.kind_of? CExpression
@lexpr = CExpression.new(nil, nil, @lexpr, @type)
end
if @rexpr.type != @type
@rexpr = CExpression.new(nil, nil, @rexpr, @rexpr.type) if not @rexpr.kind_of? CExpression
@rexpr = CExpression.new(nil, nil, @rexpr, @type)
end
end
when :>>, :<<
# char => int
if @lexpr.type != @type
@lexpr = CExpression.new(nil, nil, @lexpr, @lexpr.type) if not @lexpr.kind_of? CExpression
@lexpr = CExpression.new(nil, nil, @lexpr, @type)
end
when :'+=', :'-=', :'*=', :'/=', :'&=', :'|=', :'^=', :'%='
if @rexpr.type != @lexpr.type
@rexpr = CExpression.new(nil, nil, @rexpr, @rexpr.type) if not @rexpr.kind_of? CExpression
@rexpr = CExpression.new(nil, nil, @rexpr, @type)
end
end
@lexpr = CExpression.precompile_inner(compiler, scope, @lexpr)
@rexpr = CExpression.precompile_inner(compiler, scope, @rexpr)
if @op == :'&' and not @lexpr
rr = @rexpr
rr = rr.rexpr while rr.kind_of? CExpression and not rr.op
if rr.kind_of? CExpression and rr.op == :'*' and not rr.lexpr
@lexpr = nil
@op = nil
@rexpr = rr.rexpr
return precompile_inner(compiler, scope)
elsif rr != @rexpr
@rexpr = rr
return precompile_inner(compiler, scope)
end
end
CExpression.precompile_type(compiler, scope, self)
isnumeric = lambda { |e_| e_.kind_of?(::Numeric) or (e_.kind_of? CExpression and
not e_.lexpr and not e_.op and e_.rexpr.kind_of? ::Numeric) }
# calc numeric
# XXX do not simplify operations involving variables (for type overflow etc)
if isnumeric[@rexpr] and (not @lexpr or isnumeric[@lexpr]) and (val = reduce(compiler)).kind_of? ::Numeric
@lexpr = nil
@op = nil
@rexpr = val
end
self
end
end
end
end
end