36bb1fac565b0da3a70fa9b2af1ba272aade847b
[swftools.git] / lib / as3 / compiler.c
1 /* compiler.h
2
3    Compiler for parsing Flash2 AVM2 ABC Actionscript
4
5    Extension module for the rfxswf library.
6    Part of the swftools package.
7
8    Copyright (c) 2008/2009 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 "tokenizer.h"
25 #include "files.h"
26 #include "parser.h"
27 #include "parser.tab.h"
28 #include "compiler.h"
29 #include "../os.h"
30 #ifdef HAVE_SYS_STAT_H
31 #include <sys/stat.h>
32 #endif
33 #ifdef HAVE_DIRENT_H
34 #include <dirent.h>
35 #endif
36
37 /* flex/bison definitions */
38 extern int a3_parse();
39 extern int as3_lex();
40 extern int as3_lex_destroy();
41
42 void as3_setverbosity(int level)
43 {
44     as3_verbosity=level;
45 }
46 void as3_add_include_dir(char*dir)
47 {
48     add_include_dir(dir);
49 }
50
51 static char registry_initialized = 0;
52 static char parser_initialized = 0;
53
54 //#define STORE_TOKENS
55
56 //#define DEBUG
57 #define DEBUG if(0)
58
59 int a3_lex()
60 {
61     as3_tokencount++;
62     return as3_lex();
63 }
64
65 typedef struct _compile_list {
66     const char*name;
67     const char*filename;
68     struct _compile_list*next;
69 } compile_list_t;
70 static compile_list_t*compile_list=0;
71
72 static void as3_parse_file_or_array(const char*name, const char*filename, const void*mem, int length)
73 {
74     if(!registry_initialized) {
75         registry_initialized = 1;
76         registry_init();
77     }
78     if(!parser_initialized) {
79         parser_initialized = 1;
80         initialize_parser();
81     }
82
83     FILE*fi = 0;
84     if(filename) {
85         if(as3_pass==1 && !mem) {
86             // record the fact that we compiled this file
87             compile_list_t*c = rfx_calloc(sizeof(compile_list_t));
88             c->next = compile_list;
89             c->name = strdup(name);
90             c->filename = strdup(filename);
91             compile_list = c;
92         }
93         DEBUG printf("[pass %d] parse file %s %s\n", as3_pass, name, filename);
94         fi = enter_file2(name, filename, 0);
95         as3_file_input(fi);
96     } else {
97         DEBUG printf("[pass %d] parse bytearray %s (%d bytes)\n", as3_pass, name, length);
98         enter_file(name, name, 0);
99         as3_buffer_input((void*)mem, length);
100     }
101
102     as3_tokencount=0;
103     initialize_file(name, filename);
104     a3_parse();
105     as3_lex_destroy();
106     finish_file();
107 }
108
109 typedef struct _scheduled_file {
110     char*name;
111     char*filename;
112     struct _scheduled_file*next;
113 } scheduled_file_t;
114
115 static scheduled_file_t*scheduled=0;
116 dict_t*scheduled_dict=0;
117
118 void as3_parse_scheduled()
119 {
120     DEBUG printf("[pass %d] parse scheduled\n", as3_pass);
121
122     while(scheduled) {
123         scheduled_file_t*s = scheduled;
124         scheduled = 0;
125         while(s) {
126             scheduled_file_t*old = s;
127             as3_parse_file_or_array(s->name, s->filename, 0,0);
128             s = s->next;
129
130             free(old->filename);
131             free(old->name);
132             old->filename = old->name = 0;
133             free(old);
134         }
135     }
136     if(scheduled_dict) {
137         dict_destroy(scheduled_dict);
138         scheduled_dict=0;
139     }
140 }
141
142 void as3_schedule_file(const char*name, const char*filename) 
143 {
144     if(!scheduled_dict) {
145         scheduled_dict = dict_new();
146     }
147
148     filename = normalize_path(filename);
149     
150     if(dict_contains(scheduled_dict, filename)) {
151         return; //already processed
152     } else {
153         dict_put(scheduled_dict, filename, 0);
154     }
155     DEBUG printf("[pass %d] schedule %s %s\n", as3_pass, name, filename);
156
157     NEW(scheduled_file_t, f);
158     f->name = strdup(name);
159     f->filename = strdup(filename);
160     f->next = scheduled; // dfs
161     scheduled = f;
162 }
163
164 void as3_parse_list()
165 {
166     while(compile_list) {
167         as3_parse_file_or_array(compile_list->name, compile_list->filename, 0,0);
168         compile_list = compile_list->next;
169     }
170 }
171
172 void as3_parse_bytearray(const char*name, const void*mem, int length)
173 {
174     as3_pass = 1;
175     as3_parse_file_or_array(name, 0, mem, length);
176     as3_parse_scheduled();
177     
178     registry_resolve_all();
179     
180     as3_pass = 2;
181     as3_parse_file_or_array(name, 0, mem, length);
182     as3_parse_list();
183 }
184
185 void as3_parse_file(const char*filename) 
186 {
187     char*fullfilename = find_file(filename, 1);
188     if(!fullfilename)
189         return; // not found
190
191     compile_list = 0;
192     as3_pass = 1;
193     as3_parse_file_or_array(filename, fullfilename, 0,0);
194     as3_parse_scheduled();
195     
196     registry_resolve_all();
197
198     as3_pass = 2;
199     as3_parse_list();
200
201     free(fullfilename);
202 }
203
204 void as3_parse_directory(const char*dir)
205 {
206     compile_list = 0;
207
208     as3_pass = 1;
209     as3_schedule_directory(dir);
210     if(!scheduled)
211         as3_warning("Directory %s doesn't contain any ActionScript files", dir);
212     as3_parse_scheduled();
213
214     registry_resolve_all();
215
216     as3_pass = 2;
217     as3_parse_list();
218 }
219
220 char as3_schedule_directory(const char*dirname)
221 {
222     DEBUG printf("[pass %d] schedule directory %s\n", as3_pass, dirname);
223     char ok=0;
224 #ifdef HAVE_DIRENT_H
225     include_dir_t*i = current_include_dirs;
226     while(i) {
227         char*fulldirname = concat_paths(i->path, dirname);
228         DEBUG printf("[pass %d] ... %s\n", as3_pass, fulldirname);
229         DIR*dir = opendir(fulldirname);
230         if(dir) {
231             ok = 1;
232             struct dirent*ent;
233             while(1) {
234                 ent = readdir(dir);
235                 if (!ent) 
236                     break;
237                 char*name = ent->d_name;
238                 char type = 0;
239                 if(!name) continue;
240                 int l=strlen(name);
241                 if(l<4)
242                     continue;
243                 if(strncasecmp(&name[l-3], ".as", 3)) 
244                     continue;
245                 char*fullfilename = concatPaths(fulldirname, name);
246                 as3_schedule_file(name, fullfilename);
247                 free(fullfilename);
248             }
249         }
250         free(fulldirname);
251         i = i->next;
252     }
253 #endif
254     return ok;
255 }
256
257 void as3_schedule_package(const char*package)
258 {
259     DEBUG printf("[pass %d] schedule package %s\n", as3_pass, package);
260     char*dirname = strdup(package);
261     int s=0;
262     while(dirname[s]) {
263         if(dirname[s]=='.') dirname[s]='/';
264         s++;
265     };
266     if(!as3_schedule_directory(dirname))
267         as3_softwarning("Could not find package %s in file system", package);
268 }
269
270 static void schedule_class(const char*package, const char*cls, char error)
271 {
272     if(error) {
273         DEBUG printf("[pass %d] schedule class %s.%s\n",  as3_pass, package, cls);
274     }
275     if(!cls) {
276         as3_schedule_package(package);
277         return;
278     }
279     int l1 = package?strlen(package):0;
280     int l2 = cls?strlen(cls):0;
281     char*filename = malloc(l1+l2+5);
282     int s=0,t=0;
283     while(package[s]) {
284         if(package[s]=='.')
285             filename[t++]='/';
286         else
287             filename[t++] = package[s];
288         s++;
289     }
290     if(t)
291         filename[t++] = '/';
292
293     strcpy(filename+t, cls);
294     strcpy(filename+t+l2, ".as");
295     char*f=0;
296     if(!(f=find_file(filename, error))) {
297         int i;
298         /* try lower case filename (not packagename!), too */
299         for(i=t;i<t+l2;i++) {
300             if(filename[i]>='A' && filename[i]<='Z')
301                 filename[i] += 'a'-'A';
302         }
303         if(!(f=find_file(filename, error))) {
304             if(error) {
305                 strcpy(filename+t, cls);
306                 strcpy(filename+t+l2, ".as");
307                 as3_warning("Could not open file %s", filename);
308             }
309             return;
310         }
311     }
312     as3_schedule_file(filename, f);
313 }
314
315 void as3_schedule_class(const char*package, const char*cls)
316 {
317     schedule_class(package, cls, 1);
318 }
319
320 void as3_schedule_class_noerror(const char*package, const char*cls)
321 {
322     schedule_class(package, cls, 0);
323 }
324
325
326 static void*as3code = 0;
327 void* as3_getcode()
328 {
329     if(parser_initialized) {
330         parser_initialized = 0;
331         as3code = finish_parser();
332     }
333     return as3code;
334 }
335 char* as3_getglobalclass()
336 {
337     return as3_globalclass;
338 }
339
340 void as3_destroy() 
341 {
342     if(parser_initialized) {
343         parser_initialized = 0;
344         swf_FreeABC(finish_parser());
345 #ifdef STORE_TOKENS
346         mem_clear(&tokens);
347 #endif
348     }
349     if(as3_globalclass) {
350         free(as3_globalclass);as3_globalclass=0;
351     }
352 }
353