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