regenerated, added shortcut macros

diff --git a/lib/modules/swfabc_ops.c b/lib/modules/swfabc_ops.c
index 3f908c4..4dd0ec5 100644 (file)
--- a/lib/modules/swfabc_ops.c
+++ b/lib/modules/swfabc_ops.c
@@ -1,633 +1,796 @@
-void abc_add(abc_code_t*c)
+void abc_add(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xa0);
 }
 {
     swf_SetU8(c->tag, 0xa0);
 }

-void abc_add_i(abc_code_t*c)
+#define add() abc_add(abc_code)
+void abc_add_i(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xc5);
 }
 {
     swf_SetU8(c->tag, 0xc5);
 }

-void abc_atype(abc_code_t*c, char*name)
+#define add_i() abc_add_i(abc_code)
+void abc_atype(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x86);
 {
     swf_SetU8(c->tag, 0x86);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_astypelate(abc_code_t*c)
+#define atype(name) abc_atype(abc_code,name)
+void abc_astypelate(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x87);
 }
 {
     swf_SetU8(c->tag, 0x87);
 }

-void abc_bitand(abc_code_t*c)
+#define astypelate() abc_astypelate(abc_code)
+void abc_bitand(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xA8);
 }
 {
     swf_SetU8(c->tag, 0xA8);
 }

-void abc_bitnot(abc_code_t*c)
+#define bitand() abc_bitand(abc_code)
+void abc_bitnot(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x97);
 }
 {
     swf_SetU8(c->tag, 0x97);
 }

-void abc_bitor(abc_code_t*c)
+#define bitnot() abc_bitnot(abc_code)
+void abc_bitor(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xa9);
 }
 {
     swf_SetU8(c->tag, 0xa9);
 }

-void abc_bitxor(abc_code_t*c)
+#define bitor() abc_bitor(abc_code)
+void abc_bitxor(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xaa);
 }
 {
     swf_SetU8(c->tag, 0xaa);
 }

-void abc_call(abc_code_t*c, int v)
+#define bitxor() abc_bitxor(abc_code)
+void abc_call(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x41);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x41);
     swf_SetU30(c->tag, v);
 }

-void abc_callmethod(abc_code_t*c, abc_code_t*m, int v)
+#define call(v) abc_call(abc_code,v)
+void abc_callmethod(abc_method_body_t*c, abc_method_body_t* m, int v)

 {
     swf_SetU8(c->tag, 0x43);
     swf_SetU30(c->tag, m->index);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x43);
     swf_SetU30(c->tag, m->index);
     swf_SetU30(c->tag, v);
 }

-void abc_callproplex(abc_code_t*c, char*name, int v)
+#define callmethod(m,v) abc_callmethod(abc_code,m,v)
+void abc_callproplex(abc_method_body_t*c, char* name, int v)

 {
     swf_SetU8(c->tag, 0x4c);
 {
     swf_SetU8(c->tag, 0x4c);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

     swf_SetU30(c->tag, v);
 }
     swf_SetU30(c->tag, v);
 }

-void abc_callproperty(abc_code_t*c, char*name, int v)
+#define callproplex(name,v) abc_callproplex(abc_code,name,v)
+void abc_callproperty(abc_method_body_t*c, char* name, int v)

 {
     swf_SetU8(c->tag, 0x46);
 {
     swf_SetU8(c->tag, 0x46);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

     swf_SetU30(c->tag, v);
 }
     swf_SetU30(c->tag, v);
 }

-void abc_callpropvoid(abc_code_t*c, char*name, int v)
+#define callproperty(name,v) abc_callproperty(abc_code,name,v)
+void abc_callpropvoid(abc_method_body_t*c, char* name, int v)

 {
     swf_SetU8(c->tag, 0x4f);
 {
     swf_SetU8(c->tag, 0x4f);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

     swf_SetU30(c->tag, v);
 }
     swf_SetU30(c->tag, v);
 }

-void abc_callstatic(abc_code_t*c, abc_method_t*m, int v)
+#define callpropvoid(name,v) abc_callpropvoid(abc_code,name,v)
+void abc_callstatic(abc_method_body_t*c, abc_method_t* m, int v)

 {
     swf_SetU8(c->tag, 0x44);
     swf_SetU30(c->tag, m->index);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x44);
     swf_SetU30(c->tag, m->index);
     swf_SetU30(c->tag, v);
 }

-void abc_callsuper(abc_code_t*c, char*name, int v)
+#define callstatic(m,v) abc_callstatic(abc_code,m,v)
+void abc_callsuper(abc_method_body_t*c, char* name, int v)

 {
     swf_SetU8(c->tag, 0x45);
 {
     swf_SetU8(c->tag, 0x45);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

     swf_SetU30(c->tag, v);
 }
     swf_SetU30(c->tag, v);
 }

-void abc_callsupervoid(abc_code_t*c, char*name, int v)
+#define callsuper(name,v) abc_callsuper(abc_code,name,v)
+void abc_callsupervoid(abc_method_body_t*c, char* name, int v)

 {
     swf_SetU8(c->tag, 0x4e);
 {
     swf_SetU8(c->tag, 0x4e);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

     swf_SetU30(c->tag, v);
 }
     swf_SetU30(c->tag, v);
 }

-void abc_checkfilter(abc_code_t*c)
+#define callsupervoid(name,v) abc_callsupervoid(abc_code,name,v)
+void abc_checkfilter(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x78);
 }
 {
     swf_SetU8(c->tag, 0x78);
 }

-void abc_coerce(abc_code_t*c, abc_code_t*m)
+#define checkfilter() abc_checkfilter(abc_code)
+void abc_coerce(abc_method_body_t*c, abc_method_body_t* m)

 {
     swf_SetU8(c->tag, 0x80);
     swf_SetU30(c->tag, m->index);
 }
 {
     swf_SetU8(c->tag, 0x80);
     swf_SetU30(c->tag, m->index);
 }

-void abc_coerce_a(abc_code_t*c)
+#define coerce(m) abc_coerce(abc_code,m)
+void abc_coerce_a(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x82);
 }
 {
     swf_SetU8(c->tag, 0x82);
 }

-void abc_coerce_s(abc_code_t*c)
+#define coerce_a() abc_coerce_a(abc_code)
+void abc_coerce_s(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x85);
 }
 {
     swf_SetU8(c->tag, 0x85);
 }

-void abc_construct(abc_code_t*c, int v)
+#define coerce_s() abc_coerce_s(abc_code)
+void abc_construct(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x42);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x42);
     swf_SetU30(c->tag, v);
 }

-void abc_constructprop(abc_code_t*c, char*name, int v)
+#define construct(v) abc_construct(abc_code,v)
+void abc_constructprop(abc_method_body_t*c, char* name, int v)

 {
     swf_SetU8(c->tag, 0x4a);
 {
     swf_SetU8(c->tag, 0x4a);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

     swf_SetU30(c->tag, v);
 }
     swf_SetU30(c->tag, v);
 }

-void abc_constructsuper(abc_code_t*c, int v)
+#define constructprop(name,v) abc_constructprop(abc_code,name,v)
+void abc_constructsuper(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x49);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x49);
     swf_SetU30(c->tag, v);
 }

-void abc_convert_b(abc_code_t*c)
+#define constructsuper(v) abc_constructsuper(abc_code,v)
+void abc_convert_b(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x76);
 }
 {
     swf_SetU8(c->tag, 0x76);
 }

-void abc_convert_i(abc_code_t*c)
+#define convert_b() abc_convert_b(abc_code)
+void abc_convert_i(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x73);
 }
 {
     swf_SetU8(c->tag, 0x73);
 }

-void abc_convert_d(abc_code_t*c)
+#define convert_i() abc_convert_i(abc_code)
+void abc_convert_d(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x75);
 }
 {
     swf_SetU8(c->tag, 0x75);
 }

-void abc_convert_o(abc_code_t*c)
+#define convert_d() abc_convert_d(abc_code)
+void abc_convert_o(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x77);
 }
 {
     swf_SetU8(c->tag, 0x77);
 }

-void abc_convert_u(abc_code_t*c)
+#define convert_o() abc_convert_o(abc_code)
+void abc_convert_u(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x74);
 }
 {
     swf_SetU8(c->tag, 0x74);
 }

-void abc_convert_s(abc_code_t*c)
+#define convert_u() abc_convert_u(abc_code)
+void abc_convert_s(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x70);
 }
 {
     swf_SetU8(c->tag, 0x70);
 }

-void abc_debug(abc_code_t*c, int v, char*s, int v3, int v2)
+#define convert_s() abc_convert_s(abc_code)
+void abc_debug(abc_method_body_t*c, int v, char* s, int v2, int v3)

 {
     swf_SetU8(c->tag, 0xef);
     swf_SetU8(c->tag, v);
 {
     swf_SetU8(c->tag, 0xef);
     swf_SetU8(c->tag, v);

-    swf_SetU30(c->tag, dict_update(c->abc->strings, s, 0));
-    swf_SetU8(c->tag, v3);
-    swf_SetU30(c->tag, v2);
+    swf_SetU30(c->tag, dict_update(c->pool->strings, s, 0));
+    swf_SetU8(c->tag, v2);
+    swf_SetU30(c->tag, v3);

 }
 }

-void abc_debugfile(abc_code_t*c, char*s)
+#define debug(v,s,v2,v3) abc_debug(abc_code,v,s,v2,v3)
+void abc_debugfile(abc_method_body_t*c, char* s)

 {
     swf_SetU8(c->tag, 0xf1);
 {
     swf_SetU8(c->tag, 0xf1);

-    swf_SetU30(c->tag, dict_update(c->abc->strings, s, 0));
+    swf_SetU30(c->tag, dict_update(c->pool->strings, s, 0));

 }
 }

-void abc_debugline(abc_code_t*c, int v)
+#define debugfile(s) abc_debugfile(abc_code,s)
+void abc_debugline(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0xf0);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0xf0);
     swf_SetU30(c->tag, v);
 }

-void abc_declocal(abc_code_t*c, int v)
+#define debugline(v) abc_debugline(abc_code,v)
+void abc_declocal(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x94);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x94);
     swf_SetU30(c->tag, v);
 }

-void abc_declocal_i(abc_code_t*c, int v)
+#define declocal(v) abc_declocal(abc_code,v)
+void abc_declocal_i(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0xc3);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0xc3);
     swf_SetU30(c->tag, v);
 }

-void abc_decrement(abc_code_t*c)
+#define declocal_i(v) abc_declocal_i(abc_code,v)
+void abc_decrement(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x93);
 }
 {
     swf_SetU8(c->tag, 0x93);
 }

-void abc_decrement_i(abc_code_t*c)
+#define decrement() abc_decrement(abc_code)
+void abc_decrement_i(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xc1);
 }
 {
     swf_SetU8(c->tag, 0xc1);
 }

-void abc_deleteproperty(abc_code_t*c, char*name)
+#define decrement_i() abc_decrement_i(abc_code)
+void abc_deleteproperty(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x6a);
 {
     swf_SetU8(c->tag, 0x6a);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_divide(abc_code_t*c)
+#define deleteproperty(name) abc_deleteproperty(abc_code,name)
+void abc_divide(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xa3);
 }
 {
     swf_SetU8(c->tag, 0xa3);
 }

-void abc_dup(abc_code_t*c)
+#define divide() abc_divide(abc_code)
+void abc_dup(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x2a);
 }
 {
     swf_SetU8(c->tag, 0x2a);
 }

-void abc_dxns(abc_code_t*c, char*s)
+#define dup() abc_dup(abc_code)
+void abc_dxns(abc_method_body_t*c, char* s)

 {
     swf_SetU8(c->tag, 0x06);
 {
     swf_SetU8(c->tag, 0x06);

-    swf_SetU30(c->tag, dict_update(c->abc->strings, s, 0));
+    swf_SetU30(c->tag, dict_update(c->pool->strings, s, 0));

 }
 }

-void abc_dxnslate(abc_code_t*c)
+#define dxns(s) abc_dxns(abc_code,s)
+void abc_dxnslate(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x07);
 }
 {
     swf_SetU8(c->tag, 0x07);
 }

-void abc_equals(abc_code_t*c)
+#define dxnslate() abc_dxnslate(abc_code)
+void abc_equals(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xab);
 }
 {
     swf_SetU8(c->tag, 0xab);
 }

-void abc_esc_xattr(abc_code_t*c)
+#define equals() abc_equals(abc_code)
+void abc_esc_xattr(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x72);
 }
 {
     swf_SetU8(c->tag, 0x72);
 }

-void abc_esc_xelem(abc_code_t*c)
+#define esc_xattr() abc_esc_xattr(abc_code)
+void abc_esc_xelem(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x71);
 }
 {
     swf_SetU8(c->tag, 0x71);
 }

-void abc_findproperty(abc_code_t*c, char*name)
+#define esc_xelem() abc_esc_xelem(abc_code)
+void abc_findproperty(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x5e);
 {
     swf_SetU8(c->tag, 0x5e);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_findpropstrict(abc_code_t*c, char*name)
+#define findproperty(name) abc_findproperty(abc_code,name)
+void abc_findpropstrict(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x5d);
 {
     swf_SetU8(c->tag, 0x5d);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_getdescendants(abc_code_t*c, char*name)
+#define findpropstrict(name) abc_findpropstrict(abc_code,name)
+void abc_getdescendants(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x59);
 {
     swf_SetU8(c->tag, 0x59);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_getglobalscope(abc_code_t*c)
+#define getdescendants(name) abc_getdescendants(abc_code,name)
+void abc_getglobalscope(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x64);
 }
 {
     swf_SetU8(c->tag, 0x64);
 }

-void abc_getglobalslot(abc_code_t*c, int v)
+#define getglobalscope() abc_getglobalscope(abc_code)
+void abc_getglobalslot(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x6e);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x6e);
     swf_SetU30(c->tag, v);
 }

-void abc_getlex(abc_code_t*c, char*name)
+#define getglobalslot(v) abc_getglobalslot(abc_code,v)
+void abc_getlex(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x60);
 {
     swf_SetU8(c->tag, 0x60);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_getlocal(abc_code_t*c, int v)
+#define getlex(name) abc_getlex(abc_code,name)
+void abc_getlocal(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x62);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x62);
     swf_SetU30(c->tag, v);
 }

-void abc_getlocal_0(abc_code_t*c)
+#define getlocal(v) abc_getlocal(abc_code,v)
+void abc_getlocal_0(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xd0);
 }
 {
     swf_SetU8(c->tag, 0xd0);
 }

-void abc_getlocal_1(abc_code_t*c)
+#define getlocal_0() abc_getlocal_0(abc_code)
+void abc_getlocal_1(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xd1);
 }
 {
     swf_SetU8(c->tag, 0xd1);
 }

-void abc_getlocal_2(abc_code_t*c)
+#define getlocal_1() abc_getlocal_1(abc_code)
+void abc_getlocal_2(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xd2);
 }
 {
     swf_SetU8(c->tag, 0xd2);
 }

-void abc_getlocal_3(abc_code_t*c)
+#define getlocal_2() abc_getlocal_2(abc_code)
+void abc_getlocal_3(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xd3);
 }
 {
     swf_SetU8(c->tag, 0xd3);
 }

-void abc_getproperty(abc_code_t*c, char*name)
+#define getlocal_3() abc_getlocal_3(abc_code)
+void abc_getproperty(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x66);
 {
     swf_SetU8(c->tag, 0x66);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_getscopeobject(abc_code_t*c, int v)
+#define getproperty(name) abc_getproperty(abc_code,name)
+void abc_getscopeobject(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x65);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x65);
     swf_SetU30(c->tag, v);
 }

-void abc_getslot(abc_code_t*c, int v)
+#define getscopeobject(v) abc_getscopeobject(abc_code,v)
+void abc_getslot(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x6c);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x6c);
     swf_SetU30(c->tag, v);
 }

-void abc_getsuper(abc_code_t*c, char*name)
+#define getslot(v) abc_getslot(abc_code,v)
+void abc_getsuper(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x04);
 {
     swf_SetU8(c->tag, 0x04);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_greaterequals(abc_code_t*c)
+#define getsuper(name) abc_getsuper(abc_code,name)
+void abc_greaterequals(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xaf);
 }
 {
     swf_SetU8(c->tag, 0xaf);
 }

-void abc_hasnext(abc_code_t*c)
+#define greaterequals() abc_greaterequals(abc_code)
+void abc_hasnext(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x1f);
 }
 {
     swf_SetU8(c->tag, 0x1f);
 }

-void abc_hasnext2(abc_code_t*c, int v, int v2)
+#define hasnext() abc_hasnext(abc_code)
+void abc_hasnext2(abc_method_body_t*c, int v, int v2)

 {
     swf_SetU8(c->tag, 0x32);
     swf_SetU30(c->tag, v);
     swf_SetU30(c->tag, v2);
 }
 {
     swf_SetU8(c->tag, 0x32);
     swf_SetU30(c->tag, v);
     swf_SetU30(c->tag, v2);
 }

-void abc_ifeq(abc_code_t*c, int target)
+#define hasnext2(v,v2) abc_hasnext2(abc_code,v,v2)
+void abc_ifeq(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x13);
 {
     swf_SetU8(c->tag, 0x13);

+    /* FIXME: write label j */

 }
 }

-void abc_iffalse(abc_code_t*c, int target)
+#define ifeq(j) abc_ifeq(abc_code,j)
+void abc_iffalse(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x12);
 {
     swf_SetU8(c->tag, 0x12);

+    /* FIXME: write label j */

 }
 }

-void abc_ifge(abc_code_t*c, int target)
+#define iffalse(j) abc_iffalse(abc_code,j)
+void abc_ifge(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x18);
 {
     swf_SetU8(c->tag, 0x18);

+    /* FIXME: write label j */

 }
 }

-void abc_ifgt(abc_code_t*c, int target)
+#define ifge(j) abc_ifge(abc_code,j)
+void abc_ifgt(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x17);
 {
     swf_SetU8(c->tag, 0x17);

+    /* FIXME: write label j */

 }
 }

-void abc_ifle(abc_code_t*c, int target)
+#define ifgt(j) abc_ifgt(abc_code,j)
+void abc_ifle(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x16);
 {
     swf_SetU8(c->tag, 0x16);

+    /* FIXME: write label j */

 }
 }

-void abc_iflt(abc_code_t*c, int target)
+#define ifle(j) abc_ifle(abc_code,j)
+void abc_iflt(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x15);
 {
     swf_SetU8(c->tag, 0x15);

+    /* FIXME: write label j */

 }
 }

-void abc_ifnge(abc_code_t*c, int target)
+#define iflt(j) abc_iflt(abc_code,j)
+void abc_ifnge(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x0f);
 {
     swf_SetU8(c->tag, 0x0f);

+    /* FIXME: write label j */

 }
 }

-void abc_ifngt(abc_code_t*c, int target)
+#define ifnge(j) abc_ifnge(abc_code,j)
+void abc_ifngt(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x0e);
 {
     swf_SetU8(c->tag, 0x0e);

+    /* FIXME: write label j */

 }
 }

-void abc_ifnle(abc_code_t*c, int target)
+#define ifngt(j) abc_ifngt(abc_code,j)
+void abc_ifnle(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x0d);
 {
     swf_SetU8(c->tag, 0x0d);

+    /* FIXME: write label j */

 }
 }

-void abc_ifnlt(abc_code_t*c, int target)
+#define ifnle(j) abc_ifnle(abc_code,j)
+void abc_ifnlt(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x0c);
 {
     swf_SetU8(c->tag, 0x0c);

+    /* FIXME: write label j */

 }
 }

-void abc_ifne(abc_code_t*c, int target)
+#define ifnlt(j) abc_ifnlt(abc_code,j)
+void abc_ifne(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x14);
 {
     swf_SetU8(c->tag, 0x14);

+    /* FIXME: write label j */

 }
 }

-void abc_ifstricteq(abc_code_t*c, int target)
+#define ifne(j) abc_ifne(abc_code,j)
+void abc_ifstricteq(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x19);
 {
     swf_SetU8(c->tag, 0x19);

+    /* FIXME: write label j */

 }
 }

-void abc_ifstrictne(abc_code_t*c, int target)
+#define ifstricteq(j) abc_ifstricteq(abc_code,j)
+void abc_ifstrictne(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x1a);
 {
     swf_SetU8(c->tag, 0x1a);

+    /* FIXME: write label j */

 }
 }

-void abc_iftrue(abc_code_t*c, int target)
+#define ifstrictne(j) abc_ifstrictne(abc_code,j)
+void abc_iftrue(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x11);
 {
     swf_SetU8(c->tag, 0x11);

+    /* FIXME: write label j */

 }
 }

-void abc_in(abc_code_t*c)
+#define iftrue(j) abc_iftrue(abc_code,j)
+void abc_in(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xb4);
 }
 {
     swf_SetU8(c->tag, 0xb4);
 }

-void abc_inclocal(abc_code_t*c, int v)
+#define in() abc_in(abc_code)
+void abc_inclocal(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x92);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x92);
     swf_SetU30(c->tag, v);
 }

-void abc_inclocal_i(abc_code_t*c, int v)
+#define inclocal(v) abc_inclocal(abc_code,v)
+void abc_inclocal_i(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0xc2);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0xc2);
     swf_SetU30(c->tag, v);
 }

-void abc_increment(abc_code_t*c)
+#define inclocal_i(v) abc_inclocal_i(abc_code,v)
+void abc_increment(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x91);
 }
 {
     swf_SetU8(c->tag, 0x91);
 }

-void abc_increment_i(abc_code_t*c)
+#define increment() abc_increment(abc_code)
+void abc_increment_i(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xc0);
 }
 {
     swf_SetU8(c->tag, 0xc0);
 }

-void abc_initproperty(abc_code_t*c, char*name)
+#define increment_i() abc_increment_i(abc_code)
+void abc_initproperty(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x68);
 {
     swf_SetU8(c->tag, 0x68);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_instanceof(abc_code_t*c)
+#define initproperty(name) abc_initproperty(abc_code,name)
+void abc_instanceof(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xb1);
 }
 {
     swf_SetU8(c->tag, 0xb1);
 }

-void abc_istype(abc_code_t*c, char*name)
+#define instanceof() abc_instanceof(abc_code)
+void abc_istype(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0xb2);
 {
     swf_SetU8(c->tag, 0xb2);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_istypelate(abc_code_t*c)
+#define istype(name) abc_istype(abc_code,name)
+void abc_istypelate(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xb3);
 }
 {
     swf_SetU8(c->tag, 0xb3);
 }

-void abc_jump(abc_code_t*c, int target)
+#define istypelate() abc_istypelate(abc_code)
+void abc_jump(abc_method_body_t*c, abc_label_t* j)

 {
     swf_SetU8(c->tag, 0x10);
 {
     swf_SetU8(c->tag, 0x10);

+    /* FIXME: write label j */

 }
 }

-void abc_kill(abc_code_t*c, int v)
+#define jump(j) abc_jump(abc_code,j)
+void abc_kill(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x08);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x08);
     swf_SetU30(c->tag, v);
 }

-void abc_label(abc_code_t*c)
+#define kill(v) abc_kill(abc_code,v)
+void abc_label(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x09);
 }
 {
     swf_SetU8(c->tag, 0x09);
 }

-void abc_lessequals(abc_code_t*c)
+#define label() abc_label(abc_code)
+void abc_lessequals(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xae);
 }
 {
     swf_SetU8(c->tag, 0xae);
 }

-void abc_lessthan(abc_code_t*c)
+#define lessequals() abc_lessequals(abc_code)
+void abc_lessthan(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xad);
 }
 {
     swf_SetU8(c->tag, 0xad);
 }

-void abc_lshift(abc_code_t*c)
+#define lessthan() abc_lessthan(abc_code)
+void abc_lookupswitch(abc_method_body_t*c, void* labels)
+{
+    swf_SetU8(c->tag, 0x1b);
+    /* FIXME: write labels labels */
+}
+#define lookupswitch(labels) abc_lookupswitch(abc_code,labels)
+void abc_lshift(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xa5);
 }
 {
     swf_SetU8(c->tag, 0xa5);
 }

-void abc_modulo(abc_code_t*c)
+#define lshift() abc_lshift(abc_code)
+void abc_modulo(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xa4);
 }
 {
     swf_SetU8(c->tag, 0xa4);
 }

-void abc_multiply(abc_code_t*c)
+#define modulo() abc_modulo(abc_code)
+void abc_multiply(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xa2);
 }
 {
     swf_SetU8(c->tag, 0xa2);
 }

-void abc_multiply_i(abc_code_t*c)
+#define multiply() abc_multiply(abc_code)
+void abc_multiply_i(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xc7);
 }
 {
     swf_SetU8(c->tag, 0xc7);
 }

-void abc_negate(abc_code_t*c)
+#define multiply_i() abc_multiply_i(abc_code)
+void abc_negate(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x90);
 }
 {
     swf_SetU8(c->tag, 0x90);
 }

-void abc_negate_i(abc_code_t*c)
+#define negate() abc_negate(abc_code)
+void abc_negate_i(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xc4);
 }
 {
     swf_SetU8(c->tag, 0xc4);
 }

-void abc_newactivation(abc_code_t*c)
+#define negate_i() abc_negate_i(abc_code)
+void abc_newactivation(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x57);
 }
 {
     swf_SetU8(c->tag, 0x57);
 }

-void abc_newarray(abc_code_t*c, int v)
+#define newactivation() abc_newactivation(abc_code)
+void abc_newarray(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x56);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x56);
     swf_SetU30(c->tag, v);
 }

-void abc_newcatch(abc_code_t*c, int v)
+#define newarray(v) abc_newarray(abc_code,v)
+void abc_newcatch(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x5a);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x5a);
     swf_SetU30(c->tag, v);
 }

-void abc_newclass(abc_code_t*c, abc_class_t*m)
+#define newcatch(v) abc_newcatch(abc_code,v)
+void abc_newclass(abc_method_body_t*c, abc_class_t* m)

 {
     swf_SetU8(c->tag, 0x58);
     swf_SetU30(c->tag, m->index);
 }
 {
     swf_SetU8(c->tag, 0x58);
     swf_SetU30(c->tag, m->index);
 }

-void abc_newfunction(abc_code_t*c, int v)
+#define newclass(m) abc_newclass(abc_code,m)
+void abc_newfunction(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x40);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x40);
     swf_SetU30(c->tag, v);
 }

-void abc_newobject(abc_code_t*c, int v)
+#define newfunction(v) abc_newfunction(abc_code,v)
+void abc_newobject(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x55);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x55);
     swf_SetU30(c->tag, v);
 }

-void abc_nextname(abc_code_t*c)
+#define newobject(v) abc_newobject(abc_code,v)
+void abc_nextname(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x1e);
 }
 {
     swf_SetU8(c->tag, 0x1e);
 }

-void abc_nextvalue(abc_code_t*c)
+#define nextname() abc_nextname(abc_code)
+void abc_nextvalue(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x23);
 }
 {
     swf_SetU8(c->tag, 0x23);
 }

-void abc_nop(abc_code_t*c)
+#define nextvalue() abc_nextvalue(abc_code)
+void abc_nop(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x02);
 }
 {
     swf_SetU8(c->tag, 0x02);
 }

-void abc_not(abc_code_t*c)
+#define nop() abc_nop(abc_code)
+void abc_not(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x96);
 }
 {
     swf_SetU8(c->tag, 0x96);
 }

-void abc_pop(abc_code_t*c)
+#define not() abc_not(abc_code)
+void abc_pop(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x29);
 }
 {
     swf_SetU8(c->tag, 0x29);
 }

-void abc_popscope(abc_code_t*c)
+#define pop() abc_pop(abc_code)
+void abc_popscope(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x1d);
 }
 {
     swf_SetU8(c->tag, 0x1d);
 }

-void abc_pushbyte(abc_code_t*c, int v)
+#define popscope() abc_popscope(abc_code)
+void abc_pushbyte(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x24);
     swf_SetU8(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x24);
     swf_SetU8(c->tag, v);
 }

-void abc_pushdouble(abc_code_t*c, int v)
+#define pushbyte(v) abc_pushbyte(abc_code,v)
+void abc_pushdouble(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x2f);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x2f);
     swf_SetU30(c->tag, v);
 }

-void abc_pushfalse(abc_code_t*c)
+#define pushdouble(v) abc_pushdouble(abc_code,v)
+void abc_pushfalse(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x27);
 }
 {
     swf_SetU8(c->tag, 0x27);
 }

-void abc_pushint(abc_code_t*c, int v)
+#define pushfalse() abc_pushfalse(abc_code)
+void abc_pushint(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x2d);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x2d);
     swf_SetU30(c->tag, v);
 }

-void abc_pushnamespace(abc_code_t*c, int v)
+#define pushint(v) abc_pushint(abc_code,v)
+void abc_pushnamespace(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x31);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x31);
     swf_SetU30(c->tag, v);
 }

-void abc_pushnan(abc_code_t*c)
+#define pushnamespace(v) abc_pushnamespace(abc_code,v)
+void abc_pushnan(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x28);
 }
 {
     swf_SetU8(c->tag, 0x28);
 }

-void abc_pushnull(abc_code_t*c)
+#define pushnan() abc_pushnan(abc_code)
+void abc_pushnull(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x20);
 }
 {
     swf_SetU8(c->tag, 0x20);
 }

-void abc_pushscope(abc_code_t*c)
+#define pushnull() abc_pushnull(abc_code)
+void abc_pushscope(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x30);
 }
 {
     swf_SetU8(c->tag, 0x30);
 }

-void abc_pushshort(abc_code_t*c, int v)
+#define pushscope() abc_pushscope(abc_code)
+void abc_pushshort(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x25);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x25);
     swf_SetU30(c->tag, v);
 }

-void abc_pushstring(abc_code_t*c, char*s)
+#define pushshort(v) abc_pushshort(abc_code,v)
+void abc_pushstring(abc_method_body_t*c, char* s)

 {
     swf_SetU8(c->tag, 0x2c);
 {
     swf_SetU8(c->tag, 0x2c);

-    swf_SetU30(c->tag, dict_update(c->abc->strings, s, 0));
+    swf_SetU30(c->tag, dict_update(c->pool->strings, s, 0));

 }
 }

-void abc_pushtrue(abc_code_t*c)
+#define pushstring(s) abc_pushstring(abc_code,s)
+void abc_pushtrue(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x26);
 }
 {
     swf_SetU8(c->tag, 0x26);
 }

-void abc_pushuint(abc_code_t*c, int v)
+#define pushtrue() abc_pushtrue(abc_code)
+void abc_pushuint(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x2e);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x2e);
     swf_SetU30(c->tag, v);
 }

-void abc_pushundefined(abc_code_t*c)
+#define pushuint(v) abc_pushuint(abc_code,v)
+void abc_pushundefined(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x21);
 }
 {
     swf_SetU8(c->tag, 0x21);
 }

-void abc_pushwith(abc_code_t*c)
+#define pushundefined() abc_pushundefined(abc_code)
+void abc_pushwith(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x1c);
 }
 {
     swf_SetU8(c->tag, 0x1c);
 }

-void abc_returnvalue(abc_code_t*c)
+#define pushwith() abc_pushwith(abc_code)
+void abc_returnvalue(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x48);
 }
 {
     swf_SetU8(c->tag, 0x48);
 }

-void abc_returnvoid(abc_code_t*c)
+#define returnvalue() abc_returnvalue(abc_code)
+void abc_returnvoid(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x47);
 }
 {
     swf_SetU8(c->tag, 0x47);
 }

-void abc_rshift(abc_code_t*c)
+#define returnvoid() abc_returnvoid(abc_code)
+void abc_rshift(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xa6);
 }
 {
     swf_SetU8(c->tag, 0xa6);
 }

-void abc_setlocal(abc_code_t*c, int v)
+#define rshift() abc_rshift(abc_code)
+void abc_setlocal(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x63);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x63);
     swf_SetU30(c->tag, v);
 }

-void abc_setlocal_0(abc_code_t*c)
+#define setlocal(v) abc_setlocal(abc_code,v)
+void abc_setlocal_0(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xd4);
 }
 {
     swf_SetU8(c->tag, 0xd4);
 }

-void abc_setlocal_1(abc_code_t*c)
+#define setlocal_0() abc_setlocal_0(abc_code)
+void abc_setlocal_1(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xd5);
 }
 {
     swf_SetU8(c->tag, 0xd5);
 }

-void abc_setlocal_2(abc_code_t*c)
+#define setlocal_1() abc_setlocal_1(abc_code)
+void abc_setlocal_2(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xd6);
 }
 {
     swf_SetU8(c->tag, 0xd6);
 }

-void abc_setlocal_3(abc_code_t*c)
+#define setlocal_2() abc_setlocal_2(abc_code)
+void abc_setlocal_3(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xd7);
 }
 {
     swf_SetU8(c->tag, 0xd7);
 }

-void abc_setglobalshot(abc_code_t*c, int v)
+#define setlocal_3() abc_setlocal_3(abc_code)
+void abc_setglobalshot(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x6f);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x6f);
     swf_SetU30(c->tag, v);
 }

-void abc_setproperty(abc_code_t*c, char*name)
+#define setglobalshot(v) abc_setglobalshot(abc_code,v)
+void abc_setproperty(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x61);
 {
     swf_SetU8(c->tag, 0x61);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_setslot(abc_code_t*c, int v)
+#define setproperty(name) abc_setproperty(abc_code,name)
+void abc_setslot(abc_method_body_t*c, int v)

 {
     swf_SetU8(c->tag, 0x6d);
     swf_SetU30(c->tag, v);
 }
 {
     swf_SetU8(c->tag, 0x6d);
     swf_SetU30(c->tag, v);
 }

-void abc_setsuper(abc_code_t*c, char*name)
+#define setslot(v) abc_setslot(abc_code,v)
+void abc_setsuper(abc_method_body_t*c, char* name)

 {
     swf_SetU8(c->tag, 0x05);
 {
     swf_SetU8(c->tag, 0x05);

-    swf_SetU30(c->tag, multiname_index(c->abc, name));
+    swf_SetU30(c->tag, multiname_index(c->pool, name));

 }
 }

-void abc_strictequals(abc_code_t*c)
+#define setsuper(name) abc_setsuper(abc_code,name)
+void abc_strictequals(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xac);
 }
 {
     swf_SetU8(c->tag, 0xac);
 }

-void abc_subtract(abc_code_t*c)
+#define strictequals() abc_strictequals(abc_code)
+void abc_subtract(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xa1);
 }
 {
     swf_SetU8(c->tag, 0xa1);
 }

-void abc_subtract_i(abc_code_t*c)
+#define subtract() abc_subtract(abc_code)
+void abc_subtract_i(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xc6);
 }
 {
     swf_SetU8(c->tag, 0xc6);
 }

-void abc_swap(abc_code_t*c)
+#define subtract_i() abc_subtract_i(abc_code)
+void abc_swap(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x2b);
 }
 {
     swf_SetU8(c->tag, 0x2b);
 }

-void abc_throw(abc_code_t*c)
+#define swap() abc_swap(abc_code)
+void abc_throw(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x03);
 }
 {
     swf_SetU8(c->tag, 0x03);
 }

-void abc_typeof(abc_code_t*c)
+#define throw() abc_throw(abc_code)
+void abc_typeof(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0x95);
 }
 {
     swf_SetU8(c->tag, 0x95);
 }

-void abc_urshift(abc_code_t*c)
+#define typeof() abc_typeof(abc_code)
+void abc_urshift(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xa7);
 }
 {
     swf_SetU8(c->tag, 0xa7);
 }

-void abc_xxx(abc_code_t*c)
+#define urshift() abc_urshift(abc_code)
+void abc_xxx(abc_method_body_t*c)

 {
     swf_SetU8(c->tag, 0xb0);
 }
 {
     swf_SetU8(c->tag, 0xb0);
 }

+#define xxx() abc_xxx(abc_code)