ignore unknown escape sequences
[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 typedef struct _compile_list {
89     const char*name;
90     const char*filename;
91     struct _compile_list*next;
92 } compile_list_t;
93 static compile_list_t*compile_list=0;
94
95 static void as3_parse_file_or_array(int pass, const char*name, const char*filename, const void*mem, int length)
96 {
97     if(!registry_initialized) {
98         registry_initialized = 1;
99         registry_init();
100     }
101     if(!parser_initialized) {
102         parser_initialized = 1;
103         initialize_parser();
104 #if defined(STORE_TOKENS)
105         mem_init(&tokens);
106 #endif
107     }
108     as3_pass=pass;
109
110     FILE*fi = 0;
111     if(filename) {
112         if(as3_pass==1 && !mem) {
113             compile_list_t*c = rfx_calloc(sizeof(compile_list_t));
114             c->next = compile_list;
115             c->name = strdup(name);
116             c->filename = strdup(filename);
117             compile_list = c;
118         }
119         DEBUG printf("[pass %d] parse file %s %s\n", pass, name, filename);
120         fi = enter_file2(name, filename, 0);
121         as3_file_input(fi);
122     } else {
123         DEBUG printf("[pass %d] parse bytearray %s (%d bytes)\n", pass, name, length);
124         enter_file(name, name, 0);
125         as3_buffer_input((void*)mem, length);
126     }
127
128     as3_tokencount=0;
129     initialize_file(name, filename);
130     a3_parse();
131     as3_lex_destroy();
132     finish_file();
133 }
134
135 typedef struct _scheduled_file {
136     char*name;
137     char*filename;
138     struct _scheduled_file*next;
139 } scheduled_file_t;
140
141 static scheduled_file_t*scheduled=0;
142 dict_t*scheduled_dict=0;
143
144 void as3_parse_scheduled(int pass)
145 {
146     DEBUG printf("[pass %d] parse scheduled\n", pass);
147
148     while(scheduled) {
149         scheduled_file_t*s = scheduled;
150         scheduled = 0;
151         while(s) {
152             scheduled_file_t*old = s;
153             as3_parse_file_or_array(pass, s->name, s->filename, 0,0);
154             s = s->next;
155
156             free(old->filename);
157             free(old->name);
158             old->filename = old->name = 0;
159             free(old);
160         }
161     }
162     if(scheduled_dict) {
163         dict_destroy(scheduled_dict);
164         scheduled_dict=0;
165     }
166 }
167
168 void as3_schedule_file(const char*name, const char*filename) 
169 {
170     if(!scheduled_dict) {
171         scheduled_dict = dict_new();
172     }
173
174     filename = normalize_path(filename);
175     
176     if(dict_contains(scheduled_dict, filename)) {
177         return; //already processed
178     } else {
179         dict_put(scheduled_dict, filename, 0);
180     }
181     DEBUG printf("[pass %d] schedule %s %s\n", as3_pass, name, filename);
182
183     NEW(scheduled_file_t, f);
184     f->name = strdup(name);
185     f->filename = strdup(filename);
186     f->next = scheduled; // dfs
187     scheduled = f;
188 }
189
190 void as3_parse_list()
191 {
192     while(compile_list) {
193         as3_parse_file_or_array(2, compile_list->name, compile_list->filename, 0,0);
194         compile_list = compile_list->next;
195     }
196 }
197
198 void as3_parse_bytearray(const char*name, const void*mem, int length)
199 {
200     as3_pass = 1;
201     as3_parse_file_or_array(1, name, 0, mem, length);
202     as3_parse_scheduled(1);
203     
204     as3_pass = 2;
205     as3_parse_file_or_array(2, name, 0, mem, length);
206     as3_parse_list();
207 }
208
209 void as3_parse_file(const char*filename) 
210 {
211     char*fullfilename = find_file(filename, 1);
212     if(!fullfilename)
213         return; // not found
214
215     compile_list = 0;
216     as3_pass = 1;
217     as3_parse_file_or_array(1, filename, fullfilename, 0,0);
218     as3_parse_scheduled(1);
219
220     as3_pass = 2;
221     as3_parse_list();
222
223     free(fullfilename);
224 }
225
226 void as3_parse_directory(const char*dir)
227 {
228     compile_list = 0;
229     as3_pass=1;
230     as3_schedule_directory(dir);
231     if(!scheduled)
232         as3_warning("Directory %s doesn't contain any ActionScript files", dir);
233     as3_parse_scheduled(1);
234
235     as3_pass=2;
236     as3_parse_list();
237 }
238
239 char as3_schedule_directory(const char*dirname)
240 {
241     DEBUG printf("[pass %d] schedule directory %s\n", as3_pass, dirname);
242     char ok=0;
243 #ifdef HAVE_DIRENT_H
244     include_dir_t*i = current_include_dirs;
245     while(i) {
246         char*fulldirname = concat_paths(i->path, dirname);
247         DEBUG printf("[pass %d] ... %s\n", as3_pass, fulldirname);
248         DIR*dir = opendir(fulldirname);
249         if(dir) {
250             ok = 1;
251             struct dirent*ent;
252             while(1) {
253                 ent = readdir(dir);
254                 if (!ent) 
255                     break;
256                 char*name = ent->d_name;
257                 char type = 0;
258                 if(!name) continue;
259                 int l=strlen(name);
260                 if(l<4)
261                     continue;
262                 if(strncasecmp(&name[l-3], ".as", 3)) 
263                     continue;
264                 char*fullfilename = concatPaths(fulldirname, name);
265                 as3_schedule_file(name, fullfilename);
266                 free(fullfilename);
267             }
268         }
269         free(fulldirname);
270         i = i->next;
271     }
272 #endif
273     return ok;
274 }
275
276 void as3_schedule_package(const char*package)
277 {
278     DEBUG printf("[pass %d] schedule package %s\n", as3_pass, package);
279     char*dirname = strdup(package);
280     int s=0;
281     while(dirname[s]) {
282         if(dirname[s]=='.') dirname[s]='/';
283         s++;
284     };
285     if(!as3_schedule_directory(dirname))
286         as3_softwarning("Could not find package %s in file system", package);
287 }
288
289 static void schedule_class(const char*package, const char*cls, char error)
290 {
291     if(error) {
292         DEBUG printf("[pass %d] schedule class %s.%s\n",  as3_pass, package, cls);
293     }
294     if(!cls) {
295         as3_schedule_package(package);
296         return;
297     }
298     int l1 = package?strlen(package):0;
299     int l2 = cls?strlen(cls):0;
300     char*filename = malloc(l1+l2+5);
301     int s=0,t=0;
302     while(package[s]) {
303         if(package[s]=='.')
304             filename[t++]='/';
305         else
306             filename[t++] = package[s];
307         s++;
308     }
309     if(t)
310         filename[t++] = '/';
311
312     strcpy(filename+t, cls);
313     strcpy(filename+t+l2, ".as");
314     char*f=0;
315     if(!(f=find_file(filename, error))) {
316         int i;
317         /* try lower case filename (not packagename!), too */
318         for(i=t;i<t+l2;i++) {
319             if(filename[i]>='A' && filename[i]<='Z')
320                 filename[i] += 'a'-'A';
321         }
322         if(!(f=find_file(filename, error))) {
323             if(error) {
324                 strcpy(filename+t, cls);
325                 strcpy(filename+t+l2, ".as");
326                 as3_warning("Could not open file %s", filename);
327             }
328             return;
329         }
330     }
331     as3_schedule_file(filename, f);
332 }
333
334 void as3_schedule_class(const char*package, const char*cls)
335 {
336     schedule_class(package, cls, 1);
337 }
338
339 void as3_schedule_class_noerror(const char*package, const char*cls)
340 {
341     schedule_class(package, cls, 0);
342 }
343
344
345 static void*as3code = 0;
346 void* as3_getcode()
347 {
348     if(parser_initialized) {
349         parser_initialized = 0;
350         as3code = finish_parser();
351     }
352     return as3code;
353 }
354 char* as3_getglobalclass()
355 {
356     return as3_globalclass;
357 }
358
359 void as3_destroy() 
360 {
361     if(parser_initialized) {
362         parser_initialized = 0;
363         swf_FreeABC(finish_parser());
364 #ifdef STORE_TOKENS
365         mem_clear(&tokens);
366 #endif
367     }
368     if(as3_globalclass) {
369         free(as3_globalclass);as3_globalclass=0;
370     }
371 }
372