new functions getfunctionclass() isfunctionclass()
[swftools.git] / lib / as3 / registry.c
1 /* registry.c
2
3    Routines for compiling Flash2 AVM2 ABC Actionscript
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 #include <assert.h>
25 #include "pool.h"
26 #include "registry.h"
27 #include "builtin.h"
28
29 static dict_t*classes=0;
30
31 // ----------------------- class signature ------------------------------
32
33 char classinfo_equals(classinfo_t*c1, classinfo_t*c2)
34 {
35     if(!!c1 != !!c2)
36         return 0;
37     /* notice: access right is *not* respected */
38     if(!strcmp(c1->name, c2->name) &&
39        !strcmp(c1->package, c2->package)) {
40         return 1;
41     }
42     return 0;
43 }
44 static unsigned int classinfo_hash(classinfo_t*c)
45 {
46     unsigned int hash = 0;
47     hash = crc32_add_string(hash, c->package);
48     hash = crc32_add_string(hash, c->name);
49     return hash;
50 }
51
52 static void* dummy_clone(void*other) {return other;}
53 static void dummy_destroy(classinfo_t*c) {}
54
55 type_t classinfo_type = {
56     hash: (hash_func)classinfo_hash,
57     equals: (equals_func)classinfo_equals,
58     /* all signatures are static */
59     dup: (dup_func)dummy_clone,
60     free: (free_func)dummy_destroy,
61 };
62
63 // ----------------------- function signature ------------------------------
64
65 static char memberinfo_equals(memberinfo_t*f1, memberinfo_t*f2)
66 {
67     return !strcmp(f1->name, f2->name);
68 }
69 static unsigned int memberinfo_hash(memberinfo_t*f)
70 {
71     return crc32_add_string(0, f->name);
72 }
73 type_t memberinfo_type = {
74     hash: (hash_func)memberinfo_hash,
75     equals: (equals_func)memberinfo_equals,
76     /* all signatures are static */
77     dup: (dup_func)dummy_clone,
78     free: (free_func)dummy_destroy,
79 };
80
81 // ------------------------- constructors --------------------------------
82
83 #define AVERAGE_NUMBER_OF_MEMBERS 8
84 classinfo_t* classinfo_register(int access, char*package, char*name)
85 {
86     NEW(classinfo_t,c);
87     c->access = access;
88     c->package = package;
89     c->name = name;
90     dict_put(classes, c, c);
91     dict_init(&c->members,AVERAGE_NUMBER_OF_MEMBERS);
92     return c;
93 }
94
95 /* function pointers get their own type class */
96 static dict_t* functionobjects = 0;
97 classinfo_t* registry_getfunctionclass(memberinfo_t*f) {
98     if(!functionobjects) {
99         functionobjects = dict_new2(&ptr_type);
100     } else {
101         classinfo_t*c = dict_lookup(functionobjects, f);
102         if(c)
103             return c;
104     }
105
106     NEW(classinfo_t,c);
107     c->access = ACCESS_PUBLIC;
108     c->package = "";
109     c->name = "Function";
110     dict_init(&c->members,1);
111     dict_put(&c->members, "__funcptr__", f);
112
113     dict_put(functionobjects, f, c);
114     return c;
115 }
116
117 memberinfo_t* memberinfo_register(classinfo_t*cls, const char*name, U8 kind)
118 {
119     NEW(memberinfo_t,m);
120     m->kind = kind;
121     m->name = strdup(name);
122     dict_put(&cls->members, name, m);
123     return m;
124 }
125
126 // --------------- builtin classes (from builtin.c) ----------------------
127
128 void registry_init()
129 {
130     classes = builtin_getclasses();
131 }
132 classinfo_t* registry_safefindclass(const char*package, const char*name)
133 {
134     classinfo_t*c = registry_findclass(package, name);
135     assert(c);
136     return c;
137 }
138 classinfo_t* registry_findclass(const char*package, const char*name)
139 {
140     assert(classes);
141     classinfo_t tmp;
142     tmp.package = package;
143     tmp.name = name;
144     classinfo_t* c = (classinfo_t*)dict_lookup(classes, &tmp);
145     /*if(c)
146         printf("%s.%s->%08x (%s.%s)\n", package, name, c, c->package, c->name);*/
147     return c;
148 }
149 memberinfo_t* registry_findmember(classinfo_t*cls, const char*name)
150 {
151     return (memberinfo_t*)dict_lookup(&cls->members, name);
152 }
153 void registry_fill_multiname(multiname_t*m, namespace_t*n, classinfo_t*c)
154 {
155     m->type = QNAME;
156     m->ns = n;
157     m->ns->access = c->access;
158     m->ns->name = (char*)c->package;
159     m->name = c->name;
160     m->namespace_set = 0;
161 }
162 multiname_t* classinfo_to_multiname(classinfo_t*cls)
163 {
164     if(!cls)
165         return 0;
166     multiname_t*m=0;
167     namespace_t*ns = namespace_new(cls->access, cls->package);
168     return multiname_new(ns,cls->name);
169 }
170
171 // ----------------------- builtin types ------------------------------
172 classinfo_t* registry_getanytype() {return 0;}
173
174 char registry_isfunctionclass(classinfo_t*c) {
175     return (c && c->package && c->name && 
176             !strcmp(c->package, "") && !strcmp(c->name, "Function"));
177 }
178
179 classinfo_t* registry_getobjectclass() {
180     static classinfo_t*c = 0;
181     if(!c) c = registry_safefindclass("", "Object");
182     return c;
183 }
184 classinfo_t* registry_getstringclass() {
185     static classinfo_t*c = 0;
186     if(!c) c = registry_safefindclass("", "String");
187     return c;
188 }
189 classinfo_t* registry_getintclass() {
190     static classinfo_t*c = 0;
191     if(!c) c = registry_safefindclass("", "int");
192     return c;
193 }
194 classinfo_t* registry_getuintclass() {
195     static classinfo_t*c = 0;
196     if(!c) c = registry_safefindclass("", "uint");
197     return c;
198 }
199 classinfo_t* registry_getbooleanclass() {
200     static classinfo_t*c = 0;
201     if(!c) c = registry_safefindclass("", "Boolean");
202     return c;
203 }
204 classinfo_t* registry_getnumberclass() {
205     static classinfo_t*c = 0;
206     if(!c) c = registry_safefindclass("", "Number");
207     return c;
208 }
209 classinfo_t* registry_getMovieClip() {
210     static classinfo_t*c = 0;
211     if(!c) c = registry_safefindclass("flash.display", "MovieClip");
212     return c;
213 }
214
215 // ----------------------- builtin dummy types -------------------------
216 classinfo_t nullclass = {
217     ACCESS_PACKAGE, 0, "", "null", 0, 0, 0,
218 };
219 classinfo_t* registry_getnullclass() {
220     return &nullclass;
221 }
222