# HG changeset patch # User John W. Eaton # Date 1582047244 18000 # Node ID 4963f23b145cb6f64620ed65c8544457b55f6c56 # Parent 865f8ddb2c78154f5a5832c6cd31345bea4b5a88 move mex type definitions to separate file * mxtypes.in.h: New file, extracted from mxarray.in.h. * mxarray.h: Rename from mxarray.in.h. * mk-mxtypes-h.in.sh: Rename from mk-mxarray-h.in.sh. * configure.ac, libinterp/corefcn/module.mk, libinterp/module.mk: Update for name change. * : (OCTAVE_CONFIG_MOVE_IF_CHANGE_FILES): List mxtypes.in.h instead of mxarray.in.h. * ov.h: Include mxtypes.h. diff -r 865f8ddb2c78 -r 4963f23b145c configure.ac --- a/configure.ac Fri Feb 21 11:52:08 2020 -0500 +++ b/configure.ac Tue Feb 18 12:34:04 2020 -0500 @@ -2999,7 +2999,7 @@ libgui/mk-default-qt-settings.sh liboctave/external/mk-f77-def.sh liboctave/mk-version-h.sh - libinterp/corefcn/mk-mxarray-h.sh + libinterp/corefcn/mk-mxtypes-h.sh build-aux/subst-config-vals.sh build-aux/subst-cross-config-vals.sh build-aux/subst-script-vals.sh]) diff -r 865f8ddb2c78 -r 4963f23b145c libinterp/corefcn/mk-mxarray-h.in.sh --- a/libinterp/corefcn/mk-mxarray-h.in.sh Fri Feb 21 11:52:08 2020 -0500 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,34 +0,0 @@ -#! /bin/sh -# -######################################################################## -# -# Copyright (C) 2016-2020 The Octave Project Developers -# -# See the file COPYRIGHT.md in the top-level directory of this -# distribution or . -# -# This file is part of Octave. -# -# Octave is free software: you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# Octave is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with Octave; see the file COPYING. If not, see -# . -# -######################################################################## - -: ${SED=@SED@} - -OCTAVE_IDX_TYPE="@OCTAVE_IDX_TYPE@" - -$SED \ - -e "s|%NO_EDIT_WARNING%|DO NOT EDIT! Generated automatically by mx-mxarray-h.|" \ - -e "s|%OCTAVE_IDX_TYPE%|${OCTAVE_IDX_TYPE}|" diff -r 865f8ddb2c78 -r 4963f23b145c libinterp/corefcn/mk-mxtypes-h.in.sh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libinterp/corefcn/mk-mxtypes-h.in.sh Tue Feb 18 12:34:04 2020 -0500 @@ -0,0 +1,34 @@ +#! /bin/sh +# +######################################################################## +# +# Copyright (C) 2016-2020 The Octave Project Developers +# +# See the file COPYRIGHT.md in the top-level directory of this +# distribution or . +# +# This file is part of Octave. +# +# Octave is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Octave is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Octave; see the file COPYING. If not, see +# . +# +######################################################################## + +: ${SED=@SED@} + +OCTAVE_IDX_TYPE="@OCTAVE_IDX_TYPE@" + +$SED \ + -e "s|%NO_EDIT_WARNING%|DO NOT EDIT! Generated automatically by mx-mxtypes-h.sh|" \ + -e "s|%OCTAVE_IDX_TYPE%|${OCTAVE_IDX_TYPE}|" diff -r 865f8ddb2c78 -r 4963f23b145c libinterp/corefcn/module.mk --- a/libinterp/corefcn/module.mk Fri Feb 21 11:52:08 2020 -0500 +++ b/libinterp/corefcn/module.mk Tue Feb 18 12:34:04 2020 -0500 @@ -58,6 +58,7 @@ %reldir%/ls-utils.h \ %reldir%/mex.h \ %reldir%/mexproto.h \ + %reldir%/mxarray.h \ %reldir%/oct-errno.h \ %reldir%/oct-fstrm.h \ %reldir%/oct-handle.h \ @@ -299,8 +300,8 @@ fi && \ mv $@-t $@ -%reldir%/mxarray.h: %reldir%/mxarray.in.h %reldir%/mk-mxarray-h.sh | %reldir%/$(octave_dirstamp) - $(AM_V_GEN)$(call simple-filter-rule,%reldir%/mk-mxarray-h.sh) +%reldir%/mxtypes.h: %reldir%/mxtypes.in.h %reldir%/mk-mxtypes-h.sh | %reldir%/$(octave_dirstamp) + $(AM_V_GEN)$(call simple-filter-rule,%reldir%/mk-mxtypes-h.sh) %reldir%/oct-tex-lexer.ll: %reldir%/oct-tex-lexer.in.ll %reldir%/oct-tex-symbols.in | %reldir%/$(octave_dirstamp) $(AM_V_GEN)rm -f $@-t && \ @@ -333,11 +334,11 @@ %reldir%/genprops.awk \ %reldir%/graphics.in.h \ %reldir%/mk-errno-list.sh \ - %reldir%/mk-mxarray-h.in.sh \ - %reldir%/mxarray.in.h \ + %reldir%/mk-mxtypes-h.in.sh \ + %reldir%/mxtypes.in.h \ %reldir%/oct-errno.in.cc \ %reldir%/oct-tex-lexer.in.ll \ %reldir%/oct-tex-symbols.in GEN_CONFIG_SHELL += \ - %reldir%/mk-mxarray-h.sh + %reldir%/mk-mxtypes-h.sh diff -r 865f8ddb2c78 -r 4963f23b145c libinterp/corefcn/mxarray.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libinterp/corefcn/mxarray.h Tue Feb 18 12:34:04 2020 -0500 @@ -0,0 +1,525 @@ +//////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 2001-2020 The Octave Project Developers +// +// See the file COPYRIGHT.md in the top-level directory of this +// distribution or . +// +// This file is part of Octave. +// +// Octave is free software: you can redistribute it and/or modify it +// under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Octave is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Octave; see the file COPYING. If not, see +// . +// +//////////////////////////////////////////////////////////////////////// + +/* + +Part of this code was originally distributed as part of Octave Forge under +the following terms: + +Author: Paul Kienzle +I grant this code to the public domain. +2001-03-22 + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. + +*/ + +#if ! defined (octave_mxarray_h) +#define octave_mxarray_h 1 + +#include "octave-config.h" + +#include "mxtypes.h" + +#if ! defined (MXARRAY_TYPEDEFS_ONLY) + +#include +#include "error.h" + +class octave_value; +class dim_vector; + +#define DO_MUTABLE_METHOD(RET_T, METHOD_CALL) \ + RET_T retval = rep->METHOD_CALL; \ + \ + if (rep->mutation_needed ()) \ + { \ + maybe_mutate (); \ + retval = rep->METHOD_CALL; \ + } \ + \ + return retval + +#define DO_VOID_MUTABLE_METHOD(METHOD_CALL) \ + rep->METHOD_CALL; \ + \ + if (rep->mutation_needed ()) \ + { \ + maybe_mutate (); \ + rep->METHOD_CALL; \ + } + +class mxArray; + +// A class to provide the default implementation of some of the +// virtual functions declared in the mxArray class. + +class mxArray_base +{ +protected: + + mxArray_base (void) { } + +public: + + virtual mxArray_base * dup (void) const = 0; + + virtual mxArray * as_mxArray (void) const { return nullptr; } + + virtual ~mxArray_base (void) = default; + + virtual bool is_octave_value (void) const { return false; } + + virtual int iscell (void) const = 0; + + virtual int is_char (void) const = 0; + + virtual int is_class (const char *name_arg) const + { + int retval = 0; + + const char *cname = get_class_name (); + + if (cname && name_arg) + retval = ! strcmp (cname, name_arg); + + return retval; + } + + virtual int is_complex (void) const = 0; + + virtual int is_double (void) const = 0; + + virtual int is_function_handle (void) const = 0; + + virtual int is_int16 (void) const = 0; + + virtual int is_int32 (void) const = 0; + + virtual int is_int64 (void) const = 0; + + virtual int is_int8 (void) const = 0; + + virtual int is_logical (void) const = 0; + + virtual int is_numeric (void) const = 0; + + virtual int is_single (void) const = 0; + + virtual int is_sparse (void) const = 0; + + virtual int is_struct (void) const = 0; + + virtual int is_uint16 (void) const = 0; + + virtual int is_uint32 (void) const = 0; + + virtual int is_uint64 (void) const = 0; + + virtual int is_uint8 (void) const = 0; + + virtual int is_logical_scalar (void) const + { + return is_logical () && get_number_of_elements () == 1; + } + + virtual int is_logical_scalar_true (void) const = 0; + + virtual mwSize get_m (void) const = 0; + + virtual mwSize get_n (void) const = 0; + + virtual mwSize * get_dimensions (void) const = 0; + + virtual mwSize get_number_of_dimensions (void) const = 0; + + virtual void set_m (mwSize m) = 0; + + virtual void set_n (mwSize n) = 0; + + virtual int set_dimensions (mwSize *dims_arg, mwSize ndims_arg) = 0; + + virtual mwSize get_number_of_elements (void) const = 0; + + virtual int isempty (void) const = 0; + + virtual bool is_scalar (void) const = 0; + + virtual mxClassID get_class_id (void) const = 0; + + virtual const char * get_class_name (void) const = 0; + + virtual void set_class_name (const char *name_arg) = 0; + + // The following functions aren't pure virtual because they are only + // valid for one type. Making them pure virtual would mean that they + // have to be implemented for all derived types, and all of those + // would need to throw errors instead of just doing it once here. + + virtual mxArray * + get_property (mwIndex /*idx*/, const char * /*pname*/) const + { + return nullptr; + } + + virtual void set_property (mwIndex /*idx*/, const char * /*pname*/, + const mxArray * /*pval*/) + { + err_invalid_type (); + } + + virtual mxArray * get_cell (mwIndex /*idx*/) const + { + err_invalid_type (); + } + + virtual void set_cell (mwIndex idx, mxArray *val) = 0; + + virtual double get_scalar (void) const = 0; + + virtual void * get_data (void) const = 0; + + virtual void * get_imag_data (void) const = 0; + + virtual void set_data (void *pr) = 0; + + virtual void set_imag_data (void *pi) = 0; + + virtual mwIndex * get_ir (void) const = 0; + + virtual mwIndex * get_jc (void) const = 0; + + virtual mwSize get_nzmax (void) const = 0; + + virtual void set_ir (mwIndex *ir) = 0; + + virtual void set_jc (mwIndex *jc) = 0; + + virtual void set_nzmax (mwSize nzmax) = 0; + + virtual int add_field (const char *key) = 0; + + virtual void remove_field (int key_num) = 0; + + virtual mxArray * get_field_by_number (mwIndex index, int key_num) const = 0; + + virtual void + set_field_by_number (mwIndex index, int key_num, mxArray *val) = 0; + + virtual int get_number_of_fields (void) const = 0; + + virtual const char * get_field_name_by_number (int key_num) const = 0; + + virtual int get_field_number (const char *key) const = 0; + + virtual int get_string (char *buf, mwSize buflen) const = 0; + + virtual char * array_to_string (void) const = 0; + + virtual mwIndex calc_single_subscript (mwSize nsubs, mwIndex *subs) const = 0; + + virtual size_t get_element_size (void) const = 0; + + virtual bool mutation_needed (void) const { return false; } + + virtual mxArray * mutate (void) const { return nullptr; } + + virtual octave_value as_octave_value (void) const = 0; + +protected: + + mxArray_base (const mxArray_base&) { } + + OCTAVE_NORETURN void err_invalid_type (void) const + { + error ("invalid type for operation"); + } +}; + +// The main interface class. The representation can be based on an +// octave_value object or a separate object that tries to reproduce +// the semantics of mxArray objects in Matlab more directly. + +class mxArray +{ +public: + + mxArray (const octave_value& ov); + + mxArray (mxClassID id, mwSize ndims, const mwSize *dims, + mxComplexity flag = mxREAL, bool init = true); + + mxArray (mxClassID id, const dim_vector& dv, mxComplexity flag = mxREAL); + + mxArray (mxClassID id, mwSize m, mwSize n, + mxComplexity flag = mxREAL, bool init = true); + + mxArray (mxClassID id, double val); + + mxArray (mxClassID id, mxLogical val); + + mxArray (const char *str); + + mxArray (mwSize m, const char **str); + + mxArray (mxClassID id, mwSize m, mwSize n, mwSize nzmax, + mxComplexity flag = mxREAL); + + mxArray (mwSize ndims, const mwSize *dims, int num_keys, const char **keys); + + mxArray (const dim_vector& dv, int num_keys, const char **keys); + + mxArray (mwSize m, mwSize n, int num_keys, const char **keys); + + mxArray (mwSize ndims, const mwSize *dims); + + mxArray (const dim_vector& dv); + + mxArray (mwSize m, mwSize n); + + mxArray * dup (void) const + { + mxArray *retval = rep->as_mxArray (); + + if (retval) + retval->set_name (name); + else + { + mxArray_base *new_rep = rep->dup (); + + retval = new mxArray (new_rep, name); + } + + return retval; + } + + // No copying! + + mxArray (const mxArray&) = delete; + + mxArray& operator = (const mxArray&) = delete; + + ~mxArray (void); + + bool is_octave_value (void) const { return rep->is_octave_value (); } + + int iscell (void) const { return rep->iscell (); } + + int is_char (void) const { return rep->is_char (); } + + int is_class (const char *name_arg) const { return rep->is_class (name_arg); } + + int is_complex (void) const { return rep->is_complex (); } + + int is_double (void) const { return rep->is_double (); } + + int is_function_handle (void) const { return rep->is_function_handle (); } + + int is_int16 (void) const { return rep->is_int16 (); } + + int is_int32 (void) const { return rep->is_int32 (); } + + int is_int64 (void) const { return rep->is_int64 (); } + + int is_int8 (void) const { return rep->is_int8 (); } + + int is_logical (void) const { return rep->is_logical (); } + + int is_numeric (void) const { return rep->is_numeric (); } + + int is_single (void) const { return rep->is_single (); } + + int is_sparse (void) const { return rep->is_sparse (); } + + int is_struct (void) const { return rep->is_struct (); } + + int is_uint16 (void) const { return rep->is_uint16 (); } + + int is_uint32 (void) const { return rep->is_uint32 (); } + + int is_uint64 (void) const { return rep->is_uint64 (); } + + int is_uint8 (void) const { return rep->is_uint8 (); } + + int is_logical_scalar (void) const { return rep->is_logical_scalar (); } + + int is_logical_scalar_true (void) const + { return rep->is_logical_scalar_true (); } + + mwSize get_m (void) const { return rep->get_m (); } + + mwSize get_n (void) const { return rep->get_n (); } + + mwSize * get_dimensions (void) const { return rep->get_dimensions (); } + + mwSize get_number_of_dimensions (void) const + { return rep->get_number_of_dimensions (); } + + void set_m (mwSize m) { DO_VOID_MUTABLE_METHOD (set_m (m)); } + + void set_n (mwSize n) { DO_VOID_MUTABLE_METHOD (set_n (n)); } + + int set_dimensions (mwSize *dims_arg, mwSize ndims_arg) + { DO_MUTABLE_METHOD (int, set_dimensions (dims_arg, ndims_arg)); } + + mwSize get_number_of_elements (void) const + { return rep->get_number_of_elements (); } + + int isempty (void) const { return get_number_of_elements () == 0; } + + bool is_scalar (void) const { return rep->is_scalar (); } + + const char * get_name (void) const { return name; } + + void set_name (const char *name_arg); + + mxClassID get_class_id (void) const { return rep->get_class_id (); } + + const char * get_class_name (void) const { return rep->get_class_name (); } + + mxArray * get_property (mwIndex idx, const char *pname) const + { return rep->get_property (idx, pname); } + + void set_property (mwIndex idx, const char *pname, const mxArray *pval) + { rep->set_property (idx, pname, pval); } + + void set_class_name (const char *name_arg) + { DO_VOID_MUTABLE_METHOD (set_class_name (name_arg)); } + + mxArray * get_cell (mwIndex idx) const + { DO_MUTABLE_METHOD (mxArray *, get_cell (idx)); } + + void set_cell (mwIndex idx, mxArray *val) + { DO_VOID_MUTABLE_METHOD (set_cell (idx, val)); } + + double get_scalar (void) const { return rep->get_scalar (); } + + void * get_data (void) const { DO_MUTABLE_METHOD (void *, get_data ()); } + + void * get_imag_data (void) const + { DO_MUTABLE_METHOD (void *, get_imag_data ()); } + + void set_data (void *pr) { DO_VOID_MUTABLE_METHOD (set_data (pr)); } + + void set_imag_data (void *pi) { DO_VOID_MUTABLE_METHOD (set_imag_data (pi)); } + + mwIndex * get_ir (void) const { DO_MUTABLE_METHOD (mwIndex *, get_ir ()); } + + mwIndex * get_jc (void) const { DO_MUTABLE_METHOD (mwIndex *, get_jc ()); } + + mwSize get_nzmax (void) const { return rep->get_nzmax (); } + + void set_ir (mwIndex *ir) { DO_VOID_MUTABLE_METHOD (set_ir (ir)); } + + void set_jc (mwIndex *jc) { DO_VOID_MUTABLE_METHOD (set_jc (jc)); } + + void set_nzmax (mwSize nzmax) { DO_VOID_MUTABLE_METHOD (set_nzmax (nzmax)); } + + int add_field (const char *key) { DO_MUTABLE_METHOD (int, add_field (key)); } + + void remove_field (int key_num) + { DO_VOID_MUTABLE_METHOD (remove_field (key_num)); } + + mxArray * get_field_by_number (mwIndex index, int key_num) const + { DO_MUTABLE_METHOD (mxArray *, get_field_by_number (index, key_num)); } + + void set_field_by_number (mwIndex index, int key_num, mxArray *val) + { DO_VOID_MUTABLE_METHOD (set_field_by_number (index, key_num, val)); } + + int get_number_of_fields (void) const { return rep->get_number_of_fields (); } + + const char * get_field_name_by_number (int key_num) const + { DO_MUTABLE_METHOD (const char*, get_field_name_by_number (key_num)); } + + int get_field_number (const char *key) const + { DO_MUTABLE_METHOD (int, get_field_number (key)); } + + int get_string (char *buf, mwSize buflen) const + { return rep->get_string (buf, buflen); } + + char * array_to_string (void) const { return rep->array_to_string (); } + + mwIndex calc_single_subscript (mwSize nsubs, mwIndex *subs) const + { return rep->calc_single_subscript (nsubs, subs); } + + size_t get_element_size (void) const { return rep->get_element_size (); } + + bool mutation_needed (void) const { return rep->mutation_needed (); } + + mxArray * mutate (void) const { return rep->mutate (); } + + static void * malloc (size_t n); + + static void * calloc (size_t n, size_t t); + + static char * strsave (const char *str) + { + char *retval = nullptr; + + if (str) + { + mwSize sz = sizeof (mxChar) * (strlen (str) + 1); + + retval = static_cast (mxArray::malloc (sz)); + + if (retval) + strcpy (retval, str); + } + + return retval; + } + + static octave_value + as_octave_value (const mxArray *ptr, bool null_is_empty = true); + + octave_value as_octave_value (void) const; + +private: + + mutable mxArray_base *rep; + + char *name; + + mxArray (mxArray_base *r, const char *n) + : rep (r), name (mxArray::strsave (n)) { } + + void maybe_mutate (void) const; +}; + +#undef DO_MUTABLE_METHOD +#undef DO_VOID_MUTABLE_METHOD + +#endif +#endif diff -r 865f8ddb2c78 -r 4963f23b145c libinterp/corefcn/mxarray.in.h --- a/libinterp/corefcn/mxarray.in.h Fri Feb 21 11:52:08 2020 -0500 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,570 +0,0 @@ -// %NO_EDIT_WARNING% - -//////////////////////////////////////////////////////////////////////// -// -// Copyright (C) 2001-2020 The Octave Project Developers -// -// See the file COPYRIGHT.md in the top-level directory of this -// distribution or . -// -// This file is part of Octave. -// -// Octave is free software: you can redistribute it and/or modify it -// under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Octave is distributed in the hope that it will be useful, but -// WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Octave; see the file COPYING. If not, see -// . -// -//////////////////////////////////////////////////////////////////////// - -/* - -Part of this code was originally distributed as part of Octave Forge under -the following terms: - -Author: Paul Kienzle -I grant this code to the public domain. -2001-03-22 - -THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -SUCH DAMAGE. - -*/ - -#if ! defined (octave_mxarray_h) -#define octave_mxarray_h 1 - -#include "octave-config.h" - -typedef enum -{ - mxUNKNOWN_CLASS = 0, - mxCELL_CLASS, - mxSTRUCT_CLASS, - mxLOGICAL_CLASS, - mxCHAR_CLASS, - mxVOID_CLASS, - mxDOUBLE_CLASS, - mxSINGLE_CLASS, - mxINT8_CLASS, - mxUINT8_CLASS, - mxINT16_CLASS, - mxUINT16_CLASS, - mxINT32_CLASS, - mxUINT32_CLASS, - mxINT64_CLASS, - mxUINT64_CLASS, - mxFUNCTION_CLASS -} -mxClassID; - -typedef enum -{ - mxREAL = 0, - mxCOMPLEX = 1 -} -mxComplexity; - -/* Matlab uses a wide char (uint16) internally, but Octave uses plain char. */ -/* typedef Uint16 mxChar; */ -typedef char mxChar; - -typedef unsigned char mxLogical; - -/* - * FIXME: Mathworks says mwSize, mwIndex should be int generally. - * But on 64-bit systems, or when mex -largeArrayDims is used, it is size_t. - * mwSignedIndex is supposed to be ptrdiff_t. All of this is confusing. - * Its better to conform to the same indexing as the rest of Octave. - */ -typedef %OCTAVE_IDX_TYPE% mwSize; -typedef %OCTAVE_IDX_TYPE% mwIndex; -typedef %OCTAVE_IDX_TYPE% mwSignedIndex; - -#if ! defined (MXARRAY_TYPEDEFS_ONLY) - -#include -#include "error.h" - -class octave_value; -class dim_vector; - -#define DO_MUTABLE_METHOD(RET_T, METHOD_CALL) \ - RET_T retval = rep->METHOD_CALL; \ - \ - if (rep->mutation_needed ()) \ - { \ - maybe_mutate (); \ - retval = rep->METHOD_CALL; \ - } \ - \ - return retval - -#define DO_VOID_MUTABLE_METHOD(METHOD_CALL) \ - rep->METHOD_CALL; \ - \ - if (rep->mutation_needed ()) \ - { \ - maybe_mutate (); \ - rep->METHOD_CALL; \ - } - -class mxArray; - -// A class to provide the default implementation of some of the -// virtual functions declared in the mxArray class. - -class mxArray_base -{ -protected: - - mxArray_base (void) { } - -public: - - virtual mxArray_base * dup (void) const = 0; - - virtual mxArray * as_mxArray (void) const { return nullptr; } - - virtual ~mxArray_base (void) = default; - - virtual bool is_octave_value (void) const { return false; } - - virtual int iscell (void) const = 0; - - virtual int is_char (void) const = 0; - - virtual int is_class (const char *name_arg) const - { - int retval = 0; - - const char *cname = get_class_name (); - - if (cname && name_arg) - retval = ! strcmp (cname, name_arg); - - return retval; - } - - virtual int is_complex (void) const = 0; - - virtual int is_double (void) const = 0; - - virtual int is_function_handle (void) const = 0; - - virtual int is_int16 (void) const = 0; - - virtual int is_int32 (void) const = 0; - - virtual int is_int64 (void) const = 0; - - virtual int is_int8 (void) const = 0; - - virtual int is_logical (void) const = 0; - - virtual int is_numeric (void) const = 0; - - virtual int is_single (void) const = 0; - - virtual int is_sparse (void) const = 0; - - virtual int is_struct (void) const = 0; - - virtual int is_uint16 (void) const = 0; - - virtual int is_uint32 (void) const = 0; - - virtual int is_uint64 (void) const = 0; - - virtual int is_uint8 (void) const = 0; - - virtual int is_logical_scalar (void) const - { - return is_logical () && get_number_of_elements () == 1; - } - - virtual int is_logical_scalar_true (void) const = 0; - - virtual mwSize get_m (void) const = 0; - - virtual mwSize get_n (void) const = 0; - - virtual mwSize * get_dimensions (void) const = 0; - - virtual mwSize get_number_of_dimensions (void) const = 0; - - virtual void set_m (mwSize m) = 0; - - virtual void set_n (mwSize n) = 0; - - virtual int set_dimensions (mwSize *dims_arg, mwSize ndims_arg) = 0; - - virtual mwSize get_number_of_elements (void) const = 0; - - virtual int isempty (void) const = 0; - - virtual bool is_scalar (void) const = 0; - - virtual mxClassID get_class_id (void) const = 0; - - virtual const char * get_class_name (void) const = 0; - - virtual void set_class_name (const char *name_arg) = 0; - - // The following functions aren't pure virtual because they are only - // valid for one type. Making them pure virtual would mean that they - // have to be implemented for all derived types, and all of those - // would need to throw errors instead of just doing it once here. - - virtual mxArray * - get_property (mwIndex /*idx*/, const char * /*pname*/) const - { - return nullptr; - } - - virtual void set_property (mwIndex /*idx*/, const char * /*pname*/, - const mxArray * /*pval*/) - { - err_invalid_type (); - } - - virtual mxArray * get_cell (mwIndex /*idx*/) const - { - err_invalid_type (); - } - - virtual void set_cell (mwIndex idx, mxArray *val) = 0; - - virtual double get_scalar (void) const = 0; - - virtual void * get_data (void) const = 0; - - virtual void * get_imag_data (void) const = 0; - - virtual void set_data (void *pr) = 0; - - virtual void set_imag_data (void *pi) = 0; - - virtual mwIndex * get_ir (void) const = 0; - - virtual mwIndex * get_jc (void) const = 0; - - virtual mwSize get_nzmax (void) const = 0; - - virtual void set_ir (mwIndex *ir) = 0; - - virtual void set_jc (mwIndex *jc) = 0; - - virtual void set_nzmax (mwSize nzmax) = 0; - - virtual int add_field (const char *key) = 0; - - virtual void remove_field (int key_num) = 0; - - virtual mxArray * get_field_by_number (mwIndex index, int key_num) const = 0; - - virtual void - set_field_by_number (mwIndex index, int key_num, mxArray *val) = 0; - - virtual int get_number_of_fields (void) const = 0; - - virtual const char * get_field_name_by_number (int key_num) const = 0; - - virtual int get_field_number (const char *key) const = 0; - - virtual int get_string (char *buf, mwSize buflen) const = 0; - - virtual char * array_to_string (void) const = 0; - - virtual mwIndex calc_single_subscript (mwSize nsubs, mwIndex *subs) const = 0; - - virtual size_t get_element_size (void) const = 0; - - virtual bool mutation_needed (void) const { return false; } - - virtual mxArray * mutate (void) const { return nullptr; } - - virtual octave_value as_octave_value (void) const = 0; - -protected: - - mxArray_base (const mxArray_base&) { } - - OCTAVE_NORETURN void err_invalid_type (void) const - { - error ("invalid type for operation"); - } -}; - -// The main interface class. The representation can be based on an -// octave_value object or a separate object that tries to reproduce -// the semantics of mxArray objects in Matlab more directly. - -class mxArray -{ -public: - - mxArray (const octave_value& ov); - - mxArray (mxClassID id, mwSize ndims, const mwSize *dims, - mxComplexity flag = mxREAL, bool init = true); - - mxArray (mxClassID id, const dim_vector& dv, mxComplexity flag = mxREAL); - - mxArray (mxClassID id, mwSize m, mwSize n, - mxComplexity flag = mxREAL, bool init = true); - - mxArray (mxClassID id, double val); - - mxArray (mxClassID id, mxLogical val); - - mxArray (const char *str); - - mxArray (mwSize m, const char **str); - - mxArray (mxClassID id, mwSize m, mwSize n, mwSize nzmax, - mxComplexity flag = mxREAL); - - mxArray (mwSize ndims, const mwSize *dims, int num_keys, const char **keys); - - mxArray (const dim_vector& dv, int num_keys, const char **keys); - - mxArray (mwSize m, mwSize n, int num_keys, const char **keys); - - mxArray (mwSize ndims, const mwSize *dims); - - mxArray (const dim_vector& dv); - - mxArray (mwSize m, mwSize n); - - mxArray * dup (void) const - { - mxArray *retval = rep->as_mxArray (); - - if (retval) - retval->set_name (name); - else - { - mxArray_base *new_rep = rep->dup (); - - retval = new mxArray (new_rep, name); - } - - return retval; - } - - // No copying! - - mxArray (const mxArray&) = delete; - - mxArray& operator = (const mxArray&) = delete; - - ~mxArray (void); - - bool is_octave_value (void) const { return rep->is_octave_value (); } - - int iscell (void) const { return rep->iscell (); } - - int is_char (void) const { return rep->is_char (); } - - int is_class (const char *name_arg) const { return rep->is_class (name_arg); } - - int is_complex (void) const { return rep->is_complex (); } - - int is_double (void) const { return rep->is_double (); } - - int is_function_handle (void) const { return rep->is_function_handle (); } - - int is_int16 (void) const { return rep->is_int16 (); } - - int is_int32 (void) const { return rep->is_int32 (); } - - int is_int64 (void) const { return rep->is_int64 (); } - - int is_int8 (void) const { return rep->is_int8 (); } - - int is_logical (void) const { return rep->is_logical (); } - - int is_numeric (void) const { return rep->is_numeric (); } - - int is_single (void) const { return rep->is_single (); } - - int is_sparse (void) const { return rep->is_sparse (); } - - int is_struct (void) const { return rep->is_struct (); } - - int is_uint16 (void) const { return rep->is_uint16 (); } - - int is_uint32 (void) const { return rep->is_uint32 (); } - - int is_uint64 (void) const { return rep->is_uint64 (); } - - int is_uint8 (void) const { return rep->is_uint8 (); } - - int is_logical_scalar (void) const { return rep->is_logical_scalar (); } - - int is_logical_scalar_true (void) const - { return rep->is_logical_scalar_true (); } - - mwSize get_m (void) const { return rep->get_m (); } - - mwSize get_n (void) const { return rep->get_n (); } - - mwSize * get_dimensions (void) const { return rep->get_dimensions (); } - - mwSize get_number_of_dimensions (void) const - { return rep->get_number_of_dimensions (); } - - void set_m (mwSize m) { DO_VOID_MUTABLE_METHOD (set_m (m)); } - - void set_n (mwSize n) { DO_VOID_MUTABLE_METHOD (set_n (n)); } - - int set_dimensions (mwSize *dims_arg, mwSize ndims_arg) - { DO_MUTABLE_METHOD (int, set_dimensions (dims_arg, ndims_arg)); } - - mwSize get_number_of_elements (void) const - { return rep->get_number_of_elements (); } - - int isempty (void) const { return get_number_of_elements () == 0; } - - bool is_scalar (void) const { return rep->is_scalar (); } - - const char * get_name (void) const { return name; } - - void set_name (const char *name_arg); - - mxClassID get_class_id (void) const { return rep->get_class_id (); } - - const char * get_class_name (void) const { return rep->get_class_name (); } - - mxArray * get_property (mwIndex idx, const char *pname) const - { return rep->get_property (idx, pname); } - - void set_property (mwIndex idx, const char *pname, const mxArray *pval) - { rep->set_property (idx, pname, pval); } - - void set_class_name (const char *name_arg) - { DO_VOID_MUTABLE_METHOD (set_class_name (name_arg)); } - - mxArray * get_cell (mwIndex idx) const - { DO_MUTABLE_METHOD (mxArray *, get_cell (idx)); } - - void set_cell (mwIndex idx, mxArray *val) - { DO_VOID_MUTABLE_METHOD (set_cell (idx, val)); } - - double get_scalar (void) const { return rep->get_scalar (); } - - void * get_data (void) const { DO_MUTABLE_METHOD (void *, get_data ()); } - - void * get_imag_data (void) const - { DO_MUTABLE_METHOD (void *, get_imag_data ()); } - - void set_data (void *pr) { DO_VOID_MUTABLE_METHOD (set_data (pr)); } - - void set_imag_data (void *pi) { DO_VOID_MUTABLE_METHOD (set_imag_data (pi)); } - - mwIndex * get_ir (void) const { DO_MUTABLE_METHOD (mwIndex *, get_ir ()); } - - mwIndex * get_jc (void) const { DO_MUTABLE_METHOD (mwIndex *, get_jc ()); } - - mwSize get_nzmax (void) const { return rep->get_nzmax (); } - - void set_ir (mwIndex *ir) { DO_VOID_MUTABLE_METHOD (set_ir (ir)); } - - void set_jc (mwIndex *jc) { DO_VOID_MUTABLE_METHOD (set_jc (jc)); } - - void set_nzmax (mwSize nzmax) { DO_VOID_MUTABLE_METHOD (set_nzmax (nzmax)); } - - int add_field (const char *key) { DO_MUTABLE_METHOD (int, add_field (key)); } - - void remove_field (int key_num) - { DO_VOID_MUTABLE_METHOD (remove_field (key_num)); } - - mxArray * get_field_by_number (mwIndex index, int key_num) const - { DO_MUTABLE_METHOD (mxArray *, get_field_by_number (index, key_num)); } - - void set_field_by_number (mwIndex index, int key_num, mxArray *val) - { DO_VOID_MUTABLE_METHOD (set_field_by_number (index, key_num, val)); } - - int get_number_of_fields (void) const { return rep->get_number_of_fields (); } - - const char * get_field_name_by_number (int key_num) const - { DO_MUTABLE_METHOD (const char*, get_field_name_by_number (key_num)); } - - int get_field_number (const char *key) const - { DO_MUTABLE_METHOD (int, get_field_number (key)); } - - int get_string (char *buf, mwSize buflen) const - { return rep->get_string (buf, buflen); } - - char * array_to_string (void) const { return rep->array_to_string (); } - - mwIndex calc_single_subscript (mwSize nsubs, mwIndex *subs) const - { return rep->calc_single_subscript (nsubs, subs); } - - size_t get_element_size (void) const { return rep->get_element_size (); } - - bool mutation_needed (void) const { return rep->mutation_needed (); } - - mxArray * mutate (void) const { return rep->mutate (); } - - static void * malloc (size_t n); - - static void * calloc (size_t n, size_t t); - - static char * strsave (const char *str) - { - char *retval = nullptr; - - if (str) - { - mwSize sz = sizeof (mxChar) * (strlen (str) + 1); - - retval = static_cast (mxArray::malloc (sz)); - - if (retval) - strcpy (retval, str); - } - - return retval; - } - - static octave_value - as_octave_value (const mxArray *ptr, bool null_is_empty = true); - - octave_value as_octave_value (void) const; - -private: - - mutable mxArray_base *rep; - - char *name; - - mxArray (mxArray_base *r, const char *n) - : rep (r), name (mxArray::strsave (n)) { } - - void maybe_mutate (void) const; -}; - -#undef DO_MUTABLE_METHOD -#undef DO_VOID_MUTABLE_METHOD - -#endif -#endif diff -r 865f8ddb2c78 -r 4963f23b145c libinterp/corefcn/mxtypes.in.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libinterp/corefcn/mxtypes.in.h Tue Feb 18 12:34:04 2020 -0500 @@ -0,0 +1,128 @@ +// %NO_EDIT_WARNING% + +//////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 2001-2020 The Octave Project Developers +// +// See the file COPYRIGHT.md in the top-level directory of this +// distribution or . +// +// This file is part of Octave. +// +// Octave is free software: you can redistribute it and/or modify it +// under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Octave is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Octave; see the file COPYING. If not, see +// . +// +//////////////////////////////////////////////////////////////////////// + +/* + +Part of this code was originally distributed as part of Octave Forge under +the following terms: + +Author: Paul Kienzle +I grant this code to the public domain. +2001-03-22 + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. + +*/ + +#if ! defined (octave_mxtypes_h) +#define octave_mxtypes_h 1 + +#include "octave-config.h" + +typedef enum +{ + mxUNKNOWN_CLASS = 0, + mxCELL_CLASS, + mxSTRUCT_CLASS, + mxLOGICAL_CLASS, + mxCHAR_CLASS, + mxVOID_CLASS, + mxDOUBLE_CLASS, + mxSINGLE_CLASS, + mxINT8_CLASS, + mxUINT8_CLASS, + mxINT16_CLASS, + mxUINT16_CLASS, + mxINT32_CLASS, + mxUINT32_CLASS, + mxINT64_CLASS, + mxUINT64_CLASS, + mxFUNCTION_CLASS +} +mxClassID; + +typedef enum +{ + mxREAL = 0, + mxCOMPLEX = 1 +} +mxComplexity; + +/* Matlab uses a wide char (uint16) internally, but Octave uses plain char. */ +/* typedef Uint16 mxChar; */ +typedef char mxChar; + +typedef unsigned char mxLogical; + +typedef double mxDouble; +typedef float mxSingle; + +typedef int8_t mxInt8; +typedef int16_t mxInt16; +typedef int32_t mxInt32; +typedef int64_t mxInt64; + +typedef uint8_t mxUint8; +typedef uint16_t mxUint16; +typedef uint32_t mxUint32; +typedef uint64_t mxUint64; + +typedef struct { mxDouble real; mxDouble imag; } mxComplexDouble; +typedef struct { mxSingle real; mxSingle imag; } mxComplexSingle; + +/* We don't have these yet but we can define the types. */ +typedef struct { mxInt8 real; mxInt8 imag; } mxComplexInt8; +typedef struct { mxInt16 real; mxInt16 imag; } mxComplexInt16; +typedef struct { mxInt32 real; mxInt32 imag; } mxComplexInt32; +typedef struct { mxInt64 real; mxInt64 imag; } mxComplexInt64; + +typedef struct { mxUint8 real; mxUint8 imag; } mxComplexUint8; +typedef struct { mxUint16 real; mxUint16 imag; } mxComplexUint16; +typedef struct { mxUint32 real; mxUint32 imag; } mxComplexUint32; +typedef struct { mxUint64 real; mxUint64 imag; } mxComplexUint64; + +/* + * FIXME: Mathworks says mwSize, mwIndex should be int generally. + * But on 64-bit systems, or when mex -largeArrayDims is used, it is size_t. + * mwSignedIndex is supposed to be ptrdiff_t. All of this is confusing. + * Its better to conform to the same indexing as the rest of Octave. + */ +typedef %OCTAVE_IDX_TYPE% mwSize; +typedef %OCTAVE_IDX_TYPE% mwIndex; +typedef %OCTAVE_IDX_TYPE% mwSignedIndex; + +#endif diff -r 865f8ddb2c78 -r 4963f23b145c libinterp/module.mk --- a/libinterp/module.mk Fri Feb 21 11:52:08 2020 -0500 +++ b/libinterp/module.mk Tue Feb 18 12:34:04 2020 -0500 @@ -33,7 +33,7 @@ %reldir%/corefcn/default-defs.h \ %reldir%/corefcn/graphics-props.cc \ %reldir%/corefcn/graphics.h \ - %reldir%/corefcn/mxarray.h \ + %reldir%/corefcn/mxtypes.h \ %reldir%/corefcn/oct-tex-parser.h \ %reldir%/corefcn/oct-tex-symbols.cc \ %reldir%/parse-tree/oct-gperf.h \ @@ -66,7 +66,7 @@ %reldir%/corefcn/default-defs.h \ %reldir%/corefcn/graphics-props.cc \ %reldir%/corefcn/graphics.h \ - %reldir%/corefcn/mxarray.h \ + %reldir%/corefcn/mxtypes.h \ %reldir%/corefcn/oct-errno.cc \ %reldir%/liboctinterp-build-info.cc \ %reldir%/operators/ops.cc @@ -99,7 +99,7 @@ %reldir%/builtin-defun-decls.h \ %reldir%/corefcn/graphics-props.cc \ %reldir%/corefcn/graphics.h \ - %reldir%/corefcn/mxarray.h + %reldir%/corefcn/mxtypes.h DIST_SRC += \ %reldir%/octave.cc \ @@ -129,7 +129,7 @@ %reldir%/builtins.cc \ %reldir%/corefcn/default-defs.h \ %reldir%/corefcn/graphics.h \ - %reldir%/corefcn/mxarray.h \ + %reldir%/corefcn/mxtypes.h \ %reldir%/corefcn/oct-errno.cc \ %reldir%/liboctinterp-build-info.cc \ %reldir%/operators/ops.cc diff -r 865f8ddb2c78 -r 4963f23b145c libinterp/octave-value/ov.h --- a/libinterp/octave-value/ov.h Fri Feb 21 11:52:08 2020 -0500 +++ b/libinterp/octave-value/ov.h Tue Feb 18 12:34:04 2020 -0500 @@ -60,6 +60,8 @@ class octave_fcn_inline; class octave_value_list; +#include "mxtypes.h" + #include "oct-stream.h" #include "ov-base.h"