home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / octave-1.1.1p1-src.tgz / tar.out / fsf / octave / src / tc-rep.h < prev    next >
C/C++ Source or Header  |  1996-09-28  |  13KB  |  402 lines
  1. // tc-rep.h                                             -*- C++ -*-
  2. /*
  3.  
  4. Copyright (C) 1992, 1993, 1994, 1995 John W. Eaton
  5.  
  6. This file is part of Octave.
  7.  
  8. Octave is free software; you can redistribute it and/or modify it
  9. under the terms of the GNU General Public License as published by the
  10. Free Software Foundation; either version 2, or (at your option) any
  11. later version.
  12.  
  13. Octave is distributed in the hope that it will be useful, but WITHOUT
  14. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with Octave; see the file COPYING.  If not, write to the Free
  20. Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. */
  23.  
  24. #if !defined (octave_tree_const_rep_h)
  25. #define octave_tree_const_rep_h 1
  26.  
  27. // The actual representation of the tree_constant.
  28.  
  29. class
  30. tree_constant_rep
  31. {
  32. friend class tree_constant;
  33.  
  34. private:
  35.  
  36.   enum constant_type
  37.     {
  38.       unknown_constant,
  39.       scalar_constant,
  40.       matrix_constant,
  41.       complex_scalar_constant,
  42.       complex_matrix_constant,
  43.       string_constant,
  44.       range_constant,
  45.       map_constant,
  46.       magic_colon,
  47.       all_va_args,
  48.     };
  49.  
  50.   enum force_orient
  51.     {
  52.       no_orient,
  53.       row_orient,
  54.       column_orient,
  55.     };
  56.  
  57.   tree_constant_rep (void);
  58.  
  59.   tree_constant_rep (double d);
  60.   tree_constant_rep (const Matrix& m);
  61.   tree_constant_rep (const DiagMatrix& d);
  62.   tree_constant_rep (const RowVector& v, int pcv);
  63.   tree_constant_rep (const ColumnVector& v, int pcv);
  64.  
  65.   tree_constant_rep (const Complex& c);
  66.   tree_constant_rep (const ComplexMatrix& m);
  67.   tree_constant_rep (const ComplexDiagMatrix& d);
  68.   tree_constant_rep (const ComplexRowVector& v, int pcv);
  69.   tree_constant_rep (const ComplexColumnVector& v, int pcv);
  70.  
  71.   tree_constant_rep (const char *s);
  72.  
  73.   tree_constant_rep (double base, double limit, double inc);
  74.   tree_constant_rep (const Range& r);
  75.  
  76.   tree_constant_rep (const Octave_map& m);
  77.  
  78.   tree_constant_rep (tree_constant_rep::constant_type t);
  79.  
  80.   tree_constant_rep (const tree_constant_rep& t);
  81.  
  82.   ~tree_constant_rep (void);
  83.  
  84. #if defined (MDEBUG)
  85.   void *operator new (size_t size);
  86.   void operator delete (void *p, size_t size);
  87. #endif
  88.  
  89.   int rows (void) const;
  90.   int columns (void) const;
  91.  
  92.   int is_defined (void) const
  93.     { return type_tag != tree_constant_rep::unknown_constant; }
  94.  
  95.   int is_undefined (void) const
  96.     { return type_tag == tree_constant_rep::unknown_constant; }
  97.  
  98.   int is_unknown (void) const
  99.     { return type_tag == tree_constant_rep::unknown_constant; }
  100.  
  101.   int is_real_scalar (void) const
  102.     { return type_tag == tree_constant_rep::scalar_constant; }
  103.  
  104.   int is_real_matrix (void) const
  105.     { return type_tag == tree_constant_rep::matrix_constant; }
  106.  
  107.   int is_complex_scalar (void) const
  108.     { return type_tag == tree_constant_rep::complex_scalar_constant; }
  109.  
  110.   int is_complex_matrix (void) const
  111.     { return type_tag == tree_constant_rep::complex_matrix_constant; }
  112.  
  113.   int is_string (void) const
  114.     { return type_tag == tree_constant_rep::string_constant; }
  115.  
  116.   int is_range (void) const
  117.     { return type_tag == tree_constant_rep::range_constant; }
  118.  
  119.   int is_map (void) const
  120.     { return type_tag == tree_constant_rep::map_constant; }
  121.  
  122.   int is_magic_colon (void) const
  123.     { return type_tag == tree_constant_rep::magic_colon; }
  124.  
  125.   int is_all_va_args (void) const
  126.     { return type_tag == tree_constant_rep::all_va_args; }
  127.  
  128.   tree_constant all (void) const;
  129.   tree_constant any (void) const;
  130.  
  131.   int is_real_type (void) const
  132.     {
  133.       return (type_tag == scalar_constant
  134.           || type_tag == matrix_constant
  135.           || type_tag == range_constant
  136.           || type_tag == string_constant);
  137.     }
  138.  
  139.   int is_complex_type (void) const
  140.     {
  141.       return (type_tag == complex_matrix_constant
  142.           || type_tag == complex_scalar_constant);
  143.     }
  144.  
  145. // Would be nice to get rid of the next four functions:
  146.  
  147.   int is_scalar_type (void) const
  148.     {
  149.       return (type_tag == scalar_constant
  150.           || type_tag == complex_scalar_constant);
  151.     }
  152.  
  153.   int is_matrix_type (void) const
  154.     {
  155.       return (type_tag == matrix_constant
  156.           || type_tag == complex_matrix_constant);
  157.     }
  158.  
  159.   int is_numeric_type (void) const
  160.     {
  161.       return (type_tag == scalar_constant
  162.           || type_tag == matrix_constant
  163.           || type_tag == complex_matrix_constant
  164.           || type_tag == complex_scalar_constant);
  165.     }
  166.  
  167.   int is_numeric_or_range_type (void) const
  168.     {
  169.       return (type_tag == scalar_constant
  170.           || type_tag == matrix_constant
  171.           || type_tag == complex_matrix_constant
  172.           || type_tag == complex_scalar_constant
  173.           || type_tag == range_constant);
  174.     }
  175.  
  176.   int valid_as_scalar_index (void) const;
  177.   int valid_as_zero_index (void) const;
  178.  
  179.   int is_true (void) const;
  180.  
  181.   double double_value (int force_string_conversion = 0) const;
  182.   Matrix matrix_value (int force_string_conversion = 0) const;
  183.   Complex complex_value (int force_string_conversion = 0) const;
  184.   ComplexMatrix complex_matrix_value (int force_string_conversion = 0) const;
  185.   char *string_value (void) const;
  186.   Range range_value (void) const;
  187.   Octave_map map_value (void) const;
  188.  
  189.   tree_constant& lookup_map_element (const char *name, int insert = 0);
  190.  
  191.   ColumnVector vector_value (int force_string_conversion = 0,
  192.                  int force_vector_conversion = 0) const;
  193.  
  194.   ComplexColumnVector complex_vector_value (int force_string_conv = 0,
  195.                         int force_vec_conv = 0) const;
  196.  
  197.   tree_constant convert_to_str (void) const;
  198.  
  199.   void convert_to_row_or_column_vector (void);
  200.  
  201.   void bump_value (tree_expression::type);
  202.  
  203.   void resize (int i, int j);
  204.   void resize (int i, int j, double val);
  205.  
  206.   void maybe_resize (int imax, force_orient fo = no_orient);
  207.   void maybe_resize (int imax, int jmax);
  208.  
  209.   void stash_original_text (char *s);
  210.  
  211.   void maybe_mutate (void);
  212.  
  213.   void print (void);
  214.  
  215.   void print_code (ostream& os);
  216.  
  217.   void gripe_wrong_type_arg (const char *name,
  218.                  const tree_constant_rep& tcr) const;
  219.  
  220.   char *type_as_string (void) const;
  221.  
  222. // Binary and unary operations.
  223.  
  224.   friend tree_constant do_binary_op (tree_constant& a, tree_constant& b,
  225.                      tree_expression::type t);
  226.  
  227.   friend tree_constant do_unary_op (tree_constant& a,
  228.                     tree_expression::type t);
  229.  
  230. // -------------------------------------------------------------------
  231.  
  232. // We want to eliminate this.
  233.  
  234.   constant_type const_type (void) const { return type_tag; }
  235.  
  236. // We want to get rid of these too:
  237.  
  238.   void force_numeric (int force_str_conv = 0);
  239.   tree_constant make_numeric (int force_str_conv = 0) const;
  240.  
  241. // Indexing.
  242.  
  243.   tree_constant do_index (const Octave_object& args);
  244.  
  245.   tree_constant do_scalar_index (const Octave_object& args) const;
  246.  
  247.   tree_constant do_matrix_index (const Octave_object& args) const;
  248.  
  249.   tree_constant do_matrix_index (const tree_constant& i_arg) const;
  250.  
  251.   tree_constant do_matrix_index (const tree_constant& i_arg,
  252.                  const tree_constant& j_arg) const; 
  253.  
  254.   tree_constant do_matrix_index (constant_type i) const;
  255.  
  256.   tree_constant fortran_style_matrix_index (const tree_constant& i_arg) const;
  257.   tree_constant fortran_style_matrix_index (const Matrix& mi) const;
  258.  
  259.   tree_constant do_vector_index (const tree_constant& i_arg) const;
  260.  
  261.   tree_constant do_matrix_index (int i, const tree_constant& i_arg) const;
  262.   tree_constant do_matrix_index (const idx_vector& i,
  263.                  const tree_constant& i_arg) const; 
  264.   tree_constant do_matrix_index (const Range& i,
  265.                  const tree_constant& i_arg) const;
  266.   tree_constant do_matrix_index (constant_type i,
  267.                  const tree_constant& i_arg) const;
  268.  
  269.   tree_constant do_matrix_index (int i, int j) const;
  270.   tree_constant do_matrix_index (int i, const idx_vector& j) const;
  271.   tree_constant do_matrix_index (int i, const Range& j) const;
  272.   tree_constant do_matrix_index (int i, constant_type cj) const;
  273.  
  274.   tree_constant do_matrix_index (const idx_vector& i, int j) const;
  275.   tree_constant do_matrix_index (const idx_vector& i,
  276.                  const idx_vector& j) const;
  277.   tree_constant do_matrix_index (const idx_vector& i, const Range& j) const;
  278.   tree_constant do_matrix_index (const idx_vector& i, constant_type j) const;
  279.  
  280.   tree_constant do_matrix_index (const Range& i, int j) const;
  281.   tree_constant do_matrix_index (const Range& i, const idx_vector& j) const;
  282.   tree_constant do_matrix_index (const Range& i, const Range& j) const;
  283.   tree_constant do_matrix_index (const Range& i, constant_type j) const;
  284.  
  285.   tree_constant do_matrix_index (constant_type i, int j) const;
  286.   tree_constant do_matrix_index (constant_type i, const idx_vector& j) const;
  287.   tree_constant do_matrix_index (constant_type i, const Range& j) const;
  288.   tree_constant do_matrix_index (constant_type i, constant_type j) const;
  289.  
  290. // Assignment.
  291.  
  292.   void assign (tree_constant& rhs, const Octave_object& args);
  293.  
  294.   void do_scalar_assignment (const tree_constant& rhs,
  295.                  const Octave_object& args);
  296.  
  297.   void do_matrix_assignment (const tree_constant& rhs,
  298.                  const Octave_object& args);
  299.  
  300.   void do_matrix_assignment (const tree_constant& rhs,
  301.                  const tree_constant& i_arg);
  302.  
  303.   void fortran_style_matrix_assignment (const tree_constant& rhs,
  304.                     const tree_constant& i_arg);
  305.  
  306.   void fortran_style_matrix_assignment (const tree_constant& rhs,
  307.                     constant_type ci);
  308.  
  309.   void fortran_style_matrix_assignment (const tree_constant& rhs,
  310.                     idx_vector& i);
  311.  
  312.   void vector_assignment (const tree_constant& rhs,
  313.               const tree_constant& i_arg);
  314.  
  315.   void check_vector_assign (int rhs_nr, int rhs_nc, int ilen,
  316.                 const char *rm);
  317.  
  318.   void do_vector_assign (const tree_constant& rhs, int i);
  319.   void do_vector_assign (const tree_constant& rhs, idx_vector& i);
  320.   void do_vector_assign (const tree_constant& rhs, Range& i);
  321.  
  322.   void do_matrix_assignment (const tree_constant& rhs,
  323.                  const tree_constant& i_arg,
  324.                  const tree_constant& j_arg);
  325.  
  326.   void do_matrix_assignment (const tree_constant& rhs, int i,
  327.                  const tree_constant& j_arg);
  328.   void do_matrix_assignment (const tree_constant& rhs, idx_vector& i,
  329.                  const tree_constant& j_arg);
  330.   void do_matrix_assignment (const tree_constant& rhs, Range& i,
  331.                  const tree_constant& j_arg);
  332.   void do_matrix_assignment (const tree_constant& rhs, constant_type i,
  333.                  const tree_constant& j_arg);
  334.  
  335.   void do_matrix_assignment (const tree_constant& rhs, int i, int j);
  336.   void do_matrix_assignment (const tree_constant& rhs, int i, idx_vector& jv);
  337.   void do_matrix_assignment (const tree_constant& rhs, int i, Range& j);
  338.   void do_matrix_assignment (const tree_constant& rhs, int i, constant_type cj);
  339.  
  340.   void do_matrix_assignment (const tree_constant& rhs, idx_vector& iv,
  341.                  int j);
  342.   void do_matrix_assignment (const tree_constant& rhs, idx_vector& iv,
  343.                  idx_vector& jv);
  344.   void do_matrix_assignment (const tree_constant& rhs, idx_vector& iv,
  345.                  Range& j);
  346.   void do_matrix_assignment (const tree_constant& rhs, idx_vector& iv,
  347.                  constant_type j);
  348.  
  349.   void do_matrix_assignment (const tree_constant& rhs, Range& i, int j);
  350.   void do_matrix_assignment (const tree_constant& rhs, Range& i,
  351.                  idx_vector& jv);
  352.   void do_matrix_assignment (const tree_constant& rhs, Range& i,
  353.                  Range& j);
  354.   void do_matrix_assignment (const tree_constant& rhs, Range& i,
  355.                  constant_type j);
  356.  
  357.   void do_matrix_assignment (const tree_constant& rhs, constant_type i, int j);
  358.   void do_matrix_assignment (const tree_constant& rhs, constant_type i,
  359.                  idx_vector& jv);
  360.   void do_matrix_assignment (const tree_constant& rhs, constant_type i,
  361.                  Range& j);
  362.   void do_matrix_assignment (const tree_constant& rhs,
  363.                  const constant_type i,
  364.                  constant_type j);
  365.  
  366.   void delete_row (int);
  367.   void delete_rows (idx_vector& i);
  368.   void delete_rows (Range& i);
  369.  
  370.   void delete_column (int);
  371.   void delete_columns (idx_vector& j);
  372.   void delete_columns (Range& j);
  373.  
  374. // Data.
  375.  
  376.   int count;
  377.  
  378.   constant_type type_tag;
  379.  
  380.   union
  381.     {
  382.       double scalar;            // A real scalar constant.
  383.       Matrix *matrix;            // A real matrix constant.
  384.       Complex *complex_scalar;        // A real scalar constant.
  385.       ComplexMatrix *complex_matrix;    // A real matrix constant.
  386.       char *string;            // A character string constant.
  387.       Range *range;            // A set of evenly spaced values.
  388.       Octave_map *a_map;        // An associative array.
  389.     };
  390.  
  391.   char *orig_text;
  392. };
  393.  
  394. #endif
  395.  
  396. /*
  397. ;;; Local Variables: ***
  398. ;;; mode: C++ ***
  399. ;;; page-delimiter: "^/\\*" ***
  400. ;;; End: ***
  401. */
  402.