X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fcompiler.c;h=597f3b9e5e07f41e38db7f5abe756fb71b92348f;hb=71b5bc980e9f3fa962167da70043f0b16e253906;hp=28769e8a7b5cc93f6c9ad7921dd3e9ce9f794625;hpb=dac2d533ddea79fcc214638837bb5b746639dbab;p=swftools.git

diff --git a/lib/as3/compiler.c b/lib/as3/compiler.c
index 28769e8..597f3b9 100644
--- a/lib/as3/compiler.c
+++ b/lib/as3/compiler.c
@@ -21,12 +21,16 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
+#include "common.h"
 #include "tokenizer.h"
 #include "files.h"
 #include "parser.h"
 #include "parser.tab.h"
 #include "compiler.h"
 #include "../os.h"
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
 #ifdef HAVE_DIRENT_H
 #include <dirent.h>
 #endif
@@ -36,6 +40,8 @@ extern int a3_parse();
 extern int as3_lex();
 extern int as3_lex_destroy();
 
+static char config_recurse = 0;
+
 void as3_setverbosity(int level)
 {
     as3_verbosity=level;
@@ -44,42 +50,35 @@ void as3_add_include_dir(char*dir)
 {
     add_include_dir(dir);
 }
+void as3_set_option(const char*key, const char*value)
+{
+    if(!strcmp(key, "recurse")) {
+        config_recurse=atoi(value);
+    }
+}
 
 static char registry_initialized = 0;
 static char parser_initialized = 0;
 
 //#define STORE_TOKENS
 
-#ifdef STORE_TOKENS
-static mem_t tokens;
-#endif
+//#define DEBUG
+#define DEBUG if(0)
 
 int a3_lex()
 {
     as3_tokencount++;
-#ifdef STORE_TOKENS
-    if(as3_pass==1) {
-        int token = as3_lex();
-        /* FIXME: current_file needs to be stored, too */
-        mem_put(&tokens, &token, sizeof(token));
-        mem_put(&tokens, &a3_lval, sizeof(a3_lval));
-        mem_put(&tokens, &current_line, sizeof(current_line));
-        mem_put(&tokens, &current_column, sizeof(current_column));
-        return token;
-    } else {
-        int token;
-        mem_get(&tokens, &token, sizeof(token));
-        mem_get(&tokens, &a3_lval, sizeof(a3_lval));
-        mem_get(&tokens, &current_line, sizeof(current_line));
-        mem_get(&tokens, &current_column, sizeof(current_column));
-        return token;
-    }
-#else
     return as3_lex();
-#endif
 }
 
-static void as3_parse_file_or_array(int pass, const char*name, const char*filename, void*mem, int length)
+typedef struct _compile_list {
+    const char*name;
+    const char*filename;
+    struct _compile_list*next;
+} compile_list_t;
+static compile_list_t*compile_list=0;
+
+static void as3_parse_file_or_array(const char*name, const char*filename, const void*mem, int length)
 {
     if(!registry_initialized) {
         registry_initialized = 1;
@@ -88,29 +87,36 @@ static void as3_parse_file_or_array(int pass, const char*name, const char*filena
     if(!parser_initialized) {
         parser_initialized = 1;
         initialize_parser();
-#if defined(STORE_TOKENS)
-        mem_init(&tokens);
-#endif
     }
-    as3_pass=pass;
 
     FILE*fi = 0;
     if(filename) {
+        if(as3_pass==1 && !mem) {
+            // record the fact that we compiled this file
+            compile_list_t*c = rfx_calloc(sizeof(compile_list_t));
+            c->next = compile_list;
+            c->name = strdup(name);
+            c->filename = strdup(filename);
+            compile_list = c;
+        }
+        DEBUG printf("[pass %d] parse file %s %s\n", as3_pass, name, filename);
         fi = enter_file2(name, filename, 0);
         as3_file_input(fi);
     } else {
+        DEBUG printf("[pass %d] parse bytearray %s (%d bytes)\n", as3_pass, name, length);
         enter_file(name, name, 0);
-        as3_buffer_input(mem, length);
+        as3_buffer_input((void*)mem, length);
     }
 
     as3_tokencount=0;
-    initialize_file(name);
+    initialize_file(name, filename);
     a3_parse();
     as3_lex_destroy();
     finish_file();
 }
 
 typedef struct _scheduled_file {
+    char*name;
     char*filename;
     struct _scheduled_file*next;
 } scheduled_file_t;
@@ -120,74 +126,116 @@ dict_t*scheduled_dict=0;
 
 void as3_parse_scheduled()
 {
+    DEBUG printf("[pass %d] parse scheduled\n", as3_pass);
+
     while(scheduled) {
-        scheduled_file_t*old = scheduled;
-        as3_parse_file(scheduled->filename);
-        scheduled = scheduled->next;
-        free(old->filename);
-        free(old);
+        scheduled_file_t*s = scheduled;
+        scheduled = 0;
+        while(s) {
+            scheduled_file_t*old = s;
+            as3_parse_file_or_array(s->name, s->filename, 0,0);
+            s = s->next;
+
+            free(old->filename);
+            free(old->name);
+            old->filename = old->name = 0;
+            free(old);
+        }
     }
     if(scheduled_dict) {
         dict_destroy(scheduled_dict);
         scheduled_dict=0;
     }
 }
-void as3_schedule_file(const char*filename) 
+
+void as3_schedule_file(const char*name, const char*filename) 
 {
-    if(!scheduled_dict) 
+    if(!scheduled_dict) {
         scheduled_dict = dict_new();
+    }
 
-    if(dict_lookup(scheduled_dict, filename)) {
+    filename = normalize_path(filename);
+    
+    if(dict_contains(scheduled_dict, filename)) {
         return; //already processed
     } else {
         dict_put(scheduled_dict, filename, 0);
     }
+    DEBUG printf("[pass %d] schedule %s %s\n", as3_pass, name, filename);
 
     NEW(scheduled_file_t, f);
+    f->name = strdup(name);
     f->filename = strdup(filename);
     f->next = scheduled; // dfs
     scheduled = f;
-    printf("schedule %s\n", filename);
 }
 
-void as3_parse_bytearray(const char*name, void*mem, int length)
+void as3_parse_list()
+{
+    while(compile_list) {
+        as3_parse_file_or_array(compile_list->name, compile_list->filename, 0,0);
+        compile_list = compile_list->next;
+    }
+}
+
+void as3_parse_bytearray(const char*name, const void*mem, int length)
 {
-    as3_parse_file_or_array(1, name, 0, mem, length);
+    as3_pass = 1;
+    as3_parse_file_or_array(name, 0, mem, length);
     as3_parse_scheduled();
     
-    as3_parse_file_or_array(2, name, 0, mem, length);
-    as3_parse_scheduled();
+    registry_resolve_all();
+    
+    as3_pass = 2;
+    as3_parse_file_or_array(name, 0, mem, length);
+    as3_parse_list();
 }
 
 void as3_parse_file(const char*filename) 
 {
-    char*fullfilename = find_file(filename);
+    char*fullfilename = find_file(filename, 1);
     if(!fullfilename)
         return; // not found
-    
-    as3_parse_file_or_array(1, filename, fullfilename, 0,0);
-    as3_parse_scheduled();
 
-    as3_parse_file_or_array(2, filename, fullfilename, 0,0);
+    compile_list = 0;
+    as3_pass = 1;
+    as3_parse_file_or_array(filename, fullfilename, 0,0);
     as3_parse_scheduled();
+    
+    registry_resolve_all();
+
+    as3_pass = 2;
+    as3_parse_list();
 
     free(fullfilename);
 }
 
-void as3_schedule_package(const char*package)
+void as3_parse_directory(const char*dir)
 {
-    char*dirname = strdup(package);
-    int s=0;
-    while(dirname[s]) {
-        if(package[s]=='.') dirname[s]='/';
-        s++;
-    };
+    compile_list = 0;
+
+    as3_pass = 1;
+    as3_schedule_directory(dir);
+    if(!scheduled)
+        as3_warning("Directory %s doesn't contain any ActionScript files", dir);
+    as3_parse_scheduled();
+
+    registry_resolve_all();
+
+    as3_pass = 2;
+    as3_parse_list();
+}
+
+char as3_schedule_directory(const char*dirname)
+{
+    DEBUG printf("[pass %d] schedule directory %s\n", as3_pass, dirname);
     char ok=0;
 #ifdef HAVE_DIRENT_H
     include_dir_t*i = current_include_dirs;
     while(i) {
-        char*fulldirname = concatPaths(i->path, dirname);
-        DIR*dir = opendir(dirname);
+        char*fulldirname = concat_paths(i->path, dirname);
+        DEBUG printf("[pass %d] ... %s\n", as3_pass, fulldirname);
+        DIR*dir = opendir(fulldirname);
         if(dir) {
             ok = 1;
             struct dirent*ent;
@@ -203,8 +251,8 @@ void as3_schedule_package(const char*package)
                     continue;
                 if(strncasecmp(&name[l-3], ".as", 3)) 
                     continue;
-                char*fullfilename = concatPaths(dirname, name);
-                as3_schedule_file(fullfilename);
+                char*fullfilename = concatPaths(fulldirname, name);
+                as3_schedule_file(name, fullfilename);
                 free(fullfilename);
             }
         }
@@ -212,12 +260,27 @@ void as3_schedule_package(const char*package)
         i = i->next;
     }
 #endif
-    if(!ok)
-        as3_warning("Could not find package %s", package);
+    return ok;
 }
 
-void as3_schedule_class(const char*package, const char*cls)
+void as3_schedule_package(const char*package)
+{
+    DEBUG printf("[pass %d] schedule package %s\n", as3_pass, package);
+    char*dirname = strdup(package);
+    int s=0;
+    while(dirname[s]) {
+        if(dirname[s]=='.') dirname[s]='/';
+        s++;
+    };
+    if(!as3_schedule_directory(dirname))
+        as3_softwarning("Could not find package %s in file system", package);
+}
+
+static void schedule_class(const char*package, const char*cls, char error)
 {
+    if(error) {
+        DEBUG printf("[pass %d] schedule class %s.%s\n",  as3_pass, package, cls);
+    }
     if(!cls) {
         as3_schedule_package(package);
         return;
@@ -239,23 +302,38 @@ void as3_schedule_class(const char*package, const char*cls)
     strcpy(filename+t, cls);
     strcpy(filename+t+l2, ".as");
     char*f=0;
-    if(!(f=find_file(filename))) {
+    if(!(f=find_file(filename, error))) {
         int i;
         /* try lower case filename (not packagename!), too */
         for(i=t;i<t+l2;i++) {
             if(filename[i]>='A' && filename[i]<='Z')
                 filename[i] += 'a'-'A';
         }
-        if(!(f=find_file(filename))) {
-            strcpy(filename+t, cls);
-            strcpy(filename+t+l2, ".as");
-            as3_warning("Could not open file %s", filename);
+        if(!(f=find_file(filename, error))) {
+            if(error) {
+                strcpy(filename+t, cls);
+                strcpy(filename+t+l2, ".as");
+                as3_warning("Could not open file %s", filename);
+            }
             return;
         }
     }
-    as3_schedule_file(f);
+    as3_schedule_file(filename, f);
+}
+
+void as3_schedule_class(const char*package, const char*cls)
+{
+    schedule_class(package, cls, 1);
+}
+
+void as3_schedule_class_noerror(const char*package, const char*cls)
+{
+    if(config_recurse) {
+        schedule_class(package, cls, 0);
+    }
 }
 
+
 static void*as3code = 0;
 void* as3_getcode()
 {