more stub code
[swftools.git] / lib / as3 / pool.h
1 /* pool.h
2
3    Routines for handling Flash2 AVM2 ABC contantpool entries.
4
5    Extension module for the rfxswf library.
6    Part of the swftools package.
7
8    Copyright (c) 2008 Matthias Kramm <kramm@quiss.org>
9  
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
23
24 #ifndef __pool_h__
25 #define __pool_h__
26
27 #include "../q.h"
28 #include "../rfxswf.h"
29
30 DECLARE(pool);
31 DECLARE(constant);
32 DECLARE_LIST(constant);
33 DECLARE(multiname);
34 DECLARE(namespace);
35 DECLARE(namespace_set);
36 DECLARE_LIST(multiname);
37 DECLARE_LIST(namespace);
38 DECLARE_LIST(trait);
39
40 /* abc file constant pool */
41 struct _pool {
42     array_t*x_ints;
43     array_t*x_uints;
44     array_t*x_floats;
45     array_t*x_strings;
46     array_t*x_namespaces;
47     array_t*x_namespace_sets;
48     array_t*x_multinames;
49 };
50
51 typedef enum access_type
52 {ACCESS_STANDARD=0x16,
53  ACCESS_PACKAGE=0x16,
54  ACCESS_PACKAGEINTERNAL=0x17,
55  ACCESS_PROTECTED=0x18,
56  ACCESS_EXPLICIT=0x19,
57  ACCESS_STATICPROTECTED=0x1a,
58  ACCESS_PRIVATE=0x05
59 } access_type_t;
60
61
62 typedef enum constant_type
63 {
64 CONSTANT_STRING=0x01,
65 CONSTANT_INT=0x03,
66 CONSTANT_UINT=0x04,
67 CONSTANT_FLOAT=0x06,
68  
69 CONSTANT_TRUE=0x0B,
70 CONSTANT_FALSE=0x0A,
71 CONSTANT_NULL=0x0C,
72 CONSTANT_UNDEFINED=0x00,
73  
74 CONSTANT_NAMESPACE=0x08,
75 CONSTANT_NAMESPACE_PACKAGE=0x16,
76 CONSTANT_NAMESPACE_PACKAGEINTERNAL=0x17,
77 CONSTANT_NAMESPACE_PROTECTED=0x18,
78 CONSTANT_NAMESPACE_EXPLICIT=0x19,
79 CONSTANT_NAMESPACE_STATICPROTECTED=0x1A,
80 CONSTANT_NAMESPACE_PRIVATE=0x05,
81 } contant_type_t;
82
83 struct _constant {
84     union {
85         double f;
86         int i;
87         unsigned int u;
88         char*s;
89         namespace_t*ns;
90     };
91     int type;
92 };
93
94 constant_t* constant_new_int(int x);
95 constant_t* constant_new_uint(unsigned int x);
96 constant_t* constant_new_float(double x);
97 constant_t* constant_new_string(char*s);
98 constant_t* constant_new_namespace(namespace_t*ns);
99 constant_t* constant_new_true();
100 constant_t* constant_new_false();
101 constant_t* constant_new_null();
102 constant_t* constant_new_undefined();
103 char constant_has_index(constant_t*c);
104 constant_t* constant_fromindex(pool_t*pool, int index, int type);
105 char* constant_tostring(constant_t*c);
106 int constant_get_index(pool_t*pool, constant_t*c);
107 void constant_free(constant_t*c);
108
109 typedef enum multiname_type
110 {QNAME=0x07,
111  RTQNAME=0x0F,
112  RTQNAMEL=0x11,
113  MULTINAME=0x09,
114  MULTINAMEL=0x1B,
115  QNAMEA=0x0D,
116  RTQNAMEA=0x10,
117  RTQNAMELA=0x12,
118  MULTINAMEA=0x0E,
119  MULTINAMELA=0x1C
120 } multiname_type_t;
121
122 char* access2str(int type);
123
124 struct _namespace {
125     U8 access;
126     char*name;
127 };
128 struct _namespace_set {
129     namespace_list_t*namespaces;
130 };
131
132 extern type_t multiname_type;
133 struct _multiname {
134     multiname_type_t type;
135     namespace_t*ns;
136     namespace_set_t*namespace_set;
137     const char*name;
138 };
139
140 /* object -> string */
141 char* namespace_set_tostring(namespace_set_t*set);
142 char* multiname_tostring(multiname_t*m);
143 char* namespace_tostring(namespace_t*ns);
144
145 /* integer -> object */
146 int pool_lookup_int(pool_t*pool, int i);
147 unsigned int pool_lookup_uint(pool_t*pool, int i);
148 double pool_lookup_float(pool_t*pool, int i);
149 char*pool_lookup_string(pool_t*pool, int i);
150 namespace_t*pool_lookup_namespace(pool_t*pool, int i);
151 namespace_set_t*pool_lookup_namespace_set(pool_t*pool, int i);
152 multiname_t*pool_lookup_multiname(pool_t*pool, int i);
153
154 /* object -> integer (lookup) */
155 int pool_find_int(pool_t*pool, int x);
156 int pool_find_uint(pool_t*pool, unsigned int x);
157 int pool_find_double(pool_t*pool, double x);
158 int pool_find_namespace(pool_t*pool, namespace_t*ns);
159 int pool_find_namespace_set(pool_t*pool, namespace_set_t*set);
160 int pool_find_string(pool_t*pool, const char*s);
161 int pool_find_multiname(pool_t*pool, multiname_t*name);
162
163 /* object -> integer (lookup/creation) */
164 int pool_register_int(pool_t*p, int i);
165 int pool_register_uint(pool_t*p, unsigned int i);
166 int pool_register_float(pool_t*p, double d);
167 int pool_register_string(pool_t*pool, const char*s);
168 int pool_register_namespace(pool_t*pool, namespace_t*ns);
169 int pool_register_namespace_set(pool_t*pool, namespace_set_t*set);
170 int pool_register_multiname(pool_t*pool, multiname_t*n);
171 int pool_register_multiname2(pool_t*pool, char*name);
172
173 /* creation */
174 namespace_t* namespace_new(U8 access, const char*name);
175 namespace_t* namespace_new_package(const char*name);
176 namespace_t* namespace_new_packageinternal(const char*name);
177 namespace_t* namespace_new_protected(const char*name);
178 namespace_t* namespace_new_explicit(const char*name);
179 namespace_t* namespace_new_staticprotected(const char*name);
180 namespace_t* namespace_new_private(const char*name);
181 namespace_t* namespace_clone(namespace_t*ns);
182
183 namespace_t* namespace_fromstring(const char*name);
184
185 multiname_t* multiname_fromstring(const char*name);
186 multiname_t* multiname_new(namespace_t*ns, const char*name);
187 multiname_t* multiname_clone(multiname_t*other);
188
189 /* accessors etc. */
190 char multiname_late_namespace(multiname_t*m);
191 char multiname_late_name(multiname_t*m);
192
193 /* freeing */
194 void multiname_destroy(multiname_t*m);
195 void namespace_destroy(namespace_t*n);
196
197 /* pool constructors/destructors */
198 pool_t*pool_new();
199 void pool_read(pool_t*pool, TAG*tag);
200 void pool_write(pool_t*pool, TAG*tag);
201 void pool_destroy(pool_t*pool);
202
203 #endif