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