Mercurial > octave

changeset 22465:6149f6b34cbc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Change all mxIs* functions in MEX API to return bool rather than int. * bootstrap.conf: Add stdbool to the list of gnulib modules needed. * mex.h: Remove CPP code to typedef int to bool when bool does not exist. * mexproto.h: #include <stdbool.h> when using a C compiler. Change all prototypes of mxIs* functions to return bool. * mex.cc: Change all implementations of mxIs* functions to return bool.
author Rik <rik@octave.org>
date Sun, 11 Sep 2016 08:20:53 -0700
parents 1d2960b5efe6
children 7eaa642810f7
files bootstrap.conf libinterp/corefcn/mex.cc libinterp/corefcn/mex.h libinterp/corefcn/mexproto.h
diffstat 4 files changed, 54 insertions(+), 64 deletions(-) [+]
line wrap: on
line diff
--- a/bootstrap.conf	Sun Sep 11 07:58:42 2016 -0700
+++ b/bootstrap.conf	Sun Sep 11 08:20:53 2016 -0700
@@ -71,6 +71,7 @@
   sigprocmask
   stat
   std-gnu11
+  stdbool
   stddef
   stdio
   strdup
--- a/libinterp/corefcn/mex.cc	Sun Sep 11 07:58:42 2016 -0700
+++ b/libinterp/corefcn/mex.cc	Sun Sep 11 08:20:53 2016 -0700
@@ -2394,19 +2394,19 @@
 
 // Floating point predicates.
 
-int
+bool
 mxIsFinite (const double v)
 {
   return lo_ieee_finite (v) != 0;
 }
 
-int
+bool
 mxIsInf (const double v)
 {
   return lo_ieee_isinf (v) != 0;
 }
 
-int
+bool
 mxIsNaN (const double v)
 {
   return lo_ieee_isnan (v) != 0;
@@ -2595,136 +2595,136 @@
 }
 
 // Type Predicates.
-int
+bool
 mxIsCell (const mxArray *ptr)
 {
   return ptr->is_cell ();
 }
 
-int
+bool
 mxIsChar (const mxArray *ptr)
 {
   return ptr->is_char ();
 }
 
-int
+bool
 mxIsClass (const mxArray *ptr, const char *name)
 {
   return ptr->is_class (name);
 }
 
-int
+bool
 mxIsComplex (const mxArray *ptr)
 {
   return ptr->is_complex ();
 }
 
-int
+bool
 mxIsDouble (const mxArray *ptr)
 {
   return ptr->is_double ();
 }
 
-int
+bool
 mxIsFunctionHandle (const mxArray *ptr)
 {
   return ptr->is_function_handle ();
 }
 
-int
+bool
 mxIsInt16 (const mxArray *ptr)
 {
   return ptr->is_int16 ();
 }
 
-int
+bool
 mxIsInt32 (const mxArray *ptr)
 {
   return ptr->is_int32 ();
 }
 
-int
+bool
 mxIsInt64 (const mxArray *ptr)
 {
   return ptr->is_int64 ();
 }
 
-int
+bool
 mxIsInt8 (const mxArray *ptr)
 {
   return ptr->is_int8 ();
 }
 
-int
+bool
 mxIsLogical (const mxArray *ptr)
 {
   return ptr->is_logical ();
 }
 
-int
+bool
 mxIsNumeric (const mxArray *ptr)
 {
   return ptr->is_numeric ();
 }
 
-int
+bool
 mxIsSingle (const mxArray *ptr)
 {
   return ptr->is_single ();
 }
 
-int
+bool
 mxIsSparse (const mxArray *ptr)
 {
   return ptr->is_sparse ();
 }
 
-int
+bool
 mxIsStruct (const mxArray *ptr)
 {
   return ptr->is_struct ();
 }
 
-int
+bool
 mxIsUint16 (const mxArray *ptr)
 {
   return ptr->is_uint16 ();
 }
 
-int
+bool
 mxIsUint32 (const mxArray *ptr)
 {
   return ptr->is_uint32 ();
 }
 
-int
+bool
 mxIsUint64 (const mxArray *ptr)
 {
   return ptr->is_uint64 ();
 }
 
-int
+bool
 mxIsUint8 (const mxArray *ptr)
 {
   return ptr->is_uint8 ();
 }
 
 // Odd type+size predicate.
-int
+bool
 mxIsLogicalScalar (const mxArray *ptr)
 {
   return ptr->is_logical_scalar ();
 }
 
 // Odd type+size+value predicate.
-int
+bool
 mxIsLogicalScalarTrue (const mxArray *ptr)
 {
   return ptr->is_logical_scalar_true ();
 }
 
 // Size predicate.
-int
+bool
 mxIsEmpty (const mxArray *ptr)
 {
   return ptr->is_empty ();
@@ -2738,7 +2738,7 @@
 
 // FIXME: Just plain odd thing to ask of a value.
 // Still, Octave is incompatible because it does not implement this.
-int
+bool
 mxIsFromGlobalWS (const mxArray * /*ptr*/)
 {
   mexErrMsgTxt ("mxIsFromGlobalWS() is unimplemented");
--- a/libinterp/corefcn/mex.h	Sun Sep 11 07:58:42 2016 -0700
+++ b/libinterp/corefcn/mex.h	Sun Sep 11 08:20:53 2016 -0700
@@ -54,18 +54,6 @@
 
 typedef void mxArray;
 
-#if ! defined (__cplusplus) && ! defined (__bool_true_false_are_defined)
-#  if ! defined (bool)
-typedef int bool;
-#  endif
-#  if ! defined (true)
-#    define true 1
-#  endif
-#  if ! defined (false)
-#    define false 0
-#  endif
-#endif
-
 /* -V4 stuff */
 #if defined (V4)
 #  define Matrix mxArray
--- a/libinterp/corefcn/mexproto.h	Sun Sep 11 07:58:42 2016 -0700
+++ b/libinterp/corefcn/mexproto.h	Sun Sep 11 08:20:53 2016 -0700
@@ -55,6 +55,7 @@
 extern "C" {
 #else
 #  include <stdlib.h>
+#  include <stdbool.h>
 #endif
 
 /* The definition of OCTINTERP_API is normally provided by Octave's
@@ -123,9 +124,9 @@
 extern OCTINTERP_API int mexAtExit (void (*f) (void));
 
 /* Floating point predicates.  */
-extern OCTINTERP_API int mxIsFinite (double v);
-extern OCTINTERP_API int mxIsInf (double v);
-extern OCTINTERP_API int mxIsNaN (double v);
+extern OCTINTERP_API bool mxIsFinite (double v);
+extern OCTINTERP_API bool mxIsInf (double v);
+extern OCTINTERP_API bool mxIsNaN (double v);
 
 /* Floating point values.  */
 extern OCTINTERP_API double mxGetEps (void);
@@ -188,38 +189,38 @@
 extern OCTINTERP_API void mxDestroyArray (mxArray *v);
 
 /* Type Predicates.  */
-extern OCTINTERP_API int mxIsCell (const mxArray *ptr);
-extern OCTINTERP_API int mxIsChar (const mxArray *ptr);
-extern OCTINTERP_API int mxIsClass (const mxArray *ptr, const char *name);
-extern OCTINTERP_API int mxIsComplex (const mxArray *ptr);
-extern OCTINTERP_API int mxIsDouble (const mxArray *ptr);
-extern OCTINTERP_API int mxIsFunctionHandle (const mxArray *ptr);
-extern OCTINTERP_API int mxIsInt16 (const mxArray *ptr);
-extern OCTINTERP_API int mxIsInt32 (const mxArray *ptr);
-extern OCTINTERP_API int mxIsInt64 (const mxArray *ptr);
-extern OCTINTERP_API int mxIsInt8 (const mxArray *ptr);
-extern OCTINTERP_API int mxIsLogical (const mxArray *ptr);
-extern OCTINTERP_API int mxIsNumeric (const mxArray *ptr);
-extern OCTINTERP_API int mxIsSingle (const mxArray *ptr);
-extern OCTINTERP_API int mxIsSparse (const mxArray *ptr);
-extern OCTINTERP_API int mxIsStruct (const mxArray *ptr);
-extern OCTINTERP_API int mxIsUint16 (const mxArray *ptr);
-extern OCTINTERP_API int mxIsUint32 (const mxArray *ptr);
-extern OCTINTERP_API int mxIsUint64 (const mxArray *ptr);
-extern OCTINTERP_API int mxIsUint8 (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsCell (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsChar (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsClass (const mxArray *ptr, const char *name);
+extern OCTINTERP_API bool mxIsComplex (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsDouble (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsFunctionHandle (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsInt16 (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsInt32 (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsInt64 (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsInt8 (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsLogical (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsNumeric (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsSingle (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsSparse (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsStruct (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsUint16 (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsUint32 (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsUint64 (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsUint8 (const mxArray *ptr);
 
 /* Odd type+size predicate.  */
-extern OCTINTERP_API int mxIsLogicalScalar (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsLogicalScalar (const mxArray *ptr);
 
 /* Odd type+size+value predicate.  */
-extern OCTINTERP_API int mxIsLogicalScalarTrue (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsLogicalScalarTrue (const mxArray *ptr);
 
 /* Size predicates.  */
-extern OCTINTERP_API int mxIsEmpty (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsEmpty (const mxArray *ptr);
 extern OCTINTERP_API bool mxIsScalar (const mxArray *ptr);
 
 /* Just plain odd thing to ask of a value.  */
-extern OCTINTERP_API int mxIsFromGlobalWS (const mxArray *ptr);
+extern OCTINTERP_API bool mxIsFromGlobalWS (const mxArray *ptr);
 
 /* Dimension extractors.  */
 extern OCTINTERP_API size_t mxGetM (const mxArray *ptr);