dump out method flags
[swftools.git] / lib / as3 / files.c
1 /* files.c
2
3    Extension module for the rfxswf library.
4    Part of the swftools package.
5
6    Copyright (c) 2008 Matthias Kramm <kramm@quiss.org>
7  
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
21
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <stdarg.h>
25 #include <memory.h>
26 #include "files.h"
27
28 static int verbose = 0;
29 static void dbg(const char*format, ...)
30 {
31     char buf[1024];
32     int l;
33     va_list arglist;
34     if(!verbose)
35         return;
36     va_start(arglist, format);
37     vsprintf(buf, format, arglist);
38     va_end(arglist);
39     l = strlen(buf);
40     while(l && buf[l-1]=='\n') {
41         buf[l-1] = 0;
42         l--;
43     }
44     printf("(includefilehandler) ");
45     printf("%s\n", buf);
46     fflush(stdout);
47 }
48
49
50 typedef struct _include_dir {
51     char*path;
52     struct _include_dir*next;
53 } include_dir_t;
54
55 int current_line=1;
56 int current_column=0;
57 char* current_filename=0;
58 char* current_filename_short=0;
59 include_dir_t* current_include_dirs=0;
60
61 #define MAX_INCLUDE_DEPTH 16
62
63 void*include_stack[MAX_INCLUDE_DEPTH];
64 int line_stack[MAX_INCLUDE_DEPTH];
65 int column_stack[MAX_INCLUDE_DEPTH];
66 char* filename_stack[MAX_INCLUDE_DEPTH];
67 char* shortfilename_stack[MAX_INCLUDE_DEPTH];
68 include_dir_t* includedir_stack[MAX_INCLUDE_DEPTH];
69 int include_stack_ptr = 0;
70
71 void add_include_dir(char*dir)
72 {
73     include_dir_t*d = malloc(sizeof(include_dir_t));
74     memset(d , 0, sizeof(include_dir_t));
75     d->path = dir;
76     d->next = current_include_dirs;
77     current_include_dirs = d;
78 }
79 char*get_path(char*file)
80 {
81     char*path = strdup(file);
82     char*r1 = strrchr(path, '/');
83     char*r2 = strrchr(path, '\\');
84     if(r1<r2) {
85         *r2=0;
86         return path;
87     } else if(r1>r2) {
88         *r1=0;
89         return path;
90     } else {
91         return strdup(".");
92     }
93 }
94 char* concat_paths(const char*base, const char*add)
95 {
96     int l1 = strlen(base);
97     int l2 = strlen(add);
98     int pos = 0;
99     char*n = 0;
100     while(l1 && base[l1-1] == '/')
101         l1--;
102     while(pos < l2 && add[pos] == '/')
103         pos++;
104     n = (char*)malloc(l1 + (l2-pos) + 2);
105     memcpy(n,base,l1);
106     n[l1]='/';
107     memcpy(&n[l1+1],&add[pos],l2-pos+1);
108     return n;
109 }
110 char is_absolute(char*filename) 
111 {
112     if(!filename || !filename[0])
113         return 0;
114     if(filename[0]=='/' || filename[0]=='\\')
115         return 1;
116     if(filename[1]==':' && filename[1]=='/')
117         return 1;
118     if(filename[1]==':' && filename[1]=='\\')
119         return 1;
120     return 0;
121 }
122 char*find_file(char*filename)
123 {
124     include_dir_t*i = current_include_dirs;
125     FILE*fi = 0;
126     if(is_absolute(filename)) {
127         FILE*fi = fopen(filename, "rb");
128         if(fi) {
129             fclose(fi);
130             return strdup(filename);
131         }
132         return 0;
133     }
134     while(i) {
135         char*p = concat_paths(i->path, filename);
136         fi = fopen(p, "rb");
137         if(fi) {
138             fclose(fi);
139             return p;
140         }
141         i = i->next;
142     }
143     return 0;
144 }
145
146 char*enter_file(char*filename, void*state)
147 {
148     if(include_stack_ptr >= MAX_INCLUDE_DEPTH) {
149         syntaxerror("Includes nested too deeply");
150         exit(1);
151     }
152     char*fullfilename = find_file(filename);
153     if(!fullfilename) {
154         syntaxerror("Couldn't find file %s", filename);
155         include_dir_t*i = current_include_dirs;
156         while(i) {
157             fprintf(stderr, "include dir: %s\n", i->path);
158             i = i->next;
159         }
160         exit(1);
161     }
162     include_stack[include_stack_ptr] = state;
163     line_stack[include_stack_ptr] = current_line;
164     column_stack[include_stack_ptr] = current_column;
165     shortfilename_stack[include_stack_ptr] = current_filename_short = strdup(filename);
166     filename_stack[include_stack_ptr] = current_filename;
167     includedir_stack[include_stack_ptr] = current_include_dirs;
168     add_include_dir(get_path(fullfilename));
169     include_stack_ptr++;
170     
171     dbg("entering file %s", fullfilename);
172
173     current_line=1;
174     current_column=0;
175     current_filename=fullfilename;
176     return fullfilename;
177 }
178
179 void* leave_file()
180 {
181     dbg("leaving file %s", current_filename);
182     if(--include_stack_ptr<0) {
183         return 0;
184     } else {
185         current_column = column_stack[include_stack_ptr];
186         current_line = line_stack[include_stack_ptr];
187         free(current_filename);current_filename = filename_stack[include_stack_ptr];
188         free(current_filename_short);current_filename_short = shortfilename_stack[include_stack_ptr];
189         current_include_dirs = includedir_stack[include_stack_ptr];
190         return include_stack[include_stack_ptr];
191     }
192 }