Mercurial > octave

diff libinterp/parse-tree/pt-colon.cc @ 23075:4e3d47dc7e25

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
move parse tree classes inside octave namespace * lex.h, lex.ll, oct-parse.in.yy, parse.h, pt-all.h, pt-arg-list.cc, pt-arg-list.h, pt-array-list.cc, pt-array-list.h, pt-assign.cc, pt-assign.h, pt-binop.cc, pt-binop.h, pt-bp.cc, pt-bp.h, pt-cbinop.cc, pt-cbinop.h, pt.cc, pt-cell.cc, pt-cell.h, pt-check.cc, pt-check.h, pt-classdef.cc, pt-classdef.h, pt-cmd.cc, pt-cmd.h, pt-colon.cc, pt-colon.h, pt-const.cc, pt-const.h, pt-decl.cc, pt-decl.h, pt-eval.cc, pt-eval.h, pt-except.cc, pt-except.h, pt-exp.cc, pt-exp.h, pt-fcn-handle.cc, pt-fcn-handle.h, pt-funcall.cc, pt-funcall.h, pt.h, pt-id.cc, pt-id.h, pt-idx.cc, pt-idx.h, pt-jump.cc, pt-jump.h, pt-loop.cc, pt-loop.h, pt-mat.cc, pt-mat.h, pt-misc.cc, pt-misc.h, pt-pr-code.cc, pt-pr-code.h, pt-select.cc, pt-select.h, pt-stmt.cc, pt-stmt.h, pt-unop.cc, pt-unop.h, pt-walk.h, token.cc, token.h: Move classes and most functions inside octave namespace. Change all uses.
author John W. Eaton <jwe@octave.org>
date Thu, 19 Jan 2017 23:41:54 -0500
parents 3a2b891d0b33
children ef4d915df748
line wrap: on
line diff
--- a/libinterp/parse-tree/pt-colon.cc	Thu Jan 19 14:47:19 2017 -0500
+++ b/libinterp/parse-tree/pt-colon.cc	Thu Jan 19 23:41:54 2017 -0500
@@ -32,142 +32,144 @@
 #include "pt-colon.h"
 #include "pt-walk.h"
 
-// Colon expressions.
-
-tree_colon_expression *
-tree_colon_expression::append (tree_expression *t)
-{
-  tree_colon_expression *retval = 0;
-
-  if (! op_base)
-    error ("invalid colon expression");
-
-  if (op_limit)
-    {
-      if (op_increment)
-        error ("invalid colon expression");
-
-      // Stupid syntax:
-      //
-      // base : limit
-      // base : increment : limit
-
-      op_increment = op_limit;
-      op_limit = t;
-    }
-  else
-    op_limit = t;
-
-  retval = this;
-
-  return retval;
-}
-
-octave_value_list
-tree_colon_expression::rvalue (int nargout)
+namespace octave
 {
-  if (nargout > 1)
-    error ("invalid number of output arguments for colon expression");
+  // Colon expressions.
 
-  return rvalue1 (nargout);
-}
+  tree_colon_expression *
+  tree_colon_expression::append (tree_expression *t)
+  {
+    tree_colon_expression *retval = 0;
+
+    if (! op_base)
+      error ("invalid colon expression");
 
-octave_value
-tree_colon_expression::rvalue1 (int)
-{
-  octave_value retval;
+    if (op_limit)
+      {
+        if (op_increment)
+          error ("invalid colon expression");
 
-  if (! op_base || ! op_limit)
-    return retval;
+        // Stupid syntax:
+        //
+        // base : limit
+        // base : increment : limit
 
-  octave_value ov_base = op_base->rvalue1 ();
+        op_increment = op_limit;
+        op_limit = t;
+      }
+    else
+      op_limit = t;
 
-  octave_value ov_limit = op_limit->rvalue1 ();
+    retval = this;
 
-  if (ov_base.is_object () || ov_limit.is_object ())
-    {
-      octave_value_list tmp1;
+    return retval;
+  }
 
-      if (op_increment)
-        {
-          octave_value ov_increment = op_increment->rvalue1 ();
+  octave_value_list
+  tree_colon_expression::rvalue (int nargout)
+  {
+    if (nargout > 1)
+      error ("invalid number of output arguments for colon expression");
+
+    return rvalue1 (nargout);
+  }
 
-          tmp1(2) = ov_limit;
-          tmp1(1) = ov_increment;
-          tmp1(0) = ov_base;
-        }
-      else
-        {
-          tmp1(1) = ov_limit;
-          tmp1(0) = ov_base;
-        }
+  octave_value
+  tree_colon_expression::rvalue1 (int)
+  {
+    octave_value retval;
+
+    if (! op_base || ! op_limit)
+      return retval;
+
+    octave_value ov_base = op_base->rvalue1 ();
+
+    octave_value ov_limit = op_limit->rvalue1 ();
+
+    if (ov_base.is_object () || ov_limit.is_object ())
+      {
+        octave_value_list tmp1;
+
+        if (op_increment)
+          {
+            octave_value ov_increment = op_increment->rvalue1 ();
 
-      octave_value fcn = symbol_table::find_function ("colon", tmp1);
-
-      if (! fcn.is_defined ())
-        error ("can not find overloaded colon function");
+            tmp1(2) = ov_limit;
+            tmp1(1) = ov_increment;
+            tmp1(0) = ov_base;
+          }
+        else
+          {
+            tmp1(1) = ov_limit;
+            tmp1(0) = ov_base;
+          }
 
-      octave_value_list tmp2 = fcn.do_multi_index_op (1, tmp1);
+        octave_value fcn = symbol_table::find_function ("colon", tmp1);
 
-      retval = tmp2 (0);
-    }
-  else
-    {
-      octave_value ov_increment = 1.0;
+        if (! fcn.is_defined ())
+          error ("can not find overloaded colon function");
+
+        octave_value_list tmp2 = fcn.do_multi_index_op (1, tmp1);
 
-      if (op_increment)
-        ov_increment = op_increment->rvalue1 ();
+        retval = tmp2 (0);
+      }
+    else
+      {
+        octave_value ov_increment = 1.0;
 
-      retval = do_colon_op (ov_base, ov_increment, ov_limit,
-                            is_for_cmd_expr ());
-    }
+        if (op_increment)
+          ov_increment = op_increment->rvalue1 ();
 
-  return retval;
-}
+        retval = do_colon_op (ov_base, ov_increment, ov_limit,
+                              is_for_cmd_expr ());
+      }
 
-void
-tree_colon_expression::eval_error (const std::string& s) const
-{
-  error ("%s", s.c_str ());
-}
+    return retval;
+  }
+
+  void
+  tree_colon_expression::eval_error (const std::string& s) const
+  {
+    error ("%s", s.c_str ());
+  }
 
-int
-tree_colon_expression::line (void) const
-{
-  return (op_base ? op_base->line ()
-          : (op_increment ? op_increment->line ()
-             : (op_limit ? op_limit->line ()
-                : -1)));
-}
+  int
+  tree_colon_expression::line (void) const
+  {
+    return (op_base ? op_base->line ()
+            : (op_increment ? op_increment->line ()
+               : (op_limit ? op_limit->line ()
+                  : -1)));
+  }
 
-int
-tree_colon_expression::column (void) const
-{
-  return (op_base ? op_base->column ()
-          : (op_increment ? op_increment->column ()
-             : (op_limit ? op_limit->column ()
-                : -1)));
-}
+  int
+  tree_colon_expression::column (void) const
+  {
+    return (op_base ? op_base->column ()
+            : (op_increment ? op_increment->column ()
+               : (op_limit ? op_limit->column ()
+                  : -1)));
+  }
 
-tree_expression *
-tree_colon_expression::dup (symbol_table::scope_id scope,
-                            symbol_table::context_id context) const
-{
-  tree_colon_expression *new_ce = new
-    tree_colon_expression (op_base ? op_base->dup (scope, context) : 0,
-                           op_limit ? op_limit->dup (scope, context) : 0,
-                           op_increment ? op_increment->dup (scope, context)
-                                        : 0,
-                           line (), column ());
+  tree_expression *
+  tree_colon_expression::dup (symbol_table::scope_id scope,
+                              symbol_table::context_id context) const
+  {
+    tree_colon_expression *new_ce = new
+      tree_colon_expression (op_base ? op_base->dup (scope, context) : 0,
+                             op_limit ? op_limit->dup (scope, context) : 0,
+                             op_increment ? op_increment->dup (scope, context)
+                             : 0,
+                             line (), column ());
 
-  new_ce->copy_base (*new_ce);
+    new_ce->copy_base (*new_ce);
 
-  return new_ce;
-}
+    return new_ce;
+  }
 
-void
-tree_colon_expression::accept (tree_walker& tw)
-{
-  tw.visit_colon_expression (*this);
+  void
+  tree_colon_expression::accept (tree_walker& tw)
+  {
+    tw.visit_colon_expression (*this);
+  }
 }
-