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_PUBLIC=0x16,
  55  ACCESS_PACKAGEINTERNAL=0x17,
  56  ACCESS_PROTECTED=0x18,
  57  ACCESS_EXPLICIT=0x19,
  58  ACCESS_STATICPROTECTED=0x1a,
  59  ACCESS_PRIVATE=0x05,
  60  ACCESS_NAMESPACE=0x08
  61 } access_type_t;
  62
  63
  64 typedef enum constant_type
  65 {
  66 CONSTANT_STRING=0x01,
  67 CONSTANT_INT=0x03,
  68 CONSTANT_UINT=0x04,
  69 CONSTANT_FLOAT=0x06,
  70
  71 CONSTANT_TRUE=0x0B,
  72 CONSTANT_FALSE=0x0A,
  73 CONSTANT_NULL=0x0C,
  74 CONSTANT_UNDEFINED=0x00,
  75
  76 CONSTANT_NAMESPACE=0x08,
  77 CONSTANT_NAMESPACE_PACKAGE=0x16,
  78 CONSTANT_NAMESPACE_PACKAGEINTERNAL=0x17,
  79 CONSTANT_NAMESPACE_PROTECTED=0x18,
  80 CONSTANT_NAMESPACE_EXPLICIT=0x19,
  81 CONSTANT_NAMESPACE_STATICPROTECTED=0x1A,
  82 CONSTANT_NAMESPACE_PRIVATE=0x05,
  83 CONSTANT_UNKNOWN=0x55, /*used internally */
  84 } contant_type_t;
  85
  86 #define NS_TYPE(x) ((x) == 0x08 || (x) == 0x16 || (x) == 0x17 || (x) == 0x18 || (x) == 0x19 || (x) == 0x1a || (x) == 0x05)
  87
  88 struct _constant {
  89     int type;
  90     union {
  91         string_t* s;
  92         namespace_t*ns;
  93         double f;
  94         int i;
  95         unsigned int u;
  96     };
  97 };
  98
  99 constant_t* constant_clone();
 100 constant_t* constant_new_int(int x);
 101 constant_t* constant_new_uint(unsigned int x);
 102 constant_t* constant_new_float(double x);
 103 constant_t* constant_new_string(char*s);
 104 constant_t* constant_new_string2(const char*s, int len);
 105 constant_t* constant_new_namespace(namespace_t*ns);
 106 constant_t* constant_new_true();
 107 constant_t* constant_new_false();
 108 constant_t* constant_new_null();
 109 constant_t* constant_new_undefined();
 110 char constant_has_index(constant_t*c);
 111 constant_t* constant_fromindex(pool_t*pool, int index, int type);
 112 char* constant_tostring(constant_t*c);
 113 int constant_get_index(pool_t*pool, constant_t*c);
 114 void constant_free(constant_t*c);
 115
 116 typedef enum multiname_type
 117 {QNAME=0x07,
 118  RTQNAME=0x0F,
 119  RTQNAMEL=0x11,
 120  MULTINAME=0x09,
 121  MULTINAMEL=0x1B,
 122  QNAMEA=0x0D,
 123  RTQNAMEA=0x10,
 124  RTQNAMELA=0x12,
 125  MULTINAMEA=0x0E,
 126  MULTINAMELA=0x1C,
 127  POSTFIXTYPE=0x1D
 128 } multiname_type_t;
 129
 130 char* access2str(int type);
 131
 132 struct _namespace {
 133     U8 access;
 134     const char*name;
 135 };
 136 struct _namespace_set {
 137     namespace_list_t*namespaces;
 138 };
 139
 140 extern type_t multiname_type;
 141 struct _multiname {
 142     multiname_type_t type;
 143     namespace_t*ns;
 144     namespace_set_t*namespace_set;
 145     const char*name;
 146 };
 147
 148 /* object -> string */
 149 char* namespace_set_tostring(namespace_set_t*set);
 150 char* multiname_tostring(multiname_t*m);
 151 char* namespace_tostring(namespace_t*ns);
 152
 153 /* integer -> object */
 154 int pool_lookup_int(pool_t*pool, int i);
 155 unsigned int pool_lookup_uint(pool_t*pool, int i);
 156 double pool_lookup_float(pool_t*pool, int i);
 157 const char*pool_lookup_string(pool_t*pool, int i);
 158 string_t pool_lookup_string2(pool_t*pool, int i);
 159 namespace_t*pool_lookup_namespace(pool_t*pool, int i);
 160 namespace_set_t*pool_lookup_namespace_set(pool_t*pool, int i);
 161 multiname_t*pool_lookup_multiname(pool_t*pool, int i);
 162
 163 /* object -> integer (lookup) */
 164 int pool_find_int(pool_t*pool, int x);
 165 int pool_find_uint(pool_t*pool, unsigned int x);
 166 int pool_find_double(pool_t*pool, double x);
 167 int pool_find_namespace(pool_t*pool, namespace_t*ns);
 168 int pool_find_namespace_set(pool_t*pool, namespace_set_t*set);
 169 int pool_find_string(pool_t*pool, const char*s);
 170 int pool_find_multiname(pool_t*pool, multiname_t*name);
 171
 172 /* object -> integer (lookup/creation) */
 173 int pool_register_int(pool_t*p, int i);
 174 int pool_register_uint(pool_t*p, unsigned int i);
 175 int pool_register_float(pool_t*p, double d);
 176 int pool_register_string(pool_t*pool, const char*s);
 177 int pool_register_string2(pool_t*pool, string_t*s);
 178 int pool_register_namespace(pool_t*pool, namespace_t*ns);
 179 int pool_register_namespace_set(pool_t*pool, namespace_set_t*set);
 180 int pool_register_multiname(pool_t*pool, multiname_t*n);
 181 int pool_register_multiname2(pool_t*pool, char*name);
 182
 183 /* creation */
 184 namespace_t* namespace_new(U8 access, const char*name);
 185 namespace_t* namespace_new_namespace(const char*name);
 186 namespace_t* namespace_new_package(const char*name);
 187 namespace_t* namespace_new_packageinternal(const char*name);
 188 namespace_t* namespace_new_protected(const char*name);
 189 namespace_t* namespace_new_explicit(const char*name);
 190 namespace_t* namespace_new_staticprotected(const char*name);
 191 namespace_t* namespace_new_private(const char*name);
 192 namespace_t* namespace_clone(namespace_t*ns);
 193
 194 namespace_t* namespace_fromstring(const char*name);
 195
 196 multiname_t* multiname_fromstring(const char*name);
 197 multiname_t* multiname_new(namespace_t*ns, const char*name);
 198 multiname_t* multiname_clone(multiname_t*other);
 199
 200 /* accessors etc. */
 201 char multiname_late_namespace(multiname_t*m);
 202 char multiname_late_name(multiname_t*m);
 203
 204 /* freeing */
 205 void multiname_destroy(multiname_t*m);
 206 void namespace_destroy(namespace_t*n);
 207
 208 /* pool constructors/destructors */
 209 pool_t*pool_new();
 210 void pool_optimize();
 211 void pool_read(pool_t*pool, TAG*tag);
 212 void pool_write(pool_t*pool, TAG*tag);
 213 void pool_destroy(pool_t*pool);
 214 void pool_dump(pool_t*pool, FILE*fo, char flags);
 215
 216 #endif