# HG changeset patch # User John W. Eaton # Date 1625817816 14400 # Node ID c29cfcf7a941c99bc21cefb00f661236fb8622d3 # Parent 255fa40977c0fd213ac88ab958ea8cccb49c72f8 provide default definitions for more tree_walker methods For parse tree elements that are primarily containers of other elements, provide default methods that iterate over their contents. * pt-walk.cc (tree_walker::visit_anon_fcn_handle, tree_walker::visit_arguments_block, tree_walker::visit_args_block_attribute_list, tree_walker::visit_args_block_validation_list, tree_walker::visit_arg_validation, tree_walker::visit_arg_size_spec, tree_walker::visit_arg_validation_fcns, tree_walker::visit_classdef_attribute, tree_walker::visit_classdef_attribute_list, tree_walker::visit_classdef_superclass_list, tree_walker::visit_classdef_property_list, tree_walker::visit_classdef_properties_block, tree_walker::visit_classdef_methods_list, tree_walker::visit_classdef_methods_block, tree_walker::visit_classdef_events_list, tree_walker::visit_classdef_events_block, tree_walker::visit_classdef_enum_list, tree_walker::visit_classdef_enum_block, tree_walker::visit_classdef_body, tree_walker::visit_classdef): Call accept for all sub-elements. * pt-args-block.h (tree_args_block_attribute_list::attribute, tree_arg_size_spec::size_args, tree_arg_validation_fcns::fcn_args, tree_arguments_block::attribute_list, tree_arguments_block::validation_list): New functions. diff -r 255fa40977c0 -r c29cfcf7a941 libinterp/parse-tree/pt-args-block.h --- a/libinterp/parse-tree/pt-args-block.h Fri Jul 09 04:05:13 2021 -0400 +++ b/libinterp/parse-tree/pt-args-block.h Fri Jul 09 04:03:36 2021 -0400 @@ -60,6 +60,8 @@ delete m_size_args; } + tree_argument_list * size_args (void) { return m_size_args; } + void accept (tree_walker& tw) { tw.visit_arg_size_spec (*this); @@ -89,6 +91,8 @@ delete m_fcn_args; } + tree_argument_list * fcn_args (void) { return m_fcn_args; } + void accept (tree_walker& tw) { tw.visit_arg_validation_fcns (*this); @@ -160,7 +164,8 @@ tree_expression *m_default_value; }; - class tree_args_block_validation_list : public base_list + class tree_args_block_validation_list + : public base_list { public: @@ -193,8 +198,8 @@ { public: - tree_args_block_attribute_list (tree_identifier *id = nullptr) - : m_id (id) + tree_args_block_attribute_list (tree_identifier *attr = nullptr) + : m_attr (attr) { } // No copying! @@ -205,9 +210,11 @@ ~tree_args_block_attribute_list (void) { - delete m_id; + delete m_attr; } + tree_identifier * attribute (void) { return m_attr; } + void accept (tree_walker& tw) { tw.visit_args_block_attribute_list (*this); @@ -215,7 +222,7 @@ private: - tree_identifier *m_id; + tree_identifier *m_attr; }; // Arguments block. @@ -247,6 +254,16 @@ delete m_trail_comm; } + tree_args_block_attribute_list * attribute_list (void) + { + return m_attr_list; + } + + tree_args_block_validation_list * validation_list (void) + { + return m_validation_list; + } + comment_list * leading_comment (void) { return m_lead_comm; } comment_list * trailing_comment (void) { return m_trail_comm; } diff -r 255fa40977c0 -r c29cfcf7a941 libinterp/parse-tree/pt-walk.cc --- a/libinterp/parse-tree/pt-walk.cc Fri Jul 09 04:05:13 2021 -0400 +++ b/libinterp/parse-tree/pt-walk.cc Fri Jul 09 04:03:36 2021 -0400 @@ -31,9 +31,17 @@ namespace octave { - void tree_walker::visit_anon_fcn_handle (tree_anon_fcn_handle&) + void tree_walker::visit_anon_fcn_handle (tree_anon_fcn_handle& afh) { - // FIXME? + tree_parameter_list *parameter_list = afh.parameter_list (); + + if (parameter_list) + parameter_list->accept (*this); + + tree_expression *expression = afh.expression (); + + if (expression) + expression->accept (*this); } void tree_walker::visit_argument_list (tree_argument_list& lst) @@ -49,34 +57,78 @@ } } - void tree_walker::visit_arguments_block (tree_arguments_block&) + void tree_walker::visit_arguments_block (tree_arguments_block& blk) { - // FIXME? + tree_args_block_attribute_list *attribute_list = blk.attribute_list (); + + if (attribute_list) + attribute_list->accept (*this); + + tree_args_block_validation_list *validation_list = blk.validation_list (); + + if (validation_list) + validation_list->accept (*this); } - void tree_walker::visit_args_block_attribute_list (tree_args_block_attribute_list&) + void tree_walker::visit_args_block_attribute_list (tree_args_block_attribute_list& lst) { - // FIXME? + tree_identifier * attribute = lst.attribute (); + + if (attribute) + attribute->accept (*this); + } + + void tree_walker::visit_args_block_validation_list (tree_args_block_validation_list& lst) + { + for (auto *elt : lst) + { + if (elt) + elt->accept (*this); + } } - void tree_walker::visit_args_block_validation_list (tree_args_block_validation_list&) + void tree_walker::visit_arg_validation (tree_arg_validation& val) { - // FIXME? + tree_expression *arg_name = val.identifier_expression (); + + if (arg_name) + arg_name->accept (*this); + + tree_arg_size_spec *size_spec = val.size_spec (); + + if (size_spec) + size_spec->accept (*this); + + tree_identifier *class_name = val.class_name (); + + if (class_name) + class_name->accept (*this); + + tree_arg_validation_fcns *validation_fcns = val.validation_fcns (); + + if (validation_fcns) + validation_fcns->accept (*this); + + tree_expression *default_value = val.initializer_expression (); + + if (default_value) + default_value->accept (*this); } - void tree_walker::visit_arg_validation (tree_arg_validation&) + void tree_walker::visit_arg_size_spec (tree_arg_size_spec& spec) { - // FIXME? + tree_argument_list *size_args = spec.size_args (); + + if (size_args) + size_args->accept (*this); } - void tree_walker::visit_arg_size_spec (tree_arg_size_spec&) + void tree_walker::visit_arg_validation_fcns (tree_arg_validation_fcns& spec) { - // FIXME? - } + tree_argument_list *fcn_args = spec.fcn_args (); - void tree_walker::visit_arg_validation_fcns (tree_arg_validation_fcns&) - { - // FIXME? + if (fcn_args) + fcn_args->accept (*this); } void tree_walker::visit_binary_expression (tree_binary_expression& expr) @@ -553,96 +605,184 @@ void tree_walker::visit_superclass_ref (tree_superclass_ref&) { - // FIXME? + // Nothing to do. } void tree_walker::visit_metaclass_query (tree_metaclass_query&) { - // FIXME? + // Nothing to do. } - void tree_walker::visit_classdef_attribute (tree_classdef_attribute&) + void tree_walker::visit_classdef_attribute (tree_classdef_attribute& attr) { - // FIXME? + tree_identifier *id = attr.ident (); + + if (id) + id->accept (*this); + + tree_expression *expr = attr.expression (); + + if (expr) + expr->accept (*this); } - void tree_walker::visit_classdef_attribute_list (tree_classdef_attribute_list&) + void tree_walker::visit_classdef_attribute_list (tree_classdef_attribute_list& lst) { - // FIXME? + for (auto *elt : lst) + { + if (elt) + elt->accept (*this); + } } void tree_walker::visit_classdef_superclass (tree_classdef_superclass&) { - // FIXME? + // Nothing to do. } - void tree_walker::visit_classdef_superclass_list (tree_classdef_superclass_list&) + void tree_walker::visit_classdef_superclass_list (tree_classdef_superclass_list& lst) { - // FIXME? + for (auto *elt : lst) + { + if (elt) + elt->accept (*this); + } } void tree_walker::visit_classdef_property (tree_classdef_property&) { - // FIXME? + // FIXME: Should we operate on the tree_arg_validation object or the + // identifier and expression parts separately? } - void tree_walker::visit_classdef_property_list (tree_classdef_property_list&) + void tree_walker::visit_classdef_property_list (tree_classdef_property_list& lst) { - // FIXME? + for (auto *elt : lst) + { + if (elt) + elt->accept (*this); + } } - void tree_walker::visit_classdef_properties_block (tree_classdef_properties_block&) + void tree_walker::visit_classdef_properties_block (tree_classdef_properties_block& blk) { - // FIXME? + tree_classdef_property_list *property_list = blk.element_list (); + + if (property_list) + property_list->accept (*this); } - void tree_walker::visit_classdef_methods_list (tree_classdef_methods_list&) + void tree_walker::visit_classdef_methods_list (tree_classdef_methods_list& lst) { - // FIXME? + for (auto ov_meth : lst) + { + octave_user_function *meth = ov_meth.user_function_value (); + + if (meth) + meth->accept (*this); + } } - void tree_walker::visit_classdef_methods_block (tree_classdef_methods_block&) + void tree_walker::visit_classdef_methods_block (tree_classdef_methods_block& blk) { - // FIXME? + tree_classdef_methods_list *methods_list = blk.element_list (); + + if (methods_list) + methods_list->accept (*this); } void tree_walker::visit_classdef_event (tree_classdef_event&) { - // FIXME? + // Nothing to do. } - void tree_walker::visit_classdef_events_list (tree_classdef_events_list&) + void tree_walker::visit_classdef_events_list (tree_classdef_events_list& lst) { - // FIXME? + for (auto *elt : lst) + { + if (elt) + elt->accept (*this); + } } - void tree_walker::visit_classdef_events_block (tree_classdef_events_block&) + void tree_walker::visit_classdef_events_block (tree_classdef_events_block& blk) { - // FIXME? + tree_classdef_events_list *events_list = blk.element_list (); + + if (events_list) + events_list->accept (*this); } void tree_walker::visit_classdef_enum (tree_classdef_enum&) { - // FIXME? + // Nothing to do. } - void tree_walker::visit_classdef_enum_list (tree_classdef_enum_list&) + void tree_walker::visit_classdef_enum_list (tree_classdef_enum_list& lst) { - // FIXME? + for (auto *elt : lst) + { + if (elt) + elt->accept (*this); + } + } + + void tree_walker::visit_classdef_enum_block (tree_classdef_enum_block& blk) + { + tree_classdef_enum_list *enum_list = blk.element_list (); + + if (enum_list) + enum_list->accept (*this); } - void tree_walker::visit_classdef_enum_block (tree_classdef_enum_block&) + void tree_walker::visit_classdef_body (tree_classdef_body& body) { - // FIXME? + for (auto *elt : body.properties_list ()) + { + if (elt) + elt->accept (*this); + } + + for (auto *elt : body.methods_list ()) + { + if (elt) + elt->accept (*this); + } + + + for (auto *elt : body.events_list ()) + { + if (elt) + elt->accept (*this); + } + + for (auto *elt : body.enum_list ()) + { + if (elt) + elt->accept (*this); + } } - void tree_walker::visit_classdef_body (tree_classdef_body&) + void tree_walker::visit_classdef (tree_classdef& cdef) { - // FIXME? - } + tree_classdef_attribute_list *attribute_list = cdef.attribute_list (); + + if (attribute_list) + attribute_list->accept (*this); + + tree_identifier *ident = cdef.ident (); + + if (ident) + ident->accept (*this); - void tree_walker::visit_classdef (tree_classdef&) - { - // FIXME? + tree_classdef_superclass_list *superclass_list = cdef.superclass_list (); + + if (superclass_list) + superclass_list->accept (*this); + + tree_classdef_body *body = cdef.body (); + + if (body) + body->accept (*this); } }