OSDN Git Service

compiler: Add -fgo-relative-import-path.
[pf3gnuchains/gcc-fork.git] / gcc / go / gofrontend / import.cc
1 // import.cc -- Go frontend import declarations.
2
3 // Copyright 2009 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
6
7 #include "go-system.h"
8
9 #include "filenames.h"
10 #include "simple-object.h"
11
12 #include "go-c.h"
13 #include "gogo.h"
14 #include "lex.h"
15 #include "types.h"
16 #include "export.h"
17 #include "import.h"
18
19 #ifndef O_BINARY
20 #define O_BINARY 0
21 #endif
22
23 // The list of paths we search for import files.
24
25 static std::vector<std::string> search_path;
26
27 // Add a directory to the search path.  This is called from the option
28 // handling language hook.
29
30 GO_EXTERN_C
31 void
32 go_add_search_path(const char* path)
33 {
34   search_path.push_back(std::string(path));
35 }
36
37 // Find import data.  This searches the file system for FILENAME and
38 // returns a pointer to a Stream object to read the data that it
39 // exports.  If the file is not found, it returns NULL.
40
41 // When FILENAME is not an absolute path and does not start with ./ or
42 // ../, we use the search path provided by -I and -L options.
43
44 // When FILENAME does start with ./ or ../, we use
45 // RELATIVE_IMPORT_PATH as a prefix.
46
47 // When FILENAME does not exist, we try modifying FILENAME to find the
48 // file.  We use the first of these which exists:
49 //   * We append ".gox".
50 //   * We turn the base of FILENAME into libFILENAME.so.
51 //   * We turn the base of FILENAME into libFILENAME.a.
52 //   * We append ".o".
53
54 // When using a search path, we apply each of these transformations at
55 // each entry on the search path before moving on to the next entry.
56 // If the file exists, but does not contain any Go export data, we
57 // stop; we do not keep looking for another file with the same name
58 // later in the search path.
59
60 Import::Stream*
61 Import::open_package(const std::string& filename, Location location,
62                      const std::string& relative_import_path)
63 {
64   bool is_local;
65   if (IS_ABSOLUTE_PATH(filename))
66     is_local = true;
67   else if (filename[0] == '.'
68            && (filename[1] == '\0' || IS_DIR_SEPARATOR(filename[1])))
69     is_local = true;
70   else if (filename[0] == '.'
71            && filename[1] == '.'
72            && (filename[2] == '\0' || IS_DIR_SEPARATOR(filename[2])))
73     is_local = true;
74   else
75     is_local = false;
76
77   std::string fn = filename;
78   if (is_local && !IS_ABSOLUTE_PATH(filename) && !relative_import_path.empty())
79     {
80       if (fn == ".")
81         {
82           // A special case.
83           fn = relative_import_path;
84         }
85       else
86         fn = relative_import_path + '/' + fn;
87       is_local = false;
88     }
89
90   if (!is_local)
91     {
92       for (std::vector<std::string>::const_iterator p = search_path.begin();
93            p != search_path.end();
94            ++p)
95         {
96           std::string indir = *p;
97           if (!indir.empty() && indir[indir.size() - 1] != '/')
98             indir += '/';
99           indir += fn;
100           Stream* s = Import::try_package_in_directory(indir, location);
101           if (s != NULL)
102             return s;
103         }
104     }
105
106   Stream* s = Import::try_package_in_directory(fn, location);
107   if (s != NULL)
108     return s;
109
110   return NULL;
111 }
112
113 // Try to find the export data for FILENAME.
114
115 Import::Stream*
116 Import::try_package_in_directory(const std::string& filename,
117                                  Location location)
118 {
119   std::string found_filename = filename;
120   int fd = open(found_filename.c_str(), O_RDONLY | O_BINARY);
121
122   if (fd >= 0)
123     {
124       struct stat s;
125       if (fstat(fd, &s) >= 0 && S_ISDIR(s.st_mode))
126         {
127           close(fd);
128           fd = -1;
129           errno = EISDIR;
130         }
131     }
132
133   if (fd < 0)
134     {
135       if (errno != ENOENT && errno != EISDIR)
136         warning_at(location, 0, "%s: %m", filename.c_str());
137
138       fd = Import::try_suffixes(&found_filename);
139       if (fd < 0)
140         return NULL;
141     }
142
143   // The export data may not be in this file.
144   Stream* s = Import::find_export_data(found_filename, fd, location);
145   if (s != NULL)
146     return s;
147
148   close(fd);
149
150   error_at(location, "%s exists but does not contain any Go export data",
151            found_filename.c_str());
152
153   return NULL;
154 }
155
156 // Given import "*PFILENAME", where *PFILENAME does not exist, try
157 // various suffixes.  If we find one, set *PFILENAME to the one we
158 // found.  Return the open file descriptor.
159
160 int
161 Import::try_suffixes(std::string* pfilename)
162 {
163   std::string filename = *pfilename + ".gox";
164   int fd = open(filename.c_str(), O_RDONLY | O_BINARY);
165   if (fd >= 0)
166     {
167       *pfilename = filename;
168       return fd;
169     }
170
171   const char* basename = lbasename(pfilename->c_str());
172   size_t basename_pos = basename - pfilename->c_str();
173   filename = pfilename->substr(0, basename_pos) + "lib" + basename + ".so";
174   fd = open(filename.c_str(), O_RDONLY | O_BINARY);
175   if (fd >= 0)
176     {
177       *pfilename = filename;
178       return fd;
179     }
180
181   filename = pfilename->substr(0, basename_pos) + "lib" + basename + ".a";
182   fd = open(filename.c_str(), O_RDONLY | O_BINARY);
183   if (fd >= 0)
184     {
185       *pfilename = filename;
186       return fd;
187     }
188
189   filename = *pfilename + ".o";
190   fd = open(filename.c_str(), O_RDONLY | O_BINARY);
191   if (fd >= 0)
192     {
193       *pfilename = filename;
194       return fd;
195     }
196
197   return -1;
198 }
199
200 // Look for export data in the file descriptor FD.
201
202 Import::Stream*
203 Import::find_export_data(const std::string& filename, int fd,
204                          Location location)
205 {
206   // See if we can read this as an object file.
207   Import::Stream* stream = Import::find_object_export_data(filename, fd, 0,
208                                                            location);
209   if (stream != NULL)
210     return stream;
211
212   const int len = MAX(Export::v1_magic_len, Import::archive_magic_len);
213
214   if (lseek(fd, 0, SEEK_SET) < 0)
215     {
216       error_at(location, "lseek %s failed: %m", filename.c_str());
217       return NULL;
218     }
219
220   char buf[len];
221   ssize_t c = read(fd, buf, len);
222   if (c < len)
223     return NULL;
224
225   // Check for a file containing nothing but Go export data.
226   if (memcmp(buf, Export::v1_magic, Export::v1_magic_len) == 0)
227     return new Stream_from_file(fd);
228
229   // See if we can read this as an archive.
230   if (Import::is_archive_magic(buf))
231     return Import::find_archive_export_data(filename, fd, location);
232
233   return NULL;
234 }
235
236 // Look for export data in a simple_object.
237
238 Import::Stream*
239 Import::find_object_export_data(const std::string& filename,
240                                 int fd,
241                                 off_t offset,
242                                 Location location)
243 {
244   char *buf;
245   size_t len;
246   int err;
247   const char *errmsg = go_read_export_data(fd, offset, &buf, &len, &err);
248   if (errmsg != NULL)
249     {
250       if (err == 0)
251         error_at(location, "%s: %s", filename.c_str(), errmsg);
252       else
253         error_at(location, "%s: %s: %s", filename.c_str(), errmsg,
254                  xstrerror(err));
255       return NULL;
256     }
257
258   if (buf == NULL)
259     return NULL;
260
261   return new Stream_from_buffer(buf, len);
262 }
263
264 // Class Import.
265
266 // Construct an Import object.  We make the builtin_types_ vector
267 // large enough to hold all the builtin types.
268
269 Import::Import(Stream* stream, Location location)
270   : gogo_(NULL), stream_(stream), location_(location), package_(NULL),
271     add_to_globals_(false),
272     builtin_types_((- SMALLEST_BUILTIN_CODE) + 1),
273     types_()
274 {
275 }
276
277 // Import the data in the associated stream.
278
279 Package*
280 Import::import(Gogo* gogo, const std::string& local_name,
281                bool is_local_name_exported)
282 {
283   // Hold on to the Gogo structure.  Otherwise we need to pass it
284   // through all the import functions, because we need it when reading
285   // a type.
286   this->gogo_ = gogo;
287
288   // A stream of export data can include data from more than one input
289   // file.  Here we loop over each input file.
290   Stream* stream = this->stream_;
291   while (!stream->at_eof() && !stream->saw_error())
292     {
293       // The vector of types is package specific.
294       this->types_.clear();
295
296       stream->require_bytes(this->location_, Export::v1_magic,
297                             Export::v1_magic_len);
298
299       this->require_c_string("package ");
300       std::string package_name = this->read_identifier();
301       this->require_c_string(";\n");
302
303       std::string pkgpath;
304       if (this->match_c_string("prefix "))
305         {
306           this->advance(7);
307           std::string unique_prefix = this->read_identifier();
308           this->require_c_string(";\n");
309           pkgpath = unique_prefix + '.' + package_name;
310         }
311       else
312         {
313           this->require_c_string("pkgpath ");
314           pkgpath = this->read_identifier();
315           this->require_c_string(";\n");
316         }
317
318       this->package_ = gogo->add_imported_package(package_name, local_name,
319                                                   is_local_name_exported,
320                                                   pkgpath,
321                                                   this->location_,
322                                                   &this->add_to_globals_);
323       if (this->package_ == NULL)
324         {
325           stream->set_saw_error();
326           return NULL;
327         }
328
329       this->require_c_string("priority ");
330       std::string priority_string = this->read_identifier();
331       int prio;
332       if (!this->string_to_int(priority_string, false, &prio))
333         return NULL;
334       this->package_->set_priority(prio);
335       this->require_c_string(";\n");
336
337       while (stream->match_c_string("import"))
338         this->read_one_import();
339
340       if (stream->match_c_string("init"))
341         this->read_import_init_fns(gogo);
342
343       // Loop over all the input data for this package.
344       while (!stream->saw_error())
345         {
346           if (stream->match_c_string("const "))
347             this->import_const();
348           else if (stream->match_c_string("type "))
349             this->import_type();
350           else if (stream->match_c_string("var "))
351             this->import_var();
352           else if (stream->match_c_string("func "))
353             this->import_func(this->package_);
354           else if (stream->match_c_string("checksum "))
355             break;
356           else
357             {
358               error_at(this->location_,
359                        ("error in import data at %d: "
360                         "expected %<const%>, %<type%>, %<var%>, "
361                         "%<func%>, or %<checksum%>"),
362                        stream->pos());
363               stream->set_saw_error();
364               return NULL;
365             }
366         }
367
368       // We currently ignore the checksum.  In the future we could
369       // store the checksum somewhere in the generated object and then
370       // verify that the checksum matches at link time or at dynamic
371       // load time.
372       this->require_c_string("checksum ");
373       stream->advance(Export::v1_checksum_len * 2);
374       this->require_c_string(";\n");
375     }
376
377   return this->package_;
378 }
379
380 // Read an import line.  We don't actually care about these.
381
382 void
383 Import::read_one_import()
384 {
385   this->require_c_string("import ");
386   std::string package_name = this->read_identifier();
387   this->require_c_string(" ");
388   std::string pkgpath = this->read_identifier();
389   this->require_c_string(" \"");
390   Stream* stream = this->stream_;
391   while (stream->peek_char() != '"')
392     stream->advance(1);
393   this->require_c_string("\";\n");
394
395   Package* p = this->gogo_->register_package(pkgpath,
396                                              Linemap::unknown_location());
397   p->set_package_name(package_name, this->location());
398 }
399
400 // Read the list of import control functions.
401
402 void
403 Import::read_import_init_fns(Gogo* gogo)
404 {
405   this->require_c_string("init");
406   while (!this->match_c_string(";"))
407     {
408       this->require_c_string(" ");
409       std::string package_name = this->read_identifier();
410       this->require_c_string(" ");
411       std::string init_name = this->read_identifier();
412       this->require_c_string(" ");
413       std::string prio_string = this->read_identifier();
414       int prio;
415       if (!this->string_to_int(prio_string, false, &prio))
416         return;
417       gogo->add_import_init_fn(package_name, init_name, prio);
418     }
419   this->require_c_string(";\n");
420 }
421
422 // Import a constant.
423
424 void
425 Import::import_const()
426 {
427   std::string name;
428   Type* type;
429   Expression* expr;
430   Named_constant::import_const(this, &name, &type, &expr);
431   Typed_identifier tid(name, type, this->location_);
432   Named_object* no = this->package_->add_constant(tid, expr);
433   if (this->add_to_globals_)
434     this->gogo_->add_named_object(no);
435 }
436
437 // Import a type.
438
439 void
440 Import::import_type()
441 {
442   Named_type* type;
443   Named_type::import_named_type(this, &type);
444
445   // The named type has been added to the package by the type import
446   // process.  Here we need to make it visible to the parser, and it
447   // to the global bindings if necessary.
448   type->set_is_visible();
449
450   if (this->add_to_globals_)
451     this->gogo_->add_named_type(type);
452 }
453
454 // Import a variable.
455
456 void
457 Import::import_var()
458 {
459   std::string name;
460   Type* type;
461   Variable::import_var(this, &name, &type);
462   Variable* var = new Variable(type, NULL, true, false, false,
463                                this->location_);
464   Named_object* no;
465   no = this->package_->add_variable(name, var);
466   if (this->add_to_globals_)
467     this->gogo_->add_named_object(no);
468 }
469
470 // Import a function into PACKAGE.  PACKAGE is normally
471 // THIS->PACKAGE_, but it will be different for a method associated
472 // with a type defined in a different package.
473
474 Named_object*
475 Import::import_func(Package* package)
476 {
477   std::string name;
478   Typed_identifier* receiver;
479   Typed_identifier_list* parameters;
480   Typed_identifier_list* results;
481   bool is_varargs;
482   Function::import_func(this, &name, &receiver, &parameters, &results,
483                         &is_varargs);
484   Function_type *fntype = Type::make_function_type(receiver, parameters,
485                                                    results, this->location_);
486   if (is_varargs)
487     fntype->set_is_varargs();
488
489   Location loc = this->location_;
490   Named_object* no;
491   if (fntype->is_method())
492     {
493       Type* rtype = receiver->type();
494
495       // We may still be reading the definition of RTYPE, so we have
496       // to be careful to avoid calling base or convert.  If RTYPE is
497       // a named type or a forward declaration, then we know that it
498       // is not a pointer, because we are reading a method on RTYPE
499       // and named pointers can't have methods.
500
501       if (rtype->classification() == Type::TYPE_POINTER)
502         rtype = rtype->points_to();
503
504       if (rtype->is_error_type())
505         return NULL;
506       else if (rtype->named_type() != NULL)
507         no = rtype->named_type()->add_method_declaration(name, package, fntype,
508                                                          loc);
509       else if (rtype->forward_declaration_type() != NULL)
510         no = rtype->forward_declaration_type()->add_method_declaration(name,
511                                                                        package,
512                                                                        fntype,
513                                                                        loc);
514       else
515         go_unreachable();
516     }
517   else
518     {
519       no = package->add_function_declaration(name, fntype, loc);
520       if (this->add_to_globals_)
521         this->gogo_->add_named_object(no);
522     }
523   return no;
524 }
525
526 // Read a type in the import stream.  This records the type by the
527 // type index.  If the type is named, it registers the name, but marks
528 // it as invisible.
529
530 Type*
531 Import::read_type()
532 {
533   Stream* stream = this->stream_;
534   this->require_c_string("<type ");
535
536   std::string number;
537   int c;
538   while (true)
539     {
540       c = stream->get_char();
541       if (c != '-' && (c < '0' || c > '9'))
542         break;
543       number += c;
544     }
545
546   int index;
547   if (!this->string_to_int(number, true, &index))
548     return Type::make_error_type();
549
550   if (c == '>')
551     {
552       // This type was already defined.
553       if (index < 0
554           ? (static_cast<size_t>(- index) >= this->builtin_types_.size()
555              || this->builtin_types_[- index] == NULL)
556           : (static_cast<size_t>(index) >= this->types_.size()
557              || this->types_[index] == NULL))
558         {
559           error_at(this->location_,
560                    "error in import data at %d: bad type index %d",
561                    stream->pos(), index);
562           stream->set_saw_error();
563           return Type::make_error_type();
564         }
565
566       return index < 0 ? this->builtin_types_[- index] : this->types_[index];
567     }
568
569   if (c != ' ')
570     {
571       if (!stream->saw_error())
572         error_at(this->location_,
573                  "error in import data at %d: expect %< %> or %<>%>'",
574                  stream->pos());
575       stream->set_saw_error();
576       stream->advance(1);
577       return Type::make_error_type();
578     }
579
580   if (index <= 0
581       || (static_cast<size_t>(index) < this->types_.size()
582           && this->types_[index] != NULL))
583     {
584       error_at(this->location_,
585                "error in import data at %d: type index already defined",
586                stream->pos());
587       stream->set_saw_error();
588       return Type::make_error_type();
589     }
590
591   if (static_cast<size_t>(index) >= this->types_.size())
592     {
593       int newsize = std::max(static_cast<size_t>(index) + 1,
594                              this->types_.size() * 2);
595       this->types_.resize(newsize, NULL);
596     }
597
598   if (stream->peek_char() != '"')
599     {
600       Type* type = Type::import_type(this);
601       this->require_c_string(">");
602       this->types_[index] = type;
603       return type;
604     }
605
606   // This type has a name.
607
608   stream->advance(1);
609   std::string type_name;
610   while ((c = stream->get_char()) != '"')
611     type_name += c;
612
613   // If this type is in the package we are currently importing, the
614   // name will be .PKGPATH.NAME or simply NAME with no dots.
615   // Otherwise, a non-hidden symbol will be PKGPATH.NAME and a hidden
616   // symbol will be .PKGPATH.NAME.
617   std::string pkgpath;
618   if (type_name.find('.') != std::string::npos)
619     {
620       size_t start = 0;
621       if (type_name[0] == '.')
622         start = 1;
623       size_t dot = type_name.rfind('.');
624       pkgpath = type_name.substr(start, dot - start);
625       if (type_name[0] != '.')
626         type_name.erase(0, dot + 1);
627     }
628
629   this->require_c_string(" ");
630
631   // The package name may follow.  This is the name of the package in
632   // the package clause of that package.  The type name will include
633   // the pkgpath, which may be different.
634   std::string package_name;
635   if (stream->peek_char() == '"')
636     {
637       stream->advance(1);
638       while ((c = stream->get_char()) != '"')
639         package_name += c;
640       this->require_c_string(" ");
641     }
642
643   // Declare the type in the appropriate package.  If we haven't seen
644   // it before, mark it as invisible.  We declare it before we read
645   // the actual definition of the type, since the definition may refer
646   // to the type itself.
647   Package* package;
648   if (pkgpath.empty() || pkgpath == this->gogo_->pkgpath())
649     package = this->package_;
650   else
651     {
652       package = this->gogo_->register_package(pkgpath,
653                                               Linemap::unknown_location());
654       if (!package_name.empty())
655         package->set_package_name(package_name, this->location());
656     }
657
658   Named_object* no = package->bindings()->lookup(type_name);
659   if (no == NULL)
660     no = package->add_type_declaration(type_name, this->location_);
661   else if (!no->is_type_declaration() && !no->is_type())
662     {
663       error_at(this->location_, "imported %<%s.%s%> both type and non-type",
664                pkgpath.c_str(), Gogo::message_name(type_name).c_str());
665       stream->set_saw_error();
666       return Type::make_error_type();
667     }
668   else
669     go_assert(no->package() == package);
670
671   if (this->types_[index] == NULL)
672     {
673       if (no->is_type_declaration())
674         {
675           // FIXME: It's silly to make a forward declaration every time.
676           this->types_[index] = Type::make_forward_declaration(no);
677         }
678       else
679         {
680           go_assert(no->is_type());
681           this->types_[index] = no->type_value();
682         }
683     }
684
685   // If there is no type definition, then this is just a forward
686   // declaration of a type defined in some other file.
687   Type* type;
688   if (this->match_c_string(">"))
689     type = this->types_[index];
690   else
691     {
692       type = this->read_type();
693
694       if (no->is_type_declaration())
695         {
696           // We can define the type now.
697
698           no = package->add_type(type_name, type, this->location_);
699           Named_type* ntype = no->type_value();
700
701           // This type has not yet been imported.
702           ntype->clear_is_visible();
703
704           if (!type->is_undefined() && type->interface_type() != NULL)
705             this->gogo_->record_interface_type(type->interface_type());
706
707           type = ntype;
708         }
709       else if (no->is_type())
710         {
711           // We have seen this type before.  FIXME: it would be a good
712           // idea to check that the two imported types are identical,
713           // but we have not finalized the methods yet, which means
714           // that we can not reliably compare interface types.
715           type = no->type_value();
716
717           // Don't change the visibility of the existing type.
718         }
719
720       this->types_[index] = type;
721
722       // Read the type methods.
723       if (this->match_c_string("\n"))
724         {
725           this->advance(1);
726           while (this->match_c_string(" func"))
727             {
728               this->advance(1);
729               this->import_func(package);
730             }
731         }
732     }
733
734   this->require_c_string(">");
735
736   return type;
737 }
738
739 // Register the builtin types.
740
741 void
742 Import::register_builtin_types(Gogo* gogo)
743 {
744   this->register_builtin_type(gogo, "int8", BUILTIN_INT8);
745   this->register_builtin_type(gogo, "int16", BUILTIN_INT16);
746   this->register_builtin_type(gogo, "int32", BUILTIN_INT32);
747   this->register_builtin_type(gogo, "int64", BUILTIN_INT64);
748   this->register_builtin_type(gogo, "uint8", BUILTIN_UINT8);
749   this->register_builtin_type(gogo, "uint16", BUILTIN_UINT16);
750   this->register_builtin_type(gogo, "uint32", BUILTIN_UINT32);
751   this->register_builtin_type(gogo, "uint64", BUILTIN_UINT64);
752   this->register_builtin_type(gogo, "float32", BUILTIN_FLOAT32);
753   this->register_builtin_type(gogo, "float64", BUILTIN_FLOAT64);
754   this->register_builtin_type(gogo, "complex64", BUILTIN_COMPLEX64);
755   this->register_builtin_type(gogo, "complex128", BUILTIN_COMPLEX128);
756   this->register_builtin_type(gogo, "int", BUILTIN_INT);
757   this->register_builtin_type(gogo, "uint", BUILTIN_UINT);
758   this->register_builtin_type(gogo, "uintptr", BUILTIN_UINTPTR);
759   this->register_builtin_type(gogo, "bool", BUILTIN_BOOL);
760   this->register_builtin_type(gogo, "string", BUILTIN_STRING);
761   this->register_builtin_type(gogo, "error", BUILTIN_ERROR);
762   this->register_builtin_type(gogo, "byte", BUILTIN_BYTE);
763   this->register_builtin_type(gogo, "rune", BUILTIN_RUNE);
764 }
765
766 // Register a single builtin type.
767
768 void
769 Import::register_builtin_type(Gogo* gogo, const char* name, Builtin_code code)
770 {
771   Named_object* named_object = gogo->lookup_global(name);
772   go_assert(named_object != NULL && named_object->is_type());
773   int index = - static_cast<int>(code);
774   go_assert(index > 0
775              && static_cast<size_t>(index) < this->builtin_types_.size());
776   this->builtin_types_[index] = named_object->type_value();
777 }
778
779 // Read an identifier from the stream.
780
781 std::string
782 Import::read_identifier()
783 {
784   std::string ret;
785   Stream* stream = this->stream_;
786   int c;
787   while (true)
788     {
789       c = stream->peek_char();
790       if (c == -1 || c == ' ' || c == ';')
791         break;
792       ret += c;
793       stream->advance(1);
794     }
795   return ret;
796 }
797
798 // Read a name from the stream.
799
800 std::string
801 Import::read_name()
802 {
803   std::string ret = this->read_identifier();
804   if (ret == "?")
805     ret.clear();
806   else if (!Lex::is_exported_name(ret))
807     ret = '.' + this->package_->pkgpath() + '.' + ret;
808   return ret;
809 }
810
811 // Turn a string into a integer with appropriate error handling.
812
813 bool
814 Import::string_to_int(const std::string &s, bool is_neg_ok, int* ret)
815 {
816   char* end;
817   long prio = strtol(s.c_str(), &end, 10);
818   if (*end != '\0' || prio > 0x7fffffff || (prio < 0 && !is_neg_ok))
819     {
820       error_at(this->location_, "invalid integer in import data at %d",
821                this->stream_->pos());
822       this->stream_->set_saw_error();
823       return false;
824     }
825   *ret = prio;
826   return true;
827 }
828
829 // Class Import::Stream.
830
831 Import::Stream::Stream()
832   : pos_(0), saw_error_(false)
833 {
834 }
835
836 Import::Stream::~Stream()
837 {
838 }
839
840 // Return the next character to come from the stream.
841
842 int
843 Import::Stream::peek_char()
844 {
845   const char* read;
846   if (!this->do_peek(1, &read))
847     return -1;
848   // Make sure we return an unsigned char, so that we don't get
849   // confused by \xff.
850   unsigned char ret = *read;
851   return ret;
852 }
853
854 // Return true if the next LENGTH characters from the stream match
855 // BYTES
856
857 bool
858 Import::Stream::match_bytes(const char* bytes, size_t length)
859 {
860   const char* read;
861   if (!this->do_peek(length, &read))
862     return false;
863   return memcmp(bytes, read, length) == 0;
864 }
865
866 // Require that the next LENGTH bytes from the stream match BYTES.
867
868 void
869 Import::Stream::require_bytes(Location location, const char* bytes,
870                               size_t length)
871 {
872   const char* read;
873   if (!this->do_peek(length, &read)
874       || memcmp(bytes, read, length) != 0)
875     {
876       if (!this->saw_error_)
877         error_at(location, "import error at %d: expected %<%.*s%>",
878                  this->pos(), static_cast<int>(length), bytes);
879       this->saw_error_ = true;
880       return;
881     }
882   this->advance(length);
883 }
884
885 // Class Stream_from_file.
886
887 Stream_from_file::Stream_from_file(int fd)
888   : fd_(fd), data_()
889 {
890   if (lseek(fd, 0, SEEK_SET) != 0)
891     {
892       error("lseek failed: %m");
893       this->set_saw_error();
894     }
895 }
896
897 Stream_from_file::~Stream_from_file()
898 {
899   close(this->fd_);
900 }
901
902 // Read next bytes.
903
904 bool
905 Stream_from_file::do_peek(size_t length, const char** bytes)
906 {
907   if (this->data_.length() <= length)
908     {
909       *bytes = this->data_.data();
910       return true;
911     }
912   // Don't bother to handle the general case, since we don't need it.
913   go_assert(length < 64);
914   char buf[64];
915   ssize_t got = read(this->fd_, buf, length);
916
917   if (got < 0)
918     {
919       if (!this->saw_error())
920         error("read failed: %m");
921       this->set_saw_error();
922       return false;
923     }
924
925   if (lseek(this->fd_, - got, SEEK_CUR) != 0)
926     {
927       if (!this->saw_error())
928         error("lseek failed: %m");
929       this->set_saw_error();
930       return false;
931     }
932
933   if (static_cast<size_t>(got) < length)
934     return false;
935
936   this->data_.assign(buf, got);
937
938   *bytes = this->data_.data();
939   return true;
940 }
941
942 // Advance.
943
944 void
945 Stream_from_file::do_advance(size_t skip)
946 {
947   if (lseek(this->fd_, skip, SEEK_CUR) != 0)
948     {
949       if (!this->saw_error())
950         error("lseek failed: %m");
951       this->set_saw_error();
952     }
953   if (!this->data_.empty())
954     {
955       if (this->data_.length() < skip)
956         this->data_.erase(0, skip);
957       else
958         this->data_.clear();
959     }
960 }