octave: libinterp/parse-tree/oct-parse.in.yy comparison

comparison libinterp/parse-tree/oct-parse.in.yy @ 23796:4f12819a634f

Use C++11 nullptr rather than 0 in code (bug #51565). * mk-opts.pl, BlockArray.cpp, KeyboardTranslator.cpp, Screen.cpp, TerminalCharacterDecoder.cpp, TerminalView.cpp, Vt102Emulation.cpp, dialog.cc, find-files-dialog.cc, file-editor-tab.cc, main-window.cc, ls-hdf5.cc, oct-procbuf.h, oct-stream.cc, oct-tex-lexer.in.ll, zfstream.cc, ov-builtin.h, ov-fcn-handle.cc, ov-typeinfo.h, ov-usr-fcn.h, options-usage.h, lex.ll, oct-parse.in.yy, pt-loop.h, Array.cc, CSparse.cc, Sparse.h, dSparse.cc, fCMatrix.cc, idx-vector.cc, idx-vector.h, sparse-chol.cc, cmd-edit.cc, oct-sort.cc, main.in.cc: Use C++11 nullptr rather than 0 in code (bug #51565).

author	Rik <rik@octave.org>
date	Wed, 26 Jul 2017 16:26:31 -0700
parents	ea879bc55272
children	771310737137

comparison

equal deleted inserted replaced

-:980f39c3ab90
+:4f12819a634f
 // Statements and statement lists
 // ==============================
 input           : simple_list '\n'
 {
-$$ = 0;
+$$ = nullptr;
 parser.m_stmt_list = $1;
 YYACCEPT;
 }
 | simple_list END_OF_INPUT
 {
-$$ = 0;
+$$ = nullptr;
 lexer.end_of_input = true;
 parser.m_stmt_list = $1;
 YYACCEPT;
 }
 | parse_error
 {
-$$ = 0;
+$$ = nullptr;
 YYABORT;
 }
 ;
 simple_list     : opt_sep_no_nl
 {
 YYUSE ($1);
-$$ = 0;
+$$ = nullptr;
 }
 | simple_list1 opt_sep_no_nl
 { $$ = parser.set_stmt_print_flag ($1, $2, false); }
 ;
 matrix          : '[' matrix_rows ']'
 { $$ = parser.finish_matrix ($2); }
 ;
 matrix_rows     : cell_or_matrix_row
-{ $$ = $1 ? new octave::tree_matrix ($1) : 0; }
+{ $$ = $1 ? new octave::tree_matrix ($1) : nullptr; }
 | matrix_rows ';' cell_or_matrix_row
 {
 if ($1)
 {
 if ($3)
 $1->append ($3);
 $$ = $1;
 }
 else
-$$ = $3 ? new octave::tree_matrix ($3) : 0;
+$$ = $3 ? new octave::tree_matrix ($3) : nullptr;
 }
 ;
 cell            : '{' cell_rows '}'
 { $$ = parser.finish_cell ($2); }
 ;
 cell_rows       : cell_or_matrix_row
-{ $$ = $1 ? new octave::tree_cell ($1) : 0; }
+{ $$ = $1 ? new octave::tree_cell ($1) : nullptr; }
 | cell_rows ';' cell_or_matrix_row
 {
 if ($1)
 {
 if ($3)
 $1->append ($3);
 $$ = $1;
 }
 else
-$$ = $3 ? new octave::tree_cell ($3) : 0;
+$$ = $3 ? new octave::tree_cell ($3) : nullptr;
 }
 ;
 // tree_argument_list objects can't be empty or have leading or trailing
 // commas, but those are all allowed in matrix and cell array rows.
 cell_or_matrix_row
 : // empty
-{ $$ = 0; }
+{ $$ = nullptr; }
 | ','
-{ $$ = 0; }
+{ $$ = nullptr; }
 | arg_list
 { $$ = $1; }
 | arg_list ','
 { $$ = $1; }
 | ',' arg_list
 { $$ = parser.make_postfix_op (PLUS_PLUS, $1, $2); }
 | oper_expr MINUS_MINUS
 { $$ = parser.make_postfix_op (MINUS_MINUS, $1, $2); }
 | oper_expr '(' ')'
 {
-$$ = parser.make_index_expression ($1, 0, '(');
+$$ = parser.make_index_expression ($1, nullptr, '(');
 if (! $$)
 {
 // make_index_expression deleted $1.
 YYABORT;
 }
 YYABORT;
 }
 }
 | oper_expr '{' '}'
 {
-$$ = parser.make_index_expression ($1, 0, '{');
+$$ = parser.make_index_expression ($1, nullptr, '{');
 if (! $$)
 {
 // make_index_expression deleted $1.
 YYABORT;
 }
 { $$ = parser.make_postfix_op (PLUS_PLUS, $1, $2); }
 | power_expr MINUS_MINUS
 { $$ = parser.make_postfix_op (MINUS_MINUS, $1, $2); }
 | power_expr '(' ')'
 {
-$$ = parser.make_index_expression ($1, 0, '(');
+$$ = parser.make_index_expression ($1, nullptr, '(');
 if (! $$)
 {
 // make_index_expression deleted $1.
 YYABORT;
 }
 YYABORT;
 }
 }
 | power_expr '{' '}'
 {
-$$ = parser.make_index_expression ($1, 0, '{');
+$$ = parser.make_index_expression ($1, nullptr, '{');
 if (! $$)
 {
 // make_index_expression deleted $1.
 YYABORT;
 }
 | FOR stash_comment assign_lhs '=' expression stmt_begin opt_sep opt_list END
 {
 YYUSE ($4);
 YYUSE ($7);
-if (! ($$ = parser.make_for_command (FOR, $1, $3, $5, 0,
+if (! ($$ = parser.make_for_command (FOR, $1, $3, $5,
-$8, $9, $2)))
+nullptr, $8, $9, $2)))
 {
 // make_for_command deleted $3, $5, and $8.
 YYABORT;
 }
 }
 | FOR stash_comment '(' assign_lhs '=' expression ')' opt_sep opt_list END
 {
 YYUSE ($5);
 YYUSE ($8);
-if (! ($$ = parser.make_for_command (FOR, $1, $4, $6, 0,
+if (! ($$ = parser.make_for_command (FOR, $1, $4, $6,
-$9, $10, $2)))
+nullptr, $9, $10, $2)))
 {
 // make_for_command deleted $4, $6, and $9.
 YYABORT;
 }
 }
 {
 YYUSE ($4);
 YYUSE ($7);
 if (! ($$ = parser.make_for_command (PARFOR, $1, $3, $5,
-0, $8, $9, $2)))
+nullptr, $8, $9, $2)))
 {
 // make_for_command deleted $3, $5, and $8.
 YYABORT;
 }
 }
 }
 | TRY stash_comment opt_sep opt_list END
 {
 YYUSE ($3);
-if (! ($$ = parser.make_try_command ($1, $4, 0, 0, $5, $2, 0)))
+if (! ($$ = parser.make_try_command ($1, $4, 0, nullptr,
+$5, $2, nullptr)))
 {
 // make_try_command deleted $4.
 YYABORT;
 }
 }
 lexer.looking_for_object_index = false;
 }
 ;
 opt_param_list  : // empty
-{ $$ = 0; }
+{ $$ = nullptr; }
 | param_list
 { $$ = $1; }
 ;
 param_list      : param_list_beg param_list1 param_list_end
 $$ = $2;
 }
 | param_list_beg error
 {
-$$ = 0;
+$$ = nullptr;
 parser.bison_error ("invalid parameter list");
 YYABORT;
 }
 ;
 param_list1     : // empty
-{ $$ = 0; }
+{ $$ = nullptr; }
 | param_list2
 {
 $1->mark_as_formal_parameters ();
 if (parser.validate_param_list ($1, octave::tree_parameter_list::in))
 lexer.current_input_column);
 parser.make_script ($3, end_of_script);
 }
-$$ = 0;
+$$ = nullptr;
 }
 | INPUT_FILE opt_nl classdef parsing_local_fcns opt_sep opt_fcn_list END_OF_INPUT
 {
 YYUSE ($2);
 YYUSE ($5);
 YYUSE ($6);
 if (lexer.reading_classdef_file)
 parser.m_classdef_object = $3;
-$$ = 0;
+$$ = nullptr;
 }
 ;
 // ===================
 // Function definition
 function        : function_beg stash_comment fcn_name
 opt_param_list opt_sep opt_list function_end
 {
 YYUSE ($5);
-$$ = parser.make_function ($1, 0, $3, $4, $6, $7, $2);
+$$ = parser.make_function ($1, nullptr, $3, $4, $6, $7, $2);
 }
 | function_beg stash_comment return_list '=' fcn_name
 opt_param_list opt_sep opt_list function_end
 {
 YYUSE ($4);
 parser.bison_error ("classdef must appear inside a file containing only a class definition");
 YYABORT;
 }
 // Create invalid parent scope.
-lexer.symtab_context.push (0);
+lexer.symtab_context.push (nullptr);
 lexer.parsing_classdef = true;
 $$ = $1;
 }
 ;
 {
 YYUSE ($6);
 lexer.parsing_classdef = false;
-if (! ($$ = parser.make_classdef ($1, $3, $4, $5, 0, $7, $2)))
+if (! ($$ = parser.make_classdef ($1, $3, $4, $5, nullptr,
+$7, $2)))
 {
 // make_classdef deleted $3, $4, and $5.
 YYABORT;
 }
 }
 ;
 opt_attr_list   : // empty
-{ $$ = 0; }
+{ $$ = nullptr; }
 | '(' attr_list ')'
 { $$ = $2; }
 ;
 attr_list       : attr
 }
 ;
 opt_superclass_list
 : // empty
-{ $$ = 0; }
+{ $$ = nullptr; }
 | superclass_list
 { $$ = $1; }
 ;
 superclass_list : EXPR_LT
 | PROPERTIES stash_comment opt_attr_list opt_sep END
 {
 YYUSE ($4);
 if (! ($$ = parser.make_classdef_properties_block
-($1, $3, 0, $5, $2)))
+($1, $3, nullptr, $5, $2)))
 {
 // make_classdef_properties_block delete $3.
 YYABORT;
 }
 }
 | METHODS stash_comment opt_attr_list opt_sep END
 {
 YYUSE ($4);
 if (! ($$ = parser.make_classdef_methods_block
-($1, $3, 0, $5, $2)))
+($1, $3, nullptr, $5, $2)))
 {
 // make_classdef_methods_block deleted $3.
 YYABORT;
 }
 }
 ;
 ;
 method_decl1    : identifier
 {
-if (! ($$ = parser.start_classdef_external_method ($1, 0)))
+if (! ($$ = parser.start_classdef_external_method ($1, nullptr)))
 YYABORT;
 }
 | identifier param_list
 {
 if (! ($$ = parser.start_classdef_external_method ($1, $2)))
 YYABORT;
 }
 ;
 method_decl     : stash_comment method_decl1
-{ $$ = parser.finish_classdef_external_method ($2, 0, $1); }
+{ $$ = parser.finish_classdef_external_method ($2, nullptr, $1); }
 | stash_comment return_list '='
 {
 YYUSE ($3);
 lexer.defining_func++;
 | ENUMERATION stash_comment opt_attr_list opt_sep END
 {
 YYUSE ($4);
 if (! ($$ = parser.make_classdef_enum_block
-($1, $3, 0, $5, $2)))
+($1, $3, nullptr, $5, $2)))
 {
 // make_classdef_enum_block deleted $3.
 YYABORT;
 }
 }
 }
 symbol_table::scope *
 base_parser::parent_scope_info::parent_scope (void) const
 {
-return size () > 1 ? m_info[size()-2].first : 0;
+return size () > 1 ? m_info[size()-2].first : nullptr;
 }
 std::string
 base_parser::parent_scope_info::parent_name (void) const
 {
 base_parser::base_parser (base_lexer& lxr)
 : m_endfunction_found (false), m_autoloading (false),
 m_fcn_file_from_relative_lookup (false),
 m_parsing_subfunctions (false), m_parsing_local_functions (false),
-m_max_fcn_depth (0), m_curr_fcn_depth (0), m_primary_fcn_scope (0),
+m_max_fcn_depth (0), m_curr_fcn_depth (0), m_primary_fcn_scope (nullptr),
 m_curr_class_name (), m_curr_package_name (), m_function_scopes (),
-m_primary_fcn_ptr (0), m_subfunction_names (), m_classdef_object (0),
+m_primary_fcn_ptr (nullptr), m_subfunction_names (),
-m_stmt_list (0), m_lexer (lxr), m_parser_state (yypstate_new ())
+m_classdef_object (nullptr), m_stmt_list (nullptr), m_lexer (lxr),
+m_parser_state (yypstate_new ())
 { }
 base_parser::~base_parser (void)
 {
 delete m_stmt_list;
 m_fcn_file_from_relative_lookup = false;
 m_parsing_subfunctions = false;
 m_parsing_local_functions = false;
 m_max_fcn_depth = 0;
 m_curr_fcn_depth = 0;
-m_primary_fcn_scope = 0;
+m_primary_fcn_scope = nullptr;
 m_curr_class_name = "";
 m_curr_package_name = "";
 m_function_scopes.clear ();
-m_primary_fcn_ptr  = 0;
+m_primary_fcn_ptr  = nullptr;
 m_subfunction_names.clear ();
+// FIXME: What about m_classdef_object?  Shouldn't this be required?
+// m_classdef_object = nullptr;
 delete m_stmt_list;
-m_stmt_list = 0;
+m_stmt_list = nullptr;
 m_lexer.reset ();
 yypstate_delete (static_cast<yypstate *> (m_parser_state));
 m_parser_state = yypstate_new ();
 base_parser::make_constant (int op, token *tok_val)
 {
 int l = tok_val->line ();
 int c = tok_val->column ();
-tree_constant *retval = 0;
+tree_constant *retval = nullptr;
 switch (op)
 {
 case NUM:
 {
 tree_statement_list *cleanup_stmts,
 token *end_tok,
 comment_list *lc,
 comment_list *mc)
 {
-tree_command *retval = 0;
+tree_command *retval = nullptr;
 if (end_token_ok (end_tok, token::unwind_protect_end))
 {
 comment_list *tc = m_lexer.comment_buf.get_comment ();
 tree_statement_list *cleanup_stmts,
 token *end_tok,
 comment_list *lc,
 comment_list *mc)
 {
-tree_command *retval = 0;
+tree_command *retval = nullptr;
 if (end_token_ok (end_tok, token::try_catch_end))
 {
 comment_list *tc = m_lexer.comment_buf.get_comment ();
 int l = try_tok->line ();
 int c = try_tok->column ();
-tree_identifier *id = 0;
+tree_identifier *id = nullptr;
 if (! catch_sep && cleanup_stmts && ! cleanup_stmts->empty ())
 {
 tree_statement *stmt = cleanup_stmts->front ();
 {
 id = dynamic_cast<tree_identifier *> (expr);
 cleanup_stmts->pop_front ();
-stmt->set_expression (0);
+stmt->set_expression (nullptr);
 delete stmt;
 }
 }
 }
 tree_expression *maxproc,
 tree_statement_list *body,
 token *end_tok,
 comment_list *lc)
 {
-tree_command *retval = 0;
+tree_command *retval = nullptr;
 bool parfor = tok_id == PARFOR;
 if (end_token_ok (end_tok, parfor ? token::parfor_end : token::for_end))
 {
 int c = break_tok->column ();
 if (! m_lexer.looping)
 {
 bison_error ("break must appear in a loop in the same file as loop command");
-return 0;
+return nullptr;
 }
 else
 return new tree_break_command (l, c);
 }
 base_parser::finish_if_command (token *if_tok,
 tree_if_command_list *list,
 token *end_tok,
 comment_list *lc)
 {
-tree_if_command *retval = 0;
+tree_if_command *retval = nullptr;
 if (end_token_ok (end_tok, token::if_end))
 {
 comment_list *tc = m_lexer.comment_buf.get_comment ();
 tree_expression *expr,
 tree_switch_case_list *list,
 token *end_tok,
 comment_list *lc)
 {
-tree_switch_command *retval = 0;
+tree_switch_command *retval = nullptr;
 if (end_token_ok (end_tok, token::switch_end))
 {
 comment_list *tc = m_lexer.comment_buf.get_comment ();
 delete lhs;
 delete rhs;
 bison_error ("computed multiple assignment not allowed", l, c);
-return 0;
+return nullptr;
 }
 if (lhs->is_simple_assign_lhs ())
 {
 // We are looking at a simple assignment statement like x = rhs;
 delete lhs;
 delete rhs;
 bison_error ("invalid assignment to keyword \"" + kw + "\"", l, c);
-return 0;
+return nullptr;
 }
 delete lhs;
 return new tree_simple_assignment (tmp, rhs, false, l, c, t);
 delete rhs;
 bison_error ("invalid assignment to keyword \"" + kw + "\"",
 l, c);
-return 0;
+return nullptr;
 }
 }
 return new tree_multi_assignment (lhs, rhs, false, l, c);
 }
 tree_parameter_list *param_list,
 tree_statement_list *body,
 tree_statement *end_fcn_stmt,
 comment_list *lc)
 {
-tree_function_def *retval = 0;
+tree_function_def *retval = nullptr;
 int l = fcn_tok->line ();
 int c = fcn_tok->column ();
 octave_user_function *tmp_fcn
 body->append (end_fcn_stmt);
 octave_user_function *fcn
 = new octave_user_function (m_lexer.symtab_context.curr_scope (),
-param_list, 0, body);
+param_list, nullptr, body);
 if (fcn)
 {
 comment_list *tc = m_lexer.comment_buf.get_comment ();
 base_parser::finish_function (tree_parameter_list *ret_list,
 octave_user_function *fcn,
 comment_list *lc,
 int l, int c)
 {
-tree_function_def *retval = 0;
+tree_function_def *retval = nullptr;
 if (ret_list)
 ret_list->mark_as_formal_parameters ();
 if (fcn)
 tree_identifier *id,
 tree_classdef_superclass_list *sc,
 tree_classdef_body *body, token *end_tok,
 comment_list *lc)
 {
-tree_classdef *retval = 0;
+tree_classdef *retval = nullptr;
 m_lexer.symtab_context.pop ();
 std::string cls_name = id->name ();
 tree_classdef_attribute_list *a,
 tree_classdef_property_list *plist,
 token *end_tok,
 comment_list *lc)
 {
-tree_classdef_properties_block *retval = 0;
+tree_classdef_properties_block *retval = nullptr;
 if (end_token_ok (end_tok, token::properties_end))
 {
 comment_list *tc = m_lexer.comment_buf.get_comment ();
 tree_classdef_attribute_list *a,
 tree_classdef_methods_list *mlist,
 token *end_tok,
 comment_list *lc)
 {
-tree_classdef_methods_block *retval = 0;
+tree_classdef_methods_block *retval = nullptr;
 if (end_token_ok (end_tok, token::methods_end))
 {
 comment_list *tc = m_lexer.comment_buf.get_comment ();
 tree_classdef_attribute_list *a,
 tree_classdef_events_list *elist,
 token *end_tok,
 comment_list *lc)
 {
-tree_classdef_events_block *retval = 0;
+tree_classdef_events_block *retval = nullptr;
 if (end_token_ok (end_tok, token::events_end))
 {
 comment_list *tc = m_lexer.comment_buf.get_comment ();
 tree_classdef_attribute_list *a,
 tree_classdef_enum_list *elist,
 token *end_tok,
 comment_list *lc)
 {
-tree_classdef_enum_block *retval = 0;
+tree_classdef_enum_block *retval = nullptr;
 if (end_token_ok (end_tok, token::enumeration_end))
 {
 comment_list *tc = m_lexer.comment_buf.get_comment ();
 octave_user_function*
 base_parser::start_classdef_external_method (tree_identifier *id,
 tree_parameter_list *pl)
 {
-octave_user_function* retval = 0;
+octave_user_function* retval = nullptr;
 // External methods are only allowed within @-folders. In this case,
 // m_curr_class_name will be non-empty.
 if (! m_curr_class_name.empty ())
 && mname != m_curr_class_name)
 {
 // Create a dummy function that is used until the real method
 // is loaded.
-retval = new octave_user_function (0, pl);
+retval = new octave_user_function (nullptr, pl);
 retval->stash_function_name (mname);
 int l = id->line ();
 int c = id->column ();
 tree_index_expression *
 base_parser::make_index_expression (tree_expression *expr,
 tree_argument_list *args,
 char type)
 {
-tree_index_expression *retval = 0;
+tree_index_expression *retval = nullptr;
 if (args && args->has_magic_tilde ())
 {
 delete expr;
 delete args;
 tree_index_expression *
 base_parser::make_indirect_ref (tree_expression *expr,
 const std::string& elt)
 {
-tree_index_expression *retval = 0;
+tree_index_expression *retval = nullptr;
 int l = expr->line ();
 int c = expr->column ();
 if (! expr->is_postfix_indexed ())
 tree_index_expression *
 base_parser::make_indirect_ref (tree_expression *expr,
 tree_expression *elt)
 {
-tree_index_expression *retval = 0;
+tree_index_expression *retval = nullptr;
 int l = expr->line ();
 int c = expr->column ();
 if (! expr->is_postfix_indexed ())
 tree_decl_command *
 base_parser::make_decl_command (int tok, token *tok_val,
 tree_decl_init_list *lst)
 {
-tree_decl_command *retval = 0;
+tree_decl_command *retval = nullptr;
 int l = tok_val->line ();
 int c = tok_val->column ();
 switch (tok)
 }
 tree_argument_list *
 base_parser::validate_matrix_for_assignment (tree_expression *e)
 {
-tree_argument_list *retval = 0;
+tree_argument_list *retval = nullptr;
 if (e->is_constant ())
 {
 tree_evaluator& tw
 = __get_evaluator__ ("validate_matrix_for_assignment");
 }
 else
 {
 bool is_simple_assign = true;
-tree_argument_list *tmp = 0;
+tree_argument_list *tmp = nullptr;
 if (e->is_matrix ())
 {
 tree_matrix *mat = dynamic_cast<tree_matrix *> (e);
 {
 octave_value retval;
 octave::unwind_protect frame;
-octave_function *fcn_ptr = 0;
+octave_function *fcn_ptr = nullptr;
 // Open function file and parse.
 FILE *in_stream = octave::command_editor::get_input_stream ();
 frame.add_fcn (octave::command_history::ignore_entries,
 octave::command_history::ignoring_entries ());
 octave::command_history::ignore_entries ();
-FILE *ffile = 0;
+FILE *ffile = nullptr;
 if (! full_file.empty ())
 ffile = std::fopen (full_file.c_str (), "rb");
 if (ffile)
 if (fcn_ptr)
 retval = octave_value (fcn_ptr);
 delete (parser.m_classdef_object);
-parser.m_classdef_object = 0;
+parser.m_classdef_object = nullptr;
 }
 else if (fcn_ptr)
 {
 retval = octave_value (fcn_ptr);
 if (parse_status == 0)
 {
 if (parser.m_stmt_list)
 {
-tree_statement *stmt = 0;
+tree_statement *stmt = nullptr;
 tree_evaluator& tw = __get_evaluator__ ("eval_string");
 if (parser.m_stmt_list->length () == 1
 && (stmt = parser.m_stmt_list->front ())
 cleanup_statement_list (tree_statement_list **lst)
 {
 if (*lst)
 {
 delete *lst;
-*lst = 0;
+*lst = nullptr;
 }
 }
 }
 DEFUN (eval, args, nargout,

Mercurial > octave

comparison libinterp/parse-tree/oct-parse.in.yy @ 23796:4f12819a634f