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