]> git.buserror.net Git - polintos/scott/priv.git/blob - idlcomp/input.cc
Add toolchain patches.
[polintos/scott/priv.git] / idlcomp / input.cc
1 // Code to load symbols from a legacy filesystem
2 //
3 // This software is copyright (c) 2006 Scott Wood <scott@buserror.net>.
4 // 
5 // This software is provided 'as-is', without any express or implied warranty.
6 // In no event will the authors or contributors be held liable for any damages
7 // arising from the use of this software.
8 // 
9 // Permission is hereby granted to everyone, free of charge, to use, copy,
10 // modify, prepare derivative works of, publish, distribute, perform,
11 // sublicense, and/or sell copies of the Software, provided that the above
12 // copyright notice and disclaimer of warranty be included in all copies or
13 // substantial portions of this software.
14
15 #include <cstdio>
16 #include <vector>
17 #include <memory>
18 #include <cstring>
19
20 #include <errno.h>
21 #include <dirent.h>
22
23 #include <idlc.h>
24 #include <parser.h>
25
26 // To deal with namespaces on a case-insensitive filesystem, names
27 // are annotated with a hexadecimal prefix indicating the case of each
28 // letter.  Each bit in the number represents a letter, with 0 being
29 // lowercase (or a non-letter) and 1 being uppercase.  The
30 // least-significant bit is the first letter.  This is done on both
31 // case sensitive and case insensitive filesystems so that the output
32 // can be freely copied between them (it also simplifies the code).
33 // As such, hex digits should be in upper case so that case-sensitive
34 // lookups can be used.  This prefix is separated from the actual name
35 // by an underscore.
36 //
37 // When the time comes along that UTF-8 is supported, this applies to
38 // UTF-8 characters, not ASCII characters.
39 //
40 // This mangling can also be used (with a leading underscore or
41 // whatever) in case-insensitive languages, though ideally there
42 // should be aliases with the unannotated name if there is no
43 // conflict.
44 //
45 // I don't want to go the CORBA route of disallowing case conflicts,
46 // as I find using capitals for types and lowercase for instances to
47 // be a useful convention (and less ugly than appending _t, except
48 // when case sensitivity is missing), and would rather not be limited
49 // at such a fundamental level by broken languages.
50
51 static char tohex(int digit)
52 {
53         if (digit < 10)
54                 return digit + '0';
55         
56         return digit + 'A' - 10;
57 }
58
59 const String *NameSpace::mangle(const String *name)
60 {
61         String *mangled_string = new String;
62         
63         // The conversion is done manually so that I don't have to deal
64         // with bignum arithmetic.
65         
66         std::vector<bool> hex;
67         std::vector<bool>::size_type name_len = name->length();
68         
69         // Pad out the first digit with leading zeroes, so that
70         // we don't have to deal with that later.
71         
72         if (name_len & 3)
73                 for (int i = name_len & 3; i < 4; ++i)
74                         hex.push_back(0);
75
76         for (string::const_iterator i = name->begin(); i != name->end(); ++i)
77                 hex.push_back(isupper(*i));
78
79         assert((hex.size() & 3) == 0);
80
81         for (std::vector<bool>::size_type i = 0; i < hex.size(); i += 4) {
82                 int digit = hex[i]     * 8 +
83                             hex[i + 1] * 4 +
84                             hex[i + 2] * 2 +
85                             hex[i + 3];
86
87                 *mangled_string += tohex(digit);
88         }
89         
90         *mangled_string += '_';
91         *mangled_string += *name;
92         return mangled_string;
93 }
94
95 struct IOError
96 {
97         const char *msg;
98
99         IOError(FILE *f)
100         {
101                 if (ferror(f))
102                         msg = strerror(ferror(f));
103                 else
104                         msg = "Short File";
105         }
106 };
107
108 struct ImportContext {
109         const String *name;
110         const char *filename;
111         File f;
112         NameSpace *parent;
113         bool swap;
114         bool is_dir;
115         bool is_typedef;
116         CompiledDefHeader hdr;
117 };
118
119 static void import_and_validate_array(ImportContext &ctx,
120                                       CompiledArray &out,
121                                       CompiledArray &in)
122 {
123         out.bounds[0] = swap64(in.bounds[0], ctx.swap);
124         out.bounds[1] = swap64(in.bounds[1], ctx.swap);
125
126         if (out.bounds[0] < 0) {
127                 fprintf(stderr, "\"%s\" is not a valid object "
128                                 "(bad array lower bound %" PRId64 ").\n",
129                         ctx.filename, out.bounds[0]);
130                 throw UserError();
131         }
132         
133         if (out.bounds[1] < -1) {
134                 fprintf(stderr, "\"%s\" is not a valid object "
135                                 "(bad array upper bound %" PRId64 ").\n",
136                         ctx.filename, out.bounds[0]);
137                 throw UserError();
138         }
139         
140         if (out.bounds[1] > 0 &&
141             out.bounds[1] < out.bounds[0]) {
142                 fprintf(stderr, "\"%s\" is not a valid object "
143                                 "(array upper bound %" PRId64 " less than lower bound %" PRId64 ").\n",
144                         ctx.filename, out.bounds[1], out.bounds[0]);
145                 throw UserError();
146         }
147 }
148
149 static void import_and_validate_basictype(ImportContext &ctx,
150                                           CompiledBasicType &out, 
151                                           CompiledBasicType &in)
152 {
153         out.bits = swap32(in.bits, ctx.swap);
154         out.flags.raw = swap32(in.flags.raw, ctx.swap);
155
156         int num = 0;
157         if (out.flags.field.Unsigned)
158                 num++;
159         if (out.flags.field.Float)
160                 num++;
161         if (out.flags.field.Bool)
162                 num++;
163         if (num > 1) {
164                 fprintf(stderr, "\"%s\" is not a valid object "
165                                 "(bad flags 0x%08x).\n",
166                         ctx.filename, out.flags.raw);
167                 throw UserError();
168         }
169
170         if (out.flags.field.Bool) {
171                 if (out.bits != 0) {
172                         fprintf(stderr, "\"%s\" is not a valid object "
173                                         "(bad bits %d for bool type).\n",
174                                 ctx.filename, out.bits);
175                         throw UserError();
176                 }
177         } else if (out.flags.field.Float) {
178                 if (out.bits != 32 && out.bits != 64) {
179                         fprintf(stderr, "\"%s\" is not a valid object "
180                                         "(bad bits %d for floating point type).\n",
181                                 ctx.filename, out.bits);
182                         throw UserError();
183                 }
184         } else if (!dynamic_cast<BitField *>(ctx.parent) &&
185                    !dynamic_cast<Enum *>(ctx.parent)) {
186                 if (out.bits != 8 && out.bits != 16 &&
187                     out.bits != 32 && out.bits != 64) {
188                         fprintf(stderr, "\"%s\" is not a valid object "
189                                         "(bad bits %d for integer type).\n",
190                                 ctx.filename, out.bits);
191                         throw UserError();
192                 }
193                 
194                 if (out.bits == 8 && !out.flags.field.Unsigned) {
195                         fprintf(stderr, "\"%s\" is not a valid object "
196                                         "(octet type must be unsigned).\n",
197                                 ctx.filename);
198                         throw UserError();
199                 }
200         }
201         
202         // Bitfield entries can take anywhere from 1 to 64 bits, but
203         // will be verified by the parent after all entries have loaded,
204         // so it can verify that the sum does not exceed the size of
205         // the bitfield.
206
207         import_and_validate_array(ctx, out.array, in.array);
208 }
209
210 BasicType *BasicType::import(ImportContext &ctx)
211 {
212         if (ctx.is_dir) {
213                 fprintf(stderr, "\"%s\" is not a valid object "
214                                 "(a BasicType must be a file).\n",
215                         ctx.filename);
216                 throw UserError();
217         }
218
219         CompiledBasicType def;
220         if (fread(&def, sizeof(def), 1, ctx.f) != 1)
221                 throw IOError(ctx.f);
222
223         BasicType *bt = new BasicType(ctx.name);
224         ctx.parent->add_import(bt, ctx.filename);
225         
226         import_and_validate_basictype(ctx, bt->def, def);
227
228         bt->complete = true;
229         return bt;
230 }
231
232 static String *read_string_raw(ImportContext &ctx, int32_t length)
233 {
234         if (length < 0 || length > 4096) {
235                 fprintf(stderr, "\"%s\" is not a valid object "
236                                 "(unreasonable string length %d).\n",
237                         ctx.filename, length);
238                 throw UserError();
239         }
240
241         // Is there a way to reserve space in a C++ string, and pass
242         // the buffer into fread?
243         
244         char *buf = new char[length + 1];
245         
246         if (fread(buf, length + 1, 1, ctx.f) != 1)
247                 throw IOError(ctx.f);
248         
249         String *s = new String(buf);
250         delete[] buf;
251         return s;
252 }
253
254 static const String *read_string(ImportContext &ctx)
255 {
256         off_t pos = ftello(ctx.f);
257         int pad = ((pos + 3) & ~3) - pos;
258
259         if (pad != 0 && fseeko(ctx.f, pad, SEEK_CUR) != 0)
260                 throw IOError(ctx.f);
261
262         int32_t length;
263         if (fread(&length, sizeof(length), 1, ctx.f) != 1)
264                 throw IOError(ctx.f);
265         
266         return read_string_raw(ctx, swap32(length, ctx.swap));
267 }
268
269 StrList::StrList(const String *input, char delimeter)
270 {
271         const char *cur = input->c_str();
272         
273         do {
274                 char *next = strchr(cur, delimeter);
275                 String *s = new String();
276                 s->token = TOK_IDENT;
277                 
278                 if (next == cur || *cur == 0)
279                         throw InvalidArgument();
280                 
281                 if (next) {
282                         s->append(cur, next - cur);
283                         cur = next + 1;
284                 } else {
285                         s->append(cur);
286                         cur = NULL;
287                 }
288                 
289                 push_back(s);
290         } while (cur);
291 }
292
293 // FIXME: Handle illegal recursion.
294 static Symbol *lookup_sym_noyyerror(ImportContext &ctx, const String *name)
295 {
296         StrList *sl;
297
298         try {
299                 sl = new StrList(name);
300         }
301
302         catch (InvalidArgument) {
303                 fprintf(stderr, "\"%s\" is not a valid object "
304                                 "(\"%s\" is not a valid identifier).\n",
305                         ctx.filename, name->c_str());
306                 throw UserError();
307         }
308
309         try {
310                 return lookup_sym(toplevel, sl, toplevel);
311         }
312         
313         catch (UserError) {
314                 fprintf(stderr, "\"%s\" is not a valid object "
315                                 "(\"%s\" could not be loaded).\n",
316                         ctx.filename, name->c_str());
317
318                 throw UserError();
319         }
320 }
321
322 // FIXME: Handle illegal recursion.
323 static Symbol *lookup_sym_in_ns_noyyerror(ImportContext &ctx,
324                                           NameSpace *ns,
325                                           const String *name)
326 {
327         Symbol *sym = ns->lookup_noex(name);
328         if (!sym) {
329                 fprintf(stderr, "\"%s\" is not a valid object "
330                                 "(\"%s\" is not found).\n",
331                         ctx.filename, name->c_str());
332
333                 throw UserError();
334         }
335         
336         return sym;
337 }
338
339 Datum *Datum::import(ImportContext &ctx)
340 {
341         if (ctx.is_dir) {
342                 fprintf(stderr, "\"%s\" is not a valid object "
343                                 "(a Datum must be a file).\n",
344                         ctx.filename);
345                 throw UserError();
346         }
347
348         CompiledDatum def;
349         if (fread(&def, sizeof(def), 1, ctx.f) != 1)
350                 throw IOError(ctx.f);
351
352         Datum *d = new Datum(ctx.name);
353         d->def.flags.raw = swap32(def.flags.raw, ctx.swap);
354
355         if (d->def.flags.field.Invalid) {
356                 fprintf(stderr, "\"%s\" is not a valid object "
357                                 "(bad flags 0x%08x).\n",
358                         ctx.filename, d->def.flags.raw);
359                 throw UserError();
360         }
361
362         ctx.parent->add_import(d, ctx.filename);
363
364         d->def.type.length = swap32(def.type.length, ctx.swap);
365
366         if (d->def.type.length != 0) {
367                 d->type_fq_name = read_string_raw(ctx, d->def.type.length);
368                 Symbol *sym = lookup_sym_noyyerror(ctx, d->type_fq_name);
369                 d->type = dynamic_cast<Type *>(sym);
370                 
371                 if (!d->type) {
372                         fprintf(stderr, "\"%s\" is not a valid object "
373                                         "(\"%s\" is not a type).\n",
374                                 ctx.filename, d->type_fq_name->c_str());
375                         throw UserError();
376                 }
377                 
378                 import_and_validate_array(ctx, d->def.basictype.array,
379                                           def.basictype.array);
380         
381                 BasicType *bt = dynamic_cast<BasicType *>(*d->type);
382                 if (bt)
383                         d->cbt = &bt->def;
384                 else
385                         d->cbt = NULL;
386         } else {
387                 d->basic = true;
388                 import_and_validate_basictype(ctx, d->def.basictype,
389                                               def.basictype);
390                 d->cbt = &d->def.basictype;
391         }
392
393         d->def.ucon = swap64(def.ucon, ctx.swap);
394
395         if (d->def.flags.field.Const) {
396                 if (!d->cbt) {
397                         fprintf(stderr, "\"%s\" is not a valid object "
398                                         "(constant, but non-basic type).\n",
399                                 ctx.filename);
400                         throw UserError();
401                 }
402         
403                 if (d->cbt->flags.field.Float)
404                         d->con_type = TOK_FCON;
405                 else if (!d->cbt->flags.field.Unsigned)
406                         d->con_type = TOK_ICON;
407                 else
408                         d->con_type = TOK_UCON;
409         
410                 if (!d->verify_const()) {
411                         fprintf(stderr, "\"%s\" is not a valid object "
412                                         "(bad constant).\n",
413                                 ctx.filename);
414                         throw UserError();
415                 }
416         } else {
417                 d->con_type = TOK_NONE;
418         }
419
420         return d;
421 }
422
423 // OPT: Importing methods and supers isn't necessary for idlc to
424 // work; it could be made optional to speed up large compilations.
425
426 Interface *Interface::import(ImportContext &ctx)
427 {
428         if (!ctx.is_dir) {
429                 fprintf(stderr, "\"%s\" is not a valid object "
430                                 "(an Interface must be a directory).\n",
431                         ctx.filename);
432                 throw UserError();
433         }
434
435         CompiledInterface def;
436         if (fread(&def, sizeof(def), 1, ctx.f) != 1)
437                 throw IOError(ctx.f);
438
439         Interface *iface = new Interface(ctx.name);
440         iface->path = new String(ctx.filename);
441         ctx.parent->add_import(iface, ctx.filename);
442         
443         iface->def.guid[0] = def.guid[0];
444         iface->def.guid[1] = def.guid[1];
445
446         int32_t num_methods = swap32(def.num_methods, ctx.swap);
447         int32_t num_supers = swap32(def.num_supers, ctx.swap);
448         
449         if (num_methods < 0 || num_methods > 4096) {
450                 fprintf(stderr, "\"%s\" is not a valid object "
451                                 "(unreasonable num_methods %d).\n",
452                         ctx.filename, num_methods);
453                 throw UserError();
454         }
455
456         if (num_supers < 0 || num_supers > 4096) {
457                 fprintf(stderr, "\"%s\" is not a valid object "
458                                 "(unreasonable num_supers %d).\n",
459                         ctx.filename, num_supers);
460                 throw UserError();
461         }
462         
463         for (int32_t i = 0; i < num_methods; i++) {
464                 const String *str = read_string(ctx);
465                 Symbol *sym = lookup_sym_in_ns_noyyerror(ctx, iface, str);
466                 Method *m = dynamic_cast<Method *>(sym);
467                 
468                 if (!m) {
469                         fprintf(stderr, "\"%s\" is not a valid object "
470                                         "(\"%s\" is not a method).\n",
471                                 ctx.filename, str->c_str());
472                         throw UserError();
473                 }
474                 
475                 iface->add_elem(m);
476         }
477
478         // FIXME: Check for bad recursion again
479
480         for (int32_t i = 0; i < num_supers; i++) {
481                 const String *str = read_string(ctx);
482                 Symbol *sym = lookup_sym_noyyerror(ctx, str);
483                 Interface *super = dynamic_cast<Interface *>(sym);
484         
485                 if (!super) {
486                         fprintf(stderr, "\"%s\" is not a valid object "
487                                         "(\"%s\" is not an interface).\n",
488                                 ctx.filename, str->c_str());
489                         throw UserError();
490                 }
491         
492                 iface->add_super(super);
493         }
494         
495         assert(num_methods == iface->def.num_methods);
496         assert(num_supers == iface->def.num_supers);
497
498         iface->sort_chains();
499         return iface;
500 }
501
502 Method *Method::import(ImportContext &ctx)
503 {
504         if (!ctx.is_dir) {
505                 fprintf(stderr, "\"%s\" is not a valid object "
506                                 "(a Method must be a directory).\n",
507                         ctx.filename);
508                 throw UserError();
509         }
510
511         CompiledMethod def;
512         if (fread(&def, sizeof(def), 1, ctx.f) != 1)
513                 throw IOError(ctx.f);
514
515         Method *m = new Method(ctx.name);
516         m->path = new String(ctx.filename);
517         ctx.parent->add_import(m, ctx.filename);
518
519         int32_t num_entries = swap32(def.num_entries, ctx.swap);
520
521         m->def.flags.raw = swap32(def.flags.raw, ctx.swap);
522         
523         if (num_entries < 0 || num_entries > 4096) {
524                 fprintf(stderr, "\"%s\" is not a valid object "
525                                 "(unreasonable num_entries %d).\n",
526                         ctx.filename, num_entries);
527                 throw UserError();
528         }
529
530         for (int32_t i = 0; i < num_entries; i++) {
531                 const String *str = read_string(ctx);
532                 Symbol *sym = lookup_sym_in_ns_noyyerror(ctx, m, str);
533                 Param *p = dynamic_cast<Param *>(sym);
534                 
535                 if (!p) {
536                         fprintf(stderr, "\"%s\" is not a valid object "
537                                         "(\"%s\" is not a parameter).\n",
538                                 ctx.filename, str->c_str());
539                         throw UserError();
540                 }
541                 
542                 m->add_elem(p);
543         }
544
545         assert(num_entries == m->def.num_entries);
546         return m;
547 }
548
549 Param *Param::import(ImportContext &ctx)
550 {
551         if (ctx.is_dir) {
552                 fprintf(stderr, "\"%s\" is not a valid object "
553                                 "(a Parameter must be a file).\n",
554                         ctx.filename);
555                 throw UserError();
556         }
557
558         CompiledParam def;
559         if (fread(&def, sizeof(def), 1, ctx.f) != 1)
560                 throw IOError(ctx.f);
561
562         Param *p = new Param(ctx.name);
563         ctx.parent->add_import(p, ctx.filename);
564
565         p->def.type.length = swap32(def.type.length, ctx.swap);
566
567         if (p->def.type.length != 0) {
568                 p->type_fq_name = read_string_raw(ctx, p->def.type.length);
569                 Symbol *sym = lookup_sym_noyyerror(ctx, p->type_fq_name);
570                 p->type = dynamic_cast<Type *>(sym);
571                 
572                 if (!p->type) {
573                         fprintf(stderr, "\"%s\" is not a valid object "
574                                         "(\"%s\" is not a type).\n",
575                                 ctx.filename, p->type_fq_name->c_str());
576                         throw UserError();
577                 }
578                 
579                 import_and_validate_array(ctx, p->def.basictype.array,
580                                           def.basictype.array);
581         } else {
582                 import_and_validate_basictype(ctx, p->def.basictype,
583                                               def.basictype);
584         }
585
586         p->def.flags.raw = swap32(def.flags.raw, ctx.swap);
587         return p;
588 }
589
590 // OPT: Importing data and super isn't necessary for idlc to
591 // work; it could be made optional to speed up large compilations.
592
593 Struct *Struct::import(ImportContext &ctx)
594 {
595         if (!ctx.is_dir) {
596                 fprintf(stderr, "\"%s\" is not a valid object "
597                                 "(a Struct must be a directory).\n",
598                         ctx.filename);
599                 throw UserError();
600         }
601
602         CompiledStruct def;
603         if (fread(&def, sizeof(def), 1, ctx.f) != 1)
604                 throw IOError(ctx.f);
605
606         Struct *s = new Struct(ctx.name);
607         s->path = new String(ctx.filename);
608         ctx.parent->add_import(s, ctx.filename);
609         
610         s->def.guid[0] = def.guid[0];
611         s->def.guid[1] = def.guid[1];
612         
613         int32_t num_entries = swap32(def.num_entries, ctx.swap);
614
615         s->def.flags.raw = swap32(def.flags.raw, ctx.swap);
616         
617         if (num_entries < 0 || num_entries > 4096) {
618                 fprintf(stderr, "\"%s\" is not a valid object "
619                                 "(unreasonable num_entries %d).\n",
620                         ctx.filename, num_entries);
621                 throw UserError();
622         }
623
624         for (int32_t i = 0; i < num_entries; i++) {
625                 const String *str = read_string(ctx);
626                 
627                 Symbol *sym = lookup_sym_in_ns_noyyerror(ctx, s, str);
628                 Datum *d = dynamic_cast<Datum *>(sym);
629                 
630                 if (!d) {
631                         fprintf(stderr, "\"%s\" is not a valid object "
632                                         "(\"%s\" is not a datum).\n",
633                                 ctx.filename, str->c_str());
634                         throw UserError();
635                 }
636                 
637                 s->add_elem(d);
638         }
639         
640         if (s->def.flags.field.Super) {
641                 const String *str = read_string(ctx);
642                 Symbol *sym = lookup_sym_noyyerror(ctx, str);
643                 Struct *super = dynamic_cast<Struct *>(sym);
644                 
645                 if (!super) {
646                         fprintf(stderr, "\"%s\" is not a valid object "
647                                         "(\"%s\" is not a struct).\n",
648                                 ctx.filename, str->c_str());
649                         throw UserError();
650                 }
651                 
652                 s->super = super;
653                 
654                 if (super->is_virtual() && !s->is_virtual()) {
655                         fprintf(stderr, "\"%s\" is not a valid object "
656                                         "(not virtual but parent is).\n",
657                                 ctx.filename);
658                         throw UserError();
659                 }
660         }
661
662         assert(num_entries == s->def.num_entries);
663         return s;
664 }
665
666 // OPT: Importing elements isn't necessary for idlc to work (at
667 // least, not unless inheritance is implemented); it could be made
668 // optional to speed up large compilations.
669
670 BitField *BitField::import(ImportContext &ctx)
671 {
672         if (!ctx.is_dir) {
673                 fprintf(stderr, "\"%s\" is not a valid object "
674                                 "(a BitField must be a directory).\n",
675                         ctx.filename);
676                 throw UserError();
677         }
678
679         CompiledBitField def;
680         if (fread(&def, sizeof(def), 1, ctx.f) != 1)
681                 throw IOError(ctx.f);
682
683         BitField *bf = new BitField(ctx.name);
684         bf->path = new String(ctx.filename);
685         ctx.parent->add_import(bf, ctx.filename);
686
687         int32_t num_entries = swap32(def.num_entries, ctx.swap);
688         bf->def.bits = swap32(def.bits, ctx.swap);
689
690         if (num_entries < 0 || num_entries > 4096) {
691                 fprintf(stderr, "\"%s\" is not a valid object "
692                                 "(unreasonable num_entries %d).\n",
693                         ctx.filename, num_entries);
694                 throw UserError();
695         }
696         
697         // FIXME: bits can only be 16, 32, or 64 when not in another bitfield.
698
699         if (bf->def.bits < 1 || bf->def.bits > 64) {
700                 fprintf(stderr, "\"%s\" is not a valid object "
701                                 "(unreasonable bits %d).\n",
702                         ctx.filename, num_entries);
703                 throw UserError();
704         }
705
706         for (int32_t i = 0; i < num_entries; i++) {
707                 const String *str = read_string(ctx);
708                 Symbol *sym = lookup_sym_in_ns_noyyerror(ctx, bf, str);
709                 Datum *d = dynamic_cast<Datum *>(sym);
710                 
711                 if (!d) {
712                         fprintf(stderr, "\"%s\" is not a valid object "
713                                         "(\"%s\" is not a datum).\n",
714                                 ctx.filename, str->c_str());
715                         throw UserError();
716                 }
717                 
718                 bf->add_elem(d);
719         }
720         
721         assert(num_entries == bf->def.num_entries);
722         return bf;
723 }
724
725 // OPT: Importing elements isn't necessary for idlc to work (at
726 // least, not unless inheritance is implemented); it could be made
727 // optional to speed up large compilations.
728
729 Enum *Enum::import(ImportContext &ctx)
730 {
731         if (!ctx.is_dir) {
732                 fprintf(stderr, "\"%s\" is not a valid object "
733                                 "(a Enum must be a directory).\n",
734                         ctx.filename);
735                 throw UserError();
736         }
737
738         CompiledEnum def;
739         if (fread(&def, sizeof(def), 1, ctx.f) != 1)
740                 throw IOError(ctx.f);
741
742         Enum *e = new Enum(ctx.name);
743         e->path = new String(ctx.filename);
744         ctx.parent->add_import(e, ctx.filename);
745
746         int32_t num_entries = swap32(def.num_entries, ctx.swap);
747         e->def.bits = swap32(def.bits, ctx.swap);
748
749         if (num_entries < 0 || num_entries > 4096) {
750                 fprintf(stderr, "\"%s\" is not a valid object "
751                                 "(unreasonable num_entries %d).\n",
752                         ctx.filename, num_entries);
753                 throw UserError();
754         }
755         
756         // FIXME: bits can only be 16, 32, or 64 when not in another bitfield.
757
758         if (e->def.bits < 1 || e->def.bits > 64) {
759                 fprintf(stderr, "\"%s\" is not a valid object "
760                                 "(unreasonable bits %d).\n",
761                         ctx.filename, num_entries);
762                 throw UserError();
763         }
764
765         for (int32_t i = 0; i < num_entries; i++) {
766                 const String *str = read_string(ctx);
767                 Symbol *sym = lookup_sym_in_ns_noyyerror(ctx, e, str);
768                 Datum *d = dynamic_cast<Datum *>(sym);
769                 
770                 if (!d) {
771                         fprintf(stderr, "\"%s\" is not a valid object "
772                                         "(\"%s\" is not a datum).\n",
773                                 ctx.filename, str->c_str());
774                         throw UserError();
775                 }
776                 
777                 e->add_elem(d);
778         }
779         
780         assert(num_entries == e->def.num_entries);
781         return e;
782 }
783
784 Alias *Alias::import(ImportContext &ctx)
785 {
786         if (ctx.is_dir) {
787                 fprintf(stderr, "\"%s\" is not a valid object "
788                                 "(an Alias must be a file).\n",
789                         ctx.filename);
790                 throw UserError();
791         }
792
793         Alias *a = new Alias(ctx.name);
794         ctx.parent->add_import(a, ctx.filename);
795
796         const String *str = read_string(ctx);
797         Symbol *sym = lookup_sym_noyyerror(ctx, str);
798         
799         Alias *aptr = dynamic_cast<Alias *>(sym);
800         if (aptr) {
801                 fprintf(stderr, "\"%s\" is not a valid object "
802                                 "(points to \"%s\", which is an alias).\n",
803                         ctx.filename, str->c_str());
804                 throw UserError();
805         }
806
807         a->real_sym = sym;
808         a->sym_fq_name = str;
809         a->def.length = str->length();
810
811         return a;
812 }
813
814 TypeDef *TypeDef::import(ImportContext &ctx)
815 {
816         if (ctx.is_dir) {
817                 fprintf(stderr, "\"%s\" is not a valid object "
818                                 "(a TypeDef must be a file).\n",
819                         ctx.filename);
820                 throw UserError();
821         }
822
823         TypeDef *td = new TypeDef(ctx.name);
824         ctx.parent->add_import(td, ctx.filename);
825
826         const String *str = read_string(ctx);
827         Symbol *sym = lookup_sym_noyyerror(ctx, str);
828         
829         Alias *aptr = dynamic_cast<Alias *>(sym);
830         if (aptr) {
831                 fprintf(stderr, "\"%s\" is not a valid object "
832                                 "(points to \"%s\", which is an alias).\n",
833                         ctx.filename, str->c_str());
834                 throw UserError();
835         }
836
837         td->real_sym = sym;
838         td->sym_fq_name = str;
839         td->def.length = str->length();
840
841         return td;
842 }
843
844 UserNameSpace *UserNameSpace::import(ImportContext &ctx)
845 {
846         if (!ctx.is_dir) {
847                 fprintf(stderr, "\"%s\" is not a valid object "
848                                 "(a NameSpace must be a directory).\n",
849                         ctx.filename);
850                 throw UserError();
851         }
852
853         UserNameSpace *uns = new UserNameSpace();
854         uns->path = new String(ctx.filename);
855         
856         // FIXME: sanity check the mount point
857
858         uns->name = ctx.name;   
859         ctx.parent->add_import(uns, ctx.filename);
860         return uns;
861 }
862
863 Symbol *do_load(ImportContext &ctx)
864 {
865         int type = swap32(ctx.hdr.type, ctx.swap);
866         
867         switch (type) {
868                 case CompiledDefHeader::NameSpace:
869                         return UserNameSpace::import(ctx);
870                         break;
871                 
872                 case CompiledDefHeader::BasicType:
873                         return BasicType::import(ctx);
874                         break;
875
876                 case CompiledDefHeader::Datum:
877                         return Datum::import(ctx);
878                         break;
879
880                 case CompiledDefHeader::Interface:
881                         return Interface::import(ctx);
882                         break;
883
884                 case CompiledDefHeader::Method:
885                         return Method::import(ctx);
886                         break;
887
888                 case CompiledDefHeader::Param:
889                         return Param::import(ctx);
890                         break;
891
892                 case CompiledDefHeader::Struct:
893                         return Struct::import(ctx);
894                         break;
895
896                 case CompiledDefHeader::Enum:
897                         return Enum::import(ctx);
898                         break;
899
900                 case CompiledDefHeader::BitField:
901                         return BitField::import(ctx);
902                         break;
903
904                 case CompiledDefHeader::Alias:
905                         ctx.is_typedef = false;
906                         return Alias::import(ctx);
907                         break;
908
909                 case CompiledDefHeader::TypeDef:
910                         ctx.is_typedef = true;
911                         return TypeDef::import(ctx);
912                         break;
913
914                 default:
915                         fprintf(stderr, "\"%s\" is not a valid object "
916                                         "(bad type %08x).\n",
917                                 ctx.filename, type);
918                         
919                         throw UserError();
920         }
921 }
922
923 Symbol *NameSpace::load(const String *symname)
924 {
925         ImportContext ctx;
926         const String *mangled = mangle(symname);
927
928         ctx.name = new String(*symname);
929         ctx.is_dir = true;
930         ctx.parent = this;
931
932         string filename_no_self(path);
933         filename_no_self += '/';
934         filename_no_self += *mangled;
935         ctx.filename = filename_no_self.c_str();
936
937         string filename(filename_no_self);
938         filename.append("/.self");
939
940         ctx.f = fopen(filename.c_str(), "rb");
941         if (!ctx.f) {
942                 ctx.is_dir = false;
943                 ctx.f = fopen(ctx.filename, "rb");
944                 
945                 if (!ctx.f)
946                         return NULL;
947                 
948                 filename = filename_no_self;
949         }
950         
951         Symbol *ret;
952         try {
953                 if (fread(&ctx.hdr, sizeof(ctx.hdr), 1, ctx.f) != 1)
954                         throw IOError(ctx.f);
955
956                 if (ctx.hdr.magic == CompiledDefHeader::magic_normal)
957                         ctx.swap = false;
958                 else if (ctx.hdr.magic == CompiledDefHeader::magic_reversed)
959                         ctx.swap = true;
960                 else {
961                         fprintf(stderr, "\"%s\" is not a valid object "
962                                         "(bad magic 0x%08x).\n",
963                                 ctx.filename, ctx.hdr.magic);
964         
965                         throw UserError();
966                 }
967                 
968                 ret = do_load(ctx);
969         }
970         
971         catch (IOError &e) {
972                 fprintf(stderr, "Cannot read from file \"%s\": %s.\n",
973                         ctx.filename, e.msg);
974         
975                 throw UserError();
976         }
977         
978         return ret;
979 }
980
981 NameSpace *check_for_imports(NameSpace *ns)
982 {
983         while (ns) {
984                 if (ns->get_path())
985                         return ns;
986
987                 ns = ns->get_ns();
988         }
989         
990         return NULL;
991 }
992
993 void UserNameSpace::declare_import(const char *path)
994 {
995         ImportContext ctx;
996         UserNameSpace *ns = new UserNameSpace();
997         string filename(path);
998         filename.append("/.self");
999
1000         ctx.parent = NULL;
1001         ctx.filename = path;
1002         
1003         ctx.f = fopen(filename.c_str(), "rb");
1004         if (!ctx.f) {
1005                 fprintf(stderr, "Cannot import \"%s\": %s.\n",
1006                         path, strerror(errno));
1007         
1008                 throw UserError();
1009         }
1010         
1011         const String *mount;
1012         try {
1013                 if (fread(&ctx.hdr, sizeof(ctx.hdr), 1, ctx.f) != 1)
1014                         throw IOError(ctx.f);
1015         
1016                 if (ctx.hdr.magic == CompiledDefHeader::magic_normal)
1017                         ctx.swap = false;
1018                 else if (ctx.hdr.magic == CompiledDefHeader::magic_reversed)
1019                         ctx.swap = true;
1020                 else {
1021                         fprintf(stderr, "\"%s\" is not a valid object "
1022                                         "(bad magic 0x%08x).\n",
1023                                 ctx.filename, ctx.hdr.magic);
1024         
1025                         throw UserError();
1026                 }
1027                 
1028                 mount = read_string(ctx);
1029         }
1030         
1031         catch (IOError &e) {
1032                 fprintf(stderr, "Cannot read from file \"%s\": %s.\n",
1033                         ctx.filename, e.msg);
1034         
1035                 throw UserError();
1036         }
1037
1038         StrList *strl = new StrList(mount);
1039         if (!strl) {
1040                 fprintf(stderr, "\"%s\" is not a valid object "
1041                                 "(mount point \"%s\" is not valid).\n",
1042                         ctx.filename, mount->c_str());
1043
1044                 throw UserError();
1045         }
1046
1047         ns->name = strl->back();
1048         strl->pop_back();
1049         
1050         if (strl->size() != 0) {
1051                 ctx.parent = add_nspace(strl, false);
1052
1053                 if (!ctx.parent)
1054                         BUG();
1055                 
1056                 NameSpace *conflict = check_for_imports(ctx.parent);
1057                 if (conflict) {         
1058                         fprintf(stderr, "Import \"%s\" conflicts"
1059                                         " with \"%s\" at \"%s\".\n",
1060                                 path, conflict->get_fq_name()->flatten()->c_str(),
1061                                 conflict->get_path()->c_str());
1062
1063                         throw UserError();
1064                 }
1065         } else {
1066                 ctx.parent = toplevel;
1067         }
1068         
1069         ns->path = new String(path);
1070         ctx.parent->add_import(ns, ctx.filename);
1071 }
1072
1073 void NameSpace::import_all()
1074 {
1075         if (!path)
1076                 return;
1077         
1078         DIR *dir = opendir(path->c_str());
1079         if (!dir) {
1080                 fprintf(stderr, "Cannot open directory \"%s\".\n", path->c_str());
1081                 throw UserError();
1082         }
1083         
1084         struct dirent ent, *entp;
1085         while (true) {
1086                 // readdir_r is buggy on osx 10.2, and will fail if errno is
1087                 // non-zero.
1088                 errno = 0;
1089                 
1090                 if (readdir_r(dir, &ent, &entp)) {
1091                         fprintf(stderr, "1 Cannot readdir on \"%s\": %s.\n",
1092                                 path->c_str(), strerror(errno));
1093
1094                         closedir(dir);
1095                         throw UserError();
1096                 }
1097                 
1098                 if (!entp)
1099                         break;
1100                 
1101                 // Ignore ".", "..", and ".self".
1102                 if (ent.d_name[0] == '.')
1103                         continue;
1104                 
1105                 try {
1106                         char *under = strchr(ent.d_name, '_');
1107                         if (!under) {
1108                                 fprintf(stderr, "\"%s\" is not a valid namespace "
1109                                                 "(bad member \"%s\").\n",
1110                                         path->c_str(), ent.d_name);
1111
1112                                 throw UserError();
1113                         }
1114                         
1115                         String *s = new String(under + 1);
1116                         lookup(s);
1117                 }
1118                 
1119                 catch (SymbolNotFound) {
1120                         fprintf(stderr, "\"%s\" is not a valid namespace "
1121                                         "(member \"%s\" disappeared).\n",
1122                                 path->c_str(), ent.d_name);
1123
1124                         closedir(dir);
1125                         throw UserError();
1126                 }
1127         }
1128         
1129         closedir(dir);
1130 }
1131
1132 void NameSpace::import_all_recursive()
1133 {
1134         import_all();
1135         
1136         for (const_iterator i = begin(); i != end(); ++i) {
1137                 Symbol *sym = (*i).second;
1138                 NameSpace *ns = dynamic_cast<NameSpace *>(sym);
1139                 if (ns)
1140                         ns->import_all_recursive();
1141         }
1142 }