Branch data Line data Source code
1 : : // import.h -- Go frontend import declarations. -*- C++ -*-
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 : : #ifndef GO_IMPORT_H
8 : : #define GO_IMPORT_H
9 : :
10 : : #include "export.h"
11 : : #include "go-linemap.h"
12 : :
13 : : class Gogo;
14 : : class Block;
15 : : class Package;
16 : : class Type;
17 : : class Named_object;
18 : : class Named_type;
19 : : class Expression;
20 : : class Import_function_body;
21 : : class Temporary_statement;
22 : : class Unnamed_label;
23 : : class Finalize_methods;
24 : :
25 : : // Expressions can be imported either directly from import data (for
26 : : // simple constant expressions that can appear in a const declaration
27 : : // or as an array length in a type definition) or from an exported
28 : : // function body (for an inlinable function). These two cases happen
29 : : // at different points in the compilation and have different
30 : : // requirements, so it's not easy to unify them. Import_expression is
31 : : // an abstract interface that permits the expression import code to
32 : : // work at either point. When importing expressions that only occur
33 : : // for an inlinable function, the ifb method is available to get the
34 : : // full Import_function_body.
35 : :
36 : 34055 : class Import_expression
37 : : {
38 : : public:
39 : : // Return the import function body. This should only be called for
40 : : // expressions that can not appear outside of an inlinable function
41 : : // body.
42 : : virtual Import_function_body*
43 : : ifb() = 0;
44 : :
45 : : // The location to report in an error message.
46 : : virtual Location
47 : : location() const = 0;
48 : :
49 : : // Peek at the next character in the input, returning a value from 0
50 : : // to 0xff. Returns -1 at end of stream.
51 : : virtual int
52 : : peek_char() = 0;
53 : :
54 : : // Return the next character and advance.
55 : : virtual int
56 : : get_char() = 0;
57 : :
58 : : // Return true if the next bytes match STR.
59 : : virtual bool
60 : : match_c_string(const char* str) = 0;
61 : :
62 : : // Require that the next bytes match STR.
63 : : virtual void
64 : : require_c_string(const char* str) = 0;
65 : :
66 : : // Advance the stream SKIP bytes.
67 : : virtual void
68 : : advance(size_t skip) = 0;
69 : :
70 : : // Read an identifier.
71 : : virtual std::string
72 : : read_identifier() = 0;
73 : :
74 : : // Read a type.
75 : : virtual Type*
76 : : read_type() = 0;
77 : :
78 : : // Return the maximum valid package index.
79 : : virtual size_t
80 : : max_package_index() const = 0;
81 : :
82 : : // Return the package for a package index.
83 : : virtual Package*
84 : : package_at_index(int index) = 0;
85 : :
86 : : // Return the version number of the export data we're reading.
87 : : virtual Export_data_version
88 : : version() const = 0;
89 : : };
90 : :
91 : : // This class manages importing Go declarations.
92 : :
93 : : class Import : public Import_expression
94 : : {
95 : : public:
96 : : // The Stream class is an interface used to read the data. The
97 : : // caller should instantiate a child of this class.
98 : : class Stream
99 : : {
100 : : public:
101 : : Stream();
102 : : virtual ~Stream();
103 : :
104 : : // Set the position, for error messages.
105 : : void
106 : 1975892 : set_pos(int pos)
107 : 1975892 : { this->pos_ = pos; }
108 : :
109 : : // Return whether we have seen an error.
110 : : bool
111 : 2500518 : saw_error() const
112 : 2500518 : { return this->saw_error_; }
113 : :
114 : : // Record that we've seen an error.
115 : : void
116 : 0 : set_saw_error()
117 : 0 : { this->saw_error_ = true; }
118 : :
119 : : // Return the next character (a value from 0 to 0xff) without
120 : : // advancing. Returns -1 at end of stream.
121 : : int
122 : : peek_char();
123 : :
124 : : // Look for LENGTH characters, setting *BYTES to point to them.
125 : : // Returns false if the bytes are not available. Does not
126 : : // advance.
127 : : bool
128 : 10312051 : peek(size_t length, const char** bytes)
129 : 10312051 : { return this->do_peek(length, bytes); }
130 : :
131 : : // Return the next character (a value from 0 to 0xff) and advance
132 : : // the read position by 1. Returns -1 at end of stream.
133 : : int
134 : 66222916 : get_char()
135 : : {
136 : 66222916 : int c = this->peek_char();
137 : 132445832 : this->advance(1);
138 : 66222916 : return c;
139 : : }
140 : :
141 : : // Return true if at the end of the stream.
142 : : bool
143 : 6647315 : at_eof()
144 : 6647315 : { return this->peek_char() == -1; }
145 : :
146 : : // Return true if the next bytes match STR.
147 : : bool
148 : 60797101 : match_c_string(const char* str)
149 : 60797101 : { return this->match_bytes(str, strlen(str)); }
150 : :
151 : : // Return true if the next LENGTH bytes match BYTES.
152 : : bool
153 : : match_bytes(const char* bytes, size_t length);
154 : :
155 : : // Give an error if the next bytes do not match STR. Advance the
156 : : // read position by the length of STR.
157 : : void
158 : 74490370 : require_c_string(Location location, const char* str)
159 : 74490370 : { this->require_bytes(location, str, strlen(str)); }
160 : :
161 : : // Given an error if the next LENGTH bytes do not match BYTES.
162 : : // Advance the read position by LENGTH.
163 : : void
164 : : require_bytes(Location, const char* bytes, size_t length);
165 : :
166 : : // Advance the read position by SKIP bytes.
167 : : void
168 : 290771805 : advance(size_t skip)
169 : : {
170 : 285228985 : this->do_advance(skip);
171 : 223720931 : this->pos_ += skip;
172 : 136884719 : }
173 : :
174 : : // Return the current read position. This returns int because it
175 : : // is more convenient in error reporting. FIXME.
176 : : int
177 : 12345360 : pos()
178 : 12345360 : { return static_cast<int>(this->pos_); }
179 : :
180 : : protected:
181 : : // This function should set *BYTES to point to a buffer holding
182 : : // the LENGTH bytes at the current read position. It should
183 : : // return false if the bytes are not available. This should not
184 : : // change the current read position.
185 : : virtual bool
186 : : do_peek(size_t length, const char** bytes) = 0;
187 : :
188 : : // This function should advance the current read position LENGTH
189 : : // bytes.
190 : : virtual void
191 : : do_advance(size_t skip) = 0;
192 : :
193 : : private:
194 : : // The current read position.
195 : : size_t pos_;
196 : : // True if we've seen an error reading from this stream.
197 : : bool saw_error_;
198 : : };
199 : :
200 : : // Find import data. This searches the file system for FILENAME and
201 : : // returns a pointer to a Stream object to read the data that it
202 : : // exports. LOCATION is the location of the import statement.
203 : : // RELATIVE_IMPORT_PATH is used as a prefix for a relative import.
204 : : static Stream*
205 : : open_package(const std::string& filename, Location location,
206 : : const std::string& relative_import_path);
207 : :
208 : : // Constructor.
209 : : Import(Stream*, Location);
210 : :
211 : : // Register the builtin types.
212 : : void
213 : : register_builtin_types(Gogo*);
214 : :
215 : : // Import everything defined in the stream. LOCAL_NAME is the local
216 : : // name to be used for bindings; if it is the string "." then
217 : : // bindings should be inserted in the global scope. If LOCAL_NAME
218 : : // is the empty string then the name of the package itself is the
219 : : // local name. This returns the imported package, or NULL on error.
220 : : Package*
221 : : import(Gogo*, const std::string& local_name, bool is_local_name_exported);
222 : :
223 : : // The location of the import statement.
224 : : Location
225 : 12557570 : location() const
226 : 12557570 : { return this->location_; }
227 : :
228 : : // Return the package we are importing.
229 : : Package*
230 : 65117 : package() const
231 : 65117 : { return this->package_; }
232 : :
233 : : // Return the next character.
234 : : int
235 : 26702549 : peek_char()
236 : 26702549 : { return this->stream_->peek_char(); }
237 : :
238 : : // Return the next character and advance.
239 : : int
240 : 2071503 : get_char()
241 : 2071503 : { return this->stream_->get_char(); }
242 : :
243 : : // Read LENGTH characters into *OUT and advance past them. On
244 : : // EOF reports an error and sets *OUT to an empty string.
245 : : void
246 : : read(size_t length, std::string* out);
247 : :
248 : : // Return true at the end of the stream.
249 : : bool
250 : : at_eof()
251 : : { return this->stream_->at_eof(); }
252 : :
253 : : // Return whether the next bytes match STR.
254 : : bool
255 : 49567982 : match_c_string(const char* str)
256 : 49567982 : { return this->stream_->match_c_string(str); }
257 : :
258 : : // Require that the next bytes match STR.
259 : : void
260 : 74490370 : require_c_string(const char* str)
261 : 74490370 : { this->stream_->require_c_string(this->location_, str); }
262 : :
263 : : // Advance the stream SKIP bytes.
264 : : void
265 : 5848203 : advance(size_t skip)
266 : 5848203 : { this->stream_->advance(skip); }
267 : :
268 : : // Stream position, for error reporting.
269 : : int
270 : 0 : pos()
271 : 0 : { return this->stream_->pos(); }
272 : :
273 : : // Return the version number of the export data we're reading.
274 : : Export_data_version
275 : 1297450 : version() const { return this->version_; }
276 : :
277 : : // Skip a semicolon if using an older version.
278 : : void
279 : 4010448 : require_semicolon_if_old_version()
280 : : {
281 : 4010448 : if (this->version_ == EXPORT_FORMAT_V1
282 : 4010448 : || this->version_ == EXPORT_FORMAT_V2)
283 : 0 : this->require_c_string(";");
284 : 4010448 : }
285 : :
286 : : // Read an identifier.
287 : : std::string
288 : : read_identifier();
289 : :
290 : : // Read a name. This is like read_identifier, except that a "?" is
291 : : // returned as an empty string. This matches Export::write_name.
292 : : std::string
293 : : read_name();
294 : :
295 : : // Return the maximum valid package index. This is the size of
296 : : // packages_ because we will subtract 1 in package_at_index.
297 : : size_t
298 : 246614 : max_package_index() const
299 : 246614 : { return this->packages_.size(); }
300 : :
301 : : // Return the package at an index. (We subtract 1 because package
302 : : // index 0 is not used.)
303 : : Package*
304 : 246614 : package_at_index(int index)
305 : 246614 : { return this->packages_.at(index - 1); }
306 : :
307 : : // Read a type.
308 : : Type*
309 : : read_type();
310 : :
311 : : // Return the type for a type index. INPUT_NAME and INPUT_OFFSET
312 : : // are only for error reporting. PARSED is set to whether we parsed
313 : : // the type information for a new type.
314 : : Type*
315 : : type_for_index(int index, const std::string& input_name,
316 : : size_t input_offset, bool* parsed);
317 : :
318 : : // Read an escape note.
319 : : std::string
320 : : read_escape();
321 : :
322 : : // Clear the stream when it is no longer accessible.
323 : : void
324 : 21808 : clear_stream()
325 : 21808 : { this->stream_ = NULL; }
326 : :
327 : : // Just so that Import implements Import_expression.
328 : : Import_function_body*
329 : 0 : ifb()
330 : 0 : { return NULL; }
331 : :
332 : : // Read a qualified identifier from an Import_expression. Sets
333 : : // *NAME, *PKG, and *IS_EXPORTED, and reports whether it succeeded.
334 : : static bool
335 : : read_qualified_identifier(Import_expression*, std::string* name,
336 : : Package** pkg, bool* is_exported);
337 : :
338 : : private:
339 : : static Stream*
340 : : try_package_in_directory(const std::string&, Location);
341 : :
342 : : static int
343 : : try_suffixes(std::string*);
344 : :
345 : : static Stream*
346 : : find_export_data(const std::string& filename, int fd, Location);
347 : :
348 : : static Stream*
349 : : find_object_export_data(const std::string& filename, int fd,
350 : : off_t offset, Location);
351 : :
352 : : static const int archive_magic_len = 8;
353 : :
354 : : static bool
355 : : is_archive_magic(const char*);
356 : :
357 : : static Stream*
358 : : find_archive_export_data(const std::string& filename, int fd,
359 : : Location);
360 : :
361 : : // Read a package line.
362 : : void
363 : : read_one_package();
364 : :
365 : : // Read an import line.
366 : : void
367 : : read_one_import();
368 : :
369 : : // Read an indirectimport line.
370 : : void
371 : : read_one_indirect_import();
372 : :
373 : : // Read the import control functions and init graph.
374 : : void
375 : : read_import_init_fns(Gogo*);
376 : :
377 : : // Read the types.
378 : : bool
379 : : read_types();
380 : :
381 : : // Import a constant.
382 : : void
383 : : import_const();
384 : :
385 : : // Import a type.
386 : : void
387 : : import_type();
388 : :
389 : : // Import a variable.
390 : : void
391 : : import_var();
392 : :
393 : : // Import a function.
394 : : void
395 : : import_func(Package*);
396 : :
397 : : // Parse a type definition.
398 : : bool
399 : : parse_type(int index);
400 : :
401 : : // Read a named type and store it at this->type_[index].
402 : : Type*
403 : : read_named_type(int index);
404 : :
405 : : // Register a single builtin type.
406 : : void
407 : : register_builtin_type(Gogo*, const char* name, Builtin_code);
408 : :
409 : : // Get an integer from a string.
410 : : bool
411 : : string_to_int(const std::string&, bool is_neg_ok, int* ret);
412 : :
413 : : // Get an unsigned integer from a string.
414 : : bool
415 : 6605358 : string_to_unsigned(const std::string& s, unsigned* ret)
416 : : {
417 : 6605358 : int ivalue;
418 : 6605358 : if (!this->string_to_int(s, false, &ivalue))
419 : : return false;
420 : 6605358 : *ret = static_cast<unsigned>(ivalue);
421 : 6605358 : return true;
422 : : }
423 : :
424 : : // Finalize methods for newly imported types.
425 : : void
426 : : finalize_methods();
427 : :
428 : : // The general IR.
429 : : Gogo* gogo_;
430 : : // The stream from which to read import data.
431 : : Stream* stream_;
432 : : // The location of the import statement we are processing.
433 : : Location location_;
434 : : // The package we are importing.
435 : : Package* package_;
436 : : // Whether to add new objects to the global scope, rather than to a
437 : : // package scope.
438 : : bool add_to_globals_;
439 : : // Mapping from package index to package.
440 : : std::vector<Package*> packages_;
441 : : // All type data.
442 : : std::string type_data_;
443 : : // Position of type data in the stream.
444 : : int type_pos_;
445 : : // Mapping from type code to offset/length in type_data_.
446 : : std::vector<std::pair<size_t, size_t> > type_offsets_;
447 : : // Mapping from negated builtin type codes to Type structures.
448 : : std::vector<Named_type*> builtin_types_;
449 : : // Mapping from exported type codes to Type structures.
450 : : std::vector<Type*> types_;
451 : : // Version of export data we're reading.
452 : : Export_data_version version_;
453 : : };
454 : :
455 : : // Read import data from a string.
456 : :
457 : : class Stream_from_string : public Import::Stream
458 : : {
459 : : public:
460 : 0 : Stream_from_string(const std::string& str)
461 : 0 : : str_(str), pos_(0)
462 : 0 : { }
463 : :
464 : : protected:
465 : : bool
466 : 0 : do_peek(size_t length, const char** bytes)
467 : : {
468 : 0 : if (this->pos_ + length > this->str_.length())
469 : : return false;
470 : 0 : *bytes = this->str_.data() + this->pos_;
471 : 0 : return true;
472 : : }
473 : :
474 : : void
475 : 0 : do_advance(size_t len)
476 : 0 : { this->pos_ += len; }
477 : :
478 : : private:
479 : : // The string of data we are reading.
480 : : std::string str_;
481 : : // The current position within the string.
482 : : size_t pos_;
483 : : };
484 : :
485 : : // Read import data from a buffer allocated using malloc.
486 : :
487 : : class Stream_from_buffer : public Import::Stream
488 : : {
489 : : public:
490 : 21808 : Stream_from_buffer(char* buf, size_t length)
491 : 21808 : : buf_(buf), length_(length), pos_(0)
492 : : { }
493 : :
494 : 43616 : ~Stream_from_buffer()
495 : 43616 : { free(this->buf_); }
496 : :
497 : : protected:
498 : : bool
499 : 194433574 : do_peek(size_t length, const char** bytes)
500 : : {
501 : 194433574 : if (this->pos_ + length > this->length_)
502 : : return false;
503 : 194411766 : *bytes = this->buf_ + this->pos_;
504 : 194411766 : return true;
505 : : }
506 : :
507 : : void
508 : 130043710 : do_advance(size_t len)
509 : 130043710 : { this->pos_ += len; }
510 : :
511 : : private:
512 : : // The data we are reading.
513 : : char* buf_;
514 : : // The length of the buffer.
515 : : size_t length_;
516 : : // The current position within the buffer.
517 : : size_t pos_;
518 : : };
519 : :
520 : : // Read import data from an open file descriptor.
521 : :
522 : : class Stream_from_file : public Import::Stream
523 : : {
524 : : public:
525 : : Stream_from_file(int fd);
526 : :
527 : : ~Stream_from_file();
528 : :
529 : : protected:
530 : : bool
531 : : do_peek(size_t, const char**);
532 : :
533 : : void
534 : : do_advance(size_t);
535 : :
536 : : private:
537 : : // No copying.
538 : : Stream_from_file(const Stream_from_file&);
539 : : Stream_from_file& operator=(const Stream_from_file&);
540 : :
541 : : // The file descriptor.
542 : : int fd_;
543 : : // Data read from the file.
544 : : std::string data_;
545 : : };
546 : :
547 : : // Read import data from an offset into a std::string. This uses a
548 : : // reference to the string, to avoid copying, so the string must be
549 : : // kept alive through some other mechanism.
550 : :
551 : : class Stream_from_string_ref : public Import::Stream
552 : : {
553 : : public:
554 : 1975892 : Stream_from_string_ref(const std::string& str, size_t offset, size_t length)
555 : 1975892 : : str_(str), pos_(offset), end_(offset + length)
556 : : { }
557 : :
558 : 1975892 : ~Stream_from_string_ref()
559 : 1975892 : {}
560 : :
561 : : protected:
562 : : bool
563 : 208592879 : do_peek(size_t length, const char** bytes)
564 : : {
565 : 208592879 : if (this->pos_ + length > this->end_)
566 : : return false;
567 : 207768302 : *bytes = &this->str_[this->pos_];
568 : 207768302 : return true;
569 : : }
570 : :
571 : : void
572 : 154124396 : do_advance(size_t length)
573 : 154124396 : { this->pos_ += length; }
574 : :
575 : : private:
576 : : // A reference to the string we are reading from.
577 : : const std::string& str_;
578 : : // The current offset into the string.
579 : : size_t pos_;
580 : : // The index after the last byte we can read.
581 : : size_t end_;
582 : : };
583 : :
584 : : // Class to manage importing a function body. This is passed around
585 : : // to Statements and Expressions. It parses the function into the IR.
586 : :
587 : : class Import_function_body : public Import_expression
588 : : {
589 : : public:
590 : : Import_function_body(Gogo* gogo, Import* imp, Named_object* named_object,
591 : : const std::string& body, size_t off, Block* block,
592 : : int indent);
593 : : ~Import_function_body();
594 : :
595 : : // The IR.
596 : : Gogo*
597 : 198401 : gogo()
598 : 102453 : { return this->gogo_; }
599 : :
600 : : // The location to report in an error message.
601 : : Location
602 : 38869 : location() const
603 : 38869 : { return this->imp_->location(); }
604 : :
605 : : // The function we are importing.
606 : : Named_object*
607 : 28767 : function() const
608 : 28767 : { return this->named_object_; }
609 : :
610 : : // A reference to the body we are reading.
611 : : const std::string&
612 : 65491 : body() const
613 : 65491 : { return this->body_; }
614 : :
615 : : // The current offset into the body.
616 : : size_t
617 : 134817 : off()
618 : 134817 : { return this->off_; }
619 : :
620 : : // Update the offset into the body.
621 : : void
622 : 134817 : set_off(size_t off)
623 : 134817 : { this->off_ = off; }
624 : :
625 : : // Advance the offset by SKIP bytes.
626 : : void
627 : 296744 : advance(size_t skip)
628 : 296744 : { this->off_ += skip; }
629 : :
630 : : // The current block.
631 : : Block*
632 : 93158 : block()
633 : 93158 : { return this->blocks_.back(); }
634 : :
635 : : // Begin importing a new block BLOCK nested within the current block.
636 : : void
637 : 26622 : begin_block(Block *block)
638 : 26622 : { this->blocks_.push_back(block); }
639 : :
640 : : // Record the fact that we're done importing the current block.
641 : : void
642 : 26622 : finish_block()
643 : 26622 : { this->blocks_.pop_back(); }
644 : :
645 : : // The current indentation.
646 : : int
647 : 95948 : indent() const
648 : 95948 : { return this->indent_; }
649 : :
650 : : // Increment the indentation level.
651 : : void
652 : 26622 : increment_indent()
653 : 26622 : { ++this->indent_; }
654 : :
655 : : // Decrement the indentation level.
656 : : void
657 : 26622 : decrement_indent()
658 : 26622 : { --this->indent_; }
659 : :
660 : : // The name of the function we are parsing.
661 : : const std::string&
662 : : name() const;
663 : :
664 : : // Return the next character in the input stream, or -1 at the end.
665 : : int
666 : 152242 : peek_char()
667 : : {
668 : 152242 : if (this->body_.length() <= this->off_)
669 : : return -1;
670 : 152242 : return static_cast<unsigned char>(this->body_[this->off_]);
671 : : }
672 : :
673 : : // Return the next character and advance.
674 : : int
675 : 151368 : get_char()
676 : : {
677 : 151368 : if (this->body_.length() <= this->off_)
678 : : return -1;
679 : 151368 : int c = static_cast<unsigned char>(this->body_[this->off_]);
680 : 151368 : this->off_++;
681 : 151368 : return c;
682 : : }
683 : :
684 : : // Return whether the C string matches the current body position.
685 : : bool
686 : 1881747 : match_c_string(const char* str)
687 : : {
688 : 1881747 : size_t len = strlen(str);
689 : 1881747 : return (this->body_.length() >= this->off_ + len
690 : 1881747 : && this->body_.compare(this->off_, len, str) == 0);
691 : : }
692 : :
693 : : // Give an error if the next bytes do not match STR. Advance the
694 : : // offset by the length of STR.
695 : : void
696 : : require_c_string(const char* str);
697 : :
698 : : // Read an identifier.
699 : : std::string
700 : : read_identifier();
701 : :
702 : : // Read a type.
703 : : Type*
704 : : read_type();
705 : :
706 : : Export_data_version
707 : 287492 : version() const
708 : 287492 : { return this->imp_->version(); }
709 : :
710 : : // Record the index of a temporary statement.
711 : : void
712 : : record_temporary(Temporary_statement*, unsigned int);
713 : :
714 : : // Return a temporary statement given an index.
715 : : Temporary_statement*
716 : : temporary_statement(unsigned int);
717 : :
718 : : // Return an unnamed label given an index, defining the label if we
719 : : // haven't seen it already.
720 : : Unnamed_label*
721 : : unnamed_label(unsigned int, Location);
722 : :
723 : : // Implement Import_expression.
724 : : Import_function_body*
725 : 76294 : ifb()
726 : 76294 : { return this; }
727 : :
728 : : // Return the maximum valid package index.
729 : : size_t
730 : 3874 : max_package_index() const
731 : 3874 : { return this->imp_->max_package_index(); }
732 : :
733 : : // Return the package at an index.
734 : : Package*
735 : 3874 : package_at_index(int index)
736 : 3874 : { return this->imp_->package_at_index(index); }
737 : :
738 : : // Return whether we have seen an error.
739 : : bool
740 : 76294 : saw_error() const
741 : 76294 : { return this->saw_error_; }
742 : :
743 : : // Record that we have seen an error.
744 : : void
745 : 0 : set_saw_error()
746 : 0 : { this->saw_error_ = true; }
747 : :
748 : : private:
749 : : static size_t
750 : : next_size(size_t);
751 : :
752 : : // The IR.
753 : : Gogo* gogo_;
754 : : // The importer.
755 : : Import* imp_;
756 : : // The function we are parsing.
757 : : Named_object* named_object_;
758 : : // The exported data we are parsing. Note that this is a reference;
759 : : // the body string must laster longer than this object.
760 : : const std::string& body_;
761 : : // The current offset into body_.
762 : : size_t off_;
763 : : // Stack to record nesting of blocks being imported.
764 : : std::vector<Block *> blocks_;
765 : : // Current expected indentation level.
766 : : int indent_;
767 : : // Temporary statements by index.
768 : : std::vector<Temporary_statement*> temporaries_;
769 : : // Unnamed labels by index.
770 : : std::vector<Unnamed_label*> labels_;
771 : : // Whether we've seen an error. Used to avoid reporting excess
772 : : // errors.
773 : : bool saw_error_;
774 : : };
775 : :
776 : : #endif // !defined(GO_IMPORT_H)
|
