finished ast implementation
[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 <errno.h>
27 #include "files.h"
28 #include "common.h"
29 #include "tokenizer.h"
30
31 static int verbose = 0;
32 static void dbg(const char*format, ...)
33 {
34     char buf[1024];
35     int l;
36     va_list arglist;
37     if(!verbose)
38         return;
39     va_start(arglist, format);
40     vsprintf(buf, format, arglist);
41     va_end(arglist);
42     l = strlen(buf);
43     while(l && buf[l-1]=='\n') {
44         buf[l-1] = 0;
45         l--;
46     }
47     printf("(includefilehandler) ");
48     printf("%s\n", buf);
49     fflush(stdout);
50 }
51
52
53 int current_line=1;
54 int current_column=0;
55 char* current_filename=0;
56 char* current_filename_short=0;
57 char* current_filename_long=0;
58 include_dir_t* current_include_dirs=0;
59
60 #define MAX_INCLUDE_DEPTH 16
61
62 void*include_stack[MAX_INCLUDE_DEPTH];
63 int line_stack[MAX_INCLUDE_DEPTH];
64 int column_stack[MAX_INCLUDE_DEPTH];
65 char* filename_stack[MAX_INCLUDE_DEPTH];
66 char* shortfilename_stack[MAX_INCLUDE_DEPTH];
67 char* longfilename_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 = strdup(dir);
76     d->next = current_include_dirs;
77     current_include_dirs = d;
78 }
79
80 void del_include_dirs(include_dir_t*d, include_dir_t*d2)
81 {
82     while(d && d!=d2) {
83         include_dir_t*next = d->next;
84         free(d->path);d->path=0;
85         d->next = 0;
86         free(d);
87         d = next;
88     }
89 }
90
91 char*get_path(const char*file)
92 {
93     char*path = strdup(file);
94     char*r1 = strrchr(path, '/');
95     char*r2 = strrchr(path, '\\');
96     if(r1<r2) {
97         *r2=0;
98         return path;
99     } else if(r1>r2) {
100         *r1=0;
101         return path;
102     } else {
103         return strdup(".");
104     }
105 }
106 char* normalize_path(const char*path)
107 {
108     char*n = 0, *d = 0;
109     if(path[0] != '/') {
110         char buf[512];
111         char*c = getcwd(buf,512);
112         int l = strlen(buf);
113         d = n = malloc(l+strlen(path)+10);
114         strcpy(n, buf);d += l;
115         if(!l || n[l-1]!='/') {
116             *d='/';d++;
117         }
118     } else {
119         d = n = strdup(path);
120     }
121     const char*s=path;
122     char init = 1;
123
124     while(*s) {
125         if(init && s[0] == '.' && (s[1]=='/' || s[1]=='\0')) {
126             if(!s[1]) break;
127             s+=2;
128             init=1;
129             continue;
130         }
131         if(init && s[0] == '.' && s[1] == '.' && (s[2] == '/' || s[2]=='\0')) {
132             // step one down
133             char*last = 0;
134             if(d<=n) 
135                 return 0;
136             *--d = 0;
137             if(!(last=strrchr(n, '/'))) {
138                 return 0;
139             }
140             d = last+1;
141             if(!s[2]) break;
142             s+=3;
143             init=1;
144             continue;
145         }
146
147         *d = *s;
148         if(*s=='/') init=1;
149         else init=0;
150         d++;s++;
151     }
152     if(d!=n && d[-1]=='/') 
153         d--;
154     *d = 0;
155     return n;
156 }
157 static void testnormalize()
158 {
159 #define TEST(x) {printf("%s -> %s\n", (x), normalize_path(x));}
160     TEST(".");
161     TEST("../as3");
162     TEST("../as3/");
163     TEST("../as3/parser.y");
164     TEST("../as3/ok/../ok/scope.as");
165     TEST("ok/scope.as");
166     TEST("ok/./scope.as");
167     TEST("./ok/scope.as");
168     TEST("./");
169     TEST("/tmp/");
170     TEST("/./tmp/");
171     TEST("../");
172     TEST("/");
173     TEST("/tmp");
174     TEST("/tmp/../usr/");
175 }
176
177
178 char* concat_paths(const char*base, const char*add)
179 {
180     int l1 = strlen(base);
181     int l2 = strlen(add);
182     int pos = 0;
183     char*n = 0;
184     while(l1 && base[l1-1] == '/')
185         l1--;
186     while(pos < l2 && add[pos] == '/')
187         pos++;
188     n = (char*)malloc(l1 + (l2-pos) + 2);
189     memcpy(n,base,l1);
190     n[l1]='/';
191     memcpy(&n[l1+1],&add[pos],l2-pos+1);
192     return n;
193 }
194 char is_absolute(const char*filename) 
195 {
196     if(!filename || !filename[0])
197         return 0;
198     if(filename[0]=='/' || filename[0]=='\\')
199         return 1;
200     if(filename[1]==':' && filename[1]=='/')
201         return 1;
202     if(filename[1]==':' && filename[1]=='\\')
203         return 1;
204     return 0;
205 }
206
207 char*find_file(const char*filename, char error)
208 {
209     include_dir_t*i = current_include_dirs;
210     FILE*fi = 0;
211     if(is_absolute(filename)) {
212         FILE*fi = fopen(filename, "rb");
213         if(fi) {
214             fclose(fi);
215             return strdup(filename);
216         }
217     } else {
218         if(!i && error) {
219             as3_warning("Include directory stack is empty, while looking for file %s", filename);
220         }
221         while(i) {
222             char*p = concat_paths(i->path, filename);
223             fi = fopen(p, "rb");
224             if(fi) {
225                 fclose(fi);
226                 return p;
227             } else {
228                 free(p);
229             }
230             i = i->next;
231         }
232     }
233     if(!error) {
234         return 0;
235     }
236
237     as3_error("Couldn't find file %s", filename);
238     i = current_include_dirs;
239     while(i) {
240         fprintf(stderr, "include dir: %s\n", i->path);
241         i = i->next;
242     }
243     return 0;
244 }
245
246 void enter_file(const char*name, const char*filename, void*state)
247 {
248     if(include_stack_ptr >= MAX_INCLUDE_DEPTH) {
249         as3_error("Includes nested too deeply");
250         exit(1);
251     }
252     include_stack[include_stack_ptr] = state;
253     line_stack[include_stack_ptr] = current_line;
254     column_stack[include_stack_ptr] = current_column;
255     shortfilename_stack[include_stack_ptr] = current_filename_short;
256     longfilename_stack[include_stack_ptr] = current_filename_long;
257     filename_stack[include_stack_ptr] = current_filename;
258     includedir_stack[include_stack_ptr] = current_include_dirs;
259     
260     /*char*dir = get_path(filename);
261     add_include_dir(dir);
262     free(dir);*/
263
264     include_stack_ptr++;
265     
266     dbg("entering file %s", filename);
267
268     current_line=1;
269     current_column=0;
270     current_filename = strdup(name);
271     current_filename_short = strdup(name);
272     current_filename_long = strdup(filename);
273 }
274
275 FILE*enter_file2(const char*name, const char*filename, void*state)
276 {
277     enter_file(name, filename, state);
278     FILE*fi = fopen(filename, "rb");
279     if(!fi) {
280         as3_error("Couldn't find file %s: %s", filename, strerror(errno));
281     }
282     return fi;
283 }
284
285 void* leave_file()
286 {
287     dbg("leaving file %s", current_filename);
288     if(--include_stack_ptr<=0) {
289         return 0;
290     } else {
291         free(current_filename);current_filename = filename_stack[include_stack_ptr];
292         free(current_filename_short);current_filename_short = shortfilename_stack[include_stack_ptr];
293         free(current_filename_long);current_filename_long = longfilename_stack[include_stack_ptr];
294         current_column = column_stack[include_stack_ptr];
295         current_line = line_stack[include_stack_ptr];
296         del_include_dirs(includedir_stack[include_stack_ptr], current_include_dirs);
297         current_include_dirs = includedir_stack[include_stack_ptr];
298         return include_stack[include_stack_ptr];
299     }
300 }