summaryrefslogtreecommitdiff
path: root/src/resolve-names.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/resolve-names.cc')
-rw-r--r--src/resolve-names.cc347
1 files changed, 182 insertions, 165 deletions
diff --git a/src/resolve-names.cc b/src/resolve-names.cc
index 70eff09c..b5958f4a 100644
--- a/src/resolve-names.cc
+++ b/src/resolve-names.cc
@@ -29,9 +29,16 @@ namespace {
typedef Label* LabelPtr;
-struct Context : ExprVisitor::DelegateNop {
- Context();
+class NameResolver : public ExprVisitor::DelegateNop {
+ public:
+ NameResolver(WastLexer* lexer,
+ Script* script,
+ SourceErrorHandler* error_handler);
+ Result VisitModule(Module* module);
+ Result VisitScript(Script* script);
+
+ // Implementation of ExprVisitor::DelegateNop.
Result BeginBlockExpr(Expr*) override;
Result EndBlockExpr(Expr*) override;
Result OnBrExpr(Expr*) override;
@@ -49,91 +56,119 @@ struct Context : ExprVisitor::DelegateNop {
Result OnSetLocalExpr(Expr*) override;
Result OnTeeLocalExpr(Expr*) override;
- SourceErrorHandler* error_handler = nullptr;
- WastLexer* lexer = nullptr;
- Script* script = nullptr;
- Module* current_module = nullptr;
- Func* current_func = nullptr;
- ExprVisitor visitor;
- std::vector<Label*> labels;
- Result result = Result::Ok;
+ private:
+ void PrintError(const Location* loc, const char* fmt, ...);
+ void PushLabel(Label* label);
+ void PopLabel();
+ static void OnDuplicateBinding(const BindingHash::value_type& a,
+ const BindingHash::value_type& b,
+ void* user_data);
+ void CheckDuplicateBindings(const BindingHash* bindings, const char* desc);
+ void ResolveLabelVar(Var* var);
+ void ResolveVar(const BindingHash* bindings, Var* var, const char* desc);
+ void ResolveFuncVar(Var* var);
+ void ResolveGlobalVar(Var* var);
+ void ResolveFuncTypeVar(Var* var);
+ void ResolveTableVar(Var* var);
+ void ResolveMemoryVar(Var* var);
+ void ResolveLocalVar(Var* var);
+ void VisitFunc(Func* func);
+ void VisitExport(Export* export_);
+ void VisitGlobal(Global* global);
+ void VisitElemSegment(ElemSegment* segment);
+ void VisitDataSegment(DataSegment* segment);
+ void VisitRawModule(RawModule* raw_module);
+ void VisitCommand(Command* command);
+
+ SourceErrorHandler* error_handler_ = nullptr;
+ WastLexer* lexer_ = nullptr;
+ Script* script_ = nullptr;
+ Module* current_module_ = nullptr;
+ Func* current_func_ = nullptr;
+ ExprVisitor visitor_;
+ std::vector<Label*> labels_;
+ Result result_ = Result::Ok;
};
-Context::Context() : visitor(this) {}
+NameResolver::NameResolver(WastLexer* lexer,
+ Script* script,
+ SourceErrorHandler* error_handler)
+ : error_handler_(error_handler),
+ lexer_(lexer),
+ script_(script),
+ visitor_(this) {}
} // namespace
-static void WABT_PRINTF_FORMAT(3, 4)
- print_error(Context* ctx, const Location* loc, const char* fmt, ...) {
- ctx->result = Result::Error;
+void WABT_PRINTF_FORMAT(3, 4) NameResolver::PrintError(const Location* loc,
+ const char* fmt,
+ ...) {
+ result_ = Result::Error;
va_list args;
va_start(args, fmt);
- wast_format_error(ctx->error_handler, loc, ctx->lexer, fmt, args);
+ wast_format_error(error_handler_, loc, lexer_, fmt, args);
va_end(args);
}
-static void push_label(Context* ctx, Label* label) {
- ctx->labels.push_back(label);
+void NameResolver::PushLabel(Label* label) {
+ labels_.push_back(label);
}
-static void pop_label(Context* ctx) {
- ctx->labels.pop_back();
+void NameResolver::PopLabel() {
+ labels_.pop_back();
}
struct FindDuplicateBindingContext {
- Context* ctx;
+ NameResolver* resolver;
const char* desc;
};
-static void on_duplicate_binding(const BindingHash::value_type& a,
- const BindingHash::value_type& b,
- void* user_data) {
+// static
+void NameResolver::OnDuplicateBinding(const BindingHash::value_type& a,
+ const BindingHash::value_type& b,
+ void* user_data) {
FindDuplicateBindingContext* fdbc =
static_cast<FindDuplicateBindingContext*>(user_data);
/* choose the location that is later in the file */
const Location& a_loc = a.second.loc;
const Location& b_loc = b.second.loc;
const Location& loc = a_loc.line > b_loc.line ? a_loc : b_loc;
- print_error(fdbc->ctx, &loc, "redefinition of %s \"%s\"", fdbc->desc,
- a.first.c_str());
+ fdbc->resolver->PrintError(&loc, "redefinition of %s \"%s\"", fdbc->desc,
+ a.first.c_str());
}
-static void check_duplicate_bindings(Context* ctx,
- const BindingHash* bindings,
- const char* desc) {
+void NameResolver::CheckDuplicateBindings(const BindingHash* bindings,
+ const char* desc) {
FindDuplicateBindingContext fdbc;
- fdbc.ctx = ctx;
+ fdbc.resolver = this;
fdbc.desc = desc;
- bindings->find_duplicates(on_duplicate_binding, &fdbc);
+ bindings->find_duplicates(OnDuplicateBinding, &fdbc);
}
-static void resolve_label_var(Context* ctx, Var* var) {
+void NameResolver::ResolveLabelVar(Var* var) {
if (var->type == VarType::Name) {
- for (int i = ctx->labels.size() - 1; i >= 0; --i) {
- Label* label = ctx->labels[i];
+ for (int i = labels_.size() - 1; i >= 0; --i) {
+ Label* label = labels_[i];
if (string_slices_are_equal(label, &var->name)) {
destroy_string_slice(&var->name);
var->type = VarType::Index;
- var->index = ctx->labels.size() - i - 1;
+ var->index = labels_.size() - i - 1;
return;
}
}
- print_error(ctx, &var->loc,
- "undefined label variable \"" PRIstringslice "\"",
- WABT_PRINTF_STRING_SLICE_ARG(var->name));
+ PrintError(&var->loc, "undefined label variable \"" PRIstringslice "\"",
+ WABT_PRINTF_STRING_SLICE_ARG(var->name));
}
}
-static void resolve_var(Context* ctx,
- const BindingHash* bindings,
- Var* var,
- const char* desc) {
+void NameResolver::ResolveVar(const BindingHash* bindings,
+ Var* var,
+ const char* desc) {
if (var->type == VarType::Name) {
int index = get_index_from_var(bindings, var);
if (index == -1) {
- print_error(ctx, &var->loc,
- "undefined %s variable \"" PRIstringslice "\"", desc,
- WABT_PRINTF_STRING_SLICE_ARG(var->name));
+ PrintError(&var->loc, "undefined %s variable \"" PRIstringslice "\"",
+ desc, WABT_PRINTF_STRING_SLICE_ARG(var->name));
return;
}
@@ -143,37 +178,35 @@ static void resolve_var(Context* ctx,
}
}
-static void resolve_func_var(Context* ctx, Var* var) {
- resolve_var(ctx, &ctx->current_module->func_bindings, var, "function");
+void NameResolver::ResolveFuncVar(Var* var) {
+ ResolveVar(&current_module_->func_bindings, var, "function");
}
-static void resolve_global_var(Context* ctx, Var* var) {
- resolve_var(ctx, &ctx->current_module->global_bindings, var, "global");
+void NameResolver::ResolveGlobalVar(Var* var) {
+ ResolveVar(&current_module_->global_bindings, var, "global");
}
-static void resolve_func_type_var(Context* ctx, Var* var) {
- resolve_var(ctx, &ctx->current_module->func_type_bindings, var,
- "function type");
+void NameResolver::ResolveFuncTypeVar(Var* var) {
+ ResolveVar(&current_module_->func_type_bindings, var, "function type");
}
-static void resolve_table_var(Context* ctx, Var* var) {
- resolve_var(ctx, &ctx->current_module->table_bindings, var, "table");
+void NameResolver::ResolveTableVar(Var* var) {
+ ResolveVar(&current_module_->table_bindings, var, "table");
}
-static void resolve_memory_var(Context* ctx, Var* var) {
- resolve_var(ctx, &ctx->current_module->memory_bindings, var, "memory");
+void NameResolver::ResolveMemoryVar(Var* var) {
+ ResolveVar(&current_module_->memory_bindings, var, "memory");
}
-static void resolve_local_var(Context* ctx, Var* var) {
+void NameResolver::ResolveLocalVar(Var* var) {
if (var->type == VarType::Name) {
- if (!ctx->current_func)
+ if (!current_func_)
return;
- int index = get_local_index_by_var(ctx->current_func, var);
+ int index = get_local_index_by_var(current_func_, var);
if (index == -1) {
- print_error(ctx, &var->loc,
- "undefined local variable \"" PRIstringslice "\"",
- WABT_PRINTF_STRING_SLICE_ARG(var->name));
+ PrintError(&var->loc, "undefined local variable \"" PRIstringslice "\"",
+ WABT_PRINTF_STRING_SLICE_ARG(var->name));
return;
}
@@ -183,168 +216,169 @@ static void resolve_local_var(Context* ctx, Var* var) {
}
}
-Result Context::BeginBlockExpr(Expr* expr) {
- push_label(this, &expr->block->label);
+Result NameResolver::BeginBlockExpr(Expr* expr) {
+ PushLabel(&expr->block->label);
return Result::Ok;
}
-Result Context::EndBlockExpr(Expr* expr) {
- pop_label(this);
+Result NameResolver::EndBlockExpr(Expr* expr) {
+ PopLabel();
return Result::Ok;
}
-Result Context::BeginLoopExpr(Expr* expr) {
- push_label(this, &expr->loop->label);
+Result NameResolver::BeginLoopExpr(Expr* expr) {
+ PushLabel(&expr->loop->label);
return Result::Ok;
}
-Result Context::EndLoopExpr(Expr* expr) {
- pop_label(this);
+Result NameResolver::EndLoopExpr(Expr* expr) {
+ PopLabel();
return Result::Ok;
}
-Result Context::OnBrExpr(Expr* expr) {
- resolve_label_var(this, &expr->br.var);
+Result NameResolver::OnBrExpr(Expr* expr) {
+ ResolveLabelVar(&expr->br.var);
return Result::Ok;
}
-Result Context::OnBrIfExpr(Expr* expr) {
- resolve_label_var(this, &expr->br_if.var);
+Result NameResolver::OnBrIfExpr(Expr* expr) {
+ ResolveLabelVar(&expr->br_if.var);
return Result::Ok;
}
-Result Context::OnBrTableExpr(Expr* expr) {
- for (Var& target: *expr->br_table.targets)
- resolve_label_var(this, &target);
- resolve_label_var(this, &expr->br_table.default_target);
+Result NameResolver::OnBrTableExpr(Expr* expr) {
+ for (Var& target : *expr->br_table.targets)
+ ResolveLabelVar(&target);
+ ResolveLabelVar(&expr->br_table.default_target);
return Result::Ok;
}
-Result Context::OnCallExpr(Expr* expr) {
- resolve_func_var(this, &expr->call.var);
+Result NameResolver::OnCallExpr(Expr* expr) {
+ ResolveFuncVar(&expr->call.var);
return Result::Ok;
}
-Result Context::OnCallIndirectExpr(Expr* expr) {
- resolve_func_type_var(this, &expr->call_indirect.var);
+Result NameResolver::OnCallIndirectExpr(Expr* expr) {
+ ResolveFuncTypeVar(&expr->call_indirect.var);
return Result::Ok;
}
-Result Context::OnGetGlobalExpr(Expr* expr) {
- resolve_global_var(this, &expr->get_global.var);
+Result NameResolver::OnGetGlobalExpr(Expr* expr) {
+ ResolveGlobalVar(&expr->get_global.var);
return Result::Ok;
}
-Result Context::OnGetLocalExpr(Expr* expr) {
- resolve_local_var(this, &expr->get_local.var);
+Result NameResolver::OnGetLocalExpr(Expr* expr) {
+ ResolveLocalVar(&expr->get_local.var);
return Result::Ok;
}
-Result Context::BeginIfExpr(Expr* expr) {
- push_label(this, &expr->if_.true_->label);
+Result NameResolver::BeginIfExpr(Expr* expr) {
+ PushLabel(&expr->if_.true_->label);
return Result::Ok;
}
-Result Context::EndIfExpr(Expr* expr) {
- pop_label(this);
+Result NameResolver::EndIfExpr(Expr* expr) {
+ PopLabel();
return Result::Ok;
}
-Result Context::OnSetGlobalExpr(Expr* expr) {
- resolve_global_var(this, &expr->set_global.var);
+Result NameResolver::OnSetGlobalExpr(Expr* expr) {
+ ResolveGlobalVar(&expr->set_global.var);
return Result::Ok;
}
-Result Context::OnSetLocalExpr(Expr* expr) {
- resolve_local_var(this, &expr->set_local.var);
+Result NameResolver::OnSetLocalExpr(Expr* expr) {
+ ResolveLocalVar(&expr->set_local.var);
return Result::Ok;
}
-Result Context::OnTeeLocalExpr(Expr* expr) {
- resolve_local_var(this, &expr->tee_local.var);
+Result NameResolver::OnTeeLocalExpr(Expr* expr) {
+ ResolveLocalVar(&expr->tee_local.var);
return Result::Ok;
}
-static void visit_func(Context* ctx, Func* func) {
- ctx->current_func = func;
+void NameResolver::VisitFunc(Func* func) {
+ current_func_ = func;
if (decl_has_func_type(&func->decl))
- resolve_func_type_var(ctx, &func->decl.type_var);
+ ResolveFuncTypeVar(&func->decl.type_var);
- check_duplicate_bindings(ctx, &func->param_bindings, "parameter");
- check_duplicate_bindings(ctx, &func->local_bindings, "local");
+ CheckDuplicateBindings(&func->param_bindings, "parameter");
+ CheckDuplicateBindings(&func->local_bindings, "local");
- ctx->visitor.VisitFunc(func);
- ctx->current_func = nullptr;
+ visitor_.VisitFunc(func);
+ current_func_ = nullptr;
}
-static void visit_export(Context* ctx, Export* export_) {
+void NameResolver::VisitExport(Export* export_) {
switch (export_->kind) {
case ExternalKind::Func:
- resolve_func_var(ctx, &export_->var);
+ ResolveFuncVar(&export_->var);
break;
case ExternalKind::Table:
- resolve_table_var(ctx, &export_->var);
+ ResolveTableVar(&export_->var);
break;
case ExternalKind::Memory:
- resolve_memory_var(ctx, &export_->var);
+ ResolveMemoryVar(&export_->var);
break;
case ExternalKind::Global:
- resolve_global_var(ctx, &export_->var);
+ ResolveGlobalVar(&export_->var);
break;
}
}
-static void visit_global(Context* ctx, Global* global) {
- ctx->visitor.VisitExprList(global->init_expr);
+void NameResolver::VisitGlobal(Global* global) {
+ visitor_.VisitExprList(global->init_expr);
}
-static void visit_elem_segment(Context* ctx, ElemSegment* segment) {
- resolve_table_var(ctx, &segment->table_var);
- ctx->visitor.VisitExprList(segment->offset);
- for (Var& var: segment->vars)
- resolve_func_var(ctx, &var);
+void NameResolver::VisitElemSegment(ElemSegment* segment) {
+ ResolveTableVar(&segment->table_var);
+ visitor_.VisitExprList(segment->offset);
+ for (Var& var : segment->vars)
+ ResolveFuncVar(&var);
}
-static void visit_data_segment(Context* ctx, DataSegment* segment) {
- resolve_memory_var(ctx, &segment->memory_var);
- ctx->visitor.VisitExprList(segment->offset);
+void NameResolver::VisitDataSegment(DataSegment* segment) {
+ ResolveMemoryVar(&segment->memory_var);
+ visitor_.VisitExprList(segment->offset);
}
-static void visit_module(Context* ctx, Module* module) {
- ctx->current_module = module;
- check_duplicate_bindings(ctx, &module->func_bindings, "function");
- check_duplicate_bindings(ctx, &module->global_bindings, "global");
- check_duplicate_bindings(ctx, &module->func_type_bindings, "function type");
- check_duplicate_bindings(ctx, &module->table_bindings, "table");
- check_duplicate_bindings(ctx, &module->memory_bindings, "memory");
+Result NameResolver::VisitModule(Module* module) {
+ current_module_ = module;
+ CheckDuplicateBindings(&module->func_bindings, "function");
+ CheckDuplicateBindings(&module->global_bindings, "global");
+ CheckDuplicateBindings(&module->func_type_bindings, "function type");
+ CheckDuplicateBindings(&module->table_bindings, "table");
+ CheckDuplicateBindings(&module->memory_bindings, "memory");
for (Func* func : module->funcs)
- visit_func(ctx, func);
+ VisitFunc(func);
for (Export* export_ : module->exports)
- visit_export(ctx, export_);
+ VisitExport(export_);
for (Global* global : module->globals)
- visit_global(ctx, global);
+ VisitGlobal(global);
for (ElemSegment* elem_segment : module->elem_segments)
- visit_elem_segment(ctx, elem_segment);
+ VisitElemSegment(elem_segment);
for (DataSegment* data_segment : module->data_segments)
- visit_data_segment(ctx, data_segment);
+ VisitDataSegment(data_segment);
if (module->start)
- resolve_func_var(ctx, module->start);
- ctx->current_module = nullptr;
+ ResolveFuncVar(module->start);
+ current_module_ = nullptr;
+ return result_;
}
-static void visit_raw_module(Context* ctx, RawModule* raw_module) {
+void NameResolver::VisitRawModule(RawModule* raw_module) {
if (raw_module->type == RawModuleType::Text)
- visit_module(ctx, raw_module->text);
+ VisitModule(raw_module->text);
}
-static void visit_command(Context* ctx, Command* command) {
+void NameResolver::VisitCommand(Command* command) {
switch (command->type) {
case CommandType::Module:
- visit_module(ctx, command->module);
+ VisitModule(command->module);
break;
case CommandType::Action:
@@ -369,13 +403,9 @@ static void visit_command(Context* ctx, Command* command) {
* should try to resolve names when possible. */
SourceErrorHandlerNop new_error_handler;
- Context new_ctx;
- new_ctx.error_handler = &new_error_handler;
- new_ctx.lexer = ctx->lexer;
- new_ctx.result = Result::Ok;
-
- visit_raw_module(&new_ctx, command->assert_invalid.module);
- if (WABT_FAILED(new_ctx.result)) {
+ NameResolver new_resolver(lexer_, script_, &new_error_handler);
+ new_resolver.VisitRawModule(command->assert_invalid.module);
+ if (WABT_FAILED(new_resolver.result_)) {
command->type = CommandType::AssertInvalidNonBinary;
}
break;
@@ -388,46 +418,33 @@ static void visit_command(Context* ctx, Command* command) {
break;
case CommandType::AssertUnlinkable:
- visit_raw_module(ctx, command->assert_unlinkable.module);
+ VisitRawModule(command->assert_unlinkable.module);
break;
case CommandType::AssertUninstantiable:
- visit_raw_module(ctx, command->assert_uninstantiable.module);
+ VisitRawModule(command->assert_uninstantiable.module);
break;
}
}
-static void visit_script(Context* ctx, Script* script) {
- for (const std::unique_ptr<Command>& command: script->commands)
- visit_command(ctx, command.get());
-}
-
-static void init_context(Context* ctx,
- WastLexer* lexer,
- Script* script,
- SourceErrorHandler* error_handler) {
- ctx->lexer = lexer;
- ctx->error_handler = error_handler;
- ctx->result = Result::Ok;
- ctx->script = script;
+Result NameResolver::VisitScript(Script* script) {
+ for (const std::unique_ptr<Command>& command : script->commands)
+ VisitCommand(command.get());
+ return result_;
}
Result resolve_names_module(WastLexer* lexer,
Module* module,
SourceErrorHandler* error_handler) {
- Context ctx;
- init_context(&ctx, lexer, nullptr, error_handler);
- visit_module(&ctx, module);
- return ctx.result;
+ NameResolver resolver(lexer, nullptr, error_handler);
+ return resolver.VisitModule(module);
}
Result resolve_names_script(WastLexer* lexer,
Script* script,
SourceErrorHandler* error_handler) {
- Context ctx;
- init_context(&ctx, lexer, script, error_handler);
- visit_script(&ctx, script);
- return ctx.result;
+ NameResolver resolver(lexer, script, error_handler);
+ return resolver.VisitScript(script);
}
} // namespace wabt
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-26 18:33:35 +0000