OSDN Git Service

Add Go frontend, libgo library, and Go testsuite.
[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 "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, source_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                                  source_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                          source_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                                 source_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       return NULL;
248     }
249   if (c < sec_length)
250     {
251       error_at(location, "%s: short read", filename.c_str());
252       return NULL;
253     }
254
255   return new Stream_from_buffer(buf, sec_length);
256 }
257
258 // Class Import.
259
260 // Construct an Import object.  We make the builtin_types_ vector
261 // large enough to hold all the builtin types.
262
263 Import::Import(Stream* stream, source_location location)
264   : gogo_(NULL), stream_(stream), location_(location), package_(NULL),
265     add_to_globals_(false),
266     builtin_types_((- SMALLEST_BUILTIN_CODE) + 1),
267     types_()
268 {
269 }
270
271 // Import the data in the associated stream.
272
273 Package*
274 Import::import(Gogo* gogo, const std::string& local_name,
275                bool is_local_name_exported)
276 {
277   // Hold on to the Gogo structure.  Otherwise we need to pass it
278   // through all the import functions, because we need it when reading
279   // a type.
280   this->gogo_ = gogo;
281
282   // A stream of export data can include data from more than one input
283   // file.  Here we loop over each input file.
284   Stream* stream = this->stream_;
285   while (!stream->at_eof() && !stream->saw_error())
286     {
287       // The vector of types is package specific.
288       this->types_.clear();
289
290       stream->require_bytes(this->location_, Export::v1_magic,
291                             Export::v1_magic_len);
292
293       this->require_c_string("package ");
294       std::string package_name = this->read_identifier();
295       this->require_c_string(";\n");
296
297       this->require_c_string("prefix ");
298       std::string unique_prefix = this->read_identifier();
299       this->require_c_string(";\n");
300
301       this->package_ = gogo->add_imported_package(package_name, local_name,
302                                                   is_local_name_exported,
303                                                   unique_prefix,
304                                                   this->location_,
305                                                   &this->add_to_globals_);
306       if (this->package_ == NULL)
307         {
308           stream->set_saw_error();
309           return NULL;
310         }
311
312       this->require_c_string("priority ");
313       std::string priority_string = this->read_identifier();
314       int prio;
315       if (!this->string_to_int(priority_string, false, &prio))
316         return NULL;
317       this->package_->set_priority(prio);
318       this->require_c_string(";\n");
319
320       if (stream->match_c_string("import "))
321         this->read_import_init_fns(gogo);
322
323       // Loop over all the input data for this package.
324       while (!stream->saw_error())
325         {
326           if (stream->match_c_string("const "))
327             this->import_const();
328           else if (stream->match_c_string("type "))
329             this->import_type();
330           else if (stream->match_c_string("var "))
331             this->import_var();
332           else if (stream->match_c_string("func "))
333             this->import_func(this->package_);
334           else if (stream->match_c_string("checksum "))
335             break;
336           else
337             {
338               error_at(this->location_,
339                        ("error in import data at %d: "
340                         "expected %<const%>, %<type%>, %<var%>, "
341                         "%<func%>, or %<checksum%>"),
342                        stream->pos());
343               stream->set_saw_error();
344               return NULL;
345             }
346         }
347
348       // We currently ignore the checksum.  In the future we could
349       // store the checksum somewhere in the generated object and then
350       // verify that the checksum matches at link time or at dynamic
351       // load time.
352       this->require_c_string("checksum ");
353       stream->advance(Export::v1_checksum_len * 2);
354       this->require_c_string(";\n");
355     }
356
357   return this->package_;
358 }
359
360 // Read the list of import control functions.
361
362 void
363 Import::read_import_init_fns(Gogo* gogo)
364 {
365   this->require_c_string("import");
366   while (!this->match_c_string(";"))
367     {
368       this->require_c_string(" ");
369       std::string package_name = this->read_identifier();
370       this->require_c_string(" ");
371       std::string init_name = this->read_identifier();
372       this->require_c_string(" ");
373       std::string prio_string = this->read_identifier();
374       int prio;
375       if (!this->string_to_int(prio_string, false, &prio))
376         return;
377       gogo->add_import_init_fn(package_name, init_name, prio);
378     }
379   this->require_c_string(";\n");
380 }
381
382 // Import a constant.
383
384 void
385 Import::import_const()
386 {
387   std::string name;
388   Type* type;
389   Expression* expr;
390   Named_constant::import_const(this, &name, &type, &expr);
391   Typed_identifier tid(name, type, this->location_);
392   Named_object* no = this->package_->add_constant(tid, expr);
393   if (this->add_to_globals_)
394     this->gogo_->add_named_object(no);
395 }
396
397 // Import a type.
398
399 void
400 Import::import_type()
401 {
402   Named_type* type;
403   Named_type::import_named_type(this, &type);
404
405   // The named type has been added to the package by the type import
406   // process.  Here we need to make it visible to the parser, and it
407   // to the global bindings if necessary.
408   type->set_is_visible();
409
410   if (this->add_to_globals_)
411     this->gogo_->add_named_type(type);
412 }
413
414 // Import a variable.
415
416 void
417 Import::import_var()
418 {
419   std::string name;
420   Type* type;
421   Variable::import_var(this, &name, &type);
422   Variable* var = new Variable(type, NULL, true, false, false,
423                                this->location_);
424   Named_object* no;
425   no = this->package_->add_variable(name, var);
426   if (this->add_to_globals_)
427     this->gogo_->add_named_object(no);
428 }
429
430 // Import a function into PACKAGE.  PACKAGE is normally
431 // THIS->PACKAGE_, but it will be different for a method associated
432 // with a type defined in a different package.
433
434 Named_object*
435 Import::import_func(Package* package)
436 {
437   std::string name;
438   Typed_identifier* receiver;
439   Typed_identifier_list* parameters;
440   Typed_identifier_list* results;
441   bool is_varargs;
442   Function::import_func(this, &name, &receiver, &parameters, &results,
443                         &is_varargs);
444   Function_type *fntype = Type::make_function_type(receiver, parameters,
445                                                    results, this->location_);
446   if (is_varargs)
447     fntype->set_is_varargs();
448
449   source_location loc = this->location_;
450   Named_object* no;
451   if (fntype->is_method())
452     {
453       Type* rtype = receiver->type()->deref();
454       if (rtype->is_error_type())
455         return NULL;
456       Named_type* named_rtype = rtype->named_type();
457       gcc_assert(named_rtype != NULL);
458       no = named_rtype->add_method_declaration(name, package, fntype, loc);
459     }
460   else
461     {
462       no = package->add_function_declaration(name, fntype, loc);
463       if (this->add_to_globals_)
464         this->gogo_->add_named_object(no);
465     }
466   return no;
467 }
468
469 // Read a type in the import stream.  This records the type by the
470 // type index.  If the type is named, it registers the name, but marks
471 // it as invisible.
472
473 Type*
474 Import::read_type()
475 {
476   Stream* stream = this->stream_;
477   this->require_c_string("<type ");
478
479   std::string number;
480   int c;
481   while (true)
482     {
483       c = stream->get_char();
484       if (c != '-' && (c < '0' || c > '9'))
485         break;
486       number += c;
487     }
488
489   int index;
490   if (!this->string_to_int(number, true, &index))
491     return Type::make_error_type();
492
493   if (c == '>')
494     {
495       // This type was already defined.
496       if (index < 0
497           ? (static_cast<size_t>(- index) >= this->builtin_types_.size()
498              || this->builtin_types_[- index] == NULL)
499           : (static_cast<size_t>(index) >= this->types_.size()
500              || this->types_[index] == NULL))
501         {
502           error_at(this->location_,
503                    "error in import data at %d: bad type index %d",
504                    stream->pos(), index);
505           stream->set_saw_error();
506           return Type::make_error_type();
507         }
508
509       return index < 0 ? this->builtin_types_[- index] : this->types_[index];
510     }
511
512   if (c != ' ')
513     {
514       if (!stream->saw_error())
515         error_at(this->location_,
516                  "error in import data at %d: expect %< %> or %<>%>'",
517                  stream->pos());
518       stream->set_saw_error();
519       stream->advance(1);
520       return Type::make_error_type();
521     }
522
523   if (index <= 0
524       || (static_cast<size_t>(index) < this->types_.size()
525           && this->types_[index] != NULL))
526     {
527       error_at(this->location_,
528                "error in import data at %d: type index already defined",
529                stream->pos());
530       stream->set_saw_error();
531       return Type::make_error_type();
532     }
533
534   if (static_cast<size_t>(index) >= this->types_.size())
535     {
536       int newsize = std::max(static_cast<size_t>(index) + 1,
537                              this->types_.size() * 2);
538       this->types_.resize(newsize, NULL);
539     }
540
541   if (stream->peek_char() != '"')
542     {
543       Type* type = Type::import_type(this);
544       this->require_c_string(">");
545       this->types_[index] = type;
546       return type;
547     }
548
549   // This type has a name.
550
551   stream->advance(1);
552   std::string type_name;
553   while ((c = stream->get_char()) != '"')
554     type_name += c;
555
556   // If this type is in the current package, the name will be
557   // .PREFIX.PACKAGE.NAME or simply NAME with no dots.  Otherwise, a
558   // non-hidden symbol will be PREFIX.PACKAGE.NAME and a hidden symbol
559   // will be .PREFIX.PACKAGE.NAME.
560   std::string package_name;
561   std::string unique_prefix;
562   if (type_name.find('.') != std::string::npos)
563     {
564       bool is_hidden = false;
565       size_t start = 0;
566       if (type_name[0] == '.')
567         {
568           ++start;
569           is_hidden = true;
570         }
571       size_t dot1 = type_name.find('.', start);
572       size_t dot2;
573       if (dot1 == std::string::npos)
574         dot2 = std::string::npos;
575       else
576         dot2 = type_name.find('.', dot1 + 1);
577       if (dot1 == std::string::npos || dot2 == std::string::npos)
578         {
579           error_at(this->location_,
580                    ("error at import data at %d: missing dot in type name"),
581                    stream->pos());
582           stream->set_saw_error();
583         }
584       else
585         {
586           unique_prefix = type_name.substr(start, dot1 - start);
587           package_name = type_name.substr(dot1 + 1, dot2 - (dot1 + 1));
588         }
589       if (!is_hidden)
590         type_name.erase(0, dot2 + 1);
591     }
592
593   this->require_c_string(" ");
594
595   // Declare the type in the appropriate package.  If we haven't seen
596   // it before, mark it as invisible.  We declare it before we read
597   // the actual definition of the type, since the definition may refer
598   // to the type itself.
599   Package* package;
600   if (package_name.empty())
601     package = this->package_;
602   else
603     package = this->gogo_->register_package(package_name, unique_prefix,
604                                             UNKNOWN_LOCATION);
605
606   Named_object* no = package->bindings()->lookup(type_name);
607   if (no == NULL)
608     no = package->add_type_declaration(type_name, this->location_);
609   else if (!no->is_type_declaration() && !no->is_type())
610     {
611       error_at(this->location_, "imported %<%s.%s%> both type and non-type",
612                Gogo::message_name(package->name()).c_str(),
613                Gogo::message_name(type_name).c_str());
614       stream->set_saw_error();
615       return Type::make_error_type();
616     }
617   else
618     gcc_assert(no->package() == package);
619
620   if (this->types_[index] == NULL)
621     {
622       if (no->is_type_declaration())
623         {
624           // FIXME: It's silly to make a forward declaration every time.
625           this->types_[index] = Type::make_forward_declaration(no);
626         }
627       else
628         {
629           gcc_assert(no->is_type());
630           this->types_[index] = no->type_value();
631         }
632     }
633
634   // If there is no type definition, then this is just a forward
635   // declaration of a type defined in some other file.
636   Type* type;
637   if (this->match_c_string(">"))
638     type = this->types_[index];
639   else
640     {
641       type = this->read_type();
642
643       if (no->is_type_declaration())
644         {
645           // We can define the type now.
646
647           no = package->add_type(type_name, type, this->location_);
648           Named_type* ntype = no->type_value();
649
650           // This type has not yet been imported.
651           ntype->clear_is_visible();
652
653           type = ntype;
654         }
655       else if (no->is_type())
656         {
657           // We have seen this type before.  FIXME: it would be a good
658           // idea to check that the two imported types are identical,
659           // but we have not finalized the methds yet, which means
660           // that we can nt reliably compare interface types.
661           type = no->type_value();
662
663           // Don't change the visibility of the existing type.
664         }
665
666       this->types_[index] = type;
667
668       // Read the type methods.
669       if (this->match_c_string("\n"))
670         {
671           this->advance(1);
672           while (this->match_c_string(" func"))
673             {
674               this->advance(1);
675               this->import_func(package);
676             }
677         }
678     }
679
680   this->require_c_string(">");
681
682   return type;
683 }
684
685 // Register the builtin types.
686
687 void
688 Import::register_builtin_types(Gogo* gogo)
689 {
690   this->register_builtin_type(gogo, "int8", BUILTIN_INT8);
691   this->register_builtin_type(gogo, "int16", BUILTIN_INT16);
692   this->register_builtin_type(gogo, "int32", BUILTIN_INT32);
693   this->register_builtin_type(gogo, "int64", BUILTIN_INT64);
694   this->register_builtin_type(gogo, "uint8", BUILTIN_UINT8);
695   this->register_builtin_type(gogo, "uint16", BUILTIN_UINT16);
696   this->register_builtin_type(gogo, "uint32", BUILTIN_UINT32);
697   this->register_builtin_type(gogo, "uint64", BUILTIN_UINT64);
698   this->register_builtin_type(gogo, "float32", BUILTIN_FLOAT32);
699   this->register_builtin_type(gogo, "float64", BUILTIN_FLOAT64);
700   this->register_builtin_type(gogo, "complex64", BUILTIN_COMPLEX64);
701   this->register_builtin_type(gogo, "complex128", BUILTIN_COMPLEX128);
702   this->register_builtin_type(gogo, "int", BUILTIN_INT);
703   this->register_builtin_type(gogo, "uint", BUILTIN_UINT);
704   this->register_builtin_type(gogo, "uintptr", BUILTIN_UINTPTR);
705   this->register_builtin_type(gogo, "float", BUILTIN_FLOAT);
706   this->register_builtin_type(gogo, "complex", BUILTIN_COMPLEX);
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   gcc_assert(named_object != NULL && named_object->is_type());
718   int index = - static_cast<int>(code);
719   gcc_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(source_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   gcc_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 }