/[jscoverage]/trunk/instrument.c
ViewVC logotype

Diff of /trunk/instrument.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 70 by siliconforks, Thu Nov 22 02:52:38 2007 UTC revision 431 by siliconforks, Wed Feb 18 18:24:51 2009 UTC
# Line 1  Line 1 
1  /*  /*
2      instrument.c - file and directory instrumentation routines      instrument.c - file and directory instrumentation routines
3      Copyright (C) 2007 siliconforks.com      Copyright (C) 2007, 2008, 2009 siliconforks.com
4    
5      This program is free software; you can redistribute it and/or modify      This program is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published by      it under the terms of the GNU General Public License as published by
# Line 17  Line 17 
17      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  */  */
19    
20    #include <config.h>
21    
22  #include "instrument.h"  #include "instrument.h"
23    
24  #include <assert.h>  #include <assert.h>
# Line 27  Line 29 
29  #include <sys/stat.h>  #include <sys/stat.h>
30  #include <sys/types.h>  #include <sys/types.h>
31    
32    #include "encoding.h"
33    #include "global.h"
34  #include "instrument-js.h"  #include "instrument-js.h"
35  #include "resource-manager.h"  #include "resource-manager.h"
36  #include "util.h"  #include "util.h"
# Line 50  Line 54 
54      return FILE_TYPE_HTML;      return FILE_TYPE_HTML;
55    }    }
56    else {    else {
57      return FILE_TYPE_UNKNOWN;      return FILE_TYPE_OTHER;
58    }    }
59  }  }
60    
 static void highlight_file(const char * source_file, const char * destination_file, const char * relative_path) {  
   int depth = 0;  
   for (const char * p = relative_path; *p != '\0'; p++) {  
     if (*p == '/' || *p == '\\') {  
       depth++;  
     }  
   }  
   
   enum FileType file_type = get_file_type(relative_path);  
   const char * suffix = ".jscoverage.html";  
   char * highlighted_file = xmalloc(strlen(destination_file) + strlen(suffix) + 1);  
   strcpy(highlighted_file, destination_file);  
   strcat(highlighted_file, suffix);  
   
   FILE * input = xfopen(source_file, "r");  
   FILE * output = xfopen(highlighted_file, "w");  
   
   free(highlighted_file);  
   
   char * relative_path_to_ancestor = xmalloc(depth * 3 + 1);  
   for (int i = 0; i < depth; i++) {  
     strcpy(relative_path_to_ancestor + i * 3, "../");  
   }  
   relative_path_to_ancestor[depth * 3] = '\0';  
   
   fprintf(output, "<html><head><title>%s</title>\n", relative_path);  
   fprintf(output, "<link rel=\"stylesheet\" type='text/css' href='%sjscoverage.css'>\n", relative_path_to_ancestor);  
   fprintf(output, "<link rel=\"stylesheet\" type='text/css' href='%sjscoverage-sh_nedit.css'>\n", relative_path_to_ancestor);  
   fprintf(output, "<script src=\"%sjscoverage.js\"></script>\n", relative_path_to_ancestor);  
   fprintf(output, "<script src=\"%sjscoverage-sh_main.js\"></script>\n", relative_path_to_ancestor);  
   fprintf(output, "<script src=\"%sjscoverage-sh_javascript.js\"></script>\n", relative_path_to_ancestor);  
   fprintf(output, "<script>\n");  
   fprintf(output, "var gCurrentFile = \"%s\";\n", relative_path);  
   fprintf(output, "</script>\n");  
   fprintf(output, "</head><body onload=\"source_load();\">\n");  
   fprintf(output, "<h1>%s</h1>\n", relative_path);  
   fprintf(output, "<pre id=\"sourceDiv\" class='sh_%s'>", file_type == FILE_TYPE_JS? "javascript": "html");  
   free(relative_path_to_ancestor);  
   
   int c;  
   int atLineStart = 1;  
   int line = 1;  
   while ((c = fgetc(input)) != EOF) {  
     if (atLineStart) {  
       atLineStart = 0;  
     }  
   
     if (c == '<') {  
       fprintf(output, "&lt;");  
     }  
     else if (c == '>') {  
       fprintf(output, "&gt;");  
     }  
     else if (c == '&') {  
       fprintf(output, "&amp;");  
     }  
     else {  
       if (c == '\n') {  
         line++;  
         atLineStart = 1;  
       }  
       fputc(c, output);  
     }  
   }  
   fprintf(output, "</pre></body></html>\n");  
   
   fclose(output);  
   fclose(input);  
   
   suffix = ".jscoverage.js";  
   char original_file[strlen(destination_file) + strlen(suffix) + 1];  
   strcpy(original_file, destination_file);  
   strcat(original_file, suffix);  
   copy_file(source_file, original_file);  
 }  
   
61  static void check_same_file(const char * file1, const char * file2) {  static void check_same_file(const char * file1, const char * file2) {
62    if (is_same_file(file1, file2)) {    if (is_same_file(file1, file2)) {
63      fatal("source and destination are the same");      fatal("source and destination are the same");
# Line 157  Line 85 
85    if (instrumenting) {    if (instrumenting) {
86      enum FileType file_type = get_file_type(source_file);      enum FileType file_type = get_file_type(source_file);
87      switch (file_type) {      switch (file_type) {
88      case FILE_TYPE_UNKNOWN:      case FILE_TYPE_OTHER:
89      case FILE_TYPE_HTML:      case FILE_TYPE_HTML:
90        copy_file(source_file, destination_file);        copy_file(source_file, destination_file);
91        break;        break;
92      case FILE_TYPE_JS:      case FILE_TYPE_JS:
93        {        {
94          FILE * input = xfopen(source_file, "r");          FILE * input = xfopen(source_file, "rb");
95          FILE * output = xfopen(destination_file, "w");          FILE * output = xfopen(destination_file, "wb");
96          const char * suffix = ".jscoverage.js";  
97          char temporary_file_name[strlen(destination_file) + strlen(suffix) + 1];          Stream * input_stream = Stream_new(0);
98          strcpy(temporary_file_name, destination_file);          Stream * output_stream = Stream_new(0);
99          strcat(temporary_file_name, suffix);  
100          jscoverage_instrument_js(id, input, output, temporary_file_name);          Stream_write_file_contents(input_stream, input);
101    
102            size_t num_characters = input_stream->length;
103            uint16_t * characters = NULL;
104            int result = jscoverage_bytes_to_characters(jscoverage_encoding, input_stream->data, input_stream->length, &characters, &num_characters);
105            if (result == JSCOVERAGE_ERROR_ENCODING_NOT_SUPPORTED) {
106              fatal("encoding %s not supported", jscoverage_encoding);
107            }
108            else if (result == JSCOVERAGE_ERROR_INVALID_BYTE_SEQUENCE) {
109              fatal("error decoding %s in file %s", jscoverage_encoding, id);
110            }
111            jscoverage_instrument_js(id, characters, num_characters, output_stream);
112            free(characters);
113    
114            if (fwrite(output_stream->data, 1, output_stream->length, output) != output_stream->length) {
115              fatal("cannot write to file: %s", destination_file);
116            }
117    
118            Stream_delete(input_stream);
119            Stream_delete(output_stream);
120    
121          fclose(input);          fclose(input);
122          fclose(output);          fclose(output);
123        }        }
       highlight_file(source_file, destination_file, id);  
124        break;        break;
125      }      }
126    }    }
# Line 215  Line 162 
162        fatal("not a directory: %s", destination);        fatal("not a directory: %s", destination);
163      }      }
164      if (! directory_is_empty(destination)) {      if (! directory_is_empty(destination)) {
165        char * jscoverage_html = make_path(destination, "jscoverage.html");        char * expected_file = NULL;
166        if (stat(jscoverage_html, &buf) == -1) {        if (jscoverage_mode == JSCOVERAGE_MOZILLA) {
167            char * modules_directory = make_path(destination, "modules");
168            expected_file = make_path(modules_directory, "jscoverage.jsm");
169            free(modules_directory);
170          }
171          else {
172            expected_file = make_path(destination, "jscoverage.html");
173          }
174          if (stat(expected_file, &buf) == -1) {
175          fatal("refusing to overwrite directory: %s", destination);          fatal("refusing to overwrite directory: %s", destination);
176        }        }
177        free(jscoverage_html);        free(expected_file);
178      }      }
179    }    }
180    else if (errno == ENOENT) {    else if (errno == ENOENT) {
# Line 230  Line 185 
185    }    }
186    
187    /* copy the resources */    /* copy the resources */
188    jscoverage_copy_resources(destination);    if (jscoverage_mode == JSCOVERAGE_MOZILLA) {
189        char * chrome_directory = make_path(destination, "chrome");
190        char * jscoverage_chrome_directory = make_path(chrome_directory, "jscoverage");
191        mkdirs(jscoverage_chrome_directory);
192        copy_resource("jscoverage.manifest", chrome_directory);
193        copy_resource("jscoverage.html", jscoverage_chrome_directory);
194        copy_resource("jscoverage.css", jscoverage_chrome_directory);
195        copy_resource("jscoverage.js", jscoverage_chrome_directory);
196        copy_resource("jscoverage-throbber.gif", jscoverage_chrome_directory);
197        copy_resource("jscoverage-highlight.css", jscoverage_chrome_directory);
198        copy_resource("jscoverage.xul", jscoverage_chrome_directory);
199        copy_resource("jscoverage-overlay.js", jscoverage_chrome_directory);
200        free(jscoverage_chrome_directory);
201        free(chrome_directory);
202    
203        char * modules_directory = make_path(destination, "modules");
204        mkdirs(modules_directory);
205        copy_resource("jscoverage.jsm", modules_directory);
206        free(modules_directory);
207      }
208      else {
209        jscoverage_copy_resources(destination);
210      }
211    
212    /* finally: copy the directory */    /* finally: copy the directory */
213    struct DirListEntry * list = make_recursive_dir_list(source);    struct DirListEntry * list = make_recursive_dir_list(source);
# Line 269  Line 246 
246      free(s);      free(s);
247      free(d);      free(d);
248    }    }
   free_dir_list(list);  
 }  
249    
250  void jscoverage_copy_resources(const char * destination_directory) {    free_dir_list(list);
   copy_resource("jscoverage.html", destination_directory);  
   copy_resource("jscoverage.css", destination_directory);  
   copy_resource("jscoverage.js", destination_directory);  
   copy_resource("jscoverage-throbber.gif", destination_directory);  
   copy_resource("jscoverage-sh_main.js", destination_directory);  
   copy_resource("jscoverage-sh_javascript.js", destination_directory);  
   copy_resource("jscoverage-sh_nedit.css", destination_directory);  
251  }  }

Legend:
Removed from v.70  
changed lines
  Added in v.431

  ViewVC Help
Powered by ViewVC 1.1.24