class Metasm::IndExpression

an Expression whose ::parser handles indirection (byte ptr [foobar])

Attributes

parse_cb[RW]

callback used to customize the parsing of /^([0-9]+)$/ tokens implicitely set by parse(expr) { cb } allows eg parsing '40000' as 0x40000 when relevant

Public Class Methods

new(op, r, l) click to toggle source
Calls superclass method Metasm::Expression.new
# File metasm/parse.rb, line 872
def new(op, r, l)
        return Indirection[[l, :+, r], nil] if op == :'->'
        super(op, r, l)
end
parse(*a, &b) click to toggle source
Calls superclass method Metasm::Expression.parse
# File metasm/parse.rb, line 838
def parse(*a, &b)
        # custom decimal converter
        @parse_cb = b if b
        e = super(*a)
        @parse_cb = nil if b
        e
end
parse_intfloat(lexer, tok) click to toggle source
# File metasm/parse.rb, line 851
def parse_intfloat(lexer, tok)
        case tok.raw
        when /^([0-9]+)$/; tok.value = parse_cb ? @parse_cb[$1] : $1.to_i
        when /^0x([0-9a-f]+)$/, /^([0-9a-f]+)h$/; tok.value = $1.to_i(16)
        when /^0b([01]+)$/; tok.value = $1.to_i(2)
        end
end
parse_value(lexer) click to toggle source
Calls superclass method Metasm::Expression.parse_value
# File metasm/parse.rb, line 802
def parse_value(lexer)
        sz = nil
        ptr = nil
        loop do
                nil while tok = lexer.readtok and tok.type == :space
                return if not tok
                case tok.raw
                when 'qword'; sz=8
                when 'dword'; sz=4
                when 'word'; sz=2
                when 'byte'; sz=1
                when 'ptr'
                when '['
                        ptr = parse(lexer)
                        nil while tok = lexer.readtok and tok.type == :space
                        raise tok || lexer, '] expected' if tok.raw != ']'
                        break
                when '*'
                        ptr = parse_value(lexer)
                        break
                when ':'    # symbols, eg ':eax'
                        n = lexer.readtok
                        nil while tok = lexer.readtok and tok.type == :space
                        lexer.unreadtok tok
                        return n.raw.to_sym
                else
                        lexer.unreadtok tok
                        break
                end
        end
        raise lexer, 'invalid indirection' if sz and not ptr
        if ptr; Indirection[ptr, sz] # if sz is nil, default cpu pointersz is set in resolve_expr
        else super(lexer)
        end
end
readop(lexer) click to toggle source
Calls superclass method Metasm::Expression.readop
# File metasm/parse.rb, line 859
def readop(lexer)
        if t0 = lexer.readtok and t0.raw == '-' and t1 = lexer.readtok and t1.raw == '>'
                op = t0.dup
                op.raw << t1.raw
                op.value = op.raw.to_sym
                op
        else
                lexer.unreadtok t1
                lexer.unreadtok t0
                super(lexer)
        end
end