comparison: src/scanner.c
src/scanner.c
- changeset 66
- be2084398c37
- parent 61
- 9c8d768f0244
- child 76
- d11c154e33e1
equal
deleted
inserted
replaced
| 65:49fa681f3a7e | 66:be2084398c37 |
|---|---|
| 27 | 27 |
| 28 #include "scanner.h" | 28 #include "scanner.h" |
| 29 #include "bfile_heuristics.h" | 29 #include "bfile_heuristics.h" |
| 30 #include "regex_parser.h" | 30 #include "regex_parser.h" |
| 31 #include <sys/stat.h> | 31 #include <sys/stat.h> |
| 32 #include <ctype.h> | |
| 32 | 33 |
| 33 typedef struct filelist filelist_t; | 34 typedef struct filelist filelist_t; |
| 34 | 35 |
| 35 struct filelist { | 36 struct filelist { |
| 36 char *displayname; | 37 char *displayname; |
| 37 int displayname_len; | 38 unsigned displayname_len; |
| 38 char *filename; | 39 char *filename; |
| 39 char *ext; | 40 char *ext; |
| 40 int st_mode; | 41 unsigned st_mode; |
| 41 filelist_t *next; | 42 filelist_t *next; |
| 42 }; | 43 }; |
| 43 | 44 |
| 44 static bool testSuffix(char* filename, string_list_t* list) { | 45 static bool testSuffix(char* filename, string_list_t* list) { |
| 45 bool ret = false; | 46 bool ret = false; |
| 46 int tokenlen, fnamelen = strlen(filename); | 47 size_t tokenlen, fnamelen = strlen(filename); |
| 47 for (int t = 0 ; t < list->count ; t++) { | 48 for (size_t t = 0 ; t < list->count ; t++) { |
| 48 tokenlen = strlen(list->items[t]); | 49 tokenlen = strlen(list->items[t]); |
| 49 if (fnamelen >= tokenlen && tokenlen > 0) { | 50 if (fnamelen >= tokenlen && tokenlen > 0) { |
| 50 if (strncmp(filename+fnamelen-tokenlen, | 51 if (strncmp(filename+fnamelen-tokenlen, |
| 51 list->items[t], tokenlen) == 0) { | 52 list->items[t], tokenlen) == 0) { |
| 52 ret = true; | 53 ret = true; |
| 55 } | 56 } |
| 56 } | 57 } |
| 57 return ret; | 58 return ret; |
| 58 } | 59 } |
| 59 | 60 |
| 60 static void addLinesPerExtension(scanresult_ext_t* result, | 61 static void addResultPerExtension(scanresult_ext_t* result, |
| 61 char* ext, int lines) { | 62 char* ext, unsigned value) { |
| 62 if (!result) return; | 63 if (!result) return; |
| 63 | 64 |
| 64 if (!ext) ext = "w/o"; | 65 if (!ext) ext = "w/o"; |
| 65 | 66 |
| 66 for (int i = 0 ; i < result->count ; i++) { | 67 for (unsigned i = 0 ; i < result->count ; i++) { |
| 67 if (strcasecmp(result->extensions[i], ext) == 0) { | 68 if (strcasecmp(result->extensions[i], ext) == 0) { |
| 68 result->lines[i] += lines; | 69 result->result[i] += value; |
| 69 return; | 70 return; |
| 70 } | 71 } |
| 71 } | 72 } |
| 72 | 73 |
| 73 if (result->count == result->capacity) { | 74 if (result->count == result->capacity) { |
| 74 int newcap = result->capacity+8; | 75 unsigned newcap = result->capacity+8; |
| 75 char** extarr = realloc(result->extensions, newcap*sizeof(char*)); | 76 char** extarr = realloc(result->extensions, newcap*sizeof(char*)); |
| 76 int* linesarr = realloc(result->lines, newcap*sizeof(int)); | 77 unsigned* resultarr = realloc(result->result, newcap*sizeof(unsigned)); |
| 77 if (!extarr || !linesarr) { | 78 if (!extarr || !resultarr) { |
| 78 fprintf(stderr, "Memory allocation error.\n"); | 79 fprintf(stderr, "Memory allocation error.\n"); |
| 79 abort(); | 80 abort(); |
| 80 } | 81 } |
| 81 result->extensions = extarr; | 82 result->extensions = extarr; |
| 82 result->lines = linesarr; | 83 result->result = resultarr; |
| 83 result->capacity = newcap; | 84 result->capacity = newcap; |
| 84 } | 85 } |
| 85 | 86 |
| 86 result->extensions[result->count] = strdup(ext); | 87 result->extensions[result->count] = strdup(ext); |
| 87 result->lines[result->count] = lines; | 88 result->result[result->count] = value; |
| 88 result->count++; | 89 result->count++; |
| 89 } | 90 } |
| 90 | 91 |
| 91 scanresult_t* new_scanresult_t(settings_t* settings) { | 92 scanresult_t* new_scanresult_t(settings_t* settings) { |
| 92 scanresult_t* result = calloc(1, sizeof(scanresult_t)); | 93 scanresult_t* result = calloc(1, sizeof(scanresult_t)); |
| 97 } | 98 } |
| 98 | 99 |
| 99 void destroy_scanresult_t(scanresult_t* result) { | 100 void destroy_scanresult_t(scanresult_t* result) { |
| 100 if (result->ext) { | 101 if (result->ext) { |
| 101 if (result->ext->count > 0) { | 102 if (result->ext->count > 0) { |
| 102 for (int i = 0 ; i < result->ext->count ; i++) { | 103 for (unsigned i = 0 ; i < result->ext->count ; i++) { |
| 103 free(result->ext->extensions[i]); | 104 free(result->ext->extensions[i]); |
| 104 } | 105 } |
| 105 free(result->ext->extensions); | 106 free(result->ext->extensions); |
| 106 free(result->ext->lines); | 107 free(result->ext->result); |
| 107 } | 108 } |
| 108 free(result->ext); | 109 free(result->ext); |
| 109 } | 110 } |
| 110 free(result); | 111 free(result); |
| 111 } | 112 } |
| 112 | 113 |
| 113 | 114 static filelist_t *buildFileList(scanner_t scanner, settings_t* settings) { |
| 114 static filelist_t *buildFileList(scanner_t scanner, settings_t* settings, | 115 |
| 115 filelist_t* list) { | 116 filelist_t* list = NULL; |
| 116 | |
| 117 DIR *dirf; | 117 DIR *dirf; |
| 118 struct dirent *entry; | 118 struct dirent *entry; |
| 119 struct stat statbuf; | 119 struct stat statbuf; |
| 120 | 120 |
| 121 if ((dirf = opendir(scanner.dir)) == NULL) { | 121 if ((dirf = opendir(scanner.dir)) == NULL) { |
| 157 perror(" Error in stat call"); | 157 perror(" Error in stat call"); |
| 158 continue; | 158 continue; |
| 159 } | 159 } |
| 160 | 160 |
| 161 if (list) { | 161 if (list) { |
| 162 // create fake root to have a pointer on the true root | 162 /* create fake root to have a pointer on the true root */ |
| 163 filelist_t root; | 163 filelist_t root; |
| 164 root.next = list; | 164 root.next = list; |
| 165 filelist_t *parent = &root; | 165 filelist_t *parent = &root; |
| 166 while (parent->next && | 166 while (parent->next && |
| 167 (strcasecmp(parent->next->displayname, newentry->displayname) < 0 || | 167 (strcasecmp(parent->next->displayname, newentry->displayname) < 0 || |
| 186 } | 186 } |
| 187 | 187 |
| 188 void scanDirectory(scanner_t scanner, settings_t* settings, | 188 void scanDirectory(scanner_t scanner, settings_t* settings, |
| 189 string_list_t* output, scanresult_t* result) { | 189 string_list_t* output, scanresult_t* result) { |
| 190 | 190 |
| 191 result->lines = 0; | 191 result->result = 0; |
| 192 int a; | |
| 193 bool bfile; | 192 bool bfile; |
| 194 char *outbuf; | 193 char *outbuf; |
| 195 | 194 const char *result_type = settings->count_chars ? "chars" : "lines"; |
| 196 filelist_t *filelist = buildFileList(scanner, settings, NULL); | 195 |
| 196 filelist_t *filelist = buildFileList(scanner, settings); | |
| 197 | 197 |
| 198 while (filelist != NULL) { | 198 while (filelist != NULL) { |
| 199 | 199 |
| 200 /* Scan subdirectories */ | 200 /* Scan subdirectories */ |
| 201 if (!S_ISREG(filelist->st_mode)) { | 201 if (!S_ISREG(filelist->st_mode)) { |
| 204 scanresult_t recresult; | 204 scanresult_t recresult; |
| 205 recresult.ext = result->ext; | 205 recresult.ext = result->ext; |
| 206 scanDirectory( | 206 scanDirectory( |
| 207 (scanner_t) {filelist->filename, scanner.spaces+1}, | 207 (scanner_t) {filelist->filename, scanner.spaces+1}, |
| 208 settings, recoutput, &recresult); | 208 settings, recoutput, &recresult); |
| 209 result->lines += recresult.lines; | 209 result->result += recresult.result; |
| 210 if (!settings->matchesOnly || recoutput->count > 0) { | 210 if (!settings->matchesOnly || recoutput->count > 0) { |
| 211 outbuf = (char*) malloc(81); | 211 outbuf = (char*) malloc(81); |
| 212 snprintf(outbuf, 81, "%*s/%*s%13d lines\n", | 212 snprintf(outbuf, 81, "%*s/%*s%13u %s\n", |
| 213 filelist->displayname_len+scanner.spaces, filelist->displayname, | 213 filelist->displayname_len+scanner.spaces, filelist->displayname, |
| 214 60-filelist->displayname_len-scanner.spaces-1, "", | 214 60-filelist->displayname_len-scanner.spaces-1, "", |
| 215 recresult.lines); | 215 recresult.result, result_type); |
| 216 add_string(output, outbuf); | 216 add_string(output, outbuf); |
| 217 for (int i = 0 ; i < recoutput->count ; i++) { | 217 for (unsigned i = 0 ; i < recoutput->count ; i++) { |
| 218 add_string(output, recoutput->items[i]); | 218 add_string(output, recoutput->items[i]); |
| 219 } | 219 } |
| 220 } | 220 } |
| 221 destroy_string_list_t(recoutput); | 221 destroy_string_list_t(recoutput); |
| 222 } else { | 222 } else { |
| 223 outbuf = (char*) malloc(81); | 223 outbuf = (char*) malloc(81); |
| 224 snprintf(outbuf, 81, "%*s\n", filelist->displayname_len+scanner.spaces, | 224 snprintf(outbuf, 81, "%*s\n", |
| 225 filelist->displayname); | 225 filelist->displayname_len+scanner.spaces, |
| 226 filelist->displayname); | |
| 226 add_string(output, outbuf); | 227 add_string(output, outbuf); |
| 227 } | 228 } |
| 228 } else { | 229 } else { |
| 229 if ((settings->includeSuffixes->count == 0 | 230 if ((settings->includeSuffixes->count == 0 |
| 230 || testSuffix(filelist->displayname, settings->includeSuffixes)) | 231 || testSuffix(filelist->displayname, settings->includeSuffixes)) |
| 231 && !testSuffix(filelist->displayname, settings->excludeSuffixes)) { | 232 && !testSuffix(filelist->displayname, settings->excludeSuffixes)) { |
| 232 | 233 |
| 233 /* Count lines */ | 234 /* Count */ |
| 234 int lines = 0; | 235 unsigned res_value = 0; |
| 235 bfile = false; | 236 bfile = false; |
| 236 bfile_reset(settings->bfileHeuristics); | 237 bfile_reset(settings->bfileHeuristics); |
| 237 regex_parser_reset(settings->regex); | 238 regex_parser_reset(settings->regex); |
| 238 char line_buffer[REGEX_MAX_LINELENGTH]; | 239 char line_buffer[MAX_LINELENGTH]; |
| 239 int line_buffer_offset = 0; | 240 unsigned line_buffer_pos = 0; |
| 240 | 241 |
| 241 FILE *file = fopen(filelist->filename, "r"); | 242 FILE *file = fopen(filelist->filename, "r"); |
| 242 if (file == NULL) { | 243 if (file == NULL) { |
| 243 outbuf = (char*) malloc(81); | 244 outbuf = (char*) malloc(81); |
| 244 snprintf(outbuf, 81, "%*s", filelist->displayname_len+scanner.spaces, | 245 snprintf(outbuf, 81, "%*s", |
| 245 filelist->displayname); | 246 filelist->displayname_len+scanner.spaces, |
| 247 filelist->displayname); | |
| 246 add_string(output, outbuf); | 248 add_string(output, outbuf); |
| 247 perror(" File acces failed"); | 249 perror(" File acces failed"); |
| 248 } else { | 250 } else { |
| 251 int a; | |
| 249 do { | 252 do { |
| 250 a = fgetc(file); | 253 a = fgetc(file); |
| 251 | 254 |
| 252 bfile = bfile_check(settings->bfileHeuristics, a); | 255 bfile = bfile_check(settings->bfileHeuristics, a); |
| 253 | 256 |
| 257 /* ignore carriage return completely */ | |
| 258 if (a == 13) continue; | |
| 259 | |
| 254 if (a == 10 || a == EOF) { | 260 if (a == 10 || a == EOF) { |
| 255 line_buffer[line_buffer_offset] = 0; | 261 line_buffer[line_buffer_pos] = 0; |
| 256 if (regex_parser_do(settings->regex, line_buffer) == 0) { | 262 if (regex_parser_do(settings->regex, line_buffer) == 0) { |
| 257 /* Only subtract lines when matching has finished */ | 263 /* Subtract excluded lines/chars when matching has finished */ |
| 258 if (!regex_parser_matching(settings->regex)) { | 264 if (!regex_parser_matching(settings->regex)) { |
| 259 lines -= settings->regex->matched_lines; | 265 res_value -= settings->regex->matched_counted; |
| 260 } | 266 } |
| 261 } | 267 } |
| 262 | 268 |
| 263 line_buffer_offset = 0; | 269 if (settings->count_chars) { |
| 264 lines++; | 270 for (size_t i = 0 ; i < line_buffer_pos ; i++) { |
| 271 if (!isspace(line_buffer[i])) res_value++; | |
| 272 } | |
| 273 } else { | |
| 274 res_value++; | |
| 275 } | |
| 276 line_buffer_pos = 0; | |
| 265 } else { | 277 } else { |
| 266 if (line_buffer_offset < REGEX_MAX_LINELENGTH) { | 278 if (line_buffer_pos < MAX_LINELENGTH) { |
| 267 line_buffer[line_buffer_offset] = a; | 279 line_buffer[line_buffer_pos] = (char) a; |
| 268 line_buffer_offset++; | 280 line_buffer_pos++; |
| 269 } else { | 281 } else { |
| 270 line_buffer[line_buffer_offset-1] = 0; | 282 line_buffer[line_buffer_pos - 1] = 0; |
| 271 settings->confusing_lnlen = true; | 283 settings->confusing_lnlen = true; |
| 272 } | 284 } |
| 273 } | 285 } |
| 274 } while (!bfile && a != EOF); | 286 } while (!bfile && a != EOF); |
| 275 fclose(file); | 287 fclose(file); |
| 283 filelist->displayname, | 295 filelist->displayname, |
| 284 60-filelist->displayname_len-scanner.spaces, "", "binary"); | 296 60-filelist->displayname_len-scanner.spaces, "", "binary"); |
| 285 add_string(output, outbuf); | 297 add_string(output, outbuf); |
| 286 } | 298 } |
| 287 } else { | 299 } else { |
| 288 addLinesPerExtension(result->ext, filelist->ext, lines); | 300 addResultPerExtension(result->ext, filelist->ext, res_value); |
| 289 result->lines += lines; | 301 result->result += res_value; |
| 290 outbuf = (char*) malloc(81); | 302 outbuf = (char*) malloc(81); |
| 291 snprintf(outbuf, 81, "%*s%*s%13d lines\n", | 303 snprintf(outbuf, 81, "%*s%*s%13u %s\n", |
| 292 filelist->displayname_len+scanner.spaces, filelist->displayname, | 304 filelist->displayname_len+scanner.spaces, |
| 293 60-filelist->displayname_len-scanner.spaces, "", lines); | 305 filelist->displayname, |
| 306 60-filelist->displayname_len-scanner.spaces, | |
| 307 "", | |
| 308 res_value, | |
| 309 result_type | |
| 310 ); | |
| 294 add_string(output, outbuf); | 311 add_string(output, outbuf); |
| 295 } | 312 } |
| 296 } | 313 } |
| 297 } else { | 314 } else { |
| 298 if (!settings->matchesOnly) { | 315 if (!settings->matchesOnly) { |
