|
1
|
1
|
|
|
2 // Copyright (c) 1999-2006 by Digital Mars
|
|
|
3 // All Rights Reserved
|
|
|
4 // written by Walter Bright
|
|
|
5 // www.digitalmars.com
|
|
|
6 // License for redistribution is by either the Artistic License
|
|
|
7 // in artistic.txt, or the GNU General Public License in gnu.txt.
|
|
|
8 // See the included readme.txt for details.
|
|
|
9
|
|
|
10 #include <stdio.h>
|
|
|
11 #include <stdlib.h>
|
|
|
12 #include <stdarg.h>
|
|
|
13 #include <string.h>
|
|
|
14 #include <stdint.h>
|
|
|
15 #include <assert.h>
|
|
|
16
|
|
|
17 #if _MSC_VER
|
|
|
18 #include <malloc.h>
|
|
|
19 #endif
|
|
|
20
|
|
|
21 #if _WIN32
|
|
|
22 #include <windows.h>
|
|
|
23 #include <direct.h>
|
|
|
24 #endif
|
|
|
25
|
|
|
26 #if linux
|
|
|
27 #include <sys/types.h>
|
|
|
28 #include <sys/stat.h>
|
|
|
29 #include <fcntl.h>
|
|
|
30 #include <errno.h>
|
|
|
31 #include <unistd.h>
|
|
|
32 #include <utime.h>
|
|
|
33 #endif
|
|
|
34
|
|
|
35 #include "port.h"
|
|
|
36 #include "root.h"
|
|
|
37 #include "dchar.h"
|
|
|
38 #include "mem.h"
|
|
|
39
|
|
|
40 #if 0 //__SC__ //def DEBUG
|
|
|
41 extern "C" void __cdecl _assert(void *e, void *f, unsigned line)
|
|
|
42 {
|
|
|
43 printf("Assert('%s','%s',%d)\n",e,f,line);
|
|
|
44 fflush(stdout);
|
|
|
45 *(char *)0 = 0;
|
|
|
46 }
|
|
|
47 #endif
|
|
|
48
|
|
|
49 /*************************************
|
|
|
50 * Convert wchar string to ascii string.
|
|
|
51 */
|
|
|
52
|
|
|
53 char *wchar2ascii(wchar_t *us)
|
|
|
54 {
|
|
|
55 return wchar2ascii(us, wcslen(us));
|
|
|
56 }
|
|
|
57
|
|
|
58 char *wchar2ascii(wchar_t *us, unsigned len)
|
|
|
59 {
|
|
|
60 unsigned i;
|
|
|
61 char *p;
|
|
|
62
|
|
|
63 p = (char *)mem.malloc(len + 1);
|
|
|
64 for (i = 0; i <= len; i++)
|
|
|
65 p[i] = (char) us[i];
|
|
|
66 return p;
|
|
|
67 }
|
|
|
68
|
|
|
69 int wcharIsAscii(wchar_t *us)
|
|
|
70 {
|
|
|
71 return wcharIsAscii(us, wcslen(us));
|
|
|
72 }
|
|
|
73
|
|
|
74 int wcharIsAscii(wchar_t *us, unsigned len)
|
|
|
75 {
|
|
|
76 unsigned i;
|
|
|
77
|
|
|
78 for (i = 0; i <= len; i++)
|
|
|
79 {
|
|
|
80 if (us[i] & ~0xFF) // if high bits set
|
|
|
81 return 0; // it's not ascii
|
|
|
82 }
|
|
|
83 return 1;
|
|
|
84 }
|
|
|
85
|
|
|
86
|
|
|
87 /***********************************
|
|
|
88 * Compare length-prefixed strings (bstr).
|
|
|
89 */
|
|
|
90
|
|
|
91 int bstrcmp(unsigned char *b1, unsigned char *b2)
|
|
|
92 {
|
|
|
93 return (*b1 == *b2 && memcmp(b1 + 1, b2 + 1, *b2) == 0) ? 0 : 1;
|
|
|
94 }
|
|
|
95
|
|
|
96 /***************************************
|
|
|
97 * Convert bstr into a malloc'd string.
|
|
|
98 */
|
|
|
99
|
|
|
100 char *bstr2str(unsigned char *b)
|
|
|
101 {
|
|
|
102 char *s;
|
|
|
103 unsigned len;
|
|
|
104
|
|
|
105 len = *b;
|
|
|
106 s = (char *) mem.malloc(len + 1);
|
|
|
107 s[len] = 0;
|
|
|
108 return (char *)memcpy(s,b + 1,len);
|
|
|
109 }
|
|
|
110
|
|
|
111 /**************************************
|
|
|
112 * Print error message and exit.
|
|
|
113 */
|
|
|
114
|
|
|
115 void error(const char *format, ...)
|
|
|
116 {
|
|
|
117 va_list ap;
|
|
|
118
|
|
|
119 va_start(ap, format);
|
|
|
120 printf("Error: ");
|
|
|
121 vprintf(format, ap);
|
|
|
122 va_end( ap );
|
|
|
123 printf("\n");
|
|
|
124 fflush(stdout);
|
|
|
125
|
|
|
126 exit(EXIT_FAILURE);
|
|
|
127 }
|
|
|
128
|
|
|
129 #if M_UNICODE
|
|
|
130 void error(const dchar *format, ...)
|
|
|
131 {
|
|
|
132 va_list ap;
|
|
|
133
|
|
|
134 va_start(ap, format);
|
|
|
135 printf("Error: ");
|
|
|
136 vwprintf(format, ap);
|
|
|
137 va_end( ap );
|
|
|
138 printf("\n");
|
|
|
139 fflush(stdout);
|
|
|
140
|
|
|
141 exit(EXIT_FAILURE);
|
|
|
142 }
|
|
|
143 #endif
|
|
|
144
|
|
|
145 void error_mem()
|
|
|
146 {
|
|
|
147 error("out of memory");
|
|
|
148 }
|
|
|
149
|
|
|
150 /**************************************
|
|
|
151 * Print warning message.
|
|
|
152 */
|
|
|
153
|
|
|
154 void warning(const char *format, ...)
|
|
|
155 {
|
|
|
156 va_list ap;
|
|
|
157
|
|
|
158 va_start(ap, format);
|
|
|
159 printf("Warning: ");
|
|
|
160 vprintf(format, ap);
|
|
|
161 va_end( ap );
|
|
|
162 printf("\n");
|
|
|
163 fflush(stdout);
|
|
|
164 }
|
|
|
165
|
|
|
166 /****************************** Object ********************************/
|
|
|
167
|
|
|
168 int Object::equals(Object *o)
|
|
|
169 {
|
|
|
170 return o == this;
|
|
|
171 }
|
|
|
172
|
|
|
173 hash_t Object::hashCode()
|
|
|
174 {
|
|
|
175 return (hash_t) this;
|
|
|
176 }
|
|
|
177
|
|
|
178 int Object::compare(Object *obj)
|
|
|
179 {
|
|
|
180 return this - obj;
|
|
|
181 }
|
|
|
182
|
|
|
183 void Object::print()
|
|
|
184 {
|
|
|
185 printf("%s %p\n", toChars(), this);
|
|
|
186 }
|
|
|
187
|
|
|
188 char *Object::toChars()
|
|
|
189 {
|
|
|
190 return "Object";
|
|
|
191 }
|
|
|
192
|
|
|
193 dchar *Object::toDchars()
|
|
|
194 {
|
|
|
195 #if M_UNICODE
|
|
|
196 return L"Object";
|
|
|
197 #else
|
|
|
198 return toChars();
|
|
|
199 #endif
|
|
|
200 }
|
|
|
201
|
|
|
202 int Object::dyncast()
|
|
|
203 {
|
|
|
204 return 0;
|
|
|
205 }
|
|
|
206
|
|
|
207 void Object::toBuffer(OutBuffer *b)
|
|
|
208 {
|
|
|
209 b->writestring("Object");
|
|
|
210 }
|
|
|
211
|
|
|
212 void Object::mark()
|
|
|
213 {
|
|
|
214 }
|
|
|
215
|
|
|
216 /****************************** String ********************************/
|
|
|
217
|
|
|
218 String::String(char *str, int ref)
|
|
|
219 {
|
|
|
220 this->str = ref ? str : mem.strdup(str);
|
|
|
221 this->ref = ref;
|
|
|
222 }
|
|
|
223
|
|
|
224 String::~String()
|
|
|
225 {
|
|
|
226 mem.free(str);
|
|
|
227 }
|
|
|
228
|
|
|
229 void String::mark()
|
|
|
230 {
|
|
|
231 mem.mark(str);
|
|
|
232 }
|
|
|
233
|
|
|
234 hash_t String::calcHash(const char *str, size_t len)
|
|
|
235 {
|
|
|
236 hash_t hash = 0;
|
|
|
237
|
|
|
238 for (;;)
|
|
|
239 {
|
|
|
240 switch (len)
|
|
|
241 {
|
|
|
242 case 0:
|
|
|
243 return hash;
|
|
|
244
|
|
|
245 case 1:
|
|
|
246 hash *= 37;
|
|
|
247 hash += *(uint8_t *)str;
|
|
|
248 return hash;
|
|
|
249
|
|
|
250 case 2:
|
|
|
251 hash *= 37;
|
|
|
252 hash += *(uint16_t *)str;
|
|
|
253 return hash;
|
|
|
254
|
|
|
255 case 3:
|
|
|
256 hash *= 37;
|
|
|
257 hash += (*(uint16_t *)str << 8) +
|
|
|
258 ((uint8_t *)str)[2];
|
|
|
259 return hash;
|
|
|
260
|
|
|
261 default:
|
|
|
262 hash *= 37;
|
|
|
263 hash += *(uint32_t *)str;
|
|
|
264 str += 4;
|
|
|
265 len -= 4;
|
|
|
266 break;
|
|
|
267 }
|
|
|
268 }
|
|
|
269 }
|
|
|
270
|
|
|
271 hash_t String::calcHash(const char *str)
|
|
|
272 {
|
|
|
273 return calcHash(str, strlen(str));
|
|
|
274 }
|
|
|
275
|
|
|
276 hash_t String::hashCode()
|
|
|
277 {
|
|
|
278 return calcHash(str, strlen(str));
|
|
|
279 }
|
|
|
280
|
|
|
281 unsigned String::len()
|
|
|
282 {
|
|
|
283 return strlen(str);
|
|
|
284 }
|
|
|
285
|
|
|
286 int String::equals(Object *obj)
|
|
|
287 {
|
|
|
288 return strcmp(str,((String *)obj)->str) == 0;
|
|
|
289 }
|
|
|
290
|
|
|
291 int String::compare(Object *obj)
|
|
|
292 {
|
|
|
293 return strcmp(str,((String *)obj)->str);
|
|
|
294 }
|
|
|
295
|
|
|
296 char *String::toChars()
|
|
|
297 {
|
|
|
298 return str;
|
|
|
299 }
|
|
|
300
|
|
|
301 void String::print()
|
|
|
302 {
|
|
|
303 printf("String '%s'\n",str);
|
|
|
304 }
|
|
|
305
|
|
|
306
|
|
|
307 /****************************** FileName ********************************/
|
|
|
308
|
|
|
309 FileName::FileName(char *str, int ref)
|
|
|
310 : String(str,ref)
|
|
|
311 {
|
|
|
312 }
|
|
|
313
|
|
|
314 char *FileName::combine(char *path, char *name)
|
|
|
315 { char *f;
|
|
|
316 size_t pathlen;
|
|
|
317 size_t namelen;
|
|
|
318
|
|
|
319 if (!path || !*path)
|
|
|
320 return name;
|
|
|
321 pathlen = strlen(path);
|
|
|
322 namelen = strlen(name);
|
|
|
323 f = (char *)mem.malloc(pathlen + 1 + namelen + 1);
|
|
|
324 memcpy(f, path, pathlen);
|
|
|
325 #if linux
|
|
|
326 if (path[pathlen - 1] != '/')
|
|
|
327 { f[pathlen] = '/';
|
|
|
328 pathlen++;
|
|
|
329 }
|
|
|
330 #endif
|
|
|
331 #if _WIN32
|
|
|
332 if (path[pathlen - 1] != '\\' && path[pathlen - 1] != ':')
|
|
|
333 { f[pathlen] = '\\';
|
|
|
334 pathlen++;
|
|
|
335 }
|
|
|
336 #endif
|
|
|
337 memcpy(f + pathlen, name, namelen + 1);
|
|
|
338 return f;
|
|
|
339 }
|
|
|
340
|
|
|
341 FileName::FileName(char *path, char *name)
|
|
|
342 : String(combine(path,name),1)
|
|
|
343 {
|
|
|
344 }
|
|
|
345
|
|
|
346 // Split a path into an Array of paths
|
|
|
347 Array *FileName::splitPath(const char *path)
|
|
|
348 {
|
|
|
349 char c = 0; // unnecessary initializer is for VC /W4
|
|
|
350 const char *p;
|
|
|
351 OutBuffer buf;
|
|
|
352 Array *array;
|
|
|
353
|
|
|
354 array = new Array();
|
|
|
355 if (path)
|
|
|
356 {
|
|
|
357 p = path;
|
|
|
358 do
|
|
|
359 { char instring = 0;
|
|
|
360
|
|
|
361 while (isspace(*p)) // skip leading whitespace
|
|
|
362 p++;
|
|
|
363 buf.reserve(strlen(p) + 1); // guess size of path
|
|
|
364 for (; ; p++)
|
|
|
365 {
|
|
|
366 c = *p;
|
|
|
367 switch (c)
|
|
|
368 {
|
|
|
369 case '"':
|
|
|
370 instring ^= 1; // toggle inside/outside of string
|
|
|
371 continue;
|
|
|
372
|
|
|
373 #if MACINTOSH
|
|
|
374 case ',':
|
|
|
375 #endif
|
|
|
376 #if _WIN32
|
|
|
377 case ';':
|
|
|
378 #endif
|
|
|
379 #if linux
|
|
|
380 case ':':
|
|
|
381 #endif
|
|
|
382 p++;
|
|
|
383 break; // note that ; cannot appear as part
|
|
|
384 // of a path, quotes won't protect it
|
|
|
385
|
|
|
386 case 0x1A: // ^Z means end of file
|
|
|
387 case 0:
|
|
|
388 break;
|
|
|
389
|
|
|
390 case '\r':
|
|
|
391 continue; // ignore carriage returns
|
|
|
392
|
|
|
393 #if linux
|
|
|
394 case '~':
|
|
|
395 buf.writestring(getenv("HOME"));
|
|
|
396 continue;
|
|
|
397 #endif
|
|
|
398
|
|
|
399 case ' ':
|
|
|
400 case '\t': // tabs in filenames?
|
|
|
401 if (!instring) // if not in string
|
|
|
402 break; // treat as end of path
|
|
|
403 default:
|
|
|
404 buf.writeByte(c);
|
|
|
405 continue;
|
|
|
406 }
|
|
|
407 break;
|
|
|
408 }
|
|
|
409 if (buf.offset) // if path is not empty
|
|
|
410 {
|
|
|
411 buf.writeByte(0); // to asciiz
|
|
|
412 array->push(buf.extractData());
|
|
|
413 }
|
|
|
414 } while (c);
|
|
|
415 }
|
|
|
416 return array;
|
|
|
417 }
|
|
|
418
|
|
|
419 hash_t FileName::hashCode()
|
|
|
420 {
|
|
|
421 #if _WIN32
|
|
|
422 // We need a different hashCode because it must be case-insensitive
|
|
|
423 size_t len = strlen(str);
|
|
|
424 hash_t hash = 0;
|
|
|
425 unsigned char *s = (unsigned char *)str;
|
|
|
426
|
|
|
427 for (;;)
|
|
|
428 {
|
|
|
429 switch (len)
|
|
|
430 {
|
|
|
431 case 0:
|
|
|
432 return hash;
|
|
|
433
|
|
|
434 case 1:
|
|
|
435 hash *= 37;
|
|
|
436 hash += *(uint8_t *)s | 0x20;
|
|
|
437 return hash;
|
|
|
438
|
|
|
439 case 2:
|
|
|
440 hash *= 37;
|
|
|
441 hash += *(uint16_t *)s | 0x2020;
|
|
|
442 return hash;
|
|
|
443
|
|
|
444 case 3:
|
|
|
445 hash *= 37;
|
|
|
446 hash += ((*(uint16_t *)s << 8) +
|
|
|
447 ((uint8_t *)s)[2]) | 0x202020;
|
|
|
448 break;
|
|
|
449
|
|
|
450 default:
|
|
|
451 hash *= 37;
|
|
|
452 hash += *(uint32_t *)s | 0x20202020;
|
|
|
453 s += 4;
|
|
|
454 len -= 4;
|
|
|
455 break;
|
|
|
456 }
|
|
|
457 }
|
|
|
458 #else
|
|
|
459 // darwin HFS is case insensitive, though...
|
|
|
460 return String::hashCode();
|
|
|
461 #endif
|
|
|
462 }
|
|
|
463
|
|
|
464 int FileName::compare(Object *obj)
|
|
|
465 {
|
|
|
466 #if _WIN32
|
|
|
467 return stricmp(str,((FileName *)obj)->str);
|
|
|
468 #else
|
|
|
469 return String::compare(obj);
|
|
|
470 #endif
|
|
|
471 }
|
|
|
472
|
|
|
473 int FileName::equals(Object *obj)
|
|
|
474 {
|
|
|
475 #if _WIN32
|
|
|
476 return stricmp(str,((FileName *)obj)->str) == 0;
|
|
|
477 #else
|
|
|
478 return String::equals(obj);
|
|
|
479 #endif
|
|
|
480 }
|
|
|
481
|
|
|
482 /************************************
|
|
|
483 * Return !=0 if absolute path name.
|
|
|
484 */
|
|
|
485
|
|
|
486 int FileName::absolute(const char *name)
|
|
|
487 {
|
|
|
488 #if _WIN32
|
|
|
489 return (*name == '\\') ||
|
|
|
490 (*name == '/') ||
|
|
|
491 (*name && name[1] == ':');
|
|
|
492 #endif
|
|
|
493 #if linux
|
|
|
494 return (*name == '/');
|
|
|
495 #endif
|
|
|
496 }
|
|
|
497
|
|
|
498 /********************************
|
|
|
499 * Return filename extension (read-only).
|
|
|
500 * If there isn't one, return NULL.
|
|
|
501 */
|
|
|
502
|
|
|
503 char *FileName::ext(const char *str)
|
|
|
504 {
|
|
|
505 char *e;
|
|
|
506 size_t len = strlen(str);
|
|
|
507
|
|
|
508 e = (char *)str + len;
|
|
|
509 for (;;)
|
|
|
510 {
|
|
|
511 switch (*e)
|
|
|
512 { case '.':
|
|
|
513 return e + 1;
|
|
|
514 #if linux
|
|
|
515 case '/':
|
|
|
516 break;
|
|
|
517 #endif
|
|
|
518 #if _WIN32
|
|
|
519 case '\\':
|
|
|
520 case ':':
|
|
|
521 break;
|
|
|
522 #endif
|
|
|
523 default:
|
|
|
524 if (e == str)
|
|
|
525 break;
|
|
|
526 e--;
|
|
|
527 continue;
|
|
|
528 }
|
|
|
529 return NULL;
|
|
|
530 }
|
|
|
531 }
|
|
|
532
|
|
|
533 char *FileName::ext()
|
|
|
534 {
|
|
|
535 return ext(str);
|
|
|
536 }
|
|
|
537
|
|
|
538 /********************************
|
|
|
539 * Return filename name excluding path (read-only).
|
|
|
540 */
|
|
|
541
|
|
|
542 char *FileName::name(const char *str)
|
|
|
543 {
|
|
|
544 char *e;
|
|
|
545 size_t len = strlen(str);
|
|
|
546
|
|
|
547 e = (char *)str + len;
|
|
|
548 for (;;)
|
|
|
549 {
|
|
|
550 switch (*e)
|
|
|
551 {
|
|
|
552 #if linux
|
|
|
553 case '/':
|
|
|
554 return e + 1;
|
|
|
555 #endif
|
|
|
556 #if _WIN32
|
|
|
557 case '\\':
|
|
|
558 case ':':
|
|
|
559 return e + 1;
|
|
|
560 #endif
|
|
|
561 default:
|
|
|
562 if (e == str)
|
|
|
563 break;
|
|
|
564 e--;
|
|
|
565 continue;
|
|
|
566 }
|
|
|
567 return e;
|
|
|
568 }
|
|
|
569 }
|
|
|
570
|
|
|
571 char *FileName::name()
|
|
|
572 {
|
|
|
573 return name(str);
|
|
|
574 }
|
|
|
575
|
|
|
576 /**************************************
|
|
|
577 * Return path portion of str.
|
|
|
578 * Path will does not include trailing path separator.
|
|
|
579 */
|
|
|
580
|
|
|
581 char *FileName::path(const char *str)
|
|
|
582 {
|
|
|
583 char *n = name(str);
|
|
|
584 char *path;
|
|
|
585 size_t pathlen;
|
|
|
586
|
|
|
587 if (n > str)
|
|
|
588 {
|
|
|
589 #if linux
|
|
|
590 if (n[-1] == '/')
|
|
|
591 n--;
|
|
|
592 #endif
|
|
|
593 #if _WIN32
|
|
|
594 if (n[-1] == '\\')
|
|
|
595 n--;
|
|
|
596 #endif
|
|
|
597 }
|
|
|
598 pathlen = n - str;
|
|
|
599 path = (char *)mem.malloc(pathlen + 1);
|
|
|
600 memcpy(path, str, pathlen);
|
|
|
601 path[pathlen] = 0;
|
|
|
602 return path;
|
|
|
603 }
|
|
|
604
|
|
|
605 /**************************************
|
|
|
606 * Replace filename portion of path.
|
|
|
607 */
|
|
|
608
|
|
|
609 char *FileName::replaceName(char *path, char *name)
|
|
|
610 { char *f;
|
|
|
611 char *n;
|
|
|
612 size_t pathlen;
|
|
|
613 size_t namelen;
|
|
|
614
|
|
|
615 if (absolute(name))
|
|
|
616 return name;
|
|
|
617
|
|
|
618 n = FileName::name(path);
|
|
|
619 if (n == path)
|
|
|
620 return name;
|
|
|
621 pathlen = n - path;
|
|
|
622 namelen = strlen(name);
|
|
|
623 f = (char *)mem.malloc(pathlen + 1 + namelen + 1);
|
|
|
624 memcpy(f, path, pathlen);
|
|
|
625 #if linux
|
|
|
626 if (path[pathlen - 1] != '/')
|
|
|
627 { f[pathlen] = '/';
|
|
|
628 pathlen++;
|
|
|
629 }
|
|
|
630 #endif
|
|
|
631 #if _WIN32
|
|
|
632 if (path[pathlen - 1] != '\\' && path[pathlen - 1] != ':')
|
|
|
633 { f[pathlen] = '\\';
|
|
|
634 pathlen++;
|
|
|
635 }
|
|
|
636 #endif
|
|
|
637 memcpy(f + pathlen, name, namelen + 1);
|
|
|
638 return f;
|
|
|
639 }
|
|
|
640
|
|
|
641 /***************************
|
|
|
642 */
|
|
|
643
|
|
|
644 FileName *FileName::defaultExt(const char *name, const char *ext)
|
|
|
645 {
|
|
|
646 char *e;
|
|
|
647 char *s;
|
|
|
648 size_t len;
|
|
|
649 size_t extlen;
|
|
|
650
|
|
|
651 e = FileName::ext(name);
|
|
|
652 if (e) // if already has an extension
|
|
|
653 return new FileName((char *)name, 0);
|
|
|
654
|
|
|
655 len = strlen(name);
|
|
|
656 extlen = strlen(ext);
|
|
|
657 s = (char *)alloca(len + 1 + extlen + 1);
|
|
|
658 memcpy(s,name,len);
|
|
|
659 s[len] = '.';
|
|
|
660 memcpy(s + len + 1, ext, extlen + 1);
|
|
|
661 return new FileName(s, 0);
|
|
|
662 }
|
|
|
663
|
|
|
664 /***************************
|
|
|
665 */
|
|
|
666
|
|
|
667 FileName *FileName::forceExt(const char *name, const char *ext)
|
|
|
668 {
|
|
|
669 char *e;
|
|
|
670 char *s;
|
|
|
671 size_t len;
|
|
|
672 size_t extlen;
|
|
|
673
|
|
|
674 e = FileName::ext(name);
|
|
|
675 if (e) // if already has an extension
|
|
|
676 {
|
|
|
677 len = e - name;
|
|
|
678 extlen = strlen(ext);
|
|
|
679
|
|
|
680 s = (char *)alloca(len + extlen + 1);
|
|
|
681 memcpy(s,name,len);
|
|
|
682 memcpy(s + len, ext, extlen + 1);
|
|
|
683 return new FileName(s, 0);
|
|
|
684 }
|
|
|
685 else
|
|
|
686 return defaultExt(name, ext); // doesn't have one
|
|
|
687 }
|
|
|
688
|
|
|
689 /******************************
|
|
|
690 * Return !=0 if extensions match.
|
|
|
691 */
|
|
|
692
|
|
|
693 int FileName::equalsExt(const char *ext)
|
|
|
694 { const char *e;
|
|
|
695
|
|
|
696 e = FileName::ext();
|
|
|
697 if (!e && !ext)
|
|
|
698 return 1;
|
|
|
699 if (!e || !ext)
|
|
|
700 return 0;
|
|
|
701 #if linux
|
|
|
702 return strcmp(e,ext) == 0;
|
|
|
703 #endif
|
|
|
704 #if _WIN32
|
|
|
705 return stricmp(e,ext) == 0;
|
|
|
706 #endif
|
|
|
707 }
|
|
|
708
|
|
|
709 /*************************************
|
|
|
710 * Copy file from this to to.
|
|
|
711 */
|
|
|
712
|
|
|
713 void FileName::CopyTo(FileName *to)
|
|
|
714 {
|
|
|
715 File file(this);
|
|
|
716
|
|
|
717 #if _WIN32
|
|
|
718 file.touchtime = mem.malloc(sizeof(WIN32_FIND_DATAA)); // keep same file time
|
|
|
719 #endif
|
|
|
720 #if linux
|
|
|
721 file.touchtime = mem.malloc(sizeof(struct stat)); // keep same file time
|
|
|
722 #endif
|
|
|
723 file.readv();
|
|
|
724 file.name = to;
|
|
|
725 file.writev();
|
|
|
726 }
|
|
|
727
|
|
|
728 /*************************************
|
|
|
729 * Search Path for file.
|
|
|
730 * Input:
|
|
|
731 * cwd if !=0, search current directory before searching path
|
|
|
732 */
|
|
|
733
|
|
|
734 char *FileName::searchPath(Array *path, char *name, int cwd)
|
|
|
735 {
|
|
|
736 if (absolute(name))
|
|
|
737 {
|
|
|
738 return exists(name) ? name : NULL;
|
|
|
739 }
|
|
|
740 if (cwd)
|
|
|
741 {
|
|
|
742 if (exists(name))
|
|
|
743 return name;
|
|
|
744 }
|
|
|
745 if (path)
|
|
|
746 { unsigned i;
|
|
|
747
|
|
|
748 for (i = 0; i < path->dim; i++)
|
|
|
749 {
|
|
|
750 char *p = (char *)path->data[i];
|
|
|
751 char *n = combine(p, name);
|
|
|
752
|
|
|
753 if (exists(n))
|
|
|
754 return n;
|
|
|
755 }
|
|
|
756 }
|
|
|
757 return NULL;
|
|
|
758 }
|
|
|
759
|
|
|
760 int FileName::exists(const char *name)
|
|
|
761 {
|
|
|
762 #if linux
|
|
|
763 struct stat st;
|
|
|
764
|
|
|
765 if (stat(name, &st) < 0)
|
|
|
766 return 0;
|
|
|
767 if (S_ISDIR(st.st_mode))
|
|
|
768 return 2;
|
|
|
769 return 1;
|
|
|
770 #endif
|
|
|
771 #if _WIN32
|
|
|
772 DWORD dw;
|
|
|
773 int result;
|
|
|
774
|
|
|
775 dw = GetFileAttributesA(name);
|
|
|
776 if (dw == -1L)
|
|
|
777 result = 0;
|
|
|
778 else if (dw & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
779 result = 2;
|
|
|
780 else
|
|
|
781 result = 1;
|
|
|
782 return result;
|
|
|
783 #endif
|
|
|
784 }
|
|
|
785
|
|
|
786 void FileName::ensurePathExists(const char *path)
|
|
|
787 {
|
|
|
788 //printf("FileName::ensurePathExists(%s)\n", path ? path : "");
|
|
|
789 if (path && *path)
|
|
|
790 {
|
|
|
791 if (!exists(path))
|
|
|
792 {
|
|
|
793 char *p = FileName::path(path);
|
|
|
794 if (*p)
|
|
|
795 {
|
|
|
796 #if _WIN32
|
|
|
797 size_t len = strlen(p);
|
|
|
798 if (len > 2 && p[-1] == ':')
|
|
|
799 { mem.free(p);
|
|
|
800 return;
|
|
|
801 }
|
|
|
802 #endif
|
|
|
803 ensurePathExists(p);
|
|
|
804 mem.free(p);
|
|
|
805 }
|
|
|
806 #if _WIN32
|
|
|
807 if (path[strlen(path) - 1] != '\\')
|
|
|
808 #endif
|
|
|
809 #if linux
|
|
|
810 if (path[strlen(path) - 1] != '\\')
|
|
|
811 #endif
|
|
|
812 {
|
|
|
813 //printf("mkdir(%s)\n", path);
|
|
|
814 #if _WIN32
|
|
|
815 if (mkdir(path))
|
|
|
816 #endif
|
|
|
817 #if linux
|
|
|
818 if (mkdir(path, 0777))
|
|
|
819 #endif
|
|
|
820 error("cannot create directory %s", path);
|
|
|
821 }
|
|
|
822 }
|
|
|
823 }
|
|
|
824 }
|
|
|
825
|
|
|
826 /****************************** File ********************************/
|
|
|
827
|
|
|
828 File::File(FileName *n)
|
|
|
829 {
|
|
|
830 ref = 0;
|
|
|
831 buffer = NULL;
|
|
|
832 len = 0;
|
|
|
833 touchtime = NULL;
|
|
|
834 name = n;
|
|
|
835 }
|
|
|
836
|
|
|
837 File::File(char *n)
|
|
|
838 {
|
|
|
839 ref = 0;
|
|
|
840 buffer = NULL;
|
|
|
841 len = 0;
|
|
|
842 touchtime = NULL;
|
|
|
843 name = new FileName(n, 0);
|
|
|
844 }
|
|
|
845
|
|
|
846 File::~File()
|
|
|
847 {
|
|
|
848 if (buffer)
|
|
|
849 {
|
|
|
850 if (ref == 0)
|
|
|
851 mem.free(buffer);
|
|
|
852 #if _WIN32
|
|
|
853 else if (ref == 2)
|
|
|
854 UnmapViewOfFile(buffer);
|
|
|
855 #endif
|
|
|
856 }
|
|
|
857 if (touchtime)
|
|
|
858 mem.free(touchtime);
|
|
|
859 }
|
|
|
860
|
|
|
861 void File::mark()
|
|
|
862 {
|
|
|
863 mem.mark(buffer);
|
|
|
864 mem.mark(touchtime);
|
|
|
865 mem.mark(name);
|
|
|
866 }
|
|
|
867
|
|
|
868 /*************************************
|
|
|
869 */
|
|
|
870
|
|
|
871 int File::read()
|
|
|
872 {
|
|
|
873 #if linux
|
|
|
874 off_t size;
|
|
|
875 ssize_t numread;
|
|
|
876 int fd;
|
|
|
877 struct stat buf;
|
|
|
878 int result = 0;
|
|
|
879 char *name;
|
|
|
880
|
|
|
881 name = this->name->toChars();
|
|
|
882 //printf("File::read('%s')\n",name);
|
|
|
883 fd = open(name, O_RDONLY);
|
|
|
884 if (fd == -1)
|
|
|
885 { result = errno;
|
|
|
886 //printf("\topen error, errno = %d\n",errno);
|
|
|
887 goto err1;
|
|
|
888 }
|
|
|
889
|
|
|
890 if (!ref)
|
|
|
891 mem.free(buffer);
|
|
|
892 ref = 0; // we own the buffer now
|
|
|
893
|
|
|
894 //printf("\tfile opened\n");
|
|
|
895 if (fstat(fd, &buf))
|
|
|
896 {
|
|
|
897 printf("\tfstat error, errno = %d\n",errno);
|
|
|
898 goto err2;
|
|
|
899 }
|
|
|
900 size = buf.st_size;
|
|
|
901 buffer = (unsigned char *) mem.malloc(size + 2);
|
|
|
902 if (!buffer)
|
|
|
903 {
|
|
|
904 printf("\tmalloc error, errno = %d\n",errno);
|
|
|
905 goto err2;
|
|
|
906 }
|
|
|
907
|
|
|
908 numread = ::read(fd, buffer, size);
|
|
|
909 if (numread != size)
|
|
|
910 {
|
|
|
911 printf("\tread error, errno = %d\n",errno);
|
|
|
912 goto err2;
|
|
|
913 }
|
|
|
914
|
|
|
915 if (touchtime)
|
|
|
916 memcpy(touchtime, &buf, sizeof(buf));
|
|
|
917
|
|
|
918 if (close(fd) == -1)
|
|
|
919 {
|
|
|
920 printf("\tclose error, errno = %d\n",errno);
|
|
|
921 goto err;
|
|
|
922 }
|
|
|
923
|
|
|
924 len = size;
|
|
|
925
|
|
|
926 // Always store a wchar ^Z past end of buffer so scanner has a sentinel
|
|
|
927 buffer[size] = 0; // ^Z is obsolete, use 0
|
|
|
928 buffer[size + 1] = 0;
|
|
|
929 return 0;
|
|
|
930
|
|
|
931 err2:
|
|
|
932 close(fd);
|
|
|
933 err:
|
|
|
934 mem.free(buffer);
|
|
|
935 buffer = NULL;
|
|
|
936 len = 0;
|
|
|
937
|
|
|
938 err1:
|
|
|
939 result = 1;
|
|
|
940 return result;
|
|
|
941 #endif
|
|
|
942 #if _WIN32
|
|
|
943 DWORD size;
|
|
|
944 DWORD numread;
|
|
|
945 HANDLE h;
|
|
|
946 int result = 0;
|
|
|
947 char *name;
|
|
|
948
|
|
|
949 name = this->name->toChars();
|
|
|
950 h = CreateFileA(name,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
|
|
|
951 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,0);
|
|
|
952 if (h == INVALID_HANDLE_VALUE)
|
|
|
953 goto err1;
|
|
|
954
|
|
|
955 if (!ref)
|
|
|
956 mem.free(buffer);
|
|
|
957 ref = 0;
|
|
|
958
|
|
|
959 size = GetFileSize(h,NULL);
|
|
|
960 buffer = (unsigned char *) mem.malloc(size + 2);
|
|
|
961 if (!buffer)
|
|
|
962 goto err2;
|
|
|
963
|
|
|
964 if (ReadFile(h,buffer,size,&numread,NULL) != TRUE)
|
|
|
965 goto err2;
|
|
|
966
|
|
|
967 if (numread != size)
|
|
|
968 goto err2;
|
|
|
969
|
|
|
970 if (touchtime)
|
|
|
971 {
|
|
|
972 if (!GetFileTime(h, NULL, NULL, &((WIN32_FIND_DATAA *)touchtime)->ftLastWriteTime))
|
|
|
973 goto err2;
|
|
|
974 }
|
|
|
975
|
|
|
976 if (!CloseHandle(h))
|
|
|
977 goto err;
|
|
|
978
|
|
|
979 len = size;
|
|
|
980
|
|
|
981 // Always store a wchar ^Z past end of buffer so scanner has a sentinel
|
|
|
982 buffer[size] = 0; // ^Z is obsolete, use 0
|
|
|
983 buffer[size + 1] = 0;
|
|
|
984 return 0;
|
|
|
985
|
|
|
986 err2:
|
|
|
987 CloseHandle(h);
|
|
|
988 err:
|
|
|
989 mem.free(buffer);
|
|
|
990 buffer = NULL;
|
|
|
991 len = 0;
|
|
|
992
|
|
|
993 err1:
|
|
|
994 result = 1;
|
|
|
995 return result;
|
|
|
996 #endif
|
|
|
997 }
|
|
|
998
|
|
|
999 /*****************************
|
|
|
1000 * Read a file with memory mapped file I/O.
|
|
|
1001 */
|
|
|
1002
|
|
|
1003 int File::mmread()
|
|
|
1004 {
|
|
|
1005 #if linux
|
|
|
1006 return read();
|
|
|
1007 #endif
|
|
|
1008 #if _WIN32
|
|
|
1009 HANDLE hFile;
|
|
|
1010 HANDLE hFileMap;
|
|
|
1011 DWORD size;
|
|
|
1012 char *name;
|
|
|
1013
|
|
|
1014 name = this->name->toChars();
|
|
|
1015 hFile = CreateFile(name, GENERIC_READ,
|
|
|
1016 FILE_SHARE_READ, NULL,
|
|
|
1017 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
1018 if (hFile == INVALID_HANDLE_VALUE)
|
|
|
1019 goto Lerr;
|
|
|
1020 size = GetFileSize(hFile, NULL);
|
|
|
1021 //printf(" file created, size %d\n", size);
|
|
|
1022
|
|
|
1023 hFileMap = CreateFileMapping(hFile,NULL,PAGE_READONLY,0,size,NULL);
|
|
|
1024 if (CloseHandle(hFile) != TRUE)
|
|
|
1025 goto Lerr;
|
|
|
1026
|
|
|
1027 if (hFileMap == NULL)
|
|
|
1028 goto Lerr;
|
|
|
1029
|
|
|
1030 //printf(" mapping created\n");
|
|
|
1031
|
|
|
1032 if (!ref)
|
|
|
1033 mem.free(buffer);
|
|
|
1034 ref = 2;
|
|
|
1035 buffer = (unsigned char *)MapViewOfFileEx(hFileMap, FILE_MAP_READ,0,0,size,NULL);
|
|
|
1036 if (CloseHandle(hFileMap) != TRUE)
|
|
|
1037 goto Lerr;
|
|
|
1038 if (buffer == NULL) // mapping view failed
|
|
|
1039 goto Lerr;
|
|
|
1040
|
|
|
1041 len = size;
|
|
|
1042 //printf(" buffer = %p\n", buffer);
|
|
|
1043
|
|
|
1044 return 0;
|
|
|
1045
|
|
|
1046 Lerr:
|
|
|
1047 return GetLastError(); // failure
|
|
|
1048 #endif
|
|
|
1049 }
|
|
|
1050
|
|
|
1051 /*********************************************
|
|
|
1052 * Write a file.
|
|
|
1053 * Returns:
|
|
|
1054 * 0 success
|
|
|
1055 */
|
|
|
1056
|
|
|
1057 int File::write()
|
|
|
1058 {
|
|
|
1059 #if linux
|
|
|
1060 int fd;
|
|
|
1061 ssize_t numwritten;
|
|
|
1062 char *name;
|
|
|
1063
|
|
|
1064 name = this->name->toChars();
|
|
|
1065 fd = open(name, O_CREAT | O_WRONLY | O_TRUNC, 0660);
|
|
|
1066 if (fd == -1)
|
|
|
1067 goto err;
|
|
|
1068
|
|
|
1069 numwritten = ::write(fd, buffer, len);
|
|
|
1070 if (len != numwritten)
|
|
|
1071 goto err2;
|
|
|
1072
|
|
|
1073 if (close(fd) == -1)
|
|
|
1074 goto err;
|
|
|
1075
|
|
|
1076 if (touchtime)
|
|
|
1077 { struct utimbuf ubuf;
|
|
|
1078
|
|
|
1079 ubuf.actime = ((struct stat *)touchtime)->st_atime;
|
|
|
1080 ubuf.modtime = ((struct stat *)touchtime)->st_mtime;
|
|
|
1081 if (utime(name, &ubuf))
|
|
|
1082 goto err;
|
|
|
1083 }
|
|
|
1084 return 0;
|
|
|
1085
|
|
|
1086 err2:
|
|
|
1087 close(fd);
|
|
|
1088 ::remove(name);
|
|
|
1089 err:
|
|
|
1090 return 1;
|
|
|
1091 #endif
|
|
|
1092 #if _WIN32
|
|
|
1093 HANDLE h;
|
|
|
1094 DWORD numwritten;
|
|
|
1095 char *name;
|
|
|
1096
|
|
|
1097 name = this->name->toChars();
|
|
|
1098 h = CreateFileA(name,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,
|
|
|
1099 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,NULL);
|
|
|
1100 if (h == INVALID_HANDLE_VALUE)
|
|
|
1101 goto err;
|
|
|
1102
|
|
|
1103 if (WriteFile(h,buffer,len,&numwritten,NULL) != TRUE)
|
|
|
1104 goto err2;
|
|
|
1105
|
|
|
1106 if (len != numwritten)
|
|
|
1107 goto err2;
|
|
|
1108
|
|
|
1109 if (touchtime) {
|
|
|
1110 SetFileTime(h, NULL, NULL, &((WIN32_FIND_DATAA *)touchtime)->ftLastWriteTime);
|
|
|
1111 }
|
|
|
1112 if (!CloseHandle(h))
|
|
|
1113 goto err;
|
|
|
1114 return 0;
|
|
|
1115
|
|
|
1116 err2:
|
|
|
1117 CloseHandle(h);
|
|
|
1118 DeleteFileA(name);
|
|
|
1119 err:
|
|
|
1120 return 1;
|
|
|
1121 #endif
|
|
|
1122 }
|
|
|
1123
|
|
|
1124 /*********************************************
|
|
|
1125 * Append to a file.
|
|
|
1126 * Returns:
|
|
|
1127 * 0 success
|
|
|
1128 */
|
|
|
1129
|
|
|
1130 int File::append()
|
|
|
1131 {
|
|
|
1132 #if linux
|
|
|
1133 return 1;
|
|
|
1134 #endif
|
|
|
1135 #if _WIN32
|
|
|
1136 HANDLE h;
|
|
|
1137 DWORD numwritten;
|
|
|
1138 char *name;
|
|
|
1139
|
|
|
1140 name = this->name->toChars();
|
|
|
1141 h = CreateFileA(name,GENERIC_WRITE,0,NULL,OPEN_ALWAYS,
|
|
|
1142 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,NULL);
|
|
|
1143 if (h == INVALID_HANDLE_VALUE)
|
|
|
1144 goto err;
|
|
|
1145
|
|
|
1146 #if 1
|
|
|
1147 SetFilePointer(h, 0, NULL, FILE_END);
|
|
|
1148 #else // INVALID_SET_FILE_POINTER doesn't seem to have a definition
|
|
|
1149 if (SetFilePointer(h, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER)
|
|
|
1150 goto err;
|
|
|
1151 #endif
|
|
|
1152
|
|
|
1153 if (WriteFile(h,buffer,len,&numwritten,NULL) != TRUE)
|
|
|
1154 goto err2;
|
|
|
1155
|
|
|
1156 if (len != numwritten)
|
|
|
1157 goto err2;
|
|
|
1158
|
|
|
1159 if (touchtime) {
|
|
|
1160 SetFileTime(h, NULL, NULL, &((WIN32_FIND_DATAA *)touchtime)->ftLastWriteTime);
|
|
|
1161 }
|
|
|
1162 if (!CloseHandle(h))
|
|
|
1163 goto err;
|
|
|
1164 return 0;
|
|
|
1165
|
|
|
1166 err2:
|
|
|
1167 CloseHandle(h);
|
|
|
1168 err:
|
|
|
1169 return 1;
|
|
|
1170 #endif
|
|
|
1171 }
|
|
|
1172
|
|
|
1173 /**************************************
|
|
|
1174 */
|
|
|
1175
|
|
|
1176 void File::readv()
|
|
|
1177 {
|
|
|
1178 if (read())
|
|
|
1179 error("Error reading file '%s'\n",name->toChars());
|
|
|
1180 }
|
|
|
1181
|
|
|
1182 /**************************************
|
|
|
1183 */
|
|
|
1184
|
|
|
1185 void File::mmreadv()
|
|
|
1186 {
|
|
|
1187 if (mmread())
|
|
|
1188 readv();
|
|
|
1189 }
|
|
|
1190
|
|
|
1191 void File::writev()
|
|
|
1192 {
|
|
|
1193 if (write())
|
|
|
1194 error("Error writing file '%s'\n",name->toChars());
|
|
|
1195 }
|
|
|
1196
|
|
|
1197 void File::appendv()
|
|
|
1198 {
|
|
|
1199 if (write())
|
|
|
1200 error("Error appending to file '%s'\n",name->toChars());
|
|
|
1201 }
|
|
|
1202
|
|
|
1203 /*******************************************
|
|
|
1204 * Return !=0 if file exists.
|
|
|
1205 * 0: file doesn't exist
|
|
|
1206 * 1: normal file
|
|
|
1207 * 2: directory
|
|
|
1208 */
|
|
|
1209
|
|
|
1210 int File::exists()
|
|
|
1211 {
|
|
|
1212 #if linux
|
|
|
1213 return 0;
|
|
|
1214 #endif
|
|
|
1215 #if _WIN32
|
|
|
1216 DWORD dw;
|
|
|
1217 int result;
|
|
|
1218 char *name;
|
|
|
1219
|
|
|
1220 name = this->name->toChars();
|
|
|
1221 if (touchtime)
|
|
|
1222 dw = ((WIN32_FIND_DATAA *)touchtime)->dwFileAttributes;
|
|
|
1223 else
|
|
|
1224 dw = GetFileAttributesA(name);
|
|
|
1225 if (dw == -1L)
|
|
|
1226 result = 0;
|
|
|
1227 else if (dw & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
1228 result = 2;
|
|
|
1229 else
|
|
|
1230 result = 1;
|
|
|
1231 return result;
|
|
|
1232 #endif
|
|
|
1233 }
|
|
|
1234
|
|
|
1235 void File::remove()
|
|
|
1236 {
|
|
|
1237 #if linux
|
|
|
1238 ::remove(this->name->toChars());
|
|
|
1239 #endif
|
|
|
1240 #if _WIN32
|
|
|
1241 DeleteFileA(this->name->toChars());
|
|
|
1242 #endif
|
|
|
1243 }
|
|
|
1244
|
|
|
1245 Array *File::match(char *n)
|
|
|
1246 {
|
|
|
1247 return match(new FileName(n, 0));
|
|
|
1248 }
|
|
|
1249
|
|
|
1250 Array *File::match(FileName *n)
|
|
|
1251 {
|
|
|
1252 #if linux
|
|
|
1253 return NULL;
|
|
|
1254 #endif
|
|
|
1255 #if _WIN32
|
|
|
1256 HANDLE h;
|
|
|
1257 WIN32_FIND_DATAA fileinfo;
|
|
|
1258 Array *a;
|
|
|
1259 char *c;
|
|
|
1260 char *name;
|
|
|
1261
|
|
|
1262 a = new Array();
|
|
|
1263 c = n->toChars();
|
|
|
1264 name = n->name();
|
|
|
1265 h = FindFirstFileA(c,&fileinfo);
|
|
|
1266 if (h != INVALID_HANDLE_VALUE)
|
|
|
1267 {
|
|
|
1268 do
|
|
|
1269 {
|
|
|
1270 // Glue path together with name
|
|
|
1271 char *fn;
|
|
|
1272 File *f;
|
|
|
1273
|
|
|
1274 fn = (char *)mem.malloc(name - c + strlen(fileinfo.cFileName) + 1);
|
|
|
1275 memcpy(fn, c, name - c);
|
|
|
1276 strcpy(fn + (name - c), fileinfo.cFileName);
|
|
|
1277 f = new File(fn);
|
|
|
1278 f->touchtime = mem.malloc(sizeof(WIN32_FIND_DATAA));
|
|
|
1279 memcpy(f->touchtime, &fileinfo, sizeof(fileinfo));
|
|
|
1280 a->push(f);
|
|
|
1281 } while (FindNextFileA(h,&fileinfo) != FALSE);
|
|
|
1282 FindClose(h);
|
|
|
1283 }
|
|
|
1284 return a;
|
|
|
1285 #endif
|
|
|
1286 }
|
|
|
1287
|
|
|
1288 int File::compareTime(File *f)
|
|
|
1289 {
|
|
|
1290 #if linux
|
|
|
1291 return 0;
|
|
|
1292 #endif
|
|
|
1293 #if _WIN32
|
|
|
1294 if (!touchtime)
|
|
|
1295 stat();
|
|
|
1296 if (!f->touchtime)
|
|
|
1297 f->stat();
|
|
|
1298 return CompareFileTime(&((WIN32_FIND_DATAA *)touchtime)->ftLastWriteTime, &((WIN32_FIND_DATAA *)f->touchtime)->ftLastWriteTime);
|
|
|
1299 #endif
|
|
|
1300 }
|
|
|
1301
|
|
|
1302 void File::stat()
|
|
|
1303 {
|
|
|
1304 #if linux
|
|
|
1305 if (!touchtime)
|
|
|
1306 {
|
|
|
1307 touchtime = mem.calloc(1, sizeof(struct stat));
|
|
|
1308 }
|
|
|
1309 #endif
|
|
|
1310 #if _WIN32
|
|
|
1311 HANDLE h;
|
|
|
1312
|
|
|
1313 if (!touchtime)
|
|
|
1314 {
|
|
|
1315 touchtime = mem.calloc(1, sizeof(WIN32_FIND_DATAA));
|
|
|
1316 }
|
|
|
1317 h = FindFirstFileA(name->toChars(),(WIN32_FIND_DATAA *)touchtime);
|
|
|
1318 if (h != INVALID_HANDLE_VALUE)
|
|
|
1319 {
|
|
|
1320 FindClose(h);
|
|
|
1321 }
|
|
|
1322 #endif
|
|
|
1323 }
|
|
|
1324
|
|
|
1325 void File::checkoffset(size_t offset, size_t nbytes)
|
|
|
1326 {
|
|
|
1327 if (offset > len || offset + nbytes > len)
|
|
|
1328 error("Corrupt file '%s': offset x%zx off end of file",toChars(),offset);
|
|
|
1329 }
|
|
|
1330
|
|
|
1331 char *File::toChars()
|
|
|
1332 {
|
|
|
1333 return name->toChars();
|
|
|
1334 }
|
|
|
1335
|
|
|
1336
|
|
|
1337 /************************* OutBuffer *************************/
|
|
|
1338
|
|
|
1339 OutBuffer::OutBuffer()
|
|
|
1340 {
|
|
|
1341 data = NULL;
|
|
|
1342 offset = 0;
|
|
|
1343 size = 0;
|
|
|
1344 }
|
|
|
1345
|
|
|
1346 OutBuffer::~OutBuffer()
|
|
|
1347 {
|
|
|
1348 mem.free(data);
|
|
|
1349 }
|
|
|
1350
|
|
|
1351 void *OutBuffer::extractData()
|
|
|
1352 {
|
|
|
1353 void *p;
|
|
|
1354
|
|
|
1355 p = (void *)data;
|
|
|
1356 data = NULL;
|
|
|
1357 offset = 0;
|
|
|
1358 size = 0;
|
|
|
1359 return p;
|
|
|
1360 }
|
|
|
1361
|
|
|
1362 void OutBuffer::mark()
|
|
|
1363 {
|
|
|
1364 mem.mark(data);
|
|
|
1365 }
|
|
|
1366
|
|
|
1367 void OutBuffer::reserve(unsigned nbytes)
|
|
|
1368 {
|
|
|
1369 //printf("OutBuffer::reserve: size = %d, offset = %d, nbytes = %d\n", size, offset, nbytes);
|
|
|
1370 if (size - offset < nbytes)
|
|
|
1371 {
|
|
|
1372 size = (offset + nbytes) * 2;
|
|
|
1373 data = (unsigned char *)mem.realloc(data, size);
|
|
|
1374 }
|
|
|
1375 }
|
|
|
1376
|
|
|
1377 void OutBuffer::reset()
|
|
|
1378 {
|
|
|
1379 offset = 0;
|
|
|
1380 }
|
|
|
1381
|
|
|
1382 void OutBuffer::setsize(unsigned size)
|
|
|
1383 {
|
|
|
1384 offset = size;
|
|
|
1385 }
|
|
|
1386
|
|
|
1387 void OutBuffer::write(const void *data, unsigned nbytes)
|
|
|
1388 {
|
|
|
1389 reserve(nbytes);
|
|
|
1390 memcpy(this->data + offset, data, nbytes);
|
|
|
1391 offset += nbytes;
|
|
|
1392 }
|
|
|
1393
|
|
|
1394 void OutBuffer::writebstring(unsigned char *string)
|
|
|
1395 {
|
|
|
1396 write(string,*string + 1);
|
|
|
1397 }
|
|
|
1398
|
|
|
1399 void OutBuffer::writestring(char *string)
|
|
|
1400 {
|
|
|
1401 write(string,strlen(string));
|
|
|
1402 }
|
|
|
1403
|
|
|
1404 void OutBuffer::writedstring(const char *string)
|
|
|
1405 {
|
|
|
1406 #if M_UNICODE
|
|
|
1407 for (; *string; string++)
|
|
|
1408 {
|
|
|
1409 writedchar(*string);
|
|
|
1410 }
|
|
|
1411 #else
|
|
|
1412 write(string,strlen(string));
|
|
|
1413 #endif
|
|
|
1414 }
|
|
|
1415
|
|
|
1416 void OutBuffer::writedstring(const wchar_t *string)
|
|
|
1417 {
|
|
|
1418 #if M_UNICODE
|
|
|
1419 write(string,wcslen(string) * sizeof(wchar_t));
|
|
|
1420 #else
|
|
|
1421 for (; *string; string++)
|
|
|
1422 {
|
|
|
1423 writedchar(*string);
|
|
|
1424 }
|
|
|
1425 #endif
|
|
|
1426 }
|
|
|
1427
|
|
|
1428 void OutBuffer::prependstring(char *string)
|
|
|
1429 { unsigned len;
|
|
|
1430
|
|
|
1431 len = strlen(string);
|
|
|
1432 reserve(len);
|
|
|
1433 memmove(data + len, data, offset);
|
|
|
1434 memcpy(data, string, len);
|
|
|
1435 offset += len;
|
|
|
1436 }
|
|
|
1437
|
|
|
1438 void OutBuffer::writenl()
|
|
|
1439 {
|
|
|
1440 #if _WIN32
|
|
|
1441 #if M_UNICODE
|
|
|
1442 write4(0x000A000D); // newline is CR,LF on Microsoft OS's
|
|
|
1443 #else
|
|
|
1444 writeword(0x0A0D); // newline is CR,LF on Microsoft OS's
|
|
|
1445 #endif
|
|
|
1446 #else
|
|
|
1447 #if M_UNICODE
|
|
|
1448 writeword('\n');
|
|
|
1449 #else
|
|
|
1450 writeByte('\n');
|
|
|
1451 #endif
|
|
|
1452 #endif
|
|
|
1453 }
|
|
|
1454
|
|
|
1455 void OutBuffer::writeByte(unsigned b)
|
|
|
1456 {
|
|
|
1457 reserve(1);
|
|
|
1458 this->data[offset] = (unsigned char)b;
|
|
|
1459 offset++;
|
|
|
1460 }
|
|
|
1461
|
|
|
1462 void OutBuffer::writeUTF8(unsigned b)
|
|
|
1463 {
|
|
|
1464 reserve(6);
|
|
|
1465 if (b <= 0x7F)
|
|
|
1466 {
|
|
|
1467 this->data[offset] = (unsigned char)b;
|
|
|
1468 offset++;
|
|
|
1469 }
|
|
|
1470 else if (b <= 0x7FF)
|
|
|
1471 {
|
|
|
1472 this->data[offset + 0] = (unsigned char)((b >> 6) | 0xC0);
|
|
|
1473 this->data[offset + 1] = (unsigned char)((b & 0x3F) | 0x80);
|
|
|
1474 offset += 2;
|
|
|
1475 }
|
|
|
1476 else if (b <= 0xFFFF)
|
|
|
1477 {
|
|
|
1478 this->data[offset + 0] = (unsigned char)((b >> 12) | 0xE0);
|
|
|
1479 this->data[offset + 1] = (unsigned char)(((b >> 6) & 0x3F) | 0x80);
|
|
|
1480 this->data[offset + 2] = (unsigned char)((b & 0x3F) | 0x80);
|
|
|
1481 offset += 3;
|
|
|
1482 }
|
|
|
1483 else if (b <= 0x1FFFFF)
|
|
|
1484 {
|
|
|
1485 this->data[offset + 0] = (unsigned char)((b >> 18) | 0xF0);
|
|
|
1486 this->data[offset + 1] = (unsigned char)(((b >> 12) & 0x3F) | 0x80);
|
|
|
1487 this->data[offset + 2] = (unsigned char)(((b >> 6) & 0x3F) | 0x80);
|
|
|
1488 this->data[offset + 3] = (unsigned char)((b & 0x3F) | 0x80);
|
|
|
1489 offset += 4;
|
|
|
1490 }
|
|
|
1491 else if (b <= 0x3FFFFFF)
|
|
|
1492 {
|
|
|
1493 this->data[offset + 0] = (unsigned char)((b >> 24) | 0xF8);
|
|
|
1494 this->data[offset + 1] = (unsigned char)(((b >> 18) & 0x3F) | 0x80);
|
|
|
1495 this->data[offset + 2] = (unsigned char)(((b >> 12) & 0x3F) | 0x80);
|
|
|
1496 this->data[offset + 3] = (unsigned char)(((b >> 6) & 0x3F) | 0x80);
|
|
|
1497 this->data[offset + 4] = (unsigned char)((b & 0x3F) | 0x80);
|
|
|
1498 offset += 5;
|
|
|
1499 }
|
|
|
1500 else if (b <= 0x7FFFFFFF)
|
|
|
1501 {
|
|
|
1502 this->data[offset + 0] = (unsigned char)((b >> 30) | 0xFC);
|
|
|
1503 this->data[offset + 1] = (unsigned char)(((b >> 24) & 0x3F) | 0x80);
|
|
|
1504 this->data[offset + 2] = (unsigned char)(((b >> 18) & 0x3F) | 0x80);
|
|
|
1505 this->data[offset + 3] = (unsigned char)(((b >> 12) & 0x3F) | 0x80);
|
|
|
1506 this->data[offset + 4] = (unsigned char)(((b >> 6) & 0x3F) | 0x80);
|
|
|
1507 this->data[offset + 5] = (unsigned char)((b & 0x3F) | 0x80);
|
|
|
1508 offset += 6;
|
|
|
1509 }
|
|
|
1510 else
|
|
|
1511 assert(0);
|
|
|
1512 }
|
|
|
1513
|
|
|
1514 void OutBuffer::writedchar(unsigned b)
|
|
|
1515 {
|
|
|
1516 reserve(Dchar_mbmax * sizeof(dchar));
|
|
|
1517 offset = (unsigned char *)Dchar::put((dchar *)(this->data + offset), (dchar)b) -
|
|
|
1518 this->data;
|
|
|
1519 }
|
|
|
1520
|
|
|
1521 void OutBuffer::prependbyte(unsigned b)
|
|
|
1522 {
|
|
|
1523 reserve(1);
|
|
|
1524 memmove(data + 1, data, offset);
|
|
|
1525 data[0] = (unsigned char)b;
|
|
|
1526 offset++;
|
|
|
1527 }
|
|
|
1528
|
|
|
1529 void OutBuffer::writeword(unsigned w)
|
|
|
1530 {
|
|
|
1531 reserve(2);
|
|
|
1532 *(unsigned short *)(this->data + offset) = (unsigned short)w;
|
|
|
1533 offset += 2;
|
|
|
1534 }
|
|
|
1535
|
|
|
1536 void OutBuffer::writeUTF16(unsigned w)
|
|
|
1537 {
|
|
|
1538 reserve(4);
|
|
|
1539 if (w <= 0xFFFF)
|
|
|
1540 {
|
|
|
1541 *(unsigned short *)(this->data + offset) = (unsigned short)w;
|
|
|
1542 offset += 2;
|
|
|
1543 }
|
|
|
1544 else if (w <= 0x10FFFF)
|
|
|
1545 {
|
|
|
1546 *(unsigned short *)(this->data + offset) = (unsigned short)((w >> 10) + 0xD7C0);
|
|
|
1547 *(unsigned short *)(this->data + offset + 2) = (unsigned short)((w & 0x3FF) | 0xDC00);
|
|
|
1548 offset += 4;
|
|
|
1549 }
|
|
|
1550 else
|
|
|
1551 assert(0);
|
|
|
1552 }
|
|
|
1553
|
|
|
1554 void OutBuffer::write4(unsigned w)
|
|
|
1555 {
|
|
|
1556 reserve(4);
|
|
|
1557 *(unsigned long *)(this->data + offset) = w;
|
|
|
1558 offset += 4;
|
|
|
1559 }
|
|
|
1560
|
|
|
1561 void OutBuffer::write(OutBuffer *buf)
|
|
|
1562 {
|
|
|
1563 if (buf)
|
|
|
1564 { reserve(buf->offset);
|
|
|
1565 memcpy(data + offset, buf->data, buf->offset);
|
|
|
1566 offset += buf->offset;
|
|
|
1567 }
|
|
|
1568 }
|
|
|
1569
|
|
|
1570 void OutBuffer::write(Object *obj)
|
|
|
1571 {
|
|
|
1572 if (obj)
|
|
|
1573 {
|
|
|
1574 writestring(obj->toChars());
|
|
|
1575 }
|
|
|
1576 }
|
|
|
1577
|
|
|
1578 void OutBuffer::fill0(unsigned nbytes)
|
|
|
1579 {
|
|
|
1580 reserve(nbytes);
|
|
|
1581 memset(data + offset,0,nbytes);
|
|
|
1582 offset += nbytes;
|
|
|
1583 }
|
|
|
1584
|
|
|
1585 void OutBuffer::align(unsigned size)
|
|
|
1586 { unsigned nbytes;
|
|
|
1587
|
|
|
1588 nbytes = ((offset + size - 1) & ~(size - 1)) - offset;
|
|
|
1589 fill0(nbytes);
|
|
|
1590 }
|
|
|
1591
|
|
|
1592 void OutBuffer::vprintf(const char *format, va_list args)
|
|
|
1593 {
|
|
|
1594 char buffer[128];
|
|
|
1595 char *p;
|
|
|
1596 unsigned psize;
|
|
|
1597 int count;
|
|
|
1598
|
|
|
1599 p = buffer;
|
|
|
1600 psize = sizeof(buffer);
|
|
|
1601 for (;;)
|
|
|
1602 {
|
|
|
1603 #if _WIN32
|
|
|
1604 count = _vsnprintf(p,psize,format,args);
|
|
|
1605 if (count != -1)
|
|
|
1606 break;
|
|
|
1607 psize *= 2;
|
|
|
1608 #endif
|
|
|
1609 #if linux
|
|
|
1610 count = vsnprintf(p,psize,format,args);
|
|
|
1611 if (count == -1)
|
|
|
1612 psize *= 2;
|
|
|
1613 else if (count >= psize)
|
|
|
1614 psize = count + 1;
|
|
|
1615 else
|
|
|
1616 break;
|
|
|
1617 #endif
|
|
|
1618 p = (char *) alloca(psize); // buffer too small, try again with larger size
|
|
|
1619 }
|
|
|
1620 write(p,count);
|
|
|
1621 }
|
|
|
1622
|
|
|
1623 #if M_UNICODE
|
|
|
1624 void OutBuffer::vprintf(const wchar_t *format, va_list args)
|
|
|
1625 {
|
|
|
1626 dchar buffer[128];
|
|
|
1627 dchar *p;
|
|
|
1628 unsigned psize;
|
|
|
1629 int count;
|
|
|
1630
|
|
|
1631 p = buffer;
|
|
|
1632 psize = sizeof(buffer) / sizeof(buffer[0]);
|
|
|
1633 for (;;)
|
|
|
1634 {
|
|
|
1635 #if _WIN32
|
|
|
1636 count = _vsnwprintf(p,psize,format,args);
|
|
|
1637 if (count != -1)
|
|
|
1638 break;
|
|
|
1639 psize *= 2;
|
|
|
1640 #endif
|
|
|
1641 #if linux
|
|
|
1642 count = vsnwprintf(p,psize,format,args);
|
|
|
1643 if (count == -1)
|
|
|
1644 psize *= 2;
|
|
|
1645 else if (count >= psize)
|
|
|
1646 psize = count + 1;
|
|
|
1647 else
|
|
|
1648 break;
|
|
|
1649 #endif
|
|
|
1650 p = (dchar *) alloca(psize * 2); // buffer too small, try again with larger size
|
|
|
1651 }
|
|
|
1652 write(p,count * 2);
|
|
|
1653 }
|
|
|
1654 #endif
|
|
|
1655
|
|
|
1656 void OutBuffer::printf(const char *format, ...)
|
|
|
1657 {
|
|
|
1658 va_list ap;
|
|
|
1659 va_start(ap, format);
|
|
|
1660 vprintf(format,ap);
|
|
|
1661 va_end(ap);
|
|
|
1662 }
|
|
|
1663
|
|
|
1664 #if M_UNICODE
|
|
|
1665 void OutBuffer::printf(const wchar_t *format, ...)
|
|
|
1666 {
|
|
|
1667 va_list ap;
|
|
|
1668 va_start(ap, format);
|
|
|
1669 vprintf(format,ap);
|
|
|
1670 va_end(ap);
|
|
|
1671 }
|
|
|
1672 #endif
|
|
|
1673
|
|
|
1674 void OutBuffer::bracket(char left, char right)
|
|
|
1675 {
|
|
|
1676 reserve(2);
|
|
|
1677 memmove(data + 1, data, offset);
|
|
|
1678 data[0] = left;
|
|
|
1679 data[offset + 1] = right;
|
|
|
1680 offset += 2;
|
|
|
1681 }
|
|
|
1682
|
|
|
1683 /******************
|
|
|
1684 * Insert left at i, and right at j.
|
|
|
1685 * Return index just past right.
|
|
|
1686 */
|
|
|
1687
|
|
|
1688 unsigned OutBuffer::bracket(unsigned i, char *left, unsigned j, char *right)
|
|
|
1689 {
|
|
|
1690 size_t leftlen = strlen(left);
|
|
|
1691 size_t rightlen = strlen(right);
|
|
|
1692 reserve(leftlen + rightlen);
|
|
|
1693 insert(i, left, leftlen);
|
|
|
1694 insert(j + leftlen, right, rightlen);
|
|
|
1695 return j + leftlen + rightlen;
|
|
|
1696 }
|
|
|
1697
|
|
|
1698 void OutBuffer::spread(unsigned offset, unsigned nbytes)
|
|
|
1699 {
|
|
|
1700 reserve(nbytes);
|
|
|
1701 memmove(data + offset + nbytes, data + offset,
|
|
|
1702 this->offset - offset);
|
|
|
1703 this->offset += nbytes;
|
|
|
1704 }
|
|
|
1705
|
|
|
1706 /****************************************
|
|
|
1707 * Returns: offset + nbytes
|
|
|
1708 */
|
|
|
1709
|
|
|
1710 unsigned OutBuffer::insert(unsigned offset, const void *p, unsigned nbytes)
|
|
|
1711 {
|
|
|
1712 spread(offset, nbytes);
|
|
|
1713 memmove(data + offset, p, nbytes);
|
|
|
1714 return offset + nbytes;
|
|
|
1715 }
|
|
|
1716
|
|
|
1717 void OutBuffer::remove(unsigned offset, unsigned nbytes)
|
|
|
1718 {
|
|
|
1719 memmove(data + offset, data + offset + nbytes, this->offset - (offset + nbytes));
|
|
|
1720 this->offset -= nbytes;
|
|
|
1721 }
|
|
|
1722
|
|
|
1723 char *OutBuffer::toChars()
|
|
|
1724 {
|
|
|
1725 writeByte(0);
|
|
|
1726 return (char *)data;
|
|
|
1727 }
|
|
|
1728
|
|
|
1729 /********************************* Bits ****************************/
|
|
|
1730
|
|
|
1731 Bits::Bits()
|
|
|
1732 {
|
|
|
1733 data = NULL;
|
|
|
1734 bitdim = 0;
|
|
|
1735 allocdim = 0;
|
|
|
1736 }
|
|
|
1737
|
|
|
1738 Bits::~Bits()
|
|
|
1739 {
|
|
|
1740 mem.free(data);
|
|
|
1741 }
|
|
|
1742
|
|
|
1743 void Bits::mark()
|
|
|
1744 {
|
|
|
1745 mem.mark(data);
|
|
|
1746 }
|
|
|
1747
|
|
|
1748 void Bits::resize(unsigned bitdim)
|
|
|
1749 {
|
|
|
1750 unsigned allocdim;
|
|
|
1751 unsigned mask;
|
|
|
1752
|
|
|
1753 allocdim = (bitdim + 31) / 32;
|
|
|
1754 data = (unsigned *)mem.realloc(data, allocdim * sizeof(data[0]));
|
|
|
1755 if (this->allocdim < allocdim)
|
|
|
1756 memset(data + this->allocdim, 0, (allocdim - this->allocdim) * sizeof(data[0]));
|
|
|
1757
|
|
|
1758 // Clear other bits in last word
|
|
|
1759 mask = (1 << (bitdim & 31)) - 1;
|
|
|
1760 if (mask)
|
|
|
1761 data[allocdim - 1] &= ~mask;
|
|
|
1762
|
|
|
1763 this->bitdim = bitdim;
|
|
|
1764 this->allocdim = allocdim;
|
|
|
1765 }
|
|
|
1766
|
|
|
1767 void Bits::set(unsigned bitnum)
|
|
|
1768 {
|
|
|
1769 data[bitnum / 32] |= 1 << (bitnum & 31);
|
|
|
1770 }
|
|
|
1771
|
|
|
1772 void Bits::clear(unsigned bitnum)
|
|
|
1773 {
|
|
|
1774 data[bitnum / 32] &= ~(1 << (bitnum & 31));
|
|
|
1775 }
|
|
|
1776
|
|
|
1777 int Bits::test(unsigned bitnum)
|
|
|
1778 {
|
|
|
1779 return data[bitnum / 32] & (1 << (bitnum & 31));
|
|
|
1780 }
|
|
|
1781
|
|
|
1782 void Bits::set()
|
|
|
1783 { unsigned mask;
|
|
|
1784
|
|
|
1785 memset(data, ~0, allocdim * sizeof(data[0]));
|
|
|
1786
|
|
|
1787 // Clear other bits in last word
|
|
|
1788 mask = (1 << (bitdim & 31)) - 1;
|
|
|
1789 if (mask)
|
|
|
1790 data[allocdim - 1] &= mask;
|
|
|
1791 }
|
|
|
1792
|
|
|
1793 void Bits::clear()
|
|
|
1794 {
|
|
|
1795 memset(data, 0, allocdim * sizeof(data[0]));
|
|
|
1796 }
|
|
|
1797
|
|
|
1798 void Bits::copy(Bits *from)
|
|
|
1799 {
|
|
|
1800 assert(bitdim == from->bitdim);
|
|
|
1801 memcpy(data, from->data, allocdim * sizeof(data[0]));
|
|
|
1802 }
|
|
|
1803
|
|
|
1804 Bits *Bits::clone()
|
|
|
1805 {
|
|
|
1806 Bits *b;
|
|
|
1807
|
|
|
1808 b = new Bits();
|
|
|
1809 b->resize(bitdim);
|
|
|
1810 b->copy(this);
|
|
|
1811 return b;
|
|
|
1812 }
|
|
|
1813
|
|
|
1814 void Bits::sub(Bits *b)
|
|
|
1815 {
|
|
|
1816 unsigned u;
|
|
|
1817
|
|
|
1818 for (u = 0; u < allocdim; u++)
|
|
|
1819 data[u] &= ~b->data[u];
|
|
|
1820 }
|
|
|
1821
|
|
|
1822
|
|
|
1823
|
|
|
1824
|
|
|
1825
|
|
|
1826
|
|
|
1827
|
|
|
1828
|
|
|
1829
|
|
|
1830
|
|
|
1831
|
|
|
1832
|
|
|
1833
|
|
|
1834
|
|
|
1835
|
