# 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/preprocessor'
module Metasm
# c parser
# inspired from http://www.math.grin.edu/~stone/courses/languages/C-syntax.xhtml
module C
Keyword = %w[struct union enum if else for while do switch goto
register extern auto static typedef const volatile
void int float double char signed unsigned long short
case continue break return default __attribute__
asm __asm __asm__ sizeof typeof
__declspec __cdecl __stdcall __fastcall __noreturn
inline __inline __inline__ __volatile__
__int8 __int16 __int32 __int64
__builtin_offsetof
].inject({}) { |h, w| h.update w => true }
class Statement
end
module Typed # allows quick testing whether an object is an CExpr or a Variable
end
class Block < Statement
attr_accessor :symbol # hash name => Type/Variable/enum value
attr_accessor :struct # hash name => Struct/Union/Enum
attr_accessor :outer # parent block
attr_accessor :statements # array of Statement/Declaration
attr_accessor :anonymous_enums # array of anonymous Enum
def initialize(outer, statements=[], symbol={}, struct={})
@outer = outer
@statements = statements
@symbol = symbol
@struct = struct
end
def struct_ancestors
@outer ? @outer.struct_ancestors.merge(@struct) : @struct
end
def symbol_ancestors
@outer ? @outer.symbol_ancestors.merge(@symbol) : @symbol
end
end
module Attributes
attr_accessor :attributes
DECLSPECS = %w[cdecl stdcall fastcall inline naked thiscall noreturn]
# parses a sequence of __attribute__((anything)) into self.attributes (array of string)
def parse_attributes(parser, allow_declspec = false)
while tok = parser.skipspaces and tok.type == :string
case keyword = tok.raw
when '__attribute__', '__declspec' # synonymous: __attribute__((foo)) == __declspec(foo)
raise tok || parser if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '('
raise tok || parser if keyword == '__attribute__' and (not tok = parser.skipspaces or tok.type != :punct or tok.raw != '(')
nest = 0
attrib = ''
loop do
raise parser if not tok = parser.skipspaces
if tok.type == :punct and tok.raw == ')'
if nest == 0
raise tok || parser if keyword == '__attribute__' and (not tok = parser.skipspaces or tok.type != :punct or tok.raw != ')')
break
else
nest -= 1
end
elsif tok.type == :punct and tok.raw == '('
nest += 1
elsif nest == 0 and tok.type == :punct and tok.raw == ','
raise tok || parser if not allow_declspec and DECLSPECS.include? attrib
add_attribute attrib
attrib = ''
next
end
attrib << tok.raw
end
raise tok || parser, "attr #{attrib.inspect} not allowed here" if not allow_declspec and DECLSPECS.include? attrib
else
if allow_declspec and DECLSPECS.include? keyword.gsub('_', '')
attrib = keyword.gsub('_', '')
else break
end
end
add_attribute(attrib)
end
parser.unreadtok tok
end
# checks if the object has an attribute in its attribute list
def has_attribute(attr)
attributes.to_a.include? attr
end
# adds an attribute to the object attribute list if it is not already in it
def add_attribute(attr)
(@attributes ||= []) << attr if not has_attribute(attr)
end
# checks if the object has an attributes a la __attribute__((attr(stuff))), returns 'stuff' (raw, no split on ',' or anything)
def has_attribute_var(attr)
$1 if attributes.to_a.find { |a| a =~ /^#{attr}\((.*)\)$/ }
end
end
class Type
include Attributes
attr_accessor :qualifier # const volatile
def pointer? ; false end
def arithmetic? ; false end
def integral? ; false end
def float? ; false end
def void? ; false end
def base ; self end
def untypedef ; self end
def parse_initializer(parser, scope)
raise parser, 'expr expected' if not ret = CExpression.parse(parser, scope, false)
p, i = pointer?, integral?
r = ret.reduce(parser) if p or i
if (not p and not i) or (i and not r.kind_of? ::Integer) or (p and r != 0)
parser.check_compatible_type(parser, ret.type, self)
end
ret
end
def parse_initializer_designator(parser, scope, value, idx, root=true)
if not root and (not nt = parser.skipspaces or nt.type != :punct or nt.raw != '=')
raise nt || parser, '"=" expected'
end
value[idx] = parse_initializer(parser, scope)
idx + 1
end
end
class BaseType < Type
attr_accessor :name # :int :long :longlong :short :double :longdouble :float :char :void :__int8/16/32/64
attr_accessor :specifier # sign specifier only
def arithmetic? ; @name != :void end
def integral? ; [:char, :short, :int, :long, :longlong, :ptr,
:__int8, :__int16, :__int32, :__int64].include? @name end
def signed? ; specifier != :unsigned end
def float? ; [:float, :double, :longdouble].include? @name end
def void? ; @name == :void end
def align(parser) @name == :double ? 4 : parser.typesize[@name] end
def initialize(name, *specs)
@name = name
specs.each { |s|
case s
when :const, :volatile; (@qualifier ||= []) << s
when :signed, :unsigned; @specifier = s
when nil
else raise "internal error, got #{name.inspect} #{specs.inspect}"
end
}
end
def ==(o)
o.object_id == self.object_id or
(o.class == self.class and o.name == self.name and o.specifier == self.specifier and o.attributes == self.attributes)
end
end
class TypeDef < Type
attr_accessor :name
attr_accessor :type
attr_accessor :backtrace
def initialize(name, type, backtrace)
@name, @type, @backtrace = name, type, backtrace
end
def parse_initializer(parser, scope)
@type.parse_initializer(parser, scope)
end
def pointer? ; @type.pointer? end
def arithmetic? ; @type.arithmetic? end
def integral? ; @type.integral? end
def signed? ; @type.signed? end # relevant only if integral? returns true
def float? ; @type.float? end
def void? ; @type.void? end
def untypedef ; @type.untypedef end
def align(parser) @type.align(parser) end # XXX __attribute__ ?
def pointed ; @type.pointed end
end
class Function < Type
attr_accessor :type # return type
attr_accessor :args # [name, Variable]
attr_accessor :varargs # true/false
def initialize(type=nil, args=nil)
@type = type
@args = args if args
end
def base ; @type.base ; end
end
class Union < Type
attr_accessor :members # [Variable]
attr_accessor :bits # [bits] or nil
attr_accessor :name
attr_accessor :backtrace
attr_accessor :fldoffset, :fldbitoffset, :fldlist
def align(parser) @members.to_a.map { |m| m.type.align(parser) }.max end
# there is only one instance of a given named struct per parser
# so we just compare struct names here
# for comparison between parsers, see #compare_deep
def ==(o)
o.object_id == self.object_id or
(o.class == self.class and o.name == self.name and ((o.name and true) or compare_deep(o)))
end
# compare to another structure, comparing members recursively (names and type)
# returns true if the self is same as o
def compare_deep(o, seen = [])
return true if o.object_id == self.object_id
return if o.class != self.class or o.name != self.name or o.attributes != self.attributes
o.members.to_a.zip(self.members.to_a).each { |om, sm|
return if om.name != sm.name
return if om.type != sm.type
if om.type.pointer?
ot = om.type
st = sm.type
500.times { # limit for selfpointers (shouldnt happen)
break if not ot.pointer?
ot = ot.pointed.untypedef
st = st.pointed.untypedef
}
if ot.kind_of?(C::Union) and ot.name and not seen.include?(ot)
return if not st.compare_deep(ot, seen+[ot])
end
end
}
true
end
def findmember(name, igncase=false)
raise parser, 'undefined structure' if not @members
return @fldlist[name] if fldlist and @fldlist[name]
name = name.downcase if igncase
if m = @members.find { |m_| (n = m_.name) and (igncase ? n.downcase : n) == name }
return m
else
@members.each { |m_|
if t = m_.type.untypedef and t.kind_of? Union and mm = t.findmember(name, igncase)
return mm
end
}
end
nil
end
def offsetof(parser, name)
raise parser, 'undefined structure' if not @members
update_member_cache(parser) if not fldlist
return 0 if @fldlist[name]
if name.kind_of?(Variable)
return 0 if @members.include? name
raise ParseError, 'unknown union member'
end
raise parser, 'unknown union member' if not findmember(name)
@members.find { |m|
m.type.untypedef.kind_of? Union and m.type.untypedef.findmember(name)
}.type.untypedef.offsetof(parser, name)
end
def bitoffsetof(parser, name)
raise parser, 'undefined structure' if not @members
update_member_cache(parser) if not fldlist
return if @fldlist[name] or @members.include?(name)
raise parser, 'undefined union' if not @members
raise parser, 'unknown union member' if not findmember(name)
@members.find { |m|
m.type.untypedef.kind_of? Union and m.type.untypedef.findmember(name)
}.type.untypedef.bitoffsetof(parser, name)
end
def parse_members(parser, scope)
@fldlist = nil if fldlist # invalidate fld offset cache
@members = []
# parse struct/union members in definition
loop do
raise parser if not tok = parser.skipspaces
break if tok.type == :punct and tok.raw == '}'
parser.unreadtok tok
raise tok, 'invalid struct member type' if not basetype = Variable.parse_type(parser, scope)
loop do
member = basetype.dup
member.parse_declarator(parser, scope)
member.type.length ||= 0 if member.type.kind_of?(Array) # struct { char blarg[]; };
raise member.backtrace, 'member redefinition' if member.name and @members.find { |m| m.name == member.name }
@members << member
raise tok || parser if not tok = parser.skipspaces or tok.type != :punct
if tok.raw == ':' # bits
raise tok, 'bad type for bitslice' if not member.type.integral?
bits = nil
raise tok, "bad bit count #{bits.inspect}" if not bits = CExpression.parse(parser, scope, false) or
not bits.constant? or !(bits = bits.reduce(parser)).kind_of? ::Integer
#raise tok, 'need more bits' if bits > 8*parser.sizeof(member)
# WORD wReserved:17; => yay windows.h
(@bits ||= [])[@members.length-1] = bits
raise tok || parser, '"," or ";" expected' if not tok = parser.skipspaces or tok.type != :punct
end
case tok.raw
when ';'; break
when ','
when '}'; parser.unreadtok(tok); break
else raise tok, '"," or ";" expected'
end
end
end
parse_attributes(parser)
end
# updates the @fldoffset / @fldbitoffset hash storing the offset of members
def update_member_cache(parser)
@fldlist = {}
@members.to_a.each { |m|
@fldlist[m.name] = m if m.name
}
end
def parse_initializer(parser, scope)
if tok = parser.skipspaces and tok.type == :punct and tok.raw == '{'
# struct x toto = { 1, .4, .member[0][6].bla = 12 };
raise tok, 'undefined struct' if not @members
ret = []
if tok = parser.skipspaces and (tok.type != :punct or tok.raw != '}')
parser.unreadtok tok
idx = 0
loop do
idx = parse_initializer_designator(parser, scope, ret, idx, true)
raise tok || parser, '"," or "}" expected' if not tok = parser.skipspaces or tok.type != :punct or (tok.raw != '}' and tok.raw != ',')
break if tok.raw == '}'
raise tok, 'struct is smaller than that' if idx >= @members.length
end
end
ret
else
parser.unreadtok tok
super(parser, scope)
end
end
# parses a designator+initializer eg '.toto = 4' or '.tutu[42][12].bla = 16' or (root ? '4' : '=4')
def parse_initializer_designator(parser, scope, value, idx, root=true)
if nt = parser.skipspaces and nt.type == :punct and nt.raw == '.' and
nnt = parser.skipspaces and nnt.type == :string and
findmember(nnt.raw)
raise nnt, 'unhandled indirect initializer' if not nidx = @members.index(@members.find { |m| m.name == nnt.raw }) # TODO
if not root
value[idx] ||= [] # AryRecorder may change [] to AryRec.new, can't do v = v[i] ||= []
value = value[idx]
end
idx = nidx
@members[idx].type.untypedef.parse_initializer_designator(parser, scope, value, idx, false)
else
parser.unreadtok nnt
if root
parser.unreadtok nt
value[idx] = @members[idx].type.parse_initializer(parser, scope)
else
raise nt || parser, '"=" expected' if not nt or nt.type != :punct or nt.raw != '='
value[idx] = parse_initializer(parser, scope)
end
end
idx + 1
end
end
class Struct < Union
attr_accessor :pack
def align(parser) [@members.to_a.map { |m| m.type.align(parser) }.max || 1, (pack || 8)].min end
def offsetof(parser, name)
raise parser, 'undefined structure' if not @members
update_member_cache(parser) if not fldlist
return @fldoffset[name] if @fldoffset[name]
# this is almost never reached, only for <struct>.offsetof(anonymoussubstructmembername)
raise parser, 'unknown structure member' if (name.kind_of?(::String) ? !findmember(name) : !@members.include?(name))
indirect = true if name.kind_of?(::String) and not @fldlist[name]
al = align(parser)
off = 0
bit_off = 0
isz = nil
@members.each_with_index { |m, i|
if bits and b = @bits[i]
if not isz
mal = [m.type.align(parser), al].min
off = (off + mal - 1) / mal * mal
end
isz = parser.sizeof(m)
if b == 0 or (bit_off > 0 and bit_off + b > 8*isz)
bit_off = 0
mal = [m.type.align(parser), al].min
off = (off + isz + mal - 1) / mal * mal
end
break if m.name == name or m == name
bit_off += b
else
if isz
off += isz
bit_off = 0
isz = nil
end
mal = [m.type.align(parser), al].min
off = (off + mal - 1) / mal * mal
if m.name == name or m == name
break
elsif indirect and m.type.untypedef.kind_of? Union and m.type.untypedef.findmember(name)
off += m.type.untypedef.offsetof(parser, name)
break
else
off += parser.sizeof(m)
end
end
}
off
end
# returns the [bitoffset, bitlength] of the field if it is a bitfield
# this should be added to the offsetof(field)
def bitoffsetof(parser, name)
raise parser, 'undefined structure' if not @members
update_member_cache(parser) if not fldlist
return @fldbitoffset[name] if fldbitoffset and @fldbitoffset[name]
return if @fldlist[name] or @members.include?(name)
raise parser, 'undefined union' if not @members
raise parser, 'unknown union member' if not findmember(name)
@members.find { |m|
m.type.untypedef.kind_of? Union and m.type.untypedef.findmember(name)
}.type.untypedef.bitoffsetof(parser, name)
end
def parse_members(parser, scope)
super(parser, scope)
if has_attribute 'packed'
@pack = 1
elsif p = has_attribute_var('pack')
@pack = p[/\d+/].to_i
raise parser, "illegal struct pack(#{p})" if @pack == 0
end
end
# updates the @fldoffset / @fldbitoffset hash storing the offset of members
def update_member_cache(parser)
super(parser)
@fldoffset = {}
@fldbitoffset = {} if fldbitoffset
al = align(parser)
off = 0
bit_off = 0
isz = nil
@members.each_with_index { |m, i|
if bits and b = @bits[i]
if not isz
mal = [m.type.align(parser), al].min
off = (off + mal - 1) / mal * mal
end
isz = parser.sizeof(m)
if b == 0 or (bit_off > 0 and bit_off + b > 8*isz)
bit_off = 0
mal = [m.type.align(parser), al].min
off = (off + isz + mal - 1) / mal * mal
end
if m.name
@fldoffset[m.name] = off
@fldbitoffset ||= {}
@fldbitoffset[m.name] = [bit_off, b]
end
bit_off += b
else
if isz
off += isz
bit_off = 0
isz = nil
end
mal = [m.type.align(parser), al].min
off = (off + mal - 1) / mal * mal
@fldoffset[m.name] = off if m.name
off += parser.sizeof(m)
end
}
end
end
class Enum < Type
# name => value
attr_accessor :members
attr_accessor :name
attr_accessor :backtrace
def align(parser) BaseType.new(:int).align(parser) end
def arithmetic?; true end
def integral?; true end
def signed?; false end
def parse_members(parser, scope)
val = -1
@members = {}
loop do
raise parser if not tok = parser.skipspaces
break if tok.type == :punct and tok.raw == '}'
name = tok.raw
raise tok, 'bad enum name' if tok.type != :string or Keyword[name] or (?0..?9).include?(name[0])
raise parser if not tok = parser.skipspaces
if tok.type == :punct and tok.raw == '='
raise tok || parser if not val = CExpression.parse(parser, scope, false) or not val = val.reduce(parser) or not tok = parser.skipspaces
else
val += 1
end
raise tok, "enum value #{name} redefinition" if scope.symbol[name] and scope.symbol[name] != val
@members[name] = val
scope.symbol[name] = val
if tok.type == :punct and tok.raw == '}'
break
elsif tok.type == :punct and tok.raw == ','
else raise tok, '"," or "}" expected'
end
end
parse_attributes(parser)
end
end
class Pointer < Type
attr_accessor :type
def initialize(type=nil)
@type = type
end
def pointer? ; true ; end
def arithmetic? ; true ; end
def base ; @type.base ; end
def align(parser) BaseType.new(:ptr).align(parser) end
def pointed ; @type end
def ==(o)
o.class == self.class and o.type == self.type
end
end
class Array < Pointer
attr_accessor :length
def initialize(type=nil, length=nil)
super(type)
@length = length if length
end
def align(parser) @type.align(parser) end
def parse_initializer(parser, scope)
raise parser, 'cannot initialize dynamic array' if @length.kind_of? CExpression
if tok = parser.skipspaces and tok.type == :punct and tok.raw == '{'
# struct x foo[] = { { 4 }, [12].tutu = 2 };
ret = []
if tok = parser.skipspaces and (tok.type != :punct or tok.raw != '}')
parser.unreadtok tok
idx = 0
loop do
idx = parse_initializer_designator(parser, scope, ret, idx, true)
raise tok || parser, '"," or "}" expected' if not tok = parser.skipspaces or tok.type != :punct or (tok.raw != '}' and tok.raw != ',')
break if tok.raw == '}'
# allow int x[] = {1, 2, 3, };
break if tok = parser.skipspaces and tok.type == :punct and tok.raw == '}'
parser.unreadtok tok
raise tok, 'array is smaller than that' if length and idx >= @length
end
end
ret
else
parser.unreadtok tok
i = super(parser, scope)
if i.kind_of? CExpression and not i.op and i.rexpr.kind_of? String and @length and i.rexpr.length > @length
puts tok.exception("initializer is too long (#{i.rexpr.length} for #@length)").message if $VERBOSE
i.rexpr = i.rexpr[0, @length]
end
i
end
end
# this class is a hack to support [1 ... 4] array initializer
# it stores the effects of subsequent initializers (eg [1 ... 4].toto[48].bla[2 ... 57] = 12)
# which are later played back on the range
class AryRecorder
attr_accessor :log
def initialize
@log = []
end
def []=(idx, val)
val = self.class.new if val == []
@log[idx] = val
end
def [](idx)
@log[idx]
end
def playback_idx(i)
case v = @log[i]
when self.class; v.playback
else v
end
end
def playback(ary=[])
@log.each_with_index { |v, i| ary[i] = playback_idx(i) }
ary
end
end
# parses a designator+initializer eg '[12] = 4' or '[42].bla = 16' or '[3 ... 8] = 28'
def parse_initializer_designator(parser, scope, value, idx, root=true)
# root = true for 1st invocation (x = { 4 }) => immediate value allowed
# or false for recursive invocations (x = { .y = 4 }) => need '=' sign before immediate
if nt = parser.skipspaces and nt.type == :punct and nt.raw == '['
if not root
value[idx] ||= [] # AryRecorder may change [] to AryRec.new, can't do v = v[i] ||= []
value = value[idx]
end
raise nt, 'const expected' if not idx = CExpression.parse(parser, scope) or not idx.constant? or not idx = idx.reduce(parser) or not idx.kind_of? ::Integer
nt = parser.skipspaces
if nt and nt.type == :punct and nt.raw == '.' # range
raise nt || parser, '".." expected' if not nt = parser.skipspaces or nt.type != :punct or nt.raw != '.'
raise nt || parser, '"." expected' if not nt = parser.skipspaces or nt.type != :punct or nt.raw != '.'
raise nt, 'const expected' if not eidx = CExpression.parse(parser, scope) or not eidx.constant? or not eidx = eidx.reduce(parser) or not eidx.kind_of? ::Integer
raise nt, 'bad range' if eidx < idx
nt = parser.skipspaces
realvalue = value
value = AryRecorder.new
end
raise nt || parser, '"]" expected' if not nt or nt.type != :punct or nt.raw != ']'
raise nt, 'array is smaller than that' if length and (eidx||idx) >= @length
@type.untypedef.parse_initializer_designator(parser, scope, value, idx, false)
if eidx
(idx..eidx).each { |i| realvalue[i] = value.playback_idx(idx) }
idx = eidx # next default value = eidx+1 (eg int x[] = { [1 ... 3] = 4, 5 } => x[4] = 5)
end
else
if root
parser.unreadtok nt
value[idx] = @type.parse_initializer(parser, scope)
else
raise nt || parser, '"=" expected' if not nt or nt.type != :punct or nt.raw != '='
value[idx] = parse_initializer(parser, scope)
end
end
idx + 1
end
end
class Variable
include Attributes
include Typed
attr_accessor :type
attr_accessor :initializer # CExpr / Block (for Functions)
attr_accessor :name
attr_accessor :storage # auto register static extern typedef
attr_accessor :backtrace # definition backtrace info (the name token)
def initialize(name=nil, type=nil)
@name, @type = name, type
end
end
# found in a block's Statements, used to know the initialization order
# eg { int i; i = 4; struct foo { int k; } toto = {i}; }
class Declaration
attr_accessor :var
def initialize(var)
@var = var
end
end
class If < Statement
attr_accessor :test # expression
attr_accessor :bthen, :belse # statements
def initialize(test, bthen, belse=nil)
@test = test
@bthen = bthen
@belse = belse if belse
end
def self.parse(parser, scope, nest)
tok = nil
raise tok || self, '"(" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '('
raise tok, 'expr expected' if not expr = CExpression.parse(parser, scope) or not expr.type.arithmetic?
raise tok || self, '")" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ')'
bthen = parser.parse_statement scope, nest
if tok = parser.skipspaces and tok.type == :string and tok.raw == 'else'
belse = parser.parse_statement scope, nest
else
parser.unreadtok tok
end
new expr, bthen, belse
end
end
class For < Statement
attr_accessor :init, :test, :iter # CExpressions, init may be Block
attr_accessor :body
def initialize(init, test, iter, body)
@init, @test, @iter, @body = init, test, iter, body
end
def self.parse(parser, scope, nest)
tok = nil
raise tok || parser, '"(" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '('
init = forscope = Block.new(scope)
if not parser.parse_definition(forscope)
forscope = scope
init = CExpression.parse(parser, forscope)
raise tok || parser, '";" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ';'
end
test = CExpression.parse(parser, forscope)
raise tok || parser, '";" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ';'
raise tok, 'bad test expression in for loop' if test and not test.type.arithmetic?
iter = CExpression.parse(parser, forscope)
raise tok || parser, '")" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ')'
new init, test, iter, parser.parse_statement(forscope, nest + [:loop])
end
end
class While < Statement
attr_accessor :test
attr_accessor :body
def initialize(test, body)
@test = test
@body = body
end
def self.parse(parser, scope, nest)
tok = nil
raise tok || parser, '"(" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '('
raise tok, 'expr expected' if not expr = CExpression.parse(parser, scope) or not expr.type.arithmetic?
raise tok || parser, '")" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ')'
new expr, parser.parse_statement(scope, nest + [:loop])
end
end
class DoWhile < While
def self.parse(parser, scope, nest)
body = parser.parse_statement(scope, nest + [:loop])
tok = nil
raise tok || parser, '"while" expected' if not tok = parser.skipspaces or tok.type != :string or tok.raw != 'while'
raise tok || parser, '"(" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '('
raise tok, 'expr expected' if not expr = CExpression.parse(parser, scope) or not expr.type.arithmetic?
raise tok || parser, '")" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ')'
parser.checkstatementend(tok)
new expr, body
end
end
class Switch < Statement
attr_accessor :test, :body
def initialize(test, body)
@test = test
@body = body
end
def self.parse(parser, scope, nest)
raise tok || parser, '"(" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '('
raise tok, 'expr expected' if not expr = CExpression.parse(parser, scope) or not expr.type.integral?
raise tok || parser, '")" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ')'
new expr, parser.parse_statement(scope, nest + [:switch])
end
end
class Continue < Statement
end
class Break < Statement
end
class Goto < Statement
attr_accessor :target
def initialize(target)
@target = target
end
end
class Return < Statement
attr_accessor :value
def initialize(value)
@value = value
end
end
class Label < Statement
attr_accessor :name
attr_accessor :statement
def initialize(name, statement=nil)
@name, @statement = name, statement
end
end
class Case < Label
attr_accessor :expr, :exprup # exprup if range, expr may be 'default'
def initialize(expr, exprup, statement)
@expr, @statement = expr, statement
@exprup = exprup if exprup
end
def self.parse(parser, scope, nest)
raise parser, 'invalid case' if not expr = CExpression.parse(parser, scope) or not expr.constant? or not expr.type.integral?
raise tok || parser, '":" or "..." expected' if not tok = parser.skipspaces or tok.type != :punct or (tok.raw != ':' and tok.raw != '.')
if tok.raw == '.'
raise tok || parser, '".." expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '.'
raise tok || parser, '"." expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '.'
raise tok, 'invalid case range' if not exprup = CExpression.parse(parser, scope) or not exprup.constant? or not exprup.type.integral?
raise tok || parser, '":" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ':'
end
body = parser.parse_statement scope, nest
new expr, exprup, body
end
end
# inline asm statement
class Asm < Statement
include Attributes
attr_accessor :body # asm source (::String)
attr_accessor :output, :input, :clobber # I/O, gcc-style (::Array)
attr_accessor :backtrace # body Token
attr_accessor :volatile
def initialize(body, backtrace, output=nil, input=nil, clobber=nil, volatile=nil)
@body, @backtrace, @output, @input, @clobber, @volatile = body, backtrace, output, input, clobber, volatile
end
def self.parse(parser, scope)
if tok = parser.skipspaces and tok.type == :string and (tok.raw == 'volatile' or tok.raw == '__volatile__')
volatile = true
tok = parser.skipspaces
end
if not tok or tok.type != :punct or tok.raw != '('
# detect MS-style inline asm: "__asm .* __asm .*" or "asm { [\s.]* }"
ftok = tok
body = ''
if tok.type == :punct and tok.raw == '{'
loop do
raise ftok, 'unterminated asm block' if not tok = parser.lexer.readtok
break if tok.type == :punct and tok.raw == '}'
case tok.type
when :space; body << ' '
when :eol; body << "\n"
when :punct; body << tok.raw
when :quoted; body << tok.value.inspect # concat adjacent c strings
when :string
body << \
case tok.raw
when 'asm', '__asm', '__asm__'; "\n"
when '_emit'; 'db'
else tok.raw
end
end
end
# allow shell-style heredoc: asm <<EOS\n<asm>\nEOS
elsif tok.type == :punct and tok.raw == '<'
raise ftok, 'bad asm heredoc' if not tok = parser.lexer.readtok or tok.type != :punct or tok.raw != '<'
delimiter = parser.lexer.readtok
if delimiter.type == :punct and delimiter.raw == '-'
skipspc = true
delimiter = parser.lexer.readtok
end
raise ftok, 'bad asm heredoc delim' if delimiter.type != :string or not tok = parser.lexer.readtok or tok.type != :eol
nl = true
loop do
raise ftok, 'unterminated heredoc' if not tok = parser.lexer.readtok
break if nl and tok.raw == delimiter.raw
raw = tok.raw
raw = "\n" if skipspc and tok.type == :eol
body << raw
nl = (tok.type == :eol and (raw[-1] == ?\n or raw[-1] == ?\r))
end
# MS single-instr: asm inc eax;
# also allow asm "foo bar\nbaz";
else
parser.lexer.unreadtok tok
loop do
break if not tok = parser.lexer.readtok or tok.type == :eol
case tok.type
when :space; body << ' '
when :punct
case tok.raw
when '}'
parser.lexer.unreadtok tok
break
else body << tok.raw
end
when :quoted; body << (body.empty? ? tok.value : tok.value.inspect) # asm "pop\nret" VS asm add al, 'z'
when :string
body << \
case tok.raw
when 'asm', '__asm', '__asm__'; "\n"
when '_emit'; 'db'
else tok.raw
end
end
end
end
return new(body, ftok, nil, nil, nil, volatile)
end
raise tok || parser, '"(" expected' if not tok or tok.type != :punct or tok.raw != '('
raise tok || parser, 'qstring expected' if not tok = parser.skipspaces or tok.type != :quoted
body = tok
ret = new body.value, body
tok = parser.skipspaces
raise tok || parser, '":" or ")" expected' if not tok or tok.type != :punct or (tok.raw != ':' and tok.raw != ')')
if tok.raw == ':'
ret.output = []
raise parser if not tok = parser.skipspaces
while tok.type == :quoted
type = tok.value
raise tok, 'expr expected' if not var = CExpression.parse_value(parser, scope)
ret.output << [type, var]
raise tok || parser, '":" or "," or ")" expected' if not tok = parser.skipspaces or tok.type != :punct or (tok.raw != ',' and tok.raw != ')' and tok.raw != ':')
break if tok.raw == ':' or tok.raw == ')'
raise tok || parser, 'qstring expected' if not tok = parser.skipspaces or tok.type != :quoted
end
end
if tok.raw == ':'
ret.input = []
raise parser if not tok = parser.skipspaces
while tok.type == :quoted
type = tok.value
raise tok, 'expr expected' if not var = CExpression.parse_value(parser, scope)
ret.input << [type, var]
raise tok || parser, '":" or "," or ")" expected' if not tok = parser.skipspaces or tok.type != :punct or (tok.raw != ',' and tok.raw != ')' and tok.raw != ':')
break if tok.raw == ':' or tok.raw == ')'
raise tok || parser, 'qstring expected' if not tok = parser.skipspaces or tok.type != :quoted
end
end
if tok.raw == ':'
ret.clobber = []
raise parser if not tok = parser.skipspaces
while tok.type == :quoted
ret.clobber << tok.value
raise tok || parser, '"," or ")" expected' if not tok = parser.skipspaces or tok.type != :punct or (tok.raw != ',' and tok.raw != ')')
break if tok.raw == ')'
raise tok || parser, 'qstring expected' if not tok = parser.skipspaces or tok.type != :quoted
end
end
raise tok || parser, '")" expected' if not tok or tok.type != :punct or tok.raw != ')'
ret.parse_attributes(parser)
parser.checkstatementend(tok)
ret
end
end
class CExpression < Statement
include Typed
# may be :,, :., :'->', :funcall (function, [arglist]), :[] (array indexing), nil (cast)
attr_accessor :op
# nil/CExpr/Variable/Label/::String( = :quoted/struct member name)/::Integer/::Float/Block
attr_accessor :lexpr, :rexpr
# a Type
attr_accessor :type
def initialize(l, o, r, t)
raise "invalid CExpr #{[l, o, r, t].inspect}" if (o and not o.kind_of? ::Symbol) or not t.kind_of? Type
@lexpr, @op, @rexpr, @type = l, o, r, t
end
# overwrites @lexpr @op @rexpr @type from the arg
def replace(o)
@lexpr, @op, @rexpr, @type = o.lexpr, o.op, o.rexpr, o.type
self
end
# deep copy of the object
# recurses only within CExpressions, anything else is copied by reference
def deep_dup
n = dup
n.lexpr = n.lexpr.deep_dup if n.lexpr.kind_of? CExpression
n.rexpr = n.rexpr.deep_dup if n.rexpr.kind_of? CExpression
n.rexpr = n.rexpr.map { |e| e.kind_of?(CExpression) ? e.deep_dup : e } if n.rexpr.kind_of? ::Array
n
end
# recursive constructor with automatic type inference
# e.g. CExpression[foo, :+, [:*, bar]]
# assumes root args are correctly typed (eg *foo => foo must be a pointer)
# take care to use [int] with immediates, e.g. CExpression[foo, :+, [2]]
# CExpr[some_cexpr] returns some_cexpr
def self.[](*args)
# sub-arrays in args are to be passed to self.[] recursively (syntaxic sugar)
splat = lambda { |e| e.kind_of?(::Array) ? self[*e] : e }
args.shift while args.first == nil # CExpr[nil, :&, bla] => CExpr[:&, bla]
case args.length
when 4
op = args[1]
if op == :funcall or op == :'?:'
x2 = args[2].map { |a| splat[a] } if args[2]
else
x2 = splat[args[2]]
end
new(splat[args[0]], op, x2, args[3])
when 3
op = args[1]
x1 = splat[args[0]]
if op == :funcall or op == :'?:'
x2 = args[2].map { |a| splat[a] } if args[2]
else
x2 = splat[args[2]]
end
case op
when :funcall
rt = x1.type.untypedef
rt = rt.type.untypedef if rt.pointer?
new(x1, op, x2, rt.type)
when :[]; new(x1, op, x2, x1.type.untypedef.type)
when :+; new(x1, op, x2, (x2.type.pointer? ? x2.type : x1.type))
when :-; new(x1, op, x2, ((x1.type.pointer? and x2.type.pointer?) ? BaseType.new(:int) : x2.type.pointer? ? x2.type : x1.type))
when :'&&', :'||', :==, :'!=', :>, :<, :<=, :>=; new(x1, op, x2, BaseType.new(:int))
when :'.', :'->'
t = x1.type.untypedef
t = t.type.untypedef if op == :'->' and x1.type.pointer?
raise "parse error: #{t} has no member #{x2}" if not t.kind_of? Union or not m = t.findmember(x2)
new(x1, op, x2, m.type)
when :'?:'; new(x1, op, x2, x2[0].type)
when :','; new(x1, op, x2, x2.type)
else new(x1, op, x2, x1.type)
end
when 2
x0 = splat[args[0]]
x1 = splat[args[1]]
x0, x1 = x1, x0 if x0.kind_of? Type
if x1.kind_of? Type; new(nil, nil, x0, x1) # (cast)r
elsif x0 == :*; new(nil, x0, x1, x1.type.untypedef.type) # *r
elsif x0 == :& and x1.kind_of? CExpression and x1.type.kind_of? C::Array; new(nil, nil, x1, Pointer.new(x1.type.type))
elsif x0 == :&; new(nil, x0, x1, Pointer.new(x1.type)) # &r
elsif x0 == :'!'; new(nil, x0, x1, BaseType.new(:int)) # &r
elsif x1.kind_of? ::Symbol; new(x0, x1, nil, x0.type) # l++
else new(nil, x0, x1, x1.type) # +r
end
when 1
x = splat[args[0]]
case x
when CExpression; x
when ::Integer; new(nil, nil, x, BaseType.new(:int)) # XXX range => __int64 ?
when ::Float; new(nil, nil, x, BaseType.new(:double))
when ::String; new(nil, nil, x, Pointer.new(BaseType.new(:char)))
else new(nil, nil, x, x.type)
end
else raise "parse error CExpr[*#{args.inspect}]"
end
end
end
class Parser
# creates a new CParser, parses all top-level statements
def self.parse(text)
new.parse text
end
# parses the current lexer content (or the text arg) for toplevel definitions
def parse(text=nil, filename='<unk>', lineno=1)
@lexer.feed text, filename, lineno if text
nil while not @lexer.eos? and (parse_definition(@toplevel) or parse_toplevel_statement(@toplevel))
raise @lexer.readtok || self, 'invalid definition' if not @lexer.eos?
sanity_checks
self
end
# parses a C file
def parse_file(file)
parse(File.read(file), file)
end
attr_accessor :lexer, :toplevel, :typesize, :pragma_pack
attr_accessor :endianness
attr_accessor :allow_bad_c
# allowed arguments: ExeFormat, CPU, Preprocessor, Symbol (for the data model)
def initialize(*args)
model = args.grep(Symbol).first || :ilp32
lexer = args.grep(Preprocessor).first || Preprocessor.new
exe = args.grep(ExeFormat).first
cpu = args.grep(CPU).first
cpu ||= exe.cpu if exe
@lexer = lexer
@prev_pragma_callback = @lexer.pragma_callback
@lexer.pragma_callback = lambda { |tok| parse_pragma_callback(tok) }
@toplevel = Block.new(nil)
@unreadtoks = []
@endianness = cpu ? cpu.endianness : :big
@typesize = { :void => 1, :__int8 => 1, :__int16 => 2, :__int32 => 4, :__int64 => 8,
:char => 1, :float => 4, :double => 8, :longdouble => 12 }
send model
cpu.tune_cparser(self) if cpu
exe.tune_cparser(self) if exe
end
def ilp16
@typesize.update :short => 2, :ptr => 2,
:int => 2, :long => 4, :longlong => 4
end
def lp32
@typesize.update :short => 2, :ptr => 4,
:int => 2, :long => 4, :longlong => 8
end
def ilp32
@typesize.update :short => 2, :ptr => 4,
:int => 4, :long => 4, :longlong => 8
end
def llp64
@typesize.update :short => 2, :ptr => 8,
:int => 4, :long => 4, :longlong => 8
end
def lp64
@typesize.update :short => 2, :ptr => 8,
:int => 4, :long => 8, :longlong => 8
end
def ilp64
@typesize.update :short => 2, :ptr => 8,
:int => 8, :long => 8, :longlong => 8
end
def parse_pragma_callback(otok)
case otok.raw
when 'pack'
nil while lp = @lexer.readtok and lp.type == :space
nil while rp = @lexer.readtok and rp.type == :space
if not rp or rp.type != :punct or rp.raw != ')'
v1 = rp
nil while rp = @lexer.readtok and rp.type == :space
end
if rp and rp.type == :punct and rp.raw == ','
nil while v2 = @lexer.readtok and v2.type == :space
nil while rp = @lexer.readtok and rp.type == :space
end
raise otok if not rp or lp.type != :punct or rp.type != :punct or lp.raw != '(' or rp.raw != ')'
raise otok if (v1 and v1.type != :string) or (v2 and (v2.type != :string or v2.raw =~ /[^\d]/))
if not v1
@pragma_pack = nil
elsif v1.raw == 'push'
@pragma_pack_stack ||= []
@pragma_pack_stack << pragma_pack
@pragma_pack = v2.raw.to_i if v2
raise v2, 'bad pack value' if pragma_pack == 0
elsif v1.raw == 'pop'
@pragma_pack_stack ||= []
raise v1, 'pack stack empty' if @pragma_pack_stack.empty?
@pragma_pack = @pragma_pack_stack.pop
@pragma_pack = v2.raw.to_i if v2 and v2.raw # #pragma pack(pop, 4) => pop stack, but use 4 as pack value (imho)
raise v2, 'bad pack value' if @pragma_pack == 0
elsif v1.raw =~ /^\d+$/
raise v2, '2nd arg unexpected' if v2
@pragma_pack = v1.raw.to_i
raise v1, 'bad pack value' if @pragma_pack == 0
else raise otok
end
# the caller checks for :eol
when 'warning'
if $DEBUG
@prev_pragma_callback[otok]
else
# silent discard
nil while tok = @lexer.readtok_nopp and tok.type != :eol
@lexer.unreadtok tok
end
when 'prepare_visualstudio'
prepare_visualstudio
when 'prepare_gcc'
prepare_gcc
when 'data_model' # XXX use carefully, should be the very first thing parsed
nil while lp = @lexer.readtok and lp.type == :space
if lp.type != :string or lp.raw !~ /^s?[il]?lp(16|32|64)$/ or not respond_to? lp.raw
raise lp, "invalid data model (use lp32/lp64/llp64/ilp64)"
else
send lp.raw
end
else @prev_pragma_callback[otok]
end
end
def prepare_visualstudio
@lexer.define_weak('_WIN32')
@lexer.define_weak('_WIN32_WINNT', 0x500)
@lexer.define_weak('_INTEGRAL_MAX_BITS', 64)
@lexer.define_weak('__w64')
@lexer.define_weak('_cdecl', '__cdecl') # typo ? seen in winreg.h
@lexer.define_weak('_fastcall', '__fastcall') # typo ? seen in ntddk.h
@lexer.define_weak('_MSC_VER', 1300) # handle '#pragma once' and _declspec(noreturn)
@lexer.define_weak('__forceinline', '__inline')
@lexer.define_weak('__ptr32') # needed with msc_ver 1300, don't understand their use
@lexer.define_weak('__ptr64')
end
def prepare_gcc
@lexer.define_weak('__GNUC__', 2) # otherwise __attribute__ is defined to void..
@lexer.define_weak('__STDC__')
@lexer.define_weak('__const', 'const')
@lexer.define_weak('__signed', 'signed')
@lexer.define_weak('__signed__', 'signed')
@lexer.define_weak('__volatile', 'volatile')
if not @lexer.definition['__builtin_constant_p']
# magic macro to check if its arg is an immediate value
@lexer.define_weak('__builtin_constant_p', '0')
@lexer.definition['__builtin_constant_p'].args = [Preprocessor::Token.new([])]
end
@lexer.nodefine_strong('alloca') # TODO __builtin_alloca
@lexer.hooked_include['stddef.h'] = <<EOH
/* simplified, define all at first invocation. may break things... */
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wint_t
#undef __need_wchar_t
#undef __need_NULL
#undef NULL
#if !defined (_STDDEF_H)
#define _STDDEF_H
#define __PTRDIFF_TYPE__ long int
typedef __PTRDIFF_TYPE__ ptrdiff_t;
#define __SIZE_TYPE__ long unsigned int
typedef __SIZE_TYPE__ size_t;
#define __WINT_TYPE__ unsigned int
typedef __WINT_TYPE__ wint_t;
#define __WCHAR_TYPE__ int
typedef __WCHAR_TYPE__ wchar_t;
#define NULL 0
#define offsetof(TYPE, MEMBER) __builtin_offsetof (TYPE, MEMBER)
#endif
EOH
# TODO va_args
@lexer.hooked_include['stdarg.h'] = <<EOH
// TODO
typedef void* __gnuc_va_list;
/*
typedef void* va_list;
#define va_start(v, l)
#define va_end(v)
#define va_arg(v, l)
#define va_copy(d, s)
*/
EOH
@lexer.hooked_include['limits.h'] = <<EOH
#define CHAR_BIT 8
#define SCHAR_MIN (-128)
#define SCHAR_MAX 127
#define UCHAR_MAX 255
#ifdef __CHAR_UNSIGNED__
# define CHAR_MIN 0
# define CHAR_MAX UCHAR_MAX
#else
# define CHAR_MIN SCHAR_MIN
# define CHAR_MAX SCHAR_MAX
#endif
#define UINT_MAX #{(1 << (8*@typesize[:int]))-1}U
#define INT_MAX (UINT_MAX >> 1)
#define INT_MIN (-INT_MAX - 1)
#define ULONG_MAX #{(1 << (8*@typesize[:long]))-1}UL
#define LONG_MAX (ULONG_MAX >> 1L)
#define LONG_MIN (-LONG_MAX - 1L)
EOH
end
# C sanity checks
def sanity_checks
return if not $VERBOSE
# TODO
end
# checks that the types are compatible (variable predeclaration, function argument..)
# strict = false for func call/assignment (eg char compatible with int -- but int is incompatible with char)
# output warnings only
def check_compatible_type(tok, oldtype, newtype, strict = false, checked = [])
return if not $VERBOSE
oldtype = oldtype.untypedef
newtype = newtype.untypedef
oldtype = BaseType.new(:int) if oldtype.kind_of? Enum
newtype = BaseType.new(:int) if newtype.kind_of? Enum
puts tok.exception('type qualifier mismatch').message if oldtype.qualifier.to_a.uniq.length > newtype.qualifier.to_a.uniq.length
# avoid infinite recursion
return if checked.include? oldtype
checked = checked + [oldtype]
begin
case newtype
when Function
raise tok, 'type error' if not oldtype.kind_of? Function
check_compatible_type tok, oldtype.type, newtype.type, strict, checked
if oldtype.args and newtype.args
if oldtype.args.length != newtype.args.length or
oldtype.varargs != newtype.varargs
raise tok, 'type error'
end
oldtype.args.zip(newtype.args) { |oa, na|
# begin ; rescue ParseError: raise $!.message + "in parameter #{oa.name}" end
check_compatible_type tok, oa.type, na.type, strict, checked
}
end
when Pointer
if oldtype.kind_of? BaseType and oldtype.integral?
puts tok.exception('making pointer from integer without a cast').message
return
end
raise tok, 'type error' if not oldtype.kind_of? Pointer
hasvoid = true if (t = newtype.type.untypedef).kind_of? BaseType and t.name == :void
hasvoid = true if (t = oldtype.type.untypedef).kind_of? BaseType and t.name == :void # struct foo *f = NULL;
if strict and not hasvoid
check_compatible_type tok, oldtype.type, newtype.type, strict, checked
end
when Union
raise tok, 'type error' if not oldtype.class == newtype.class
if oldtype.members and newtype.members
if oldtype.members.length != newtype.members.length
raise tok, 'bad member count'
end
oldtype.members.zip(newtype.members) { |om, nm|
# raise tok if om.name and nm.name and om.name != nm.name # don't care
check_compatible_type tok, om.type, nm.type, strict, checked
}
end
when BaseType
raise tok, 'type error' if not oldtype.kind_of? BaseType
if strict
if oldtype.name != newtype.name or
oldtype.specifier != newtype.specifier
raise tok, 'type error'
end
else
raise tok, 'type error' if @typesize[newtype.name] == 0 and @typesize[oldtype.name] > 0
puts tok.exception('type size mismatch, may lose bits').message if @typesize[oldtype.name] > @typesize[newtype.name]
puts tok.exception('sign mismatch').message if oldtype.specifier != newtype.specifier and @typesize[newtype.name] == @typesize[oldtype.name]
end
end
rescue ParseError
raise $! if checked.length != 1 # bubble up
oname = (oldtype.to_s rescue oldtype.class.name)
nname = (newtype.to_s rescue newtype.class.name)
puts $!.message + " incompatible type #{oname} to #{nname}"
end
end
# allows 'raise self'
def exception(msg='EOF unexpected')
@lexer.exception msg
end
# reads a token, convert 'L"foo"' to a :quoted
def readtok_longstr
if t = @lexer.readtok and t.type == :string and t.raw == 'L' and
nt = @lexer.readtok and nt.type == :quoted and nt.raw[0] == ?"
nt.raw[0, 0] = 'L'
nt
elsif t and t.type == :punct and t.raw == '/' and
# nt has not been read
nt = @lexer.readtok and nt.type == :punct and nt.raw == '/'
# windows.h has a #define some_type_name /##/, and VS interprets this as a comment..
puts @lexer.exception('#defined //').message if $VERBOSE
t = @lexer.readtok while t and t.type != :eol
t
else
@lexer.unreadtok nt
t
end
end
private :readtok_longstr
# reads a token from self.lexer
# concatenates strings, merges spaces/eol to ' ', handles wchar strings, allows $@_ in :string
def readtok
if not t = @unreadtoks.pop
return if not t = readtok_longstr
case t.type
when :space, :eol
# merge consecutive :space/:eol
t = t.dup
t.type = :space
t.raw = ' '
nil while nt = @lexer.readtok and (nt.type == :eol or nt.type == :space)
@lexer.unreadtok nt
when :quoted
# merge consecutive :quoted
t = t.dup
while nt = readtok_longstr
case nt.type
when :quoted
if t.raw[0] == ?" and nt.raw[0, 2] == 'L"'
# ensure wide prefix is set
t.raw[0, 0] = 'L'
end
t.raw << ' ' << nt.raw
t.value << nt.value
when :space, :eol
else break
end
end
@lexer.unreadtok nt
else
if (t.type == :punct and (t.raw == '_' or t.raw == '@' or t.raw == '$')) or t.type == :string
t = t.dup
t.type = :string
nt = nil
t.raw << nt.raw while nt = @lexer.readtok and ((nt.type == :punct and (nt.raw == '_' or nt.raw == '@' or nt.raw == '$')) or nt.type == :string)
@lexer.unreadtok nt
end
end
end
t
end
def eos?
@unreadtoks.empty? and @lexer.eos?
end
def unreadtok(tok)
@unreadtoks << tok if tok
end
# returns the next non-space/non-eol token
def skipspaces
nil while t = readtok and t.type == :space
t
end
# checks that we are at the end of a statement, ie an ';' character (consumed), or a '}' (not consumed)
# otherwise, raise either the given token or self.
def checkstatementend(tok=nil)
raise tok || self, '";" expected' if not tok = skipspaces or tok.type != :punct or (tok.raw != ';' and tok.raw != '}')
unreadtok tok if tok.raw == '}'
end
# returns the size of a type in bytes
def sizeof(var, type=nil)
var, type = nil, var if var.kind_of? Type and not type
type ||= var.type
# XXX double-check class apparition order ('when' checks inheritance)
case type
when Array
case type.length
when nil
if var.kind_of? CExpression and not var.lexpr and not var.op and var.rexpr.kind_of? Variable
var = var.rexpr
end
raise self, 'unknown array size' if not var.kind_of? Variable or not var.initializer
init = var.initializer
init = init.rexpr if init.kind_of? C::CExpression and not init.op and init.rexpr.kind_of? ::String
case init
when ::String; sizeof(nil, type.type) * (init.length + 1)
when ::Array
v = init.compact.first
v ? (sizeof(nil, type.type) * init.length) : 0
else sizeof(init)
end
when ::Integer; type.length * sizeof(type.type)
when CExpression
len = type.length.reduce(self)
raise self, 'unknown array size' if not len.kind_of? ::Integer
len * sizeof(type)
else raise self, 'unknown array size'
end
when Pointer
if var.kind_of? CExpression and not var.op and var.rexpr.kind_of? ::String
# sizeof("lolz") => 5
sizeof(nil, type.type) * (var.rexpr.length + 1)
else
@typesize[:ptr]
end
when Function
# raise
1 # gcc
when BaseType
@typesize[type.name]
when Enum
@typesize[:int]
when Struct
raise self, "unknown structure size #{type.name}" if not type.members
al = type.align(self)
lm = type.members.last
lm ? (type.offsetof(self, lm) + sizeof(lm) + al - 1) / al * al : 0
when Union
raise self, "unknown structure size #{type.name}" if not type.members
type.members.map { |m| sizeof(m) }.max || 0
when TypeDef
sizeof(var, type.type)
end
end
# parses variable/function definition/declaration/initialization
# populates scope.symbols and scope.struct
# raises on redefinitions
# returns false if no definition found
def parse_definition(scope)
return false if not basetype = Variable.parse_type(self, scope, true)
# check struct predeclaration
tok = skipspaces
if tok and tok.type == :punct and tok.raw == ';' and basetype.type and
(basetype.type.kind_of? Union or basetype.type.kind_of? Enum)
return true
else unreadtok tok
end
nofunc = false
loop do
var = basetype.dup
var.parse_declarator(self, scope)
raise var.backtrace if not var.name # barrel roll
if prev = scope.symbol[var.name]
if prev.kind_of? TypeDef and var.storage == :typedef
check_compatible_type(var.backtrace, prev.type, var.type, true)
# windows.h redefines many typedefs with the same definition
puts "redefining typedef #{var.name}" if $VERBOSE
var = prev
elsif not prev.kind_of?(Variable) or
prev.initializer or
(prev.storage != :extern and prev.storage != var.storage) or
(scope != @toplevel and prev.storage != :static)
if prev.kind_of? ::Integer # enum value
prev = (scope.struct.values.grep(Enum) + scope.anonymous_enums.to_a).find { |e| e.members.index(prev) }
end
raise var.backtrace, "redefinition, previous is #{prev.backtrace.exception(nil).message rescue :unknown}"
else
check_compatible_type var.backtrace, prev.type, var.type, true
(var.attributes ||= []).concat prev.attributes if prev.attributes
end
elsif var.storage == :typedef
attrs = var.attributes
var = TypeDef.new var.name, var.type, var.backtrace
var.attributes = attrs if attrs
end
scope.statements << Declaration.new(var) unless var.kind_of? TypeDef
raise tok || self, 'punctuation expected' if not tok = skipspaces or (tok.type != :punct and not %w[asm __asm __asm__].include? tok.raw)
case tok.raw
when '{'
# function body
raise tok if nofunc or not var.kind_of? Variable or not var.type.kind_of? Function
scope.symbol[var.name] = var
body = var.initializer = Block.new(scope)
var.type.args ||= []
var.type.args.each { |v|
# put func parameters in func body scope
# arg redefinition is checked in parse_declarator
if not v.name
puts "unnamed argument in definition of #{var.name}" if $DEBUG
next # should raise to be compliant
end
body.symbol[v.name] = v # XXX will need special check in stack allocator
}
loop do
raise tok || self, var.backtrace.exception('"}" expected for end of function') if not tok = skipspaces
break if tok.type == :punct and tok.raw == '}'
unreadtok tok
if not parse_definition(body)
body.statements << parse_statement(body, [var.type.type])
end
end
if $VERBOSE and not body.statements.last.kind_of? Return and not body.statements.last.kind_of? Asm
puts tok.exception('missing function return value').message if not var.type.type.untypedef.kind_of? BaseType or var.type.type.untypedef.name != :void
end
break
when 'asm', '__asm', '__asm__'
# GCC function redirection
# void foo(void) __asm__("bar"); => when code uses 'foo', silently redirect to 'bar' instead
raise tok if nofunc or not var.kind_of? Variable or not var.type.kind_of? Function
# most of the time, 'bar' is not defined anywhere, so we support it only
# to allow parsing of headers using it, hoping noone will actually use them
unused = Asm.parse(self, scope)
puts "unsupported gcc-style __asm__ function redirect #{var.name.inspect} => #{unused.body.inspect}" if $VERBOSE
break
when '='
# variable initialization
raise tok, '"{" or ";" expected' if var.type.kind_of? Function
raise tok, 'cannot initialize extern variable' if var.storage == :extern
scope.symbol[var.name] = var # allow initializer to reference var, eg 'void *ptr = &ptr;'
var.initializer = var.type.parse_initializer(self, scope)
if var.initializer.kind_of?(CExpression) and (scope == @toplevel or var.storage == :static)
raise tok, "initializer for static #{var.name} is not constant" if not var.initializer.constant?
end
reference_value = lambda { |e, v|
found = false
case e
when Variable; found = true if e == v
when CExpression; e.walk { |ee| found ||= reference_value[ee, v] } if e.op != :& or e.lexpr
end
found
}
raise tok, "initializer for #{var.name} is not constant (selfreference)" if reference_value[var.initializer, var]
raise tok || self, '"," or ";" expected' if not tok = skipspaces or tok.type != :punct
else
scope.symbol[var.name] = var
end
case tok.raw
when ','; nofunc = true
when ';'; break
when '}'; unreadtok(tok); break
else raise tok, '";" or "," expected'
end
end
true
end
# parses toplevel statements, return nil if none found
# toplevel statements are ';' and 'asm <..>'
def parse_toplevel_statement(scope)
if tok = skipspaces and tok.type == :punct and tok.raw == ';'
true
elsif tok and tok.type == :punct and tok.raw == '{'
raise tok || self, '"}" expected' if not tok = skipspaces or tok.type != :punct or tok.raw != '}'
true
elsif tok and tok.type == :string and %w[asm __asm __asm__].include? tok.raw
scope.statements << Asm.parse(self, scope)
true
end
end
# returns a statement or raise
def parse_statement(scope, nest)
raise self, 'statement expected' if not tok = skipspaces
if tok.type == :punct and tok.raw == '{'
body = Block.new scope
loop do
raise tok || self, '"}" expected' if not tok = skipspaces
break if tok.type == :punct and tok.raw == '}'
unreadtok tok
if not parse_definition(body)
body.statements << parse_statement(body, nest)
end
end
return body
elsif tok.type == :punct and tok.raw == ';'
return Block.new(scope)
elsif tok.type != :string
unreadtok tok
raise tok, 'expr expected' if not expr = CExpression.parse(self, scope)
checkstatementend(tok)
if $VERBOSE and not nest.include?(:expression) and (expr.op or not expr.type.untypedef.kind_of? BaseType or expr.type.untypedef.name != :void) and CExpression.constant?(expr)
puts tok.exception("statement with no effect : #{expr}").message
end
return expr
end
case tok.raw
when 'if'
If.parse self, scope, nest
when 'while'
While.parse self, scope, nest
when 'do'
DoWhile.parse self, scope, nest
when 'for'
For.parse self, scope, nest
when 'switch'
Switch.parse self, scope, nest
when 'goto'
raise tok || self, 'label expected' if not tok = skipspaces or tok.type != :string
name = tok.raw
checkstatementend(tok)
Goto.new name
when 'return'
expr = CExpression.parse(self, scope) # nil allowed
p, i = nest[0].pointer?, nest[0].integral? if expr
r = expr.reduce(self) if p or i
if (not p and not i) or (i and not r.kind_of? ::Integer) or (p and r != 0)
check_compatible_type(tok, (expr ? expr.type : BaseType.new(:void)), nest[0])
end
checkstatementend(tok)
Return.new expr
when 'case'
raise tok, 'case out of switch' if not nest.include? :switch
Case.parse self, scope, nest
when 'default'
raise tok || self, '":" expected' if not tok = skipspaces or tok.type != :punct or tok.raw != ':'
raise tok, 'case out of switch' if not nest.include? :switch
Case.new 'default', nil, parse_statement(scope, nest)
when 'continue'
checkstatementend(tok)
raise tok, 'continue out of loop' if not nest.include? :loop
Continue.new
when 'break'
checkstatementend(tok)
raise tok, 'break out of loop' if not nest.include? :loop and not nest.include? :switch
Break.new
when 'asm', '__asm', '__asm__'
Asm.parse self, scope
else
if ntok = skipspaces and ntok.type == :punct and ntok.raw == ':'
begin
st = parse_statement(scope, nest)
rescue ParseError
puts "label without statement, #{$!.message}" if $VERBOSE
end
Label.new tok.raw, st
else
unreadtok ntok
unreadtok tok
raise tok, 'expr expected' if not expr = CExpression.parse(self, scope)
checkstatementend(tok)
if $VERBOSE and not nest.include?(:expression) and (expr.op or not expr.type.untypedef.kind_of? BaseType or expr.type.untypedef.name != :void) and CExpression.constant?(expr)
puts tok.exception("statement with no effect : #{expr}").message
end
expr
end
end
end
# check if a macro definition has a numeric value
# returns this value or nil
def macro_numeric(m)
d = @lexer.definition[m]
return if not d.kind_of? Preprocessor::Macro or d.args or d.varargs
# filter metasm-defined vars (eg __PE__ / _M_IX86)
return if not d.name or not bt = d.name.backtrace or (bt[0][0] != ?" and bt[0][0] != ?<)
raise 'cannot macro_numeric with unparsed data' if not eos?
@lexer.feed m
if e = CExpression.parse(self, Block.new(@toplevel)) and eos?
v = e.reduce(self)
return v if v.kind_of? ::Numeric
end
readtok until eos?
nil
rescue ParseError
readtok until eos?
nil
end
# returns all numeric constants defined with their value, either macros or enums
def numeric_constants
ret = []
# macros
@lexer.definition.each_key { |k|
if v = macro_numeric(k)
ret << [k, v]
end
}
# enums
@toplevel.symbol.each { |k, v|
ret << [k, v] if v.kind_of? ::Numeric
}
ret
end
end
class Variable
# parses a variable basetype/qualifier/(storage if allow_value), returns a new variable of this type
# populates scope.struct
def self.parse_type(parser, scope, allow_value = false)
var = new
qualifier = []
tok = nil
loop do
var.parse_attributes(parser, true)
break if not tok = parser.skipspaces
if tok.type != :string
parser.unreadtok tok
break
end
case tok.raw
when 'const', 'volatile'
qualifier << tok.raw.to_sym
next
when 'register', 'auto', 'static', 'typedef', 'extern'
raise tok, 'storage specifier not allowed here' if not allow_value
raise tok, 'multiple storage class' if var.storage
var.storage = tok.raw.to_sym
next
when 'struct'
var.type = Struct.new
var.type.pack = parser.pragma_pack if parser.pragma_pack
var.parse_type_struct(parser, scope)
when 'union'
var.type = Union.new
var.parse_type_struct(parser, scope)
when 'enum'
var.type = Enum.new
var.parse_type_struct(parser, scope)
when 'typeof'
if ntok = parser.skipspaces and ntok.type == :punct and ntok.raw == '('
# check type
if v = parse_type(parser, scope)
v.parse_declarator(parser, scope)
raise tok if v.name != false
raise tok if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ')'
else
raise tok, 'expr expected' if not v = CExpression.parse(parser, scope)
raise tok if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ')'
end
else
parser.unreadtok ntok
raise tok, 'expr expected' if not v = CExpression.parse_value(parser, scope)
end
var.type = v.type # TypeDef.new('typeof', v.type, tok)
when 'long', 'short', 'signed', 'unsigned', 'int', 'char', 'float', 'double',
'void', '__int8', '__int16', '__int32', '__int64',
'intptr_t', 'uintptr_t'
parser.unreadtok tok
var.parse_type_base(parser, scope)
else
if type = scope.symbol_ancestors[tok.raw] and type.kind_of? TypeDef
var.type = type.dup
else
parser.unreadtok tok
end
end
break
end
if not var.type
raise tok || parser, 'bad type name' if not qualifier.empty? or var.storage
nil
else
var.type.qualifier = var.type.qualifier.to_a | qualifier if not qualifier.empty?
var.type.parse_attributes(parser, true)
var
end
end
# parses a structure/union/enum declaration
def parse_type_struct(parser, scope)
@type.parse_attributes(parser)
if tok = parser.skipspaces and tok.type == :punct and tok.raw == '{'
# anonymous struct, ok
@type.backtrace = tok
if @type.kind_of? Enum
(scope.anonymous_enums ||= []) << @type
end
elsif tok and tok.type == :string
name = tok.raw
raise tok, 'bad struct name' if Keyword[name] or (?0..?9).include?(name[0])
@type.backtrace = tok
@type.name = name
@type.parse_attributes(parser)
raise parser if not ntok = parser.skipspaces
if ntok.type != :punct or ntok.raw != '{'
raise tok, "struct/union confusion" if scope.struct[name] and scope.struct[name].class != @type.class
# variable declaration
parser.unreadtok ntok
if ntok.type == :punct and ntok.raw == ';'
# struct predeclaration
# allow redefinition
@type = scope.struct[name] ||= @type
else
# check that the structure exists
struct = scope.struct_ancestors[name]
# allow incomplete types, usage as var type will raise later
struct = scope.struct[name] = @type if not struct
raise tok, 'unknown struct' if struct.class != @type.class
(struct.attributes ||= []).concat @type.attributes if @type.attributes
(struct.qualifier ||= []).concat @type.qualifier if @type.qualifier # XXX const struct foo bar => bar is const, not foo...
@type = struct
end
return
end
if scope.struct[name] and scope.struct[name].members
# redefinition of an existing struct, save for later comparison
oldstruct = scope.struct[name]
raise tok, "struct/union confusion" if oldstruct.class != @type.class
elsif struct = scope.struct[name]
raise tok, "struct/union confusion" if struct.class != @type.class
(struct.attributes ||= []).concat @type.attributes if @type.attributes
(struct.qualifier ||= []).concat @type.qualifier if @type.qualifier
struct.backtrace = @type.backtrace
struct.name = @type.name
@type = struct
else
scope.struct[name] = @type
end
else
raise tok || parser, 'struct name or "{" expected'
end
@type.parse_members(parser, scope)
if oldstruct
if not @type.compare_deep(oldstruct)
raise tok, "conflicting struct redefinition (old at #{oldstruct.backtrace.exception(nil).message rescue :unknown})"
end
@type = oldstruct
end
end
# parses int/long int/long long/double etc
def parse_type_base(parser, scope)
specifier = []
qualifier = []
name = :int
tok = nil
loop do
raise parser if not tok = parser.skipspaces
if tok.type != :string
parser.unreadtok tok
break
end
case tok.raw
when 'const', 'volatile'
qualifier << tok.raw.to_sym
when 'long', 'short', 'signed', 'unsigned'
specifier << tok.raw.to_sym
when 'int', 'char', 'void', 'float', 'double', '__int8', '__int16', '__int32', '__int64'
name = tok.raw.to_sym
break
when 'intptr_t', 'uintptr_t'
name = :ptr
specifier << :unsigned if tok.raw == 'uintptr_t'
break
else
parser.unreadtok tok
break
end
end
case name
when :double # long double
if specifier == [:long]
name = :longdouble
specifier.clear
elsif not specifier.empty?
raise tok || parser, 'invalid specifier list'
end
when :int # short, long, long long X signed, unsigned
# Array#count not available on old ruby (eg 1.8.4), so use ary.len - (ary-stuff).len
specifier = specifier - [:long] + [:longlong] if specifier.length - (specifier-[:long]).length == 2
if specifier.length - (specifier-[:signed, :unsigned]).length > 1 or specifier.length - (specifier-[:short, :long, :longlong]).length > 1
raise tok || parser, 'invalid specifier list'
else
name = (specifier & [:longlong, :long, :short])[0] || :int
specifier -= [:longlong, :long, :short]
end
specifier.delete :signed # default
when :char # signed, unsigned
# signed char != char and unsigned char != char
if (specifier & [:signed, :unsigned]).length > 1 or (specifier & [:short, :long]).length > 0
raise tok || parser, 'invalid specifier list'
end
when :__int8, :__int16, :__int32, :__int64, :ptr
if (specifier & [:signed, :unsigned]).length > 1 or (specifier & [:short, :long]).length > 0
raise tok || parser, 'invalid specifier list'
end
specifier.delete :signed # default
else # none
raise tok || parser, 'invalid type' if not specifier.empty?
end
@type = BaseType.new(name, *specifier)
@type.qualifier = qualifier if not qualifier.empty?
end
# updates @type and @name, parses pointer/arrays/function declarations
# parses anonymous declarators (@name will be false)
# the caller is responsible for detecting redefinitions
# scope used only in CExpression.parse for array sizes and function prototype argument types
# rec for internal use only
def parse_declarator(parser, scope, rec = false)
parse_attributes(parser, true)
tok = parser.skipspaces
# read upto name
if tok and tok.type == :punct and tok.raw == '*'
ptr = Pointer.new
ptr.parse_attributes(parser)
while ntok = parser.skipspaces and ntok.type == :string
case ntok.raw
when 'const', 'volatile'
(ptr.qualifier ||= []) << ntok.raw.to_sym
ptr.parse_attributes(parser)
else break
end
end
parser.unreadtok ntok
parse_declarator(parser, scope, true)
t = self
t = t.type while t.type and (t.type.kind_of?(Pointer) or t.type.kind_of?(Function))
ptr.type = t.type
t.type = ptr
if t.kind_of? Function and ptr.attributes
@attributes ||= []
@attributes |= ptr.attributes
ptr.attributes = nil
end
return
elsif tok and tok.type == :punct and tok.raw == '('
parse_declarator(parser, scope, true)
raise tok || parser, '")" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ')'
elsif tok and tok.type == :string
case tok.raw
when 'const', 'volatile'
(@type.qualifier ||= []) << tok.raw.to_sym
return parse_declarator(parser, scope, rec)
when 'register', 'auto', 'static', 'typedef', 'extern'
raise tok, 'multiple storage class' if storage
@storage = tok.raw.to_sym
puts tok.exception('misplaced storage specifier').message if $VERBOSE
return parse_declarator(parser, scope, rec)
end
raise tok if name or name == false
raise tok, 'bad var name' if Keyword[tok.raw] or (?0..?9).include?(tok.raw[0])
@name = tok.raw
@backtrace = tok
parse_attributes(parser, true)
else
# unnamed
raise tok || parser if name or name == false
@name = false
@backtrace = tok
parser.unreadtok tok
parse_attributes(parser, true)
end
parse_declarator_postfix(parser, scope)
if not rec
raise @backtrace, 'void type is invalid' if name and (t = @type.untypedef).kind_of? BaseType and
t.name == :void and storage != :typedef
raise @backtrace, "incomplete type #{@type.name}" if (@type.kind_of? Union or @type.kind_of? Enum) and
not @type.members and storage != :typedef and storage != :extern # gcc uses an undefined extern struct just to cast it later (_IO_FILE_plus)
end
end
# parses array/function type
def parse_declarator_postfix(parser, scope)
if tok = parser.skipspaces and tok.type == :punct and tok.raw == '['
# array indexing
idx = CExpression.parse(parser, scope) # may be nil
if idx and (scope == parser.toplevel or storage == :static)
raise tok, 'array size is not constant' if not idx.constant?
idx = idx.reduce(parser)
elsif idx and nidx = idx.reduce(parser) and nidx.kind_of? ::Integer
idx = nidx
end
t = self
t = t.type while t.type and (t.type.kind_of?(Pointer) or t.type.kind_of?(Function))
t.type = Array.new t.type
t.type.length = idx
raise tok || parser, '"]" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ']'
parse_attributes(parser) # should be type.attrs, but this is should be more compiler-compatible
elsif tok and tok.type == :punct and tok.raw == '('
# function prototype
# void __attribute__((noreturn)) func() => attribute belongs to func
if @type and @type.attributes
@attributes ||= []
@attributes |= @type.attributes
@type.attributes = nil
end
t = self
t = t.type while t.type and (t.type.kind_of?(Pointer) or t.type.kind_of?(Function))
t.type = Function.new t.type
if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ')'
parser.unreadtok tok
t.type.args = []
oldstyle = false # int func(a, b) int a; double b; { stuff; }
loop do
raise parser if not tok = parser.skipspaces
if tok.type == :punct and tok.raw == '.' # variadic function
raise parser, '".." expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '.'
raise parser, '"." expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '.'
raise parser, '")" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ')'
t.type.varargs = true
break
elsif tok.type == :string and tok.raw == 'register'
storage = :register
else
parser.unreadtok tok
end
if oldstyle or not v = Variable.parse_type(parser, scope)
raise tok if not @name # no oldstyle in casts
tok = parser.skipspaces
oldstyle ||= [tok] # arg to raise() later
oldstyle << tok.raw
else
v.storage = storage if storage
v.parse_declarator(parser, scope)
v.type = Pointer.new(v.type.type) if v.type.kind_of? Array
v.type = Pointer.new(v.type) if v.type.kind_of? Function
t.type.args << v if not v.type.untypedef.kind_of? BaseType or v.type.untypedef.name != :void
end
if tok = parser.skipspaces and tok.type == :punct and tok.raw == ','
raise tok, '")" expected' if v and t.type.args.last != v # last arg of type :void
elsif tok and tok.type == :punct and tok.raw == ')'
break
else raise tok || parser, '"," or ")" expected'
end
end
if oldstyle
parse_attributes(parser, true)
ra = oldstyle.shift
while t.type.args.compact.length != oldstyle.length
raise ra, "invalid prototype" if not vb = Variable.parse_type(parser, scope)
loop do
v = vb.dup
v.parse_declarator(parser, scope)
v.type = Pointer.new(v.type.type) if v.type.kind_of? Array
v.type = Pointer.new(v.type) if v.type.kind_of? Function
raise parser, "unknown arg #{v.name.inspect}" if not i = oldstyle.index(v.name)
t.type.args[i] = v
raise parser, '"," or ";" expected' if not tok = parser.skipspaces or tok.type != :punct or (tok.raw != ';' and tok.raw != ',')
break if tok.raw == ';'
end
end
parse_attributes(parser, true)
raise parser, '"{" expected' if not tok = parser.skipspaces or tok.type != :punct or tok.raw != '{'
parser.unreadtok tok
end
namedargs = t.type.args.map { |a| a.name }.compact - [false]
raise tok, "duplicate argument name #{namedargs.find { |a| namedargs.index(a) != namedargs.rindex(a) }.inspect}" if namedargs.length != namedargs.uniq.length
end
parse_attributes(parser, true) # should be type.attrs, but this should be more existing-compiler-compatible
else
parser.unreadtok tok
return
end
parse_declarator_postfix(parser, scope)
end
end
class Variable
def ===(o)
self == o or (o.class == CExpression and not o.op and o.rexpr == self)
end
end
class CExpression
def self.lvalue?(e)
e.kind_of?(self) ? e.lvalue? : (e.kind_of? Variable and e.name)
end
def lvalue?
case @op
when :*; true if not @lexpr
when :'[]', :'.', :'->'; true
when nil # cast
CExpression.lvalue?(@rexpr)
else false
end
end
def self.constant?(e)
e.kind_of?(self) ? e.constant? : true
end
def constant?
# gcc considers '1, 2' not constant
if [:',', :funcall, :'=', :'--', :'++', :'+=', :'-=', :'*=', :'/=', :'>>=', :'<<=', :'&=', :'|=', :'^=', :'%=', :'->', :'[]'].include?(@op)
false
elsif @op == :'*' and not @lexpr; false
elsif not @lexpr and not @op and @rexpr.kind_of? Block; false
else
out = true
walk { |e| break out = false if not CExpression.constant?(e) }
out
end
end
def self.reduce(parser, e)
e.kind_of?(self) ? e.reduce(parser) : e
end
def reduce(parser)
# parser used for arithmetic overflows (need basic type sizes)
case @op
when :'&&'
case l = CExpression.reduce(parser, @lexpr)
when 0; 0
when ::Integer
case r = CExpression.reduce(parser, @rexpr)
when 0; 0
when ::Integer; 1
else CExpression.new(l, @op, r, @type)
end
else CExpression.new(l, @op, @rexpr, @type)
end
when :'||'
case l = CExpression.reduce(parser, @lexpr)
when 0
case r = CExpression.reduce(parser, @rexpr)
when 0; 0
when ::Integer; 1
else CExpression.new(l, @op, r, @type)
end
when ::Integer; 1
else CExpression.new(l, @op, @rexpr, @type)
end
when :'!'
case r = CExpression.reduce(parser, @rexpr)
when 0; 1
when ::Integer; 0
else CExpression.new(nil, @op, r, @type)
end
when :'!=', :'==', :'<', :'>', :'>=', :'<='
l = CExpression.reduce(parser, @lexpr)
r = CExpression.reduce(parser, @rexpr)
if l.kind_of?(::Integer) and r.kind_of?(::Integer)
if @op == :'!='; l != r ? 1 : 0
else l.send(@op, r) ? 1 : 0
end
else
l = CExpression.new(nil, nil, l, BaseType.new(:int)) if l.kind_of? ::Integer
r = CExpression.new(nil, nil, r, BaseType.new(:int)) if r.kind_of? ::Integer
CExpression.new(l, @op, r, @type)
end
when :'.'
le = CExpression.reduce(parser, @lexpr)
if le.kind_of? Variable and le.initializer.kind_of? ::Array
midx = le.type.members.index(le.type.findmember(@rexpr))
CExpression.reduce(parser, le.initializer[midx] || 0)
else
CExpression.new(le, @op, @rexpr, @type)
end
when :'?:'
case c = CExpression.reduce(parser, @lexpr)
when 0; CExpression.reduce(parser, @rexpr[0])
when ::Integer; CExpression.reduce(parser, @rexpr[1])
else CExpression.new(c, @op, @rexpr, @type)
end
when :'+', :'-', :'*', :'/', :'^', :'%', :'&', :'|', :'>>', :'<<', :'~', nil
t = @type.untypedef
case t
when BaseType
when Pointer; return self if @op
else
return @rexpr if not @op and not @lexpr and @rexpr.kind_of? Variable and @rexpr.type == @type
return self # raise parser, 'not arithmetic type'
end
# compute value
r = CExpression.reduce(parser, @rexpr)
ret = \
if not @lexpr
# unary
case @op
when :'+', nil, :'-', :'~'
return CExpression.new(nil, @op, r, @type) if not r.kind_of? ::Numeric
case @op
when :'-'; -r
when :'~'; ~r
else r
end
else return CExpression.new(nil, @op, r, @type)
end
else
l = CExpression.reduce(parser, @lexpr)
if not l.kind_of?(::Numeric) or not r.kind_of?(::Numeric)
l = CExpression.new(nil, nil, l, BaseType.new(:int)) if l.kind_of? ::Integer
r = CExpression.new(nil, nil, r, BaseType.new(:int)) if r.kind_of? ::Integer
return CExpression.new(l, @op, r, @type)
end
l.send(@op, r)
end
# overflow
tn = (t.pointer? ? :ptr : t.name)
case tn
when :char, :short, :int, :long, :ptr, :longlong, :__int8, :__int16, :__int32, :__int64
max = 1 << (8*parser.typesize[tn])
ret = ret.to_i & (max-1)
if not t.pointer? and t.specifier != :unsigned and (ret & (max >> 1)) > 0 # char == unsigned char
ret - max
else
ret
end
when :float, :double, :longdouble
ret.to_f # TODO
end
when :funcall
l = CExpression.reduce(parser, @lexpr)
r = @rexpr.map { |rr|
rr = CExpression.reduce(parser, rr)
rr = CExpression.new(nil, nil, rr, BaseType.new(:int)) if rr.kind_of? ::Integer
rr
}
CExpression.new(l, @op, r, @type)
else
l = CExpression.reduce(parser, @lexpr) if @lexpr
r = CExpression.reduce(parser, @rexpr) if @rexpr
l = CExpression.new(nil, nil, l, BaseType.new(:int)) if l.kind_of? ::Integer
r = CExpression.new(nil, nil, r, BaseType.new(:int)) if r.kind_of? ::Integer
CExpression.new(l, @op, r, @type)
end
end
def ==(o)
o.object_id == self.object_id or
(self.class == o.class and op == o.op and lexpr == o.lexpr and rexpr == o.rexpr)
end
def ===(o)
(self.class == o.class and op == o.op and lexpr === o.lexpr and rexpr === o.rexpr) or
(o.class == Variable and not @op and @rexpr == o)
end
NegateOp = { :== => :'!=', :'!=' => :==, :> => :<=, :>= => :<, :< => :>=, :<= => :> }
# returns a CExpr negating this one (eg 'x' => '!x', 'a > b' => 'a <= b'...)
def self.negate(e)
e.kind_of?(self) ? e.negate : CExpression[:'!', e]
end
def negate
if @op == :'!'
CExpression[@rexpr]
elsif nop = NegateOp[@op]
if nop == :== and @rexpr.kind_of? CExpression and not @rexpr.op and @rexpr.rexpr == 0 and
@lexpr.kind_of? CExpression and [:==, :'!=', :>, :<, :>=, :<=, :'!'].include? @lexpr.op
# (a > b) != 0 => (a > b)
CExpression[@lexpr]
else
CExpression.new(@lexpr, nop, @rexpr, @type)
end
elsif nop = { :'||' => :'&&', :'&&' => :'||' }[@op]
CExpression.new(CExpression.negate(@lexpr), nop, CExpression.negate(@rexpr), @type)
else
CExpression[:'!', self]
end
end
def walk
case @op
when :funcall, :'?:'
yield @lexpr
@rexpr.each { |arg| yield arg }
when :'->', :'.'
yield @lexpr
else
yield @lexpr if @lexpr
yield @rexpr if @rexpr
end
end
def complexity
cx = 1
walk { |e| cx += e.complexity if e.kind_of?(CExpression) }
cx
end
RIGHTASSOC = [:'=', :'+=', :'-=', :'*=', :'/=', :'%=', :'&=',
:'|=', :'^=', :'<<=', :'>>=', :'?:'
].inject({}) { |h, op| h.update op => true }
# key = operator, value = hash regrouping operators of lower precedence
# funcall/array index/member dereference/sizeof are handled in parse_value
OP_PRIO = [[:','], [:'?:'], [:'=', :'+=', :'-=', :'*=', :'/=',
:'%=', :'&=', :'|=', :'^=', :'<<=', :'>>='], [:'||'],
[:'&&'], [:|], [:^], [:&], [:'==', :'!='],
[:'<', :'>', :'<=', :'>='], [:<<, :>>], [:+, :-],
[:*, :/, :%], ].inject({}) { |h, oplist|
lessprio = h.keys.inject({}) { |hh, op| hh.update op => true }
oplist.each { |op| lessprio.update op => true } if RIGHTASSOC[oplist.first]
oplist.each { |op| h[op] = lessprio }
h }
class << self
# reads a binary operator from the parser, returns the corresponding symbol or nil
def readop(parser)
if not op = parser.skipspaces or op.type != :punct
parser.unreadtok op
return
end
case op.raw
when '>', '<', '|', '&' # << >> || &&
if ntok = parser.readtok and ntok.type == :punct and ntok.raw == op.raw
op.raw << ntok.raw
else
parser.unreadtok ntok
end
when '!' # != (mandatory)
if not ntok = parser.readtok or ntok.type != :punct and ntok.raw != '='
parser.unreadtok op
return
end
op.raw << ntok.raw
when '+', '-', '*', '/', '%', '^', '=', ',', '?', ':', '>>', '<<', '||', '&&',
'+=','-=','*=','/=','%=','^=','==','&=','|=','!=' # ok
else # bad
parser.unreadtok op
return
end
# may be followed by '='
case op.raw
when '+', '-', '*', '/', '%', '^', '&', '|', '>>', '<<', '<', '>', '='
if ntok = parser.readtok and ntok.type == :punct and ntok.raw == '='
op.raw << ntok.raw
else
parser.unreadtok ntok
end
end
op.value = op.raw.to_sym
op
end
# parse sizeof offsetof float immediate etc into tok.value
def parse_intfloat(parser, scope, tok)
if tok.type == :string and not tok.value
case tok.raw
when 'sizeof'
if ntok = parser.skipspaces and ntok.type == :punct and ntok.raw == '('
# check type
if v = Variable.parse_type(parser, scope)
v.parse_declarator(parser, scope)
raise tok if v.name != false
raise tok if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ')'
else
raise tok, 'expr expected' if not v = parse(parser, scope)
raise tok if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ')'
end
else
parser.unreadtok ntok
raise tok, 'expr expected' if not v = parse_value(parser, scope)
end
tok.value = parser.sizeof(v)
return
when '__builtin_offsetof'
raise tok if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != '('
raise tok if not ntok = parser.skipspaces or ntok.type != :string or ntok.raw != 'struct'
raise tok if not ntok = parser.skipspaces or ntok.type != :string
raise tok, 'unknown structure' if not struct = scope.struct_ancestors[ntok.raw] or not struct.kind_of? Union or not struct.members
raise tok if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ','
raise tok if not ntok = parser.skipspaces or ntok.type != :string
tok.value = struct.offsetof(parser, ntok.raw)
raise tok if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ')'
return
end
end
Expression.parse_num_value(parser, tok)
end
# returns the next value from parser (parenthesised expression, immediate, variable, unary operators)
def parse_value(parser, scope)
return if not tok = parser.skipspaces
case tok.type
when :string
parse_intfloat(parser, scope, tok)
val = tok.value || tok.raw
if val.kind_of? ::String
raise tok, 'undefined variable' if not val = scope.symbol_ancestors[val]
end
case val
when Type
raise tok, 'invalid variable'
when Variable
val = parse_value_postfix(parser, scope, val)
when ::Float
# parse suffix
type = :double
if (?0..?9).include?(tok.raw[0])
case tok.raw.downcase[-1]
when ?l; type = :longdouble
when ?f; type = :float
end
end
val = CExpression[val, BaseType.new(type)]
when ::Integer
# parse suffix
# XXX 010h ?
type = :int
specifier = []
if (?0..?9).include?(tok.raw[0])
suffix = tok.raw.downcase[-3, 3] || tok.raw.downcase[-2, 2] || tok.raw.downcase[-1, 1] # short string
specifier << :unsigned if suffix.include?('u') # XXX or tok.raw.downcase[1] == ?x
type = :longlong if suffix.count('l') == 2
type = :long if suffix.count('l') == 1
end
val = CExpression[val, BaseType.new(type, *specifier)]
else raise parser, "internal error #{val.inspect}"
end
when :quoted
if tok.raw[0] == ?'
raise tok, 'invalid character constant' if not [1, 2, 4, 8].include? tok.value.length # TODO 0fill
val = CExpression[Expression.decode_imm(tok.value, tok.value.length, :big), BaseType.new(:int)]
else
val = CExpression[tok.value, Pointer.new(BaseType.new(tok.raw[0, 2] == 'L"' ? :short : :char))]
val = parse_value_postfix(parser, scope, val)
end
when :punct
case tok.raw
when '('
ntok = nil
# check type casting
if v = Variable.parse_type(parser, scope)
v.parse_declarator(parser, scope)
(v.type.attributes ||= []).concat v.attributes if v.attributes
raise tok, 'bad cast' if v.name != false
raise ntok || tok, 'no ")" found' if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ')'
raise ntok, 'expr expected' if not val = parse_value(parser, scope) # parses postfix too
#raise ntok, 'unable to cast a struct' if val.type.untypedef.kind_of? Union
val = CExpression[[val], v.type]
# check compound statement expression
elsif ntok = parser.skipspaces and ntok.type == :punct and ntok.raw == '{'
parser.unreadtok ntok
blk = parser.parse_statement(scope, [:expression]) # XXX nesting ?
raise ntok || tok, 'no ")" found' if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ')'
type = blk.statements.last.kind_of?(CExpression) ? blk.statements.last.type : BaseType.new(:void)
val = CExpression[blk, type]
else
parser.unreadtok ntok
if not val = parse(parser, scope)
parser.unreadtok tok
return
end
raise ntok || tok, 'no ")" found' if not ntok = parser.readtok or ntok.type != :punct or ntok.raw != ')'
val = parse_value_postfix(parser, scope, val)
end
when '.' # float
parse_intfloat(parser, scope, tok)
if not tok.value
parser.unreadtok tok
return
end
val = tok.value || tok.raw
type = :double
case tok.raw.downcase[-1]
when ?l; type = :longdouble
when ?f; type = :float
end
val = CExpression.new[val, BaseType.new(type)]
when '+', '-', '&', '!', '~', '*', '--', '++', '&&'
# unary prefix
# may have been read ahead
raise parser if not ntok = parser.readtok
# check for -- ++ &&
if ntok.type == :punct and ntok.raw == tok.raw and %w[+ - &].include?(tok.raw)
tok.raw << ntok.raw
else
parser.unreadtok ntok
end
case tok.raw
when '&'
val = parse_value(parser, scope)
if val.kind_of? CExpression and val.op == :& and not val.lexpr and
(val.rexpr.kind_of? Variable or val.rexpr.kind_of? CExpression) and val.rexpr.type.kind_of? Function
# &&function == &function
elsif (val.kind_of? CExpression or val.kind_of? Variable) and val.type.kind_of? Array
# &ary = ary
else
raise parser, "invalid lvalue #{val}" if not CExpression.lvalue?(val) and not parser.allow_bad_c
raise val.backtrace, 'cannot take addr of register' if val.kind_of? Variable and val.storage == :register and not parser.allow_bad_c
val = CExpression.new(nil, tok.raw.to_sym, val, Pointer.new(val.type))
end
when '++', '--'
val = parse_value(parser, scope)
raise parser, "invalid lvalue #{val}" if not CExpression.lvalue?(val) and not parser.allow_bad_c
val = CExpression.new(nil, tok.raw.to_sym, val, val.type)
when '&&'
raise tok, 'label name expected' if not val = parser.skipspaces or val.type != :string
val = CExpression.new(nil, nil, Label.new(val.raw, nil), Pointer.new(BaseType.new(:void)))
when '*'
raise tok, 'expr expected' if not val = parse_value(parser, scope)
raise tok, 'not a pointer' if not val.type.pointer? and not parser.allow_bad_c
newtype = val.type.pointer? ? val.type.pointed : BaseType.new(:int)
if not newtype.untypedef.kind_of? Function # *fptr == fptr
val = CExpression.new(nil, tok.raw.to_sym, val, newtype)
end
when '~', '!', '+', '-'
raise tok, 'expr expected' if not val = parse_value(parser, scope)
raise tok, 'type not arithmetic' if not val.type.arithmetic? and not parser.allow_bad_c
val = CExpression.new(nil, tok.raw.to_sym, val, val.type)
val.type = BaseType.new(:int) if tok.raw == '!'
else raise tok, 'internal error'
end
else
parser.unreadtok tok
return
end
else
parser.unreadtok tok
return
end
if val.kind_of? Variable and val.type.kind_of? Function
# void (*bla)() = printf; => ...= &printf;
val = CExpression[:&, val]
end
val
end
# parse postfix forms (postincrement, array index, struct member dereference)
def parse_value_postfix(parser, scope, val)
tok = parser.skipspaces
nval = \
if tok and tok.type == :punct
case tok.raw
when '+', '++', '-', '--', '->'
ntok = parser.readtok
if (tok.raw == '+' or tok.raw == '-') and ntok and ntok.type == :punct and
(ntok.raw == tok.raw or (tok.raw == '-' and ntok.raw == '>'))
tok.raw << ntok.raw
else
parser.unreadtok ntok
end
case tok.raw
when '+', '-'
nil
when '++', '--'
raise parser, "#{val}: invalid lvalue" if not CExpression.lvalue?(val)
CExpression.new(val, tok.raw.to_sym, nil, val.type)
when '->'
# XXX allow_bad_c..
raise tok, "#{val}: not a pointer" if not val.type.pointer?
type = val.type.pointed.untypedef
raise tok, "#{val}: bad pointer" if not type.kind_of? Union
raise tok, "#{val}: incomplete type" if not type.members
raise tok, "#{val}: invalid member" if not tok = parser.skipspaces or tok.type != :string or not m = type.findmember(tok.raw)
CExpression.new(val, :'->', tok.raw, m.type)
end
when '.'
type = val.type.untypedef
if not ntok = parser.skipspaces or ntok.type != :string or not type.kind_of? Union
parser.unreadtok ntok
nil
else
raise ntok, "#{val}: incomplete type" if not type.members
raise ntok, "#{val}: invalid member" if not m = type.findmember(ntok.raw)
CExpression.new(val, :'.', ntok.raw, m.type)
end
when '['
raise tok, "#{val}: index expected" if not idx = parse(parser, scope)
val, idx = idx, val if not val.type.pointer? # fake support of "4[tab]"
raise tok, "#{val}: not a pointer" if not val.type.pointer?
raise tok, "#{val}: invalid index" if not idx.type.integral?
raise tok, "#{val}: get perpendicular ! (elsewhere)" if idx.kind_of?(CExpression) and idx.op == :','
raise tok || parser, "']' expected" if not tok = parser.skipspaces or tok.type != :punct or tok.raw != ']'
type = val.type.untypedef.type
# TODO boundscheck (and become king of the universe)
CExpression.new(val, :'[]', idx, type)
when '('
type = val.type.untypedef
type = type.type.untypedef if type.kind_of? Pointer
raise tok, "#{val}: not a function" if not type.kind_of? Function
args = []
loop do
a = parse(parser, scope, false)
break if not a
args << a
if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ','
parser.unreadtok ntok
break
end
end
raise ntok || parser, "#{val}: ')' expected" if not ntok = parser.skipspaces or ntok.type != :punct or ntok.raw != ')'
type.args ||= []
raise tok, "#{val}: bad argument count: #{args.length} for #{type.args.length}" if (type.varargs ? (args.length < type.args.length) : (args.length != type.args.length))
type.args.zip(args) { |ta, a|
p, i = ta.type.pointer?, ta.type.integral?
r = a.reduce(parser) if p or i
if (not p and not i) or (i and not r.kind_of? ::Integer) or (p and r != 0)
tok = tok.dup ; tok.raw = a.to_s
parser.check_compatible_type(tok, a.type, ta.type)
end
}
CExpression.new(val, :funcall, args, type.type)
end
end
if nval
parse_value_postfix(parser, scope, nval)
else
parser.unreadtok tok
val
end
end
def parse(parser, scope, allow_coma = true)
opstack = []
stack = []
popstack = lambda {
r, l = stack.pop, stack.pop
case op = opstack.pop
when :'?:'
stack << CExpression.new(stack.pop, op, [l, r], l.type)
when :','
stack << CExpression.new(l, op, r, r.type)
when :'='
parser.check_compatible_type(parser, r.type, l.type)
stack << CExpression.new(l, op, r, l.type)
when :'&&', :'||'
stack << CExpression.new(l, op, r, BaseType.new(:int))
else
# XXX struct == struct ?
raise parser, "invalid type #{l.type} #{l} for #{op.inspect}" if not l.type.arithmetic? and not parser.allow_bad_c
raise parser, "invalid type #{r.type} #{r} for #{op.inspect}" if not r.type.arithmetic? and not parser.allow_bad_c
if l.type.pointer? and r.type.pointer?
type = \
case op
when :'-'; BaseType.new(:long) # addr_t or sumthin ?
when :'-='; l.type
when :'>', :'>=', :'<', :'<=', :'==', :'!='; BaseType.new(:long)
else raise parser, "cannot do #{op.inspect} on pointers" unless parser.allow_bad_c ; l.type
end
elsif l.type.pointer? or r.type.pointer?
puts parser.exception("should not #{op.inspect} a pointer").message if $VERBOSE and not [:'+', :'-', :'=', :'+=', :'-=', :==, :'!='].include? op
type = l.type.pointer? ? l.type : r.type
else
# yay integer promotion
lt = l.type.untypedef
rt = r.type.untypedef
if (t = lt).name == :longdouble or (t = rt).name == :longdouble or
(t = lt).name == :double or (t = rt).name == :double or
(t = lt).name == :float or (t = rt).name == :float
# long double > double > float ...
type = t
elsif true
# custom integer rules based on type sizes
lts = parser.typesize[lt.name]
rts = parser.typesize[rt.name]
its = parser.typesize[:int]
if not lts or not rts
type = BaseType.new(:int)
elsif lts > rts and lts >= its
type = lt
elsif rts > lts and rts >= its
type = rt
elsif lts == rts and lts >= its
type = lt
type = rt if rt.specifier == :unsigned
else
type = BaseType.new(:int)
end
# end of custom rules
elsif ((t = lt).name == :long and t.specifier == :unsigned) or
((t = rt).name == :long and t.specifier == :unsigned)
# ... ulong ...
type = t
elsif (lt.name == :long and rt.name == :int and rt.specifier == :unsigned) or
(rt.name == :long and lt.name == :int and lt.specifier == :unsigned)
# long+uint => ulong
type = BaseType.new(:long, :unsigned)
elsif (t = lt).name == :long or (t = rt).name == :long or
((t = lt).name == :int and t.specifier == :unsigned) or
((t = rt).name == :int and t.specifier == :unsigned)
# ... long > uint ...
type = t
else
# int
type = BaseType.new(:int)
end
end
case op
when :'>', :'>=', :'<', :'<=', :'==', :'!='
# cast both sides
l = CExpression[l, type] if l.type != type
r = CExpression[r, type] if r.type != type
stack << CExpression.new(l, op, r, BaseType.new(:int))
else
# promote result
stack << CExpression.new(l, op, r, type)
end
end
}
return if not e = parse_value(parser, scope)
stack << e
while op = readop(parser)
case op.value
when :'?'
# a, b ? c, d : e, f == a, (b ? (c, d) : e), f
until opstack.empty? or OP_PRIO[opstack.last][:'?:']
popstack[]
end
stack << parse(parser, scope)
raise op || parser, '":" expected' if not op = readop(parser) or op.value != :':'
op = op.dup
op.value = :'?:'
when :':'
parser.unreadtok op
break
else
if not allow_coma and op.value == :','
parser.unreadtok op
break
end
until opstack.empty? or OP_PRIO[op.value][opstack.last]
popstack[]
end
end
raise op, 'need rhs' if not e = parse_value(parser, scope)
stack << e
opstack << op.value
end
until opstack.empty?
popstack[]
end
CExpression[stack.first]
end
end
end
#
# AllocCStruct: ruby interpreter memory-mapped structure
#
# this maps a C structure from a C parser to a ruby String
# struct members are accessed through obj['fldname']
# obj.fldname is an alias
class AllocCStruct
# str is a reference to the underlying ruby String
# stroff is the offset from the start of this string (non-nul for nested structs)
# cp is a reference to the C::Parser
# struct to the C::Union/Struct/Array
# sizeof is the byte size of the C struct
attr_accessor :str, :stroff, :cp, :struct
attr_writer :sizeof
def initialize(cp, struct, str=nil, stroff=0)
@cp, @struct = cp, struct
@str = str || [0].pack('C')*sizeof
@stroff = stroff
end
def sizeof
@sizeof ||= @cp.sizeof(@struct)
end
def [](*a)
if @struct.kind_of? C::Array and a.length == 1 and @struct.length and a[0].kind_of? Integer
i = a[0]
raise "#{i} out of bounds 0...#{@struct.length}" if i < 0 or i >= @struct.length
off = @stroff + i*@cp.sizeof(@struct.type)
return @cp.decode_c_value(@str, @struct.type, off)
end
return @str[@stroff..-1][*a] if a.length != 1
a = a.first
return @str[@stroff..-1][a] if not a.kind_of? Symbol and not a.kind_of? String and not a.kind_of? C::Variable
f = a
raise "#{a.inspect} not a member" if not f.kind_of? C::Variable and not f = @struct.findmember(a.to_s, true)
a = f.name || f
off = @stroff + @struct.offsetof(@cp, a)
if bf = @struct.bitoffsetof(@cp, a)
ft = C::BaseType.new((bf[0] + bf[1] > 32) ? :__int64 : :__int32)
v = @cp.decode_c_value(@str, ft, off)
(v >> bf[0]) & ((1 << bf[1])-1)
else
@cp.decode_c_value(@str, f, off)
end
end
def []=(*a)
if @struct.kind_of? C::Array and a.length == 2 and @struct.length and a[0].kind_of? Integer
i = a[0]
raise "#{i} out of bounds 0...#{@struct.length}" if i < 0 or i >= @struct.length
off = @stroff + i*@cp.sizeof(@struct.type)
val = @cp.encode_c_value(@struct.type, a[1])
@str[off, val.length] = val
return
end
if not a.first.kind_of? Symbol and not a.first.kind_of? String and not a.first.kind_of? C::Variable
# patch @str[@stroff..-1] like a string
# so we must find the intended start offset, and add @stroff to it
if @stroff != 0
case a.first
when Range
if a.first.begin >= 0
a[0] = ::Range.new(a[0].begin+@stroff, a[0].end+@stroff, a[0].exclude_end?)
else raise 'no can do, use positive index'
end
when Integer
if a.first >= 0
a[0] += @stroff
else raise 'no can do, use positive index'
end
else raise 'no can do'
end
end
return @str.send(:'[]=', *a) # XXX *should* work...
end
a, val = a
raise "#{a.inspect} not a struct member" if not a.kind_of? C::Variable and not f = @struct.findmember(a.to_s, true)
a = f.name if a.kind_of? String or a.kind_of? Symbol
val = sizeof if val == :size
off = @stroff + @struct.offsetof(@cp, a)
if bf = @struct.bitoffsetof(@cp, a)
raise "only Integers supported in bitfield #{a}, got #{val.inspect}" if not val.kind_of?(::Integer)
# struct { int i:8; }; => size 8 or 32 ?
ft = C::BaseType.new((bf[0] + bf[1] > 32) ? :__int64 : :__int32)
mask = ((1 << bf[1]) - 1) << bf[0]
preval = @cp.decode_c_value(@str, ft, off)
val = (preval & ~mask) | ((val << bf[0]) & mask)
f = ft
end
val = @cp.encode_c_value(f, val)
@str[off, val.length] = val
end
# virtual accessors to members
# struct.foo is aliased to struct['foo'],
# struct.foo = 42 aliased to struct['foo'] = 42
def method_missing(on, *a)
n = on.to_s
if n[-1] == ?=
send :[]=, n[0...-1], *a
else
super(on, *a) if not @struct.kind_of?(C::Union) or not @struct.findmember(n, true)
send :[], n, *a
end
end
def to_s(off=nil, maxdepth=500)
return '{ /* ... */ }' if maxdepth <= 0
str = ['']
if @struct.kind_of?(C::Array)
str.last << "#{@struct.type} x[#{@struct.length}] = " if not off
mlist = (0...@struct.length)
fldoff = mlist.inject({}) { |h, i| h.update i => i*@cp.sizeof(@struct.type) }
elsif @struct.kind_of?(C::Struct)
str.last << "struct #{@struct.name || '_'} x = " if not off
@struct.update_member_cache(@cp) if not @struct.fldlist
fldoff = @struct.fldoffset
fbo = @struct.fldbitoffset || {}
mlist = @struct.members.map { |m| m.name || m }
else
str.last << "union #{@struct.name || '_'} x = " if not off
mlist = @struct.members.map { |m| m.name || m }
end
str.last << '{'
mlist.each { |k|
if k.kind_of? Variable # anonymous member
curoff = off.to_i + @struct.offsetof(@cp, k)
val = self[k]
k = '?'
else
curoff = off.to_i + (fldoff ? fldoff[k].to_i : 0)
val = self[k]
end
if val.kind_of?(::Integer)
if val >= 0x100
val = '0x%X, // +%x' % [val, curoff]
elsif val <= -0x100
val = '-0x%X, // +%x' % [-val, curoff]
else
val = '%d, // +%x' % [val, curoff]
end
elsif val.kind_of? AllocCStruct
val = val.to_s(curoff, maxdepth-1)
elsif not val
val = 'NULL, // +%x' % curoff # pointer with NULL value
else
val = val.to_s.sub(/$/, ', // +%x' % curoff)
end
val = val.gsub("\n", "\n\t")
str << "\t#{k.kind_of?(::Integer) ? "[#{k}]" : ".#{k}"} = #{val}"
}
str << '}'
str.last << (off ? ',' : ';')
str.join("\n")
end
def to_array
raise NoMethodError, "Not an Array" if not @struct.kind_of?(C::Array)
ary = []
@struct.length.times { |i| ary << self[i] }
ary
end
def to_strz
raise NoMethodError, "Not an Array" if not @struct.kind_of?(C::Array)
a = to_array
a[a.index(0)..-1] = [] if a.index(0)
a.pack('C*')
end
end
class Parser
# find a Struct/Union object from a struct name/typedef name
# raises if it cant find it
def find_c_struct(structname)
structname = structname.to_s if structname.kind_of?(::Symbol)
if structname.kind_of?(::String) and not struct = @toplevel.struct[structname]
struct = @toplevel.symbol[structname]
raise "unknown struct #{structname.inspect}" if not struct
struct = struct.type.untypedef
struct = struct.pointed while struct.pointer?
raise "unknown struct #{structname.inspect}" if not struct.kind_of? C::Union
end
struct = structname if structname.kind_of? C::Union
raise "unknown struct #{structname.inspect}" if not struct.kind_of? C::Union
struct
end
# find a C::Type (struct/union/typedef/basetype) from a string
def find_c_type(typename)
typename = typename.to_s if typename.kind_of? ::Symbol
if typename.kind_of?(::String) and not type = @toplevel.struct[typename]
if type = @toplevel.symbol[typename]
type = type.type.untypedef
else
begin
lexer.feed(typename)
b = C::Block.new(@toplevel)
var = Variable.parse_type(self, b)
var.parse_declarator(self, b)
type = var.type
rescue
end
end
end
type = typename if typename.kind_of?(C::Type)
raise "unknown type #{typename.inspect}" if not type.kind_of? C::Type
type
end
# allocate a new AllocCStruct from the struct/struct typedef name of the current toplevel
# optionally populate the fields using the 'values' hash
def alloc_c_struct(structname, values=nil)
struct = find_c_struct(structname)
st = AllocCStruct.new(self, struct)
values.each { |k, v| st[k] = v } if values
st
end
# parse a given String as an AllocCStruct
# offset is an optionnal offset from the string start
# modification to the structure will modify the underlying string
def decode_c_struct(structname, str, offset=0)
struct = find_c_struct(structname)
AllocCStruct.new(self, struct, str, offset)
end
# allocate an array of types
# init is either the length of the array, or an array of initial values
def alloc_c_ary(typename, init=1)
type = find_c_type(typename)
len = init.kind_of?(Integer) ? init : init.length
struct = C::Array.new(type, len)
st = AllocCStruct.new(self, struct)
if init.kind_of?(::Array)
init.each_with_index { |v, i|
st[i] = v
}
end
st
end
# "cast" a string to C::Array
def decode_c_ary(typename, len, str, offset=0)
type = find_c_type(typename)
struct = C::Array.new(type, len)
AllocCStruct.new(self, struct, str, offset)
end
# convert (pack) a ruby value into a C buffer
# packs integers, converts Strings to their C pointer (using DynLdr)
def encode_c_value(type, val)
type = type.type if type.kind_of? Variable
case val
when nil; val = 0
when ::Integer
when ::String
val = DynLdr.str_ptr(val)
when ::Hash
type = type.pointed while type.pointer?
raise "need a struct ptr for #{type} #{val.inspect}" if not type.kind_of? Union
buf = alloc_c_struct(type, val)
val.instance_variable_set('@rb2c', buf) # GC trick
val = buf
when ::Proc
val = DynLdr.convert_rb2c(type, val) # allocate a DynLdr callback
when AllocCStruct
val = DynLdr.str_ptr(val.str) + val.stroff
#when ::Float # TODO
else raise "TODO #{val.inspect}"
end
val = Expression.encode_immediate(val, sizeof(type), @endianness) if val.kind_of?(::Integer)
val
end
def decode_c_value(str, type, off=0)
type = type.type if type.kind_of? Variable
type = type.untypedef
if type.kind_of? C::Union or type.kind_of? C::Array
return AllocCStruct.new(self, type, str, off)
end
val = Expression.decode_immediate(str, sizeof(type), @endianness, off)
val = Expression.make_signed(val, sizeof(type)*8) if type.integral? and type.signed?
val = nil if val == 0 and type.pointer?
val
end
end
#
# Dumper : objects => C source
#
class Parser
# returns a big string containing all definitions from headers used in the source (including macros)
def factorize(*a)
factorize_init
parse(*a)
raise @lexer.readtok || self, 'eof expected' if not @lexer.eos?
factorize_final
end
def factorize_init
@lexer.traced_macros = []
end
def factorize_final
# now find all types/defs not coming from the standard headers
# all
all = @toplevel.struct.values + @toplevel.symbol.values
all -= all.grep(::Integer) # Enum values
# list of definitions of user-defined objects
userdefined = all.find_all { |t|
t.backtrace.backtrace.grep(::String).grep(/^</).empty?
}
@toplevel.statements.clear # don't want all Declarations
# a macro is fine too
@lexer.dump_macros(@lexer.traced_macros, false) + "\n\n" +
dump_definitions(userdefined, userdefined)
end
# returns a big string representing the definitions of all terms appearing in +list+, excluding +exclude+
# includes dependencies
def dump_definitions(list, exclude=[])
# recurse all dependencies
todo_rndr = {}
todo_deps = {}
list.each { |t|
todo_rndr[t], todo_deps[t] = t.dump_def(@toplevel)
}
# c.toplevel.anonymous_enums.to_a.each { |t| todo_rndr[t], todo_deps[t] = t.dump_def(c.toplevel) }
while !(ar = (todo_deps.values.flatten - todo_deps.keys)).empty?
ar.each { |t|
todo_rndr[t], todo_deps[t] = t.dump_def(@toplevel)
}
end
exclude.each { |t| todo_deps.delete t ; todo_rndr.delete t }
todo_deps.each_key { |t| todo_deps[t] -= exclude }
all = @toplevel.struct.values + @toplevel.symbol.values
all -= all.grep(::Integer) # Enum values
r, dep = @toplevel.dump_reorder(all, todo_rndr, todo_deps)
r.join("\n")
end
# returns a string containing the C definition(s) of toplevel functions, with their dependencies
def dump_definition(*funcnames)
oldst = @toplevel.statements
@toplevel.statements = []
dump_definitions(funcnames.map { |f| @toplevel.symbol[f] })
ensure
@toplevel.statements = oldst
end
def to_s
@toplevel.dump(nil)[0].join("\n")
end
end
class Statement
def self.dump(e, scope, r=[''], dep=[])
case e
when nil; r.last << ';'
when Block
r.last << ' ' if not r.last.empty?
r.last << '{'
tr, dep = e.dump(scope, [''], dep)
tr.pop if tr.last.empty?
r.concat tr.map { |s| Case.dump_indent(s) }
(r.last[-1] == ?{ ? r.last : r) << '}'
else
tr, dep = e.dump(scope, [''], dep)
r.concat tr.map { |s| Case.dump_indent(s) }
end
[r, dep]
end
def to_s
dump(Block.new(nil))[0].join(' ')
end
end
class Block
def to_s() dump(nil)[0].join("\n") end
# return array of c source lines and array of dependencies (objects)
def dump(scp, r=[''], dep=[])
mydefs = @symbol.values.grep(TypeDef) + @struct.values + anonymous_enums.to_a
todo_rndr = {}
todo_deps = {}
mydefs.each { |t| # filter out Enum values
todo_rndr[t], todo_deps[t] = t.dump_def(self)
}
r, dep = dump_reorder(mydefs, todo_rndr, todo_deps, r, dep)
dep -= @symbol.values + @struct.values
[r, dep]
end
def dump_reorder(mydefs, todo_rndr, todo_deps, r=[''], dep=[])
val = todo_deps.values.flatten.uniq
dep |= val
dep -= mydefs | todo_deps.keys
todo_deps.each { |k, v| v.delete k }
ext = val - mydefs
if ext.length > todo_deps.length
todo_deps.each_key { |k| todo_deps[k] = todo_deps[k] & mydefs }
else
ext.each { |k| todo_deps.each_value { |v| v.delete k } }
end
# predeclare structs involved in cyclic dependencies
dep_cycle = lambda { |ary|
# sexyness inside (c)
deps = todo_deps[ary.last]
if deps.include? ary.first; ary
elsif (deps-ary).find { |d| deps = dep_cycle[ary + [d]] }; deps
end
}
todo_rndr.keys.grep(Union).find_all { |t| t.name }.sort_by { |t| t.name }.each { |t|
oldc = nil
while c = dep_cycle[[t]]
break if oldc == c
r << "#{t.kind_of?(Struct) ? 'struct' : 'union'} #{t.name};" if not oldc
oldc = c
c.each { |s|
# XXX struct z { struct a* }; struct a { void (*foo)(struct z); };
todo_deps[s].delete t unless s.kind_of? Union and
s.members.find { |sm| sm.type.untypedef == t }
}
end
}
loop do
break if todo_rndr.empty?
todo_now = todo_deps.keys.find_all { |k| todo_deps[k].empty? }
if todo_now.empty?
r << '// dependency problem, this may not compile'
todo_now = todo_deps.keys
end
todo_now.sort_by { |k| k.name || '0' }.each { |k|
if k.kind_of? Variable and k.type.kind_of? Function and k.initializer
r << ''
r.concat todo_rndr.delete(k)
else
r.pop if r.last == ''
r.concat todo_rndr.delete(k)
r.last << ';'
end
todo_deps.delete k
}
todo_deps.each_key { |k| todo_deps[k] -= todo_now }
r << '' << '' << ''
end
@statements.each { |s|
r << '' if not r.last.empty?
if s.kind_of? Block
r, dep = Statement.dump(s, self, r, dep)
else
r, dep = s.dump(self, r, dep)
end
}
[r, dep]
end
end
class Declaration
def dump(scope, r=[''], dep=[])
tr, dep = @var.dump_def(scope, [''], dep)
if @var.kind_of? Variable and @var.type.kind_of? Function and @var.initializer
r << ''
r.concat tr
else
r.pop if r.last == ''
r.concat tr
r.last << ';'
end
[r, dep]
end
def to_s
dump(Block.new(nil))[0].join(' ')
end
end
module Attributes
def dump_attributes
if attributes
(attributes - DECLSPECS).map { |a| " __attribute__((#{a}))" }.join
else ''
end
end
def dump_attributes_pre
if attributes
(attributes & DECLSPECS).map { |a| "__#{a} " }.join
else ''
end
end
end
class Variable
def dump(scope, r=[''], dep=[])
if name
dep |= [scope.symbol_ancestors[@name]]
r.last << @name
end
[r, dep]
end
def dump_def(scope, r=[''], dep=[], skiptype=false)
# int a=1, b=2;
r.last << dump_attributes_pre
if not skiptype
r.last << @storage.to_s << ' ' if storage
r, dep = @type.base.dump(scope, r, dep)
r.last << ' ' if name
end
r, dep = @type.dump_declarator([(name ? @name.dup : '') << dump_attributes], scope, r, dep)
if initializer
r.last << ' = ' if not @type.kind_of?(Function)
r, dep = @type.dump_initializer(@initializer, scope, r, dep)
end
[r, dep]
end
def to_s
dump(Block.new(nil))[0].join(' ')
end
end
class Type
def dump_initializer(init, scope, r=[''], dep=[])
case init
when ::Numeric
r.last << init.to_s
[r, dep]
when ::Array
r.last << init.inspect
[r, dep]
else init.dump_inner(scope, r, dep)
end
end
def dump_declarator(decl, scope, r=[''], dep=[])
r.last << decl.shift
r.concat decl
[r, dep]
end
def dump_def(*a)
dump(*a)
end
def dump_cast(scope, r=[''], dep=[])
r.last << '('
r.last << dump_attributes_pre if not kind_of? TypeDef
r, dep = base.dump(scope, r, dep)
r, dep = dump_declarator([kind_of?(TypeDef) ? '' : dump_attributes], scope, r, dep)
r.last << ')'
[r, dep]
end
def to_s
dump_cast(Block.new(nil))[0].join(' ')
end
end
class Pointer
def dump_declarator(decl, scope, r=[''], dep=[])
d = decl[0]
decl[0] = '*'
decl[0] << ' ' << @qualifier.map { |q| q.to_s }.join(' ') << ' ' if qualifier
decl[0] << d
if @type.kind_of? Function or @type.kind_of? Array
decl[0] = '(' << decl[0]
decl.last << ')'
end
@type.dump_declarator(decl, scope, r, dep)
end
end
class Array
def dump_declarator(decl, scope, r=[''], dep=[])
decl.last << '()' if decl.last.empty?
decl.last << '['
decl, dep = CExpression.dump(@length, scope, decl, dep) if length
decl.last << ']'
@type.dump_declarator(decl, scope, r, dep)
end
def dump_initializer(init, scope, r=[''], dep=[])
return super(init, scope, r, dep) if not init.kind_of? ::Array
r.last << '{ '
showname = false
init.each_with_index { |v, i|
if not v
showname = true
next
end
r.last << ', ' if r.last[-2, 2] != '{ '
rt = ['']
if showname
showname = false
rt << "[#{i}] = "
end
rt, dep = @type.dump_initializer(v, scope, rt, dep)
r.last << rt.shift
r.concat rt.map { |s| "\t" << s }
}
r.last << ' }'
[r, dep]
end
end
class Function
def dump_declarator(decl, scope, r=[''], dep=[])
decl.last << '()' if decl.last.empty?
decl.last << '('
if args
@args.each { |arg|
decl.last << ', ' if decl.last[-1] != ?(
decl, dep = arg.dump_def(scope, decl, dep)
}
if varargs
decl.last << ', ' if decl.last[-1] != ?(
decl.last << '...'
else
decl.last << 'void' if @args.empty?
end
end
decl.last << ')'
@type.dump_declarator(decl, scope, r, dep)
end
def dump_initializer(init, scope, r=[''], dep=[])
Statement.dump(init, scope, r << '', dep)
end
end
class BaseType
def dump(scope, r=[''], dep=[])
r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
r.last << @specifier.to_s << ' ' if specifier and @name != :ptr
r.last << case @name
when :longlong; 'long long'
when :longdouble; 'long double'
when :ptr; specifier == :unsigned ? 'uintptr_t' : 'intptr_t'
else @name.to_s
end
[r, dep]
end
end
class TypeDef
def dump(scope, r=[''], dep=[])
r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
r.last << @name
dep |= [scope.symbol_ancestors[@name]]
[r, dep]
end
def dump_def(scope, r=[''], dep=[])
r.last << 'typedef '
r.last << dump_attributes_pre
r, dep = @type.base.dump(scope, r, dep)
r.last << ' '
@type.dump_declarator([(name ? @name.dup : '') << dump_attributes], scope, r, dep)
end
def dump_initializer(init, scope, r=[''], dep=[])
@type.dump_initializer(init, scope, r, dep)
end
end
class Union
def dump(scope, r=[''], dep=[])
if name
r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
r.last << self.class.name.downcase[/(?:.*::)?(.*)/, 1] << ' ' << @name
dep |= [scope.struct_ancestors[@name]]
[r, dep]
else
dump_def(scope, r, dep)
end
end
def dump_def(scope, r=[''], dep=[])
r << ''
r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
r.last << self.class.name.downcase[/(?:.*::)?(.*)/, 1]
r.last << ' ' << @name if name
if members
r.last << ' {'
@members.each_with_index { |m,i|
tr, dep = m.dump_def(scope, [''], dep)
tr.last << ':' << @bits[i].to_s if bits and @bits[i]
tr.last << ';'
r.concat tr.map { |s| "\t" << s }
}
r << '}'
end
r.last << dump_attributes
[r, dep]
end
def dump_initializer(init, scope, r=[''], dep=[])
return super(init, scope, r, dep) if not init.kind_of? ::Array
r.last << '{ '
showname = false
@members.zip(init) { |m, i|
if not i
showname = true
next
end
r.last << ', ' if r.last[-2, 2] != '{ '
rt = ['']
if showname
showname = false
rt << ".#{m.name} = "
end
rt, dep = m.type.dump_initializer(i, scope, rt, dep)
r.last << rt.shift
r.concat rt.map { |s| "\t" << s }
}
r.last << ' }'
[r, dep]
end
end
class Struct
def dump_def(scope, r=[''], dep=[])
if pack
r, dep = super(scope, r, dep)
r.last <<
if @pack == 1; (has_attribute('packed') or has_attribute_var('pack')) ? '' : " __attribute__((packed))"
else has_attribute_var('pack') ? '' : " __attribute__((pack(#@pack)))"
end
[r, dep]
else
super(scope, r, dep)
end
end
end
class Enum
def dump(scope, r=[''], dep=[])
if name
r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
r.last << 'enum ' << @name
dep |= [scope.struct_ancestors[@name]]
[r, dep]
else
dump_def(scope, r, dep)
end
end
def dump_def(scope, r=[''], dep=[])
r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
r.last << 'enum'
r.last << ' ' << @name if name
if members
r.last << ' { '
val = -1
@members.sort_by { |m, v| v }.each { |m, v|
r.last << ', ' if r.last[-2, 2] != '{ '
r.last << m
if v != (val += 1)
val = v
r.last << ' = ' << val.to_s
end
}
r.last << ' }'
end
[r, dep]
end
def dump_initializer(init, scope, r=[''], dep=[])
if members and (
k = @members.index(init) or
(init.kind_of? CExpression and not init.op and k = @members.index(init.rexpr))
)
r.last << k
dep |= [scope.struct_ancestors[@name]]
[r, dep]
else super(init, scope, r, dep)
end
end
end
class If
def dump(scope, r=[''], dep=[])
r.last << 'if ('
r, dep = CExpression.dump(@test, scope, r, dep)
r.last << ')'
r, dep = Statement.dump(@bthen, scope, r, dep)
if belse
@bthen.kind_of?(Block) ? (r.last << ' else') : (r << 'else')
if @belse.kind_of? If
# skip indent
r.last << ' '
r, dep = @belse.dump(scope, r, dep)
else
r, dep = Statement.dump(@belse, scope, r, dep)
end
end
[r, dep]
end
end
class For
def dump(scope, r=[''], dep=[])
r.last << 'for ('
if @init.kind_of? Block
scope = @init
skiptype = false
@init.symbol.each_value { |s|
r.last << ', ' if skiptype
r, dep = s.dump_def(scope, r, dep, skiptype)
skiptype = true
}
else
r, dep = CExpression.dump(@init, scope, r, dep)
end
r.last << ' ' if @init
r.last << ';'
r.last << ' ' if @test
r, dep = CExpression.dump(@test, scope, r, dep)
r.last << ' ' if @test
r.last << ';'
r.last << ' ' if @iter
r, dep = CExpression.dump(@iter, scope, r, dep)
r.last << ')'
Statement.dump(@body, scope, r, dep)
end
end
class While
def dump(scope, r=[''], dep=[])
r.last << 'while ('
r, dep = CExpression.dump(@test, scope, r, dep)
r.last << ')'
Statement.dump(@body, scope, r, dep)
end
end
class DoWhile
def dump(scope, r=[''], dep=[])
r.last << 'do'
r, dep = Statement.dump(@body, scope, r, dep)
@body.kind_of?(Block) ? (r.last << ' while (') : (r << 'while (')
r, dep = CExpression.dump(@test, scope, r, dep)
r.last << ');'
[r, dep]
end
end
class Switch
def dump(scope, r=[''], dep=[])
r.last << 'switch ('
r, dep = CExpression.dump(@test, scope, r, dep)
r.last << ')'
r.last << ' {' if @body.kind_of? Block
tr, dep = @body.dump(scope, [''], dep)
r.concat tr.map { |s| Case.dump_indent(s, true) }
r << '}' if @body.kind_of? Block
[r, dep]
end
end
class Continue
def dump(scope, r=[''], dep=[])
r.last << 'continue;'
[r, dep]
end
end
class Break
def dump(scope, r=[''], dep=[])
r.last << 'break;'
[r, dep]
end
end
class Goto
def dump(scope, r=[''], dep=[])
r.last << "goto #@target;"
[r, dep]
end
end
class Return
def dump(scope, r=[''], dep=[])
r.last << 'return '
r, dep = CExpression.dump(@value, scope, r, dep)
r.last.chop! if r.last[-1] == ?\ # the space character
r.last << ';'
[r, dep]
end
end
class Case
def dump(scope, r=[''], dep=[])
case @expr
when 'default'
r.last << @expr
else
r.last << 'case '
r, dep = CExpression.dump(@expr, scope, r, dep)
if exprup
r.last << ' ... '
r, dep = CExpression.dump(@exprup, scope, r, dep)
end
end
r.last << ':'
dump_inner(scope, r, dep)
end
def self.dump_indent(s, short=false)
case s
when /^(case|default)\W/; (short ? ' ' : "\t") << s
when /^\s+(case|default)\W/; "\t" << s
when /:$/; s
else "\t" << s
end
end
end
class Label
def dump(scope, r=[''], dep=[])
r.last << @name << ':'
dump_inner(scope, r, dep)
end
def dump_inner(scope, r=[''], dep=[])
if not @statement; [r, dep]
elsif @statement.kind_of? Block; Statement.dump(@statement, scope, r, dep)
else @statement.dump(scope, r << '', dep)
end
end
end
class Asm
def dump(scope, r=[''], dep=[])
r.last << 'asm '
r.last << 'volatile ' if @volatile
r.last << '('
r.last << @body.inspect
if @output or @input or @clobber
if @output and @output != []
# TODO
r << ': /* todo */'
elsif (@input and @input != []) or (@clobber and @clobber != [])
r.last << ' :'
end
end
if @input or @clobber
if @input and @input != []
# TODO
r << ': /* todo */'
elsif @clobber and @clobber != []
r.last << ' :'
end
end
if @clobber and @clobber != []
r << (': ' << @clobber.map { |c| c.inspect }.join(', '))
end
r.last << ');'
[r, dep]
end
end
class CExpression
def self.dump(e, scope, r=[''], dep=[], brace = false)
if $DEBUG
brace = false
case e
when CExpression, Variable
r, dep = e.type.dump_cast(scope, r, dep)
end
r.last << '('
end
r, dep = \
case e
when ::Numeric; r.last << e.to_s ; [r, dep]
when ::String; r.last << e.inspect ; [r, dep]
when CExpression; e.dump_inner(scope, r, dep, brace)
when Variable; e.dump(scope, r, dep)
when nil; [r, dep]
else raise 'wtf?' + e.inspect
end
if $DEBUG
r.last << ')'
end
[r, dep]
end
def dump(scope, r=[''], dep=[])
r, dep = dump_inner(scope, r, dep)
r.last << ';'
[r, dep]
end
def dump_inner(scope, r=[''], dep=[], brace = false)
r.last << '(' if brace and @op != :'->' and @op != :'.' and @op != :'[]' and (@op or @rexpr.kind_of? CExpression)
if not @lexpr
if not @op
case @rexpr
when ::Numeric
if @rexpr < 0
r.last << ?-
re = -@rexpr
else
re = @rexpr
end
if re >= 0x1000
r.last << ("0x%X" % re)
else
r.last << re.to_s
end
if @type.kind_of? BaseType
r.last << 'U' if @type.specifier == :unsigned
case @type.name
when :longlong, :__int64; r.last << 'LL'
when :long, :longdouble; r.last << 'L'
when :float; r.last << 'F'
end
end
when ::String
r.last << 'L' if @type.kind_of? Pointer and @type.type.kind_of? BaseType and @type.type.name == :short
r.last << @rexpr.inspect
when CExpression # cast
r, dep = @type.dump_cast(scope, r, dep)
r, dep = CExpression.dump(@rexpr, scope, r, dep, true)
when Variable
r, dep = @rexpr.dump(scope, r, dep)
when Block
r.last << '('
r, dep = Statement.dump(@rexpr, scope, r, dep)
r.last << ' )'
when Label
r.last << '&&' << @rexpr.name
else raise "wtf? #{inspect}"
end
else
r.last << @op.to_s
r, dep = CExpression.dump(@rexpr, scope, r, dep, (@rexpr.kind_of? C::CExpression and @rexpr.lexpr))
end
elsif not @rexpr
r, dep = CExpression.dump(@lexpr, scope, r, dep)
r.last << @op.to_s
else
case @op
when :'->', :'.'
r, dep = CExpression.dump(@lexpr, scope, r, dep, true)
r.last << @op.to_s << @rexpr
when :'[]'
r, dep = CExpression.dump(@lexpr, scope, r, dep, true)
r.last << '['
l = lexpr if lexpr.kind_of? Variable
l = lexpr.lexpr.type.untypedef.findmember(lexpr.rexpr) if lexpr.kind_of? CExpression and lexpr.op == :'.'
l = lexpr.lexpr.type.pointed.untypedef.findmember(lexpr.rexpr) if lexpr.kind_of? CExpression and lexpr.op == :'->'
# honor __attribute__((indexenum(enumname)))
if l and l.attributes and rexpr.kind_of? CExpression and not rexpr.op and rexpr.rexpr.kind_of? ::Integer and
n = l.has_attribute_var('indexenum') and enum = scope.struct_ancestors[n] and i = enum.members.index(rexpr.rexpr)
r.last << i
dep |= [enum]
else
r, dep = CExpression.dump(@rexpr, scope, r, dep)
end
r.last << ']'
when :funcall
r, dep = CExpression.dump(@lexpr, scope, r, dep, true)
r.last << '('
@rexpr.each { |arg|
r.last << ', ' if r.last[-1] != ?(
r, dep = CExpression.dump(arg, scope, r, dep)
}
r.last << ')'
when :'?:'
r, dep = CExpression.dump(@lexpr, scope, r, dep, true)
r.last << ' ? '
r, dep = CExpression.dump(@rexpr[0], scope, r, dep, true)
r.last << ' : '
r, dep = CExpression.dump(@rexpr[1], scope, r, dep, true)
else
r, dep = CExpression.dump(@lexpr, scope, r, dep, (@lexpr.kind_of? CExpression and @lexpr.lexpr and @lexpr.op != @op))
r.last << ' ' << @op.to_s << ' '
r, dep = CExpression.dump(@rexpr, scope, r, dep, (@rexpr.kind_of? CExpression and @rexpr.lexpr and @rexpr.op != @op and @rexpr.op != :funcall))
end
end
r.last << ')' if brace and @op != :'->' and @op != :'.' and @op != :'[]' and (@op or @rexpr.kind_of? CExpression)
[r, dep]
end
def to_s
dump_inner(Block.new(nil))[0].join(' ')
end
end
end
end