added detection for functions which need activation objects
[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 #ifdef STORE_TOKENS
60 static mem_t tokens;
61 #endif
62
63 int a3_lex()
64 {
65     as3_tokencount++;
66 #ifdef STORE_TOKENS
67     if(as3_pass==1) {
68         int token = as3_lex();
69         /* FIXME: current_file needs to be stored, too */
70         mem_put(&tokens, &token, sizeof(token));
71         mem_put(&tokens, &a3_lval, sizeof(a3_lval));
72         mem_put(&tokens, &current_line, sizeof(current_line));
73         mem_put(&tokens, &current_column, sizeof(current_column));
74         return token;
75     } else {
76         int token;
77         mem_get(&tokens, &token, sizeof(token));
78         mem_get(&tokens, &a3_lval, sizeof(a3_lval));
79         mem_get(&tokens, &current_line, sizeof(current_line));
80         mem_get(&tokens, &current_column, sizeof(current_column));
81         return token;
82     }
83 #else
84     return as3_lex();
85 #endif
86 }
87
88 static void as3_parse_file_or_array(int pass, const char*name, const char*filename, void*mem, int length)
89 {
90     if(!registry_initialized) {
91         registry_initialized = 1;
92         registry_init();
93     }
94     if(!parser_initialized) {
95         parser_initialized = 1;
96         initialize_parser();
97 #if defined(STORE_TOKENS)
98         mem_init(&tokens);
99 #endif
100     }
101     as3_pass=pass;
102
103     FILE*fi = 0;
104     if(filename) {
105         DEBUG printf("[pass %d] parse file %s %s\n", pass, name, filename);
106         fi = enter_file2(name, filename, 0);
107         as3_file_input(fi);
108     } else {
109         DEBUG printf("[pass %d] parse bytearray %s (%d bytes)\n", pass, name, length);
110         enter_file(name, name, 0);
111         as3_buffer_input(mem, length);
112     }
113
114     as3_tokencount=0;
115     initialize_file(name, filename);
116     a3_parse();
117     as3_lex_destroy();
118     finish_file();
119 }
120
121 typedef struct _scheduled_file {
122     char*name;
123     char*filename;
124     struct _scheduled_file*next;
125 } scheduled_file_t;
126
127 static scheduled_file_t*scheduled=0;
128 dict_t*scheduled_dict=0;
129
130 void as3_parse_scheduled(int pass)
131 {
132     DEBUG printf("[pass %d] parse scheduled\n", pass);
133
134     while(scheduled) {
135         scheduled_file_t*s = scheduled;
136         scheduled = 0;
137         while(s) {
138             scheduled_file_t*old = s;
139             as3_parse_file_or_array(pass, s->name, s->filename, 0,0);
140             s = s->next;
141
142             free(old->filename);
143             free(old->name);
144             old->filename = old->name = 0;
145             free(old);
146         }
147     }
148     if(scheduled_dict) {
149         dict_destroy(scheduled_dict);
150         scheduled_dict=0;
151     }
152 }
153
154 void as3_schedule_file(const char*name, const char*filename) 
155 {
156     if(!scheduled_dict) {
157         scheduled_dict = dict_new();
158     }
159
160     filename = normalize_path(filename);
161     
162     if(dict_contains(scheduled_dict, filename)) {
163         return; //already processed
164     } else {
165         dict_put(scheduled_dict, filename, 0);
166     }
167     DEBUG printf("[pass %d] schedule %s %s\n", as3_pass, name, filename);
168
169     NEW(scheduled_file_t, f);
170     f->name = strdup(name);
171     f->filename = strdup(filename);
172     f->next = scheduled; // dfs
173     scheduled = f;
174 }
175
176 void as3_parse_bytearray(const char*name, void*mem, int length)
177 {
178     as3_parse_file_or_array(1, name, 0, mem, length);
179     as3_parse_scheduled(1);
180     
181     as3_parse_file_or_array(2, name, 0, mem, length);
182     as3_parse_scheduled(2);
183 }
184
185 void as3_parse_file(const char*filename) 
186 {
187     char*fullfilename = find_file(filename);
188     if(!fullfilename)
189         return; // not found
190     
191     as3_parse_file_or_array(1, filename, fullfilename, 0,0);
192     as3_parse_scheduled(1);
193
194     as3_parse_file_or_array(2, filename, fullfilename, 0,0);
195     as3_parse_scheduled(2);
196
197     free(fullfilename);
198 }
199
200 void as3_parse_directory(const char*dir)
201 {
202     as3_pass=1;
203     as3_schedule_directory(dir);
204     if(!scheduled)
205         as3_warning("Directory %s doesn't contain any ActionScript files", dir);
206     as3_parse_scheduled(1);
207     as3_pass=2;
208     as3_schedule_directory(dir);
209     as3_parse_scheduled(2);
210 }
211
212 char as3_schedule_directory(const char*dirname)
213 {
214     DEBUG printf("[pass %d] schedule directory %s\n", as3_pass, dirname);
215     char ok=0;
216 #ifdef HAVE_DIRENT_H
217     include_dir_t*i = current_include_dirs;
218     while(i) {
219         char*fulldirname = concat_paths(i->path, dirname);
220         DEBUG printf("[pass %d] ... %s\n", as3_pass, fulldirname);
221         DIR*dir = opendir(fulldirname);
222         if(dir) {
223             ok = 1;
224             struct dirent*ent;
225             while(1) {
226                 ent = readdir(dir);
227                 if (!ent) 
228                     break;
229                 char*name = ent->d_name;
230                 char type = 0;
231                 if(!name) continue;
232                 int l=strlen(name);
233                 if(l<4)
234                     continue;
235                 if(strncasecmp(&name[l-3], ".as", 3)) 
236                     continue;
237                 char*fullfilename = concatPaths(fulldirname, name);
238                 as3_schedule_file(name, fullfilename);
239                 free(fullfilename);
240             }
241         }
242         free(fulldirname);
243         i = i->next;
244     }
245 #endif
246     return ok;
247 }
248
249 void as3_schedule_package(const char*package)
250 {
251     DEBUG printf("[pass %d] schedule package %s\n", as3_pass, package);
252     char*dirname = strdup(package);
253     int s=0;
254     while(dirname[s]) {
255         if(dirname[s]=='.') dirname[s]='/';
256         s++;
257     };
258     if(!as3_schedule_directory(package))
259         as3_softwarning("Could not find package %s in file system", package);
260 }
261
262 void as3_schedule_class(const char*package, const char*cls)
263 {
264     DEBUG printf("[pass %d] schedule class %s.%s\n",  as3_pass, package, cls);
265     if(!cls) {
266         as3_schedule_package(package);
267         return;
268     }
269     int l1 = package?strlen(package):0;
270     int l2 = cls?strlen(cls):0;
271     char*filename = malloc(l1+l2+5);
272     int s=0,t=0;
273     while(package[s]) {
274         if(package[s]=='.')
275             filename[t++]='/';
276         else
277             filename[t++] = package[s];
278         s++;
279     }
280     if(t)
281         filename[t++] = '/';
282
283     strcpy(filename+t, cls);
284     strcpy(filename+t+l2, ".as");
285     char*f=0;
286     if(!(f=find_file(filename))) {
287         int i;
288         /* try lower case filename (not packagename!), too */
289         for(i=t;i<t+l2;i++) {
290             if(filename[i]>='A' && filename[i]<='Z')
291                 filename[i] += 'a'-'A';
292         }
293         if(!(f=find_file(filename))) {
294             strcpy(filename+t, cls);
295             strcpy(filename+t+l2, ".as");
296             as3_warning("Could not open file %s", filename);
297             return;
298         }
299     }
300     as3_schedule_file(filename, f);
301 }
302
303 static void*as3code = 0;
304 void* as3_getcode()
305 {
306     if(parser_initialized) {
307         parser_initialized = 0;
308         as3code = finish_parser();
309     }
310     return as3code;
311 }
312 char* as3_getglobalclass()
313 {
314     return as3_globalclass;
315 }
316
317 void as3_destroy() 
318 {
319     if(parser_initialized) {
320         parser_initialized = 0;
321         swf_FreeABC(finish_parser());
322 #ifdef STORE_TOKENS
323         mem_clear(&tokens);
324 #endif
325     }
326     if(as3_globalclass) {
327         free(as3_globalclass);as3_globalclass=0;
328     }
329 }
330