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