src/wast-parser-lexer-shared.h

/*
 * Copyright 2016 WebAssembly Community Group participants
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef WABT_WAST_PARSER_LEXER_SHARED_H_
#define WABT_WAST_PARSER_LEXER_SHARED_H_

#include <stdarg.h>

#include <memory>

#include "common.h"
#include "ir.h"
#include "source-error-handler.h"
#include "wast-lexer.h"

#define WABT_WAST_PARSER_STYPE Token
#define WABT_WAST_PARSER_LTYPE Location
#define YYSTYPE WABT_WAST_PARSER_STYPE
#define YYLTYPE WABT_WAST_PARSER_LTYPE

#define WABT_INVALID_LINE_OFFSET (static_cast<size_t>(~0))

namespace wabt {

struct ExprList {
  Expr* first;
  Expr* last;
  size_t size;
};

struct TextListNode {
  StringSlice text;
  struct TextListNode* next;
};

struct TextList {
  TextListNode* first;
  TextListNode* last;
};

struct OptionalExport {
  std::unique_ptr<Export> export_;
  bool has_export;
};

struct ExportedFunc {
  std::unique_ptr<Func> func;
  OptionalExport export_;
};

struct ExportedGlobal {
  std::unique_ptr<Global> global;
  OptionalExport export_;
};

struct ExportedTable {
  std::unique_ptr<Table> table;
  std::unique_ptr<ElemSegment> elem_segment;
  OptionalExport export_;
  bool has_elem_segment;
};

struct ExportedMemory {
  std::unique_ptr<Memory> memory;
  std::unique_ptr<DataSegment> data_segment;
  OptionalExport export_;
  bool has_data_segment;
};

enum class FuncFieldType {
  Exprs,
  ParamTypes,
  BoundParam,
  ResultTypes,
  LocalTypes,
  BoundLocal,
};

struct BoundType {
  WABT_DISALLOW_COPY_AND_ASSIGN(BoundType);
  BoundType();
  ~BoundType();

  Location loc;
  StringSlice name;
  Type type;
};

struct FuncField {
  WABT_DISALLOW_COPY_AND_ASSIGN(FuncField);
  FuncField();
  ~FuncField();

  FuncFieldType type;
  union {
    Expr* first_expr;     /* WABT_FUNC_FIELD_TYPE_EXPRS */
    TypeVector* types;    /* WABT_FUNC_FIELD_TYPE_*_TYPES */
    BoundType bound_type; /* WABT_FUNC_FIELD_TYPE_BOUND_{LOCAL, PARAM} */
  };
  struct FuncField* next;
};

union Token {
  /* terminals */
  StringSlice text;
  Type type;
  Opcode opcode;
  Literal literal;

  /* non-terminals */
  /* some of these use pointers to keep the size of Token down; copying the
   tokens is a hotspot when parsing large files. */
  Action* action;
  Block* block;
  Command* command;
  CommandPtrVector* commands;
  Const const_;
  ConstVector* consts;
  DataSegment* data_segment;
  ElemSegment* elem_segment;
  Export* export_;
  ExportedFunc* exported_func;
  ExportedGlobal* exported_global;
  ExportedMemory* exported_memory;
  ExportedTable* exported_table;
  Expr* expr;
  ExprList expr_list;
  FuncField* func_fields;
  Func* func;
  FuncSignature* func_sig;
  FuncType* func_type;
  Global* global;
  Import* import;
  Limits limits;
  OptionalExport* optional_export;
  Memory* memory;
  Module* module;
  RawModule* raw_module;
  Script* script;
  Table* table;
  TextList text_list;
  TypeVector* types;
  uint32_t u32;
  uint64_t u64;
  Var var;
  VarVector* vars;
};

struct WastParser {
  Script* script;
  SourceErrorHandler* error_handler;
  int errors;
  /* Cached pointers to reallocated parser buffers, so they don't leak. */
  int16_t* yyssa;
  YYSTYPE* yyvsa;
  YYLTYPE* yylsa;
};

int wast_lexer_lex(union Token*,
                   struct Location*,
                   WastLexer*,
                   struct WastParser*);
Result wast_lexer_get_source_line(WastLexer*,
                                  const struct Location*,
                                  size_t line_max_length,
                                  char* line,
                                  size_t* out_line_length,
                                  int* out_column_offset);
void WABT_PRINTF_FORMAT(4, 5) wast_parser_error(struct Location*,
                                                WastLexer*,
                                                struct WastParser*,
                                                const char*,
                                                ...);
void wast_format_error(SourceErrorHandler*,
                       const struct Location*,
                       WastLexer*,
                       const char* format,
                       va_list);
void destroy_func_fields(FuncField*);
void destroy_text_list(TextList*);

}  // namespace wabt

#endif /* WABT_WAST_PARSER_LEXER_SHARED_H_ */