ignore unknown escape sequences
[swftools.git] / lib / as3 / mklib.c
1 /* code.c
2
3    File to generate builtin.c
4
5    Copyright (c) 2008 Matthias Kramm <kramm@quiss.org>
6  
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
20
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <unistd.h>
24 #include <memory.h>
25 #include "../rfxswf.h"
26 #include "../os.h"
27 #include "../q.h"
28 #include "pool.h"
29 #include "files.h"
30 #include "tokenizer.h"
31 #include "parser.tab.h"
32 #include "parser.h"
33 #include "import.h"
34
35 void fixstring(char*s)
36 {
37     char first=1;
38     for(;*s;s++) {
39         if(!((*s>='a' && *s<='z') || (*s>='A' && *s<='Z') || 
40                     (*s>='0' && *s<='9' && !first))) {
41             *s = '_';
42         }
43         first = 0;
44     }
45 }
46
47 static char* mkpid(const char*package)
48 {
49     char*id = malloc(strlen(package)+20);
50     strcpy(id, "package_");
51     if(!*package) 
52         strcat(id, "global");
53     else
54         strcat(id, package);
55     fixstring(id);
56     return id;
57 }
58 static char* mkcid(const char*package, const char*name)
59 {
60     char*id = malloc(strlen(package)+strlen(name)+10);
61     strcpy(id, package);
62     strcat(id, "_");
63     strcat(id, name);
64     fixstring(id);
65     return id;
66 }
67 static char* mkptr2(const char*package, const char*name)
68 {
69     char*id = malloc(strlen(package)+strlen(name)+10);
70     strcpy(id, "&");
71     strcat(id, package);
72     strcat(id, "_");
73     strcat(id, name);
74     fixstring(id+1);
75     return id;
76 }
77 static char* mkid2(const char*cls, const char*member)
78 {
79     char*id = malloc(strlen(cls)+strlen(member)+10);
80     strcpy(id, cls);
81     strcat(id, "_");
82     strcat(id, member);
83     fixstring(id);
84     return id;
85 }
86 #define mkid(s) ((s)?mkcid((s)->package, (s)->name):"0")
87 #define mkptr(s) ((s)?mkptr2((s)->package, (s)->name):"0")
88
89 static array_t*tosort=0;
90 static int compare_classes(const void*v1, const void*v2)
91 {
92     int x1 = *(int*)v1;
93     int x2 = *(int*)v2;
94     abc_class_t*c1 = array_getvalue(tosort, x1);
95     abc_class_t*c2 = array_getvalue(tosort, x2);
96     int i = strcmp(c1->classname->ns->name, c2->classname->ns->name);
97     if(i)
98         return i;
99     return strcmp(c1->classname->name, c2->classname->name);
100 }
101
102 static int compare_traits(const void*v1, const void*v2)
103 {
104     trait_t* x1 = *(trait_t**)v1;
105     trait_t* x2 = *(trait_t**)v2;
106     int i = strcmp(x1->name->ns->name, x2->name->ns->name);
107     if(i)
108         return i;
109     return strcmp(x1->name->name, x2->name->name);
110 }
111
112 dict_t* builtin_getclasses()
113 {
114     return dict_new2(&slotinfo_type);
115 }
116
117 extern dict_t*registry_classes;
118
119 char*mktype(slotinfo_t*s) 
120 {
121     if(s->kind == INFOTYPE_CLASS) {
122         return "classinfo_t";
123     } else if(s->kind == INFOTYPE_METHOD) {
124         return "methodinfo_t";
125     } else if(s->kind == INFOTYPE_SLOT) {
126         return "varinfo_t";
127     }
128 }
129
130 void write_slotinfo(FILE*fi, slotinfo_t*s, char*id, char*prefix);
131
132 void write_slotinfo_decl(FILE*fi, slotinfo_t*s, char*prefix)
133 {
134     fprintf(fi, "%s", prefix);
135     char*id = mkid(s);
136     fprintf(fi, "static %s %s;\n", mktype(s), id);
137
138     if(s->kind == INFOTYPE_CLASS) {
139         classinfo_t*c = (classinfo_t*)s;
140         dict_t*d = &c->members;
141         int t;
142         for(t=0;t<d->hashsize;t++) {
143             dictentry_t*l = d->slots[t];
144             while(l) {
145                 slotinfo_t*s2 = (slotinfo_t*)l->data;
146                 fprintf(fi, "static %s %s;\n", mktype(s2), mkid2(id, s2->name));
147                 l = l->next;
148             }
149         }
150     }
151 }
152 void write_initinfo(FILE*fi, slotinfo_t*s, char*prefix)
153 {
154     if(s->kind == INFOTYPE_CLASS) {
155         classinfo_t*c = (classinfo_t*)s;
156         fprintf(fi, "%s", prefix);
157         char*id = mkid(c);
158         dict_t*d = &c->members;
159         fprintf(fi, "dict_init2(&%s.members, &slotinfo_type, %d);\n", id, d->hashsize);
160         int t;
161         for(t=0;t<d->hashsize;t++) {
162             dictentry_t*l = d->slots[t];
163             while(l) {
164                 slotinfo_t*s2 = (slotinfo_t*)l->data;
165                 fprintf(fi, "%s", prefix);
166                 char*id2 = mkid2(id, s2->name);
167                 fprintf(fi, "dict_put(&%s.members, &%s, &%s);\n", id, id2,id2);
168                 l = l->next;
169             }
170         }
171     }
172 }
173 void write_slotinfo(FILE*fi, slotinfo_t*s, char*id, char*prefix)
174 {
175     fprintf(fi, "%s", prefix);
176     fprintf(fi, "static %s %s = {", mktype(s), id);
177     fprintf(fi, "0x%02x, 0x%02x, 0x%02x, 0x%02x, ", s->kind, s->subtype, s->flags, s->access);
178     if(s->package)
179         fprintf(fi, "\"%s\", ", s->package);
180     else
181         fprintf(fi, "0, ");
182     
183     if(s->name)
184         fprintf(fi, "\"%s\", ", s->name);
185     else
186         fprintf(fi, "0, ");
187
188     fprintf(fi, "%d, ", s->slot);
189
190     if(s->kind == INFOTYPE_CLASS) {
191         classinfo_t*c = (classinfo_t*)s;
192         fprintf(fi, "%s, ", mkptr(c->superclass));
193         fprintf(fi, "interfaces: {");
194         int t;
195         for(t=0;c->interfaces[t];t++) {
196             fprintf(fi, "%s", mkptr(c->interfaces[t]));
197             fprintf(fi, ", ");
198         }
199         fprintf(fi, "0}};\n");
200     }
201     if(s->kind == INFOTYPE_METHOD) {
202         methodinfo_t*m = (methodinfo_t*)s;
203         fprintf(fi, "%s, ", mkptr(m->return_type));
204         fprintf(fi, "%s, ", mkptr(m->parent));
205         fprintf(fi, "0"); // params TODO
206         fprintf(fi, "};\n");
207     }
208     if(s->kind == INFOTYPE_SLOT) {
209         varinfo_t*m = (varinfo_t*)s;
210         fprintf(fi, "%s, ", mkptr(m->type));
211         fprintf(fi, "%s, ", mkptr(m->parent));
212         fprintf(fi, "0"); // value TODO
213         fprintf(fi, "};\n");
214     }
215     
216     if(s->kind == INFOTYPE_CLASS) {
217         classinfo_t*c = (classinfo_t*)s;
218         dict_t*d = &c->members;
219         int t;
220         for(t=0;t<d->hashsize;t++) {
221             dictentry_t*l = d->slots[t];
222             while(l) {
223                 slotinfo_t*s2 = (slotinfo_t*)l->data;
224                 write_slotinfo(fi, s2, mkid2(id,s2->name), prefix);
225                 l = l->next;
226             }
227         }
228     }
229 }
230
231 int main()
232 {
233     registry_classes = builtin_getclasses();
234
235     as3_import_abc("/home/kramm/c/swftools/lib/as3/builtin.abc");
236     as3_import_abc("/home/kramm/c/swftools/lib/as3/playerglobal.abc");
237
238     FILE*fi = fopen("builtin.c", "wb");
239
240     int t;
241     int pass;
242
243
244     for(pass=1;pass<=3;pass++) {
245         if(pass==1) {
246             fprintf(fi, "#include \"builtin.h\"\n");
247             fprintf(fi, "\n");
248         }
249         if(pass==3) {
250             fprintf(fi, "dict_t* builtin_getclasses()\n");
251             fprintf(fi, "{\n");
252             fprintf(fi, "    dict_t*d = dict_new2(&slotinfo_type);\n");
253         }
254         for(t=0;t<registry_classes->hashsize;t++) {
255             dictentry_t*l = registry_classes->slots[t];
256             while(l) {
257                 slotinfo_t*s = (slotinfo_t*)l->key;
258                 //printf("%08x %s %s\n", s, s->package, s->name);
259                 char*id = mkid(s);
260                 if(pass==1) {
261                     write_slotinfo_decl(fi, s, "");
262                 }
263                 if(pass==2) {
264                     write_slotinfo(fi, s, mkid(s), "");
265                 }
266                 if(pass==3) {
267                     fprintf(fi, "    dict_put(d, &%s, &%s);\n", id, id);
268                     write_initinfo(fi, s, "    ");
269                 }
270                 l = l->next;
271             }
272         }
273     }
274     fprintf(fi, "    return d;\n");
275     fprintf(fi, "}\n");
276
277 }