metasm 1.0.0

data/tests/parse_c.rb

@@ -0,0 +1,239 @@
+#    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 'test/unit'
+require 'metasm'
+
+class TestDynldr < Test::Unit::TestCase
+	def cp
+		@cp ||= Metasm::Ia32.new.new_cparser
+	end
+
+	def test_parse_c
+		assert_nothing_raised {
+			cp.parse("static int i_1=42; __stdcall __int64 foo_1(const char*);")
+		}
+
+		assert_kind_of(Metasm::C::Function, cp.toplevel.symbol['foo_1'].type)
+
+		assert_raise(Metasm::ParseError) { cp.parse("static extern int fu;") }
+		cp.readtok until cp.eos?
+
+		assert_nothing_raised { cp.parse("const volatile volatile const char const * const * blarg_0;") }
+
+		assert_nothing_raised { cp.parse("void *ptr = &ptr;") }
+
+		assert_raise(Metasm::ParseError) { cp.parse("void *ptr = ptr;") }
+		cp.readtok until cp.eos?
+
+		assert_nothing_raised { cp.parse("struct { int sz; } bla = { .sz = sizeof(bla) };") }
+
+		assert_raise(Metasm::ParseError) { cp.parse("signed unsigned int fu;") }
+		cp.readtok until cp.eos?
+
+		assert_raise(Metasm::ParseError) { cp.parse("long long long fu;") }
+		cp.readtok until cp.eos?
+
+		assert_raise(Metasm::ParseError) { cp.parse("void badarg(int i, int i) {}") }
+		cp.readtok until cp.eos?
+
+		assert_raise(Metasm::ParseError) { cp.parse("struct strun; union strun;") }
+		cp.readtok until cp.eos?
+
+		assert_raise(Metasm::ParseError) { cp.parse <<EOS }
+asm <<EOA
+ foo
+ EOA
+EOS
+		cp.readtok until cp.eos?
+
+		assert_nothing_raised { cp.parse <<EOS }
+asm <<-EOA
+ foo
+ EOA
+EOS
+	end
+
+	def test_struct
+		cp.parse <<EOS
+struct foo_2 {
+	__int32 a;
+	__int8 b;
+	__int32 c;
+	__int8 d;
+};
+
+struct foo_3 {
+	__int8 a;
+	__int8 b;
+	__int16 c;
+	__int32 d;
+};
+
+struct foo_4 {
+	__int32 a;
+	__int8 b;
+	__int32 c;
+	__int8 d;
+} __attribute__((packed));
+
+union foo_5 {
+	__int64;
+	struct {
+		__int8;
+		__int8*;
+	};
+	struct {
+		__int16[8];
+	};
+};
+EOS
+		assert_equal(16, cp.sizeof(cp.toplevel.struct['foo_2']))
+		assert_equal(8, cp.toplevel.struct['foo_2'].offsetof(cp, 'c'))
+		assert_equal(8,  cp.sizeof(cp.toplevel.struct['foo_3']))
+		assert_equal(10, cp.sizeof(cp.toplevel.struct['foo_4']))
+		assert_equal(4, cp.toplevel.struct['foo_4'].offsetof(cp, 'b'))
+		assert_equal(5, cp.toplevel.struct['foo_4'].offsetof(cp, 'c'))
+		assert_equal(16, cp.sizeof(cp.toplevel.struct['foo_5']))
+
+		assert_raise(Metasm::ParseError) { cp.parse("struct foo_3 { __int32 a; };") }
+		cp.readtok until cp.eos?
+		assert_nothing_raised { cp.parse("struct foo_3 { __int8 a; __int8 b; __int16 c; __int32 d; };") }
+
+		assert_nothing_raised {
+			cp.parse <<EOS
+struct scop { int i; };
+
+void func1(void) {
+	struct scop { __int64 j; __int64 z; };
+	struct scop s;
+	s.j = 0;
+}
+
+void func2(void) {
+	struct scop s;
+	s.i = 0;
+}
+EOS
+		}
+	end
+
+	def test_bitfields
+		cp.parse <<EOS
+struct foo_bits {
+	__int32 f0:4;
+	__int32 :0;
+	__int32 f1:4;
+	__int32 f2:4;
+	__int8  f3;
+	__int32 f4:4;
+	__int32 f5:30;
+};
+
+struct foo_n_bits {
+	struct foo_bits;
+};
+
+struct foo2_bits {
+	__int64 f0:30;
+	__int64 f1:30;
+	__int64 f2:30;
+};
+
+struct foo3_bits {
+	__int16 f0:8;
+	__int16 f1:4;
+	__int16 f2:1;
+};
+EOS
+		st = cp.toplevel.struct['foo_bits']
+		assert_equal(20, cp.sizeof(st))
+		assert_equal([0, 4], st.bitoffsetof(cp, 'f1'))
+		assert_equal([4, 4], st.bitoffsetof(cp, 'f2'))
+		assert_equal(8,  st.offsetof(cp, 'f3'))
+		assert_equal(12,  st.offsetof(cp, 'f4'))
+		assert_equal([0, 30],  st.bitoffsetof(cp, 'f5'))
+
+		st = cp.toplevel.struct['foo_n_bits']
+		assert_equal(20, cp.sizeof(st))
+		assert_equal([0, 4], st.bitoffsetof(cp, 'f1'))
+		assert_equal([4, 4], st.bitoffsetof(cp, 'f2'))
+		assert_equal(8,  st.offsetof(cp, 'f3'))
+		assert_equal(12,  st.offsetof(cp, 'f4'))
+		assert_equal([0, 30],  st.bitoffsetof(cp, 'f5'))
+
+		st = cp.toplevel.struct['foo2_bits']
+		assert_equal([0, 30], st.bitoffsetof(cp, 'f0'))
+		assert_equal([30, 30], st.bitoffsetof(cp, 'f1'))
+		assert_equal([0, 30], st.bitoffsetof(cp, 'f2'))
+
+		st = cp.toplevel.struct['foo3_bits']
+		assert_equal(2, cp.sizeof(st))
+	end
+
+	def test_allocstruct
+cp.parse <<EOS
+struct foo_outer {
+	int i;
+	struct {
+		int j;
+		int k;
+	} inner;
+};
+EOS
+		s = cp.alloc_c_struct('foo_outer', :i => :size)
+		assert_equal(12, s.sizeof)
+		assert_equal(12, s.i)
+		assert_raise(RuntimeError) { s.l = 42 }
+		assert_nothing_raised { s.j = 0x12345678 }
+		assert_nothing_raised { s.inner.k = 0x3333_3333 }
+		assert_equal(4, s.inner.stroff)
+		assert_equal("0C0000007856341233333333", s.str.unpack('H*')[0].upcase)
+	end
+
+	def test_cmpstruct
+st = <<EOS
+struct foo {
+	struct foo *p;
+	int i;
+};
+
+struct s1 {
+	struct s2 *p;
+};
+
+struct s2 {
+	struct s1 *p;
+};
+EOS
+		cp.parse st
+		cp.parse <<EOS
+struct t1 {
+	struct t2 *pt;
+};
+struct t2 {
+	struct t1 *pt;
+};
+EOS
+
+		cp2 = Metasm::Ia32.new.new_cparser
+		cp2.parse(st)
+		cp2.parse <<EOS
+struct t1 {
+	struct t2 *pt;
+};
+struct t2 {
+	struct t3 *pt;
+};
+struct t3 {
+	struct t1 *pt;
+};
+EOS
+		assert_equal(true, cp.toplevel.struct['foo'] == cp2.toplevel.struct['foo'])
+		assert_equal(true, cp.toplevel.struct['s1'].compare_deep(cp2.toplevel.struct['s1']))
+		assert_equal(true, cp.toplevel.struct['t1'] == cp2.toplevel.struct['t1'])	# expected failure
+		assert_equal(false, !!cp.toplevel.struct['t1'].compare_deep(cp2.toplevel.struct['t1']))
+	end
+end

data/tests/preprocessor.rb

@@ -0,0 +1,269 @@
+#    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 'test/unit'
+require 'metasm/preprocessor'
+require 'metasm/parse'
+
+
+# BEWARE OF TEH RUBY PARSER
+# use single-quoted source strings
+class TestPreproc < Test::Unit::TestCase
+	def load txt, bt = caller.first
+		p = Metasm::Preprocessor.new
+		bt =~ /^(.*?):(\d+)/
+		p.feed txt, $1, $2.to_i+1
+		p
+	end
+
+	def test_gettok
+		p = load <<'EOS'
+test boo
+" bla bla\
+\"\\"   \
+xx
+EOS
+		assert_equal \
+		['test', :space, :string, :eol, :quoted, :space, 'xx', :eol, true],
+		[p.readtok.raw, p.readtok.type, p.readtok.type, p.readtok.type, p.readtok.type, p.readtok.type, p.readtok.raw, p.readtok.type, p.eos?]
+	end
+
+	def test_comment
+		p = load <<'EOS'
+foo /*/ bar ' " * /*/ baz
+kikoo // lol \
+asv
+EOS
+		toks = []
+		nil while tok = p.readtok and (tok.type == :space or tok.type == :eol)
+		until p.eos?
+			toks << tok.raw
+			nil while tok = p.readtok and (tok.type == :space or tok.type == :eol)
+		end
+		assert_equal %w[foo baz kikoo], toks
+	end
+
+	def helper_preparse(text, result)
+		p = load(text, caller.first)
+		yield p if block_given?
+		txt = ''
+		until p.eos? or not t = p.readtok
+			txt << t.raw
+	       	end
+		assert_equal(result, txt.strip)
+	end
+
+	def test_preproc
+		# ignores eol/space at begin/end
+		helper_preparse(<<EOS, '')
+#if 0  // test # as first char
+toto
+#endif
+EOS
+		helper_preparse(<<EOS, 'coucou')
+#define tutu
+#if defined ( tutu )
+tutu coucou
+#endif
+EOS
+		helper_preparse('a #define b', 'a #define b')
+		helper_preparse(<<EOS, "// true !\nblu")
+#ifdef toto // this is false
+bla
+#elif .2_3e-4 > 2 /* this one too */
+blo
+#elif (1+1)*2 > 2 // true !
+blu
+#elif 4 > 2 // not you
+ble
+#else
+bli
+#endif
+EOS
+		helper_preparse(<<'EOS', 'ab#define x')
+a\
+b\
+#define x
+EOS
+		p = load('__LINE__,__DATE__,__TIME__')
+		assert_equal(__LINE__, p.readtok.value) ; p.readtok
+		assert_not_equal('__DATE__', p.readtok.raw) ; p.readtok
+		assert_not_equal('__TIME__', p.readtok.raw)
+
+		helper_preparse(<<EOS, 'toto 1 toto 12 toto 3+(3-2) otot hoho')
+#define azer(k) 12
+# define xxx azer(7)
+#define macro(a, b, c) toto a toto b toto c otot
+macro(1, xxx, 3+(3-2)) hoho
+EOS
+		helper_preparse(<<EOS, 'c')
+#define a b
+#define d c
+#define c d
+#define b c
+a
+EOS
+		helper_preparse(<<EOS, 'b')
+#define b c
+#define a b
+#undef b
+a
+EOS
+		helper_preparse(<<EOS, 'toto tutu huhu()')
+#define toto() abcd
+#define tata huhu
+toto tutu tata()
+EOS
+		helper_preparse(<<EOS, '"haha"')
+#define d(a) #a
+d(haha)
+EOS
+		helper_preparse(<<EOS, '{')
+#define toto(a) a
+toto({)
+EOS
+		helper_preparse(<<EOS, 'x(, 1)')
+#define d(a,b) x(a, b)
+d(,1)
+EOS
+		helper_preparse(<<EOS, '"foo" "4"')
+#define str(x) #x
+#define xstr(x) str(x)
+#define foo 4
+str(foo) xstr(foo)
+EOS
+		begin
+			File.open('tests/prepro_testinclude.asm', 'w') { |fd| fd.puts '#define out in' }
+			helper_preparse(<<EOS, 'in')
+#pragma include_path "."
+#include <tests/prepro_testinclude.asm>
+out
+EOS
+		ensure
+			File.unlink('tests/prepro_testinclude.asm') rescue nil
+		end
+
+		helper_preparse(<<EOS, 'in') { |p_| p_.hooked_include['bla.h'] = '#define out in' }
+#include <bla.h>
+out
+EOS
+		helper_preparse(<<EOS, 'in') { |p_| p_.define('out', 'in') }
+out
+EOS
+		helper_preparse(<<EOS, 'in') { |p_| p_.define_strong('out', 'in') }
+out
+EOS
+		helper_preparse(<<EOS, 'in') { |p_| p_.define_strong('out', 'in') }
+#define out poil
+out
+EOS
+		helper_preparse(<<EOS, 'in') { |p_| p_.define('out', 'in') ; p_.define_weak('out', 'poil') }
+out
+EOS
+		p = load <<EOS
+#define cct(a, b) a ## _ ## b
+cct(toto, tutu)
+EOS
+		nil while tok = p.readtok and (tok.type == :space or tok.type == :eol)
+		assert_equal('toto_tutu', tok.raw)	# check we get only 1 token back
+
+		# assert_outputs_a_warning ?
+		helper_preparse(<<EOS, <<EOS.strip)
+#define va1(a, b...) toto(a, ##b)
+#define va3(a, ...)  toto(a, __VA_ARGS__)
+va1(1, 2);
+va1(1,2);
+va1(1);
+va3(1, 2);
+va3(1);
+EOS
+toto(1, 2);
+toto(1,2);
+toto(1);
+toto(1, 2);
+toto(1, );
+EOS
+
+		helper_preparse(<<EOS, "#define a c\n#define b d\na b")
+#define x(z) z
+#define y #define
+x(#)define a c
+y b d
+a b
+EOS
+		helper_preparse("#define a(a) a(a)\na(1)", '1(1)')
+		helper_preparse("#if 0\n#endif", '')
+		helper_preparse("#if 0U\n#endif", '')
+		helper_preparse("#if 0L\n#endif", '')
+		helper_preparse("#if 0LLU\n#endif", '')
+	end
+
+	def test_floats
+		t_float = lambda { |txt|
+			text = <<EOS
+#if #{txt}
+1
+#endif
+EOS
+			p = load text, caller.first
+			txt = ''
+			t = nil
+			txt << t.raw until p.eos? or not t = p.readtok
+			assert_equal('1', txt.strip)
+		}
+		t_float['1 > 0']
+		t_float['1.0 > 0']
+		t_float['1e2 > 10 && 1.0e2 < 1000']
+		t_float['1.0e+2 > 10']
+		t_float['10_00e-2 > 1 && 10_00e-2 < 100']
+		t_float['.1e2 > 1']
+		#t_float['0x1.p2L > 1 && 0x1p2f < 5']
+		t_float['0x1.p2L > 1']
+		t_float['0x1p2f < 5']
+	end
+
+	def test_errors
+		test_err = lambda { |txt| assert_raise(Metasm::ParseError) { p = load(txt, caller.first) ; p.readtok until p.eos? } }
+		t_float = lambda { |txt| assert_raise(Metasm::ParseError) { p = load("#if #{txt}\n#endif", caller.first) ; p.readtok } }
+		test_err["\"abc\n\""]
+		test_err['"abc\x"']
+		test_err['/*']
+		test_err['#if 0']
+		test_err["#define toto(tutu,"]
+		test_err["#define toto( (tutu, tata)"]
+		test_err['#error bla']
+		test_err[<<EOS]
+#if 0
+#elif 1
+#else
+#if 2
+#endif
+EOS
+		test_err[<<EOS]
+#define abc(def)
+abc (1, 3)
+EOS
+		test_err["#if 0LUL\n#endif"]
+		# warnings only
+		#test_err["#define aa\n#define aa"]
+		#test_err['#define a(b) #c']
+		#test_err['#define a(b, b)']
+		#test_err['#define a ##z']
+		t_float['1e++4']
+		t_float['1.0e 4']
+		t_float['_1.0']
+		t_float['.e2']
+		t_float['1.1e+_1']
+		t_float['.2e']
+		t_float['.']
+		t_float['1.2e*4']
+		t_float['0x1.e4']
+		t_float['0x1.p4a']
+		t_float['0x.p1']
+		t_float['0x.1lp1']
+	end
+end
+