From e47b7b1880e8a0688cdad03ea5e449476bca38ca Mon Sep 17 00:00:00 2001 From: Alexei Sheplyakov Date: Mon, 22 Sep 2008 12:55:01 +0400 Subject: [PATCH] cl_{GV,SV}: use std::size_t for size of vectors (instead of obscure uintC). --- include/cln/GV.h | 27 +++--- include/cln/GV_complex.h | 4 +- include/cln/GV_integer.h | 12 +-- include/cln/GV_modinteger.h | 4 +- include/cln/GV_number.h | 6 +- include/cln/GV_rational.h | 4 +- include/cln/GV_real.h | 4 +- include/cln/SV.h | 11 ++- include/cln/SV_complex.h | 2 +- include/cln/SV_integer.h | 2 +- include/cln/SV_number.h | 8 +- include/cln/SV_rational.h | 2 +- include/cln/SV_real.h | 2 +- include/cln/SV_ringelt.h | 8 +- src/vector/cl_GV_I.cc | 118 +++++++++++------------ src/vector/cl_GV_I_copy.cc | 6 +- src/vector/cl_GV_number.cc | 28 +++--- src/vector/cl_GV_number_copy.cc | 6 +- src/vector/cl_SV_copy.cc | 6 +- src/vector/cl_SV_number.cc | 12 +-- src/vector/cl_SV_ringelt.cc | 12 +-- src/vector/output/cl_GV_number_aprint.cc | 4 +- src/vector/output/cl_SV_aprint.cc | 6 +- src/vector/output/cl_SV_number_aprint.cc | 4 +- 24 files changed, 150 insertions(+), 148 deletions(-) diff --git a/include/cln/GV.h b/include/cln/GV.h index d1f5377..338edfa 100644 --- a/include/cln/GV.h +++ b/include/cln/GV.h @@ -7,6 +7,7 @@ #include "cln/V.h" #include "cln/exception.h" #include +#include namespace cln { @@ -25,9 +26,9 @@ template struct cl_GV_vectorops; template class cl_GV_inner { protected: - uintC len; // number of elements + std::size_t len; // number of elements public: - uintC size() const; // number of elements + std::size_t size() const; // number of elements cl_GV_vectorops* vectorops; // get/set element const cl_GV_index operator[] (unsigned long index); const cl_GV_constindex operator[] (unsigned long index) const; @@ -39,7 +40,7 @@ public: const cl_GV_constindex operator[] (int index) const; public: /* ugh */ // Constructor. - cl_GV_inner (uintC l, cl_GV_vectorops* ops) : len (l), vectorops (ops) {} + cl_GV_inner (std::size_t l, cl_GV_vectorops* ops) : len (l), vectorops (ops) {} public: // Destructor. ~cl_GV_inner (); @@ -63,10 +64,10 @@ class cl_GV_index { // through []. public: cl_GV_inner* vec; - uintC index; + std::size_t index; operator T () const; // Constructor: - cl_GV_index (cl_GV_inner* v, uintC i) : vec (v), index (i) {} + cl_GV_index (cl_GV_inner* v, std::size_t i) : vec (v), index (i) {} // Assignment operator. void operator= (const T& x) const; #if (defined(__sparc__) || defined(__sparc64__) || defined(__mips__) || defined(__mips64__)) && !defined(__GNUC__) // maybe an SGI CC and Sun CC bug? @@ -88,10 +89,10 @@ class cl_GV_constindex { // through []. It lacks the assignment operator. public: const cl_GV_inner* vec; - uintC index; + std::size_t index; operator T () const; // Constructor: - cl_GV_constindex (const cl_GV_inner* v, uintC i) : vec (v), index (i) {} + cl_GV_constindex (const cl_GV_inner* v, std::size_t i) : vec (v), index (i) {} private: // No default constructor, assignment operator. cl_GV_constindex (); @@ -100,16 +101,16 @@ private: template struct cl_GV_vectorops { - const T (*element) (const cl_GV_inner* vec, uintC index); - void (*set_element) (cl_GV_inner* vec, uintC index, const T& x); + const T (*element) (const cl_GV_inner* vec, std::size_t index); + void (*set_element) (cl_GV_inner* vec, std::size_t index, const T& x); void (*do_delete) (cl_GV_inner* vec); - void (*copy_elements) (const cl_GV_inner* srcvec, uintC srcindex, cl_GV_inner* destvec, uintC destindex, uintC count); + void (*copy_elements) (const cl_GV_inner* srcvec, std::size_t srcindex, cl_GV_inner* destvec, std::size_t destindex, std::size_t count); }; // All member functions are inline. template -inline uintC cl_GV_inner::size() const +inline std::size_t cl_GV_inner::size() const { return len; } @@ -219,7 +220,7 @@ template struct cl_GV : public BASE { public: // Length. - uintC size() const + std::size_t size() const { return ((const cl_heap_GV *) this->pointer)->v.size(); } @@ -250,7 +251,7 @@ public: cl_GV& operator= (const cl_GV&); // Copy a piece of a vector into another vector. // (Both vectors must be of the same type. Overlapping not allowed.) - static void copy_elements (const cl_GV& src, uintC srcindex, cl_GV& dest, uintC destindex, uintC count) + static void copy_elements (const cl_GV& src, std::size_t srcindex, cl_GV& dest, std::size_t destindex, std::size_t count) { const cl_heap_GV * hsrc = (const cl_heap_GV *) src.pointer; cl_heap_GV * hdest = (cl_heap_GV *) dest.pointer; diff --git a/include/cln/GV_complex.h b/include/cln/GV_complex.h index d04205e..8939deb 100644 --- a/include/cln/GV_complex.h +++ b/include/cln/GV_complex.h @@ -19,7 +19,7 @@ public: // Constructors. cl_GV_N (); cl_GV_N (const cl_GV_N&); - explicit cl_GV_N (uintC len); + explicit cl_GV_N (std::size_t len); // Assignment operators. cl_GV_N& operator= (const cl_GV_N&); // Private pointer manipulations. @@ -28,7 +28,7 @@ public: }; inline cl_GV_N::cl_GV_N (const cl_GV_N& x) : cl_GV (as_cl_private_thing(x)) {} CL_DEFINE_ASSIGNMENT_OPERATOR(cl_GV_N,cl_GV_N) -inline cl_GV_N::cl_GV_N (uintC len) +inline cl_GV_N::cl_GV_N (std::size_t len) : cl_GV ((cl_heap_GV_N*) cl_make_heap_GV_number(len)) {} inline cl_GV_N::cl_GV_N () : cl_GV ((cl_heap_GV_N*) (cl_heap_GV_number*) cl_null_GV_number) {} diff --git a/include/cln/GV_integer.h b/include/cln/GV_integer.h index 3c5c88c..dcecfde 100644 --- a/include/cln/GV_integer.h +++ b/include/cln/GV_integer.h @@ -27,9 +27,9 @@ public: cl_GV_I (); cl_GV_I (const cl_GV_I&); // Create a vector of unconstrained integers. - explicit cl_GV_I (uintC len); + explicit cl_GV_I (std::size_t len); // Create a vector of m-bit integers (>=0, <2^m). - cl_GV_I (uintC len, sintC m); + cl_GV_I (std::size_t len, sintC m); // Assignment operators. cl_GV_I& operator= (const cl_GV_I&); // Number m of bits allowed per element (-1 if unconstrained). @@ -43,11 +43,11 @@ public: }; inline cl_GV_I::cl_GV_I (const cl_GV_I& x) : cl_GV (as_cl_private_thing(x)) {} CL_DEFINE_ASSIGNMENT_OPERATOR(cl_GV_I,cl_GV_I) -extern cl_heap_GV_I* cl_make_heap_GV_I (uintC len); -inline cl_GV_I::cl_GV_I (uintC len) +extern cl_heap_GV_I* cl_make_heap_GV_I (std::size_t len); +inline cl_GV_I::cl_GV_I (std::size_t len) : cl_GV (cl_make_heap_GV_I(len)) {} -extern cl_heap_GV_I* cl_make_heap_GV_I (uintC len, sintC m); -inline cl_GV_I::cl_GV_I (uintC len, sintC m) +extern cl_heap_GV_I* cl_make_heap_GV_I (std::size_t len, sintC m); +inline cl_GV_I::cl_GV_I (std::size_t len, sintC m) : cl_GV (cl_make_heap_GV_I(len,m)) {} // Private pointer manipulations. Never throw away a `struct cl_heap_GV_I *'! diff --git a/include/cln/GV_modinteger.h b/include/cln/GV_modinteger.h index 8929ef4..b86575a 100644 --- a/include/cln/GV_modinteger.h +++ b/include/cln/GV_modinteger.h @@ -24,7 +24,7 @@ public: cl_GV_MI (); cl_GV_MI (const cl_GV_MI&); // Create a vector of modular integers. - cl_GV_MI (uintC len, cl_heap_modint_ring* R); + cl_GV_MI (std::size_t len, cl_heap_modint_ring* R); // Assignment operators. cl_GV_MI& operator= (const cl_GV_MI&); // Number m of bits allowed per element (-1 if unconstrained). @@ -37,7 +37,7 @@ inline cl_GV_MI::cl_GV_MI (const cl_GV_MI& x) : cl_GV<_cl_MI,cl_GV_any> (as_cl_p CL_DEFINE_ASSIGNMENT_OPERATOR(cl_GV_MI,cl_GV_MI) inline cl_GV_MI::cl_GV_MI () : cl_GV<_cl_MI,cl_GV_any> ((cl_heap_GV_MI*) (cl_heap_GV_I*) cl_null_GV_I) {} -inline cl_GV_MI::cl_GV_MI (uintC len, cl_heap_modint_ring* R) +inline cl_GV_MI::cl_GV_MI (std::size_t len, cl_heap_modint_ring* R) : cl_GV<_cl_MI,cl_GV_any> ((cl_heap_GV_MI*) cl_make_heap_GV_I(len,R->bits)) {} // Copy a vector. diff --git a/include/cln/GV_number.h b/include/cln/GV_number.h index 10edc88..1e61199 100644 --- a/include/cln/GV_number.h +++ b/include/cln/GV_number.h @@ -15,7 +15,7 @@ public: // Constructors. cl_GV_number (); cl_GV_number (const cl_GV_number&); - explicit cl_GV_number (uintC len); + explicit cl_GV_number (std::size_t len); // Assignment operators. cl_GV_number& operator= (const cl_GV_number&); // Private pointer manipulations. @@ -24,8 +24,8 @@ public: }; inline cl_GV_number::cl_GV_number (const cl_GV_number& x) : cl_GV (as_cl_private_thing(x)) {} CL_DEFINE_ASSIGNMENT_OPERATOR(cl_GV_number,cl_GV_number) -extern cl_heap_GV_number* cl_make_heap_GV_number (uintC len); -inline cl_GV_number::cl_GV_number (uintC len) +extern cl_heap_GV_number* cl_make_heap_GV_number (std::size_t len); +inline cl_GV_number::cl_GV_number (std::size_t len) : cl_GV (cl_make_heap_GV_number(len)) {} // Private pointer manipulations. Never throw away a `struct cl_heap_GV_number *'! diff --git a/include/cln/GV_rational.h b/include/cln/GV_rational.h index 5aaa240..e1758a6 100644 --- a/include/cln/GV_rational.h +++ b/include/cln/GV_rational.h @@ -19,7 +19,7 @@ public: // Constructors. cl_GV_RA (); cl_GV_RA (const cl_GV_RA&); - explicit cl_GV_RA (uintC len); + explicit cl_GV_RA (std::size_t len); // Assignment operators. cl_GV_RA& operator= (const cl_GV_RA&); // Private pointer manipulations. @@ -28,7 +28,7 @@ public: }; inline cl_GV_RA::cl_GV_RA (const cl_GV_RA& x) : cl_GV (as_cl_private_thing(x)) {} CL_DEFINE_ASSIGNMENT_OPERATOR(cl_GV_RA,cl_GV_RA) -inline cl_GV_RA::cl_GV_RA (uintC len) +inline cl_GV_RA::cl_GV_RA (std::size_t len) : cl_GV ((cl_heap_GV_RA*) cl_make_heap_GV_number(len)) {} inline cl_GV_RA::cl_GV_RA () : cl_GV ((cl_heap_GV_RA*) (cl_heap_GV_number*) cl_null_GV_number) {} diff --git a/include/cln/GV_real.h b/include/cln/GV_real.h index a57c56f..1bc421f 100644 --- a/include/cln/GV_real.h +++ b/include/cln/GV_real.h @@ -19,7 +19,7 @@ public: // Constructors. cl_GV_R (); cl_GV_R (const cl_GV_R&); - explicit cl_GV_R (uintC len); + explicit cl_GV_R (std::size_t len); // Assignment operators. cl_GV_R& operator= (const cl_GV_R&); // Private pointer manipulations. @@ -28,7 +28,7 @@ public: }; inline cl_GV_R::cl_GV_R (const cl_GV_R& x) : cl_GV (as_cl_private_thing(x)) {} CL_DEFINE_ASSIGNMENT_OPERATOR(cl_GV_R,cl_GV_R) -inline cl_GV_R::cl_GV_R (uintC len) +inline cl_GV_R::cl_GV_R (std::size_t len) : cl_GV ((cl_heap_GV_R*) cl_make_heap_GV_number(len)) {} inline cl_GV_R::cl_GV_R () : cl_GV ((cl_heap_GV_R*) (cl_heap_GV_number*) cl_null_GV_number) {} diff --git a/include/cln/SV.h b/include/cln/SV.h index 64342cd..7c57614 100644 --- a/include/cln/SV.h +++ b/include/cln/SV.h @@ -7,6 +7,7 @@ #include "cln/V.h" #include "cln/exception.h" #include +#include namespace cln { @@ -40,13 +41,13 @@ template class cl_SV_inner; template class cl_SV_inner { protected: - uintC len; // number of elements + std::size_t len; // number of elements private: // T data[]; // the elements T * data() { return (T *) (this+1); } const T * data() const { return (const T *) (this+1); } public: - uintC size() const { return len; } // number of elements + std::size_t size() const { return len; } // number of elements const T & operator[] (unsigned long index) const { #ifndef CL_SV_NO_RANGECHECKS @@ -76,7 +77,7 @@ public: { return operator[]((unsigned long)index); } public: /* ugh */ // Constructor. - cl_SV_inner (uintC l) : len (l) {} + cl_SV_inner (std::size_t l) : len (l) {} public: // Destructor. ~cl_SV_inner (); @@ -95,7 +96,7 @@ private: template inline cl_SV_inner::~cl_SV_inner () { - uintC i = len; + std::size_t i = len; while (i > 0) { i--; data()[i].~T(); @@ -115,7 +116,7 @@ template struct cl_SV : public BASE { public: // Length. - uintC size() const + std::size_t size() const { return ((const cl_heap_SV *) this->pointer)->v.size(); } diff --git a/include/cln/SV_complex.h b/include/cln/SV_complex.h index 6e02727..fd2eca0 100644 --- a/include/cln/SV_complex.h +++ b/include/cln/SV_complex.h @@ -19,7 +19,7 @@ public: // Constructors. cl_SV_N () : cl_SV ((cl_heap_SV_N*) (cl_heap_SV_number*) cl_null_SV_number) {}; cl_SV_N (const cl_SV_N&); - explicit cl_SV_N (uintC len) : cl_SV ((cl_heap_SV_N*) cl_make_heap_SV_number(len)) {}; + explicit cl_SV_N (std::size_t len) : cl_SV ((cl_heap_SV_N*) cl_make_heap_SV_number(len)) {}; // Assignment operators. cl_SV_N& operator= (const cl_SV_N&); // Private pointer manipulations. diff --git a/include/cln/SV_integer.h b/include/cln/SV_integer.h index aca62cc..c747e97 100644 --- a/include/cln/SV_integer.h +++ b/include/cln/SV_integer.h @@ -19,7 +19,7 @@ public: // Constructors. cl_SV_I () : cl_SV ((cl_heap_SV_I*) (cl_heap_SV_number*) cl_null_SV_number) {}; cl_SV_I (const cl_SV_I&); - explicit cl_SV_I (uintC len) : cl_SV ((cl_heap_SV_I*) cl_make_heap_SV_number(len)) {}; + explicit cl_SV_I (std::size_t len) : cl_SV ((cl_heap_SV_I*) cl_make_heap_SV_number(len)) {}; // Assignment operators. cl_SV_I& operator= (const cl_SV_I&); }; diff --git a/include/cln/SV_number.h b/include/cln/SV_number.h index 8233f26..bb685bf 100644 --- a/include/cln/SV_number.h +++ b/include/cln/SV_number.h @@ -16,7 +16,7 @@ public: // Constructors. cl_SV_number (); cl_SV_number (const cl_SV_number&); - explicit cl_SV_number (uintC len); + explicit cl_SV_number (std::size_t len); // Assignment operators. cl_SV_number& operator= (const cl_SV_number&); // Private pointer manipulations. @@ -27,10 +27,10 @@ public: inline cl_SV_number::cl_SV_number (const cl_SV_number& x) : cl_SV (as_cl_private_thing(x)) {} CL_DEFINE_ASSIGNMENT_OPERATOR(cl_SV_number,cl_SV_number) // Returns a new simple vector with uninitialized contents. -extern cl_heap_SV_number* cl_make_heap_SV_number_uninit (uintC len); +extern cl_heap_SV_number* cl_make_heap_SV_number_uninit (std::size_t len); // Returns a new simple vector with all elements initialized to 0. -extern cl_heap_SV_number* cl_make_heap_SV_number (uintC len); -inline cl_SV_number::cl_SV_number (uintC len) +extern cl_heap_SV_number* cl_make_heap_SV_number (std::size_t len); +inline cl_SV_number::cl_SV_number (std::size_t len) : cl_SV (cl_make_heap_SV_number(len)) {} // Private pointer manipulations. Never throw away a `struct cl_heap_SV_number *'! diff --git a/include/cln/SV_rational.h b/include/cln/SV_rational.h index b7003f8..ac4e1ee 100644 --- a/include/cln/SV_rational.h +++ b/include/cln/SV_rational.h @@ -19,7 +19,7 @@ public: // Constructors. cl_SV_RA () : cl_SV ((cl_heap_SV_RA*) (cl_heap_SV_number*) cl_null_SV_number) {}; cl_SV_RA (const cl_SV_RA&); - explicit cl_SV_RA (uintC len) : cl_SV ((cl_heap_SV_RA*) cl_make_heap_SV_number(len)) {}; + explicit cl_SV_RA (std::size_t len) : cl_SV ((cl_heap_SV_RA*) cl_make_heap_SV_number(len)) {}; // Assignment operators. cl_SV_RA& operator= (const cl_SV_RA&); // Private pointer manipulations. diff --git a/include/cln/SV_real.h b/include/cln/SV_real.h index d297022..e3c7650 100644 --- a/include/cln/SV_real.h +++ b/include/cln/SV_real.h @@ -19,7 +19,7 @@ public: // Constructors. cl_SV_R () : cl_SV ((cl_heap_SV_R*) (cl_heap_SV_number*) cl_null_SV_number) {}; cl_SV_R (const cl_SV_R&); - explicit cl_SV_R (uintC len) : cl_SV ((cl_heap_SV_R*) cl_make_heap_SV_number(len)) {}; + explicit cl_SV_R (std::size_t len) : cl_SV ((cl_heap_SV_R*) cl_make_heap_SV_number(len)) {}; // Assignment operators. cl_SV_R& operator= (const cl_SV_R&); // Private pointer manipulations. diff --git a/include/cln/SV_ringelt.h b/include/cln/SV_ringelt.h index be05eff..2087e4c 100644 --- a/include/cln/SV_ringelt.h +++ b/include/cln/SV_ringelt.h @@ -16,7 +16,7 @@ public: // Constructors. cl_SV_ringelt (); cl_SV_ringelt (const cl_SV_ringelt&); - explicit cl_SV_ringelt (uintC len); + explicit cl_SV_ringelt (std::size_t len); // Assignment operators. cl_SV_ringelt& operator= (const cl_SV_ringelt&); // Private pointer manipulations. @@ -27,10 +27,10 @@ public: inline cl_SV_ringelt::cl_SV_ringelt (const cl_SV_ringelt& x) : cl_SV<_cl_ring_element,cl_SV_any> (as_cl_private_thing(x)) {} CL_DEFINE_ASSIGNMENT_OPERATOR(cl_SV_ringelt,cl_SV_ringelt) // Returns a new simple vector with uninitialized contents. -extern cl_heap_SV_ringelt* cl_make_heap_SV_ringelt_uninit (uintC len); +extern cl_heap_SV_ringelt* cl_make_heap_SV_ringelt_uninit (std::size_t len); // Returns a new simple vector with all elements initialized to some value. -extern cl_heap_SV_ringelt* cl_make_heap_SV_ringelt (uintC len); -inline cl_SV_ringelt::cl_SV_ringelt (uintC len) +extern cl_heap_SV_ringelt* cl_make_heap_SV_ringelt (std::size_t len); +inline cl_SV_ringelt::cl_SV_ringelt (std::size_t len) : cl_SV<_cl_ring_element,cl_SV_any> (cl_make_heap_SV_ringelt(len)) {} // Private pointer manipulations. diff --git a/src/vector/cl_GV_I.cc b/src/vector/cl_GV_I.cc index 51a9b9c..3a54560 100644 --- a/src/vector/cl_GV_I.cc +++ b/src/vector/cl_GV_I.cc @@ -80,33 +80,33 @@ struct cl_heap_GV_I_general : public cl_heap_GV_I { cl_heap_GV_I_general (); }; -static const cl_I general_element (const cl_GV_inner* vec, uintC index) +static const cl_I general_element (const cl_GV_inner* vec, std::size_t index) { return ((const cl_heap_GV_I_general *) outcast(vec))->data[index]; } -static void general_set_element (cl_GV_inner* vec, uintC index, const cl_I& x) +static void general_set_element (cl_GV_inner* vec, std::size_t index, const cl_I& x) { ((cl_heap_GV_I_general *) outcast(vec))->data[index] = x; } static void general_do_delete (cl_GV_inner* vec) { - var cl_heap_GV_I_general* hv = (cl_heap_GV_I_general *) outcast(vec); - var uintC len = hv->v.size(); - for (var uintC i = 0; i < len; i++) + cl_heap_GV_I_general* hv = (cl_heap_GV_I_general *) outcast(vec); + std::size_t len = hv->v.size(); + for (std::size_t i = 0; i < len; i++) hv->data[i].~cl_I(); } -static void general_copy_elements (const cl_GV_inner* srcvec, uintC srcindex, cl_GV_inner* destvec, uintC destindex, uintC count) +static void general_copy_elements (const cl_GV_inner* srcvec, std::size_t srcindex, cl_GV_inner* destvec, std::size_t destindex, std::size_t count) { if (count > 0) { - var const cl_heap_GV_I_general* srcv = + const cl_heap_GV_I_general* srcv = (const cl_heap_GV_I_general *) outcast(srcvec); - var cl_heap_GV_I_general* destv = + cl_heap_GV_I_general* destv = (cl_heap_GV_I_general *) outcast(destvec); - var uintC srclen = srcv->v.size(); - var uintC destlen = destv->v.size(); + std::size_t srclen = srcv->v.size(); + std::size_t destlen = destv->v.size(); if (!(srcindex <= srcindex+count && srcindex+count <= srclen)) throw runtime_exception(); if (!(destindex <= destindex+count && destindex+count <= destlen)) @@ -125,13 +125,13 @@ static cl_GV_I_vectorops general_vectorops = {{ -1 }; -cl_heap_GV_I* cl_make_heap_GV_I (uintC len) +cl_heap_GV_I* cl_make_heap_GV_I (std::size_t len) { - var cl_heap_GV_I_general* hv = (cl_heap_GV_I_general*) malloc_hook(offsetofa(cl_heap_GV_I_general,data)+sizeof(cl_I)*len); + cl_heap_GV_I_general* hv = (cl_heap_GV_I_general*) malloc_hook(offsetofa(cl_heap_GV_I_general,data)+sizeof(cl_I)*len); hv->refcount = 1; hv->type = &cl_class_gvector_integer(); new (&hv->v) cl_GV_inner (len,&general_vectorops.ops); - for (var uintC i = 0; i < len; i++) + for (std::size_t i = 0; i < len; i++) init1(cl_I, hv->data[i]) (); return hv; } @@ -149,24 +149,24 @@ struct cl_heap_GV_I_bits##m : public cl_heap_GV_I { \ /* No default constructor. */ \ cl_heap_GV_I_bits##m (); \ }; \ -static const cl_I bits##m##_element (const cl_GV_inner* vec, uintC index); \ -static void bits##m##_set_element (cl_GV_inner* vec, uintC index, const cl_I& x); \ -static void bits##m##_copy_elements (const cl_GV_inner* srcvec, uintC srcindex, cl_GV_inner* destvec, uintC destindex, uintC count) \ +static const cl_I bits##m##_element (const cl_GV_inner* vec, std::size_t index); \ +static void bits##m##_set_element (cl_GV_inner* vec, std::size_t index, const cl_I& x); \ +static void bits##m##_copy_elements (const cl_GV_inner* srcvec, std::size_t srcindex, cl_GV_inner* destvec, std::size_t destindex, std::size_t count) \ { \ if (count > 0) { \ - var const cl_heap_GV_I_bits##m * srcv = \ + const cl_heap_GV_I_bits##m * srcv = \ (const cl_heap_GV_I_bits##m *) outcast(srcvec); \ - var cl_heap_GV_I_bits##m * destv = \ + cl_heap_GV_I_bits##m * destv = \ (cl_heap_GV_I_bits##m *) outcast(destvec); \ - var uintC srclen = srcv->v.size(); \ - var uintC destlen = destv->v.size(); \ + std::size_t srclen = srcv->v.size(); \ + std::size_t destlen = destv->v.size(); \ if (!(srcindex <= srcindex+count && srcindex+count <= srclen)) \ throw runtime_exception(); \ if (!(destindex <= destindex+count && destindex+count <= destlen)) \ throw runtime_exception(); \ if (m == intDsize) { \ - var const uintD* srcptr = &srcv->data[srcindex]; \ - var uintD* destptr = &destv->data[destindex]; \ + const uintD* srcptr = &srcv->data[srcindex]; \ + uintD* destptr = &destv->data[destindex]; \ do { \ *destptr++ = *srcptr++; \ } while (--count > 0); \ @@ -189,7 +189,7 @@ static void bits_do_delete (cl_GV_inner* vec) // Copy bits srcptr.bits[srcindex..srcindex+count-1] into destptr.bits[destindex..destindex+count-1]. // Assumes that all range checks have already been performed. -static void bits_copy (const uintD* srcptr, uintC srcindex, uintD* destptr, uintC destindex, uintC count) +static void bits_copy (const uintD* srcptr, std::size_t srcindex, uintD* destptr, std::size_t destindex, std::size_t count) { srcptr += floor(srcindex,intDsize); destptr += floor(destindex,intDsize); @@ -209,7 +209,7 @@ static void bits_copy (const uintD* srcptr, uintC srcindex, uintD* destptr, uint count -= intDsize-srcindex; } // Now srcindex and destindex can be assumed to be 0. - var uintC count1 = count%intDsize; + std::size_t count1 = count%intDsize; count = floor(count,intDsize); if (count > 0) { do { @@ -220,8 +220,8 @@ static void bits_copy (const uintD* srcptr, uintC srcindex, uintD* destptr, uint *destptr ^= (*destptr ^ *srcptr) & (uintD)(bit(count1)-1); } } else { - var uintC i = destindex - srcindex; - var uintD tmp; + std::size_t i = destindex - srcindex; + uintD tmp; if (destindex >= srcindex) { // i > 0 if (count <= intDsize-destindex) { *destptr ^= (*destptr ^ (*srcptr << i)) & ((uintD)(bit(count)-1) << destindex); @@ -242,9 +242,9 @@ static void bits_copy (const uintD* srcptr, uintC srcindex, uintD* destptr, uint } srcptr++; // tmp now contains the low i bits to be put into *destptr. - var uintC count1 = count%intDsize; + std::size_t count1 = count%intDsize; count = floor(count,intDsize); - var uintD lastdest; + uintD lastdest; if (count == 0) lastdest = tmp; else { @@ -280,17 +280,17 @@ static void bits_copy (const uintD* srcptr, uintC srcindex, uintD* destptr, uint DEFINE_cl_heap_GV_I_bits(1,uintD) -static const cl_I bits1_element (const cl_GV_inner* vec, uintC index) +static const cl_I bits1_element (const cl_GV_inner* vec, std::size_t index) { return (unsigned int)((((const cl_heap_GV_I_bits1 *) outcast(vec))->data[index/intDsize] >> (index%intDsize)) & 0x1); } -static void bits1_set_element (cl_GV_inner* vec, uintC index, const cl_I& x) +static void bits1_set_element (cl_GV_inner* vec, std::size_t index, const cl_I& x) { - var uintV xval; + uintV xval; if (fixnump(x)) { xval = FN_to_UV(x); if (xval <= 0x1) { - var uintD* ptr = &((cl_heap_GV_I_bits1 *) outcast(vec))->data[index/intDsize]; + uintD* ptr = &((cl_heap_GV_I_bits1 *) outcast(vec))->data[index/intDsize]; index = index%intDsize; *ptr = *ptr ^ ((*ptr ^ ((uintD)xval << index)) & ((uintD)0x1 << index)); return; @@ -302,17 +302,17 @@ static void bits1_set_element (cl_GV_inner* vec, uintC index, const cl_I& DEFINE_cl_heap_GV_I_bits(2,uintD) -static const cl_I bits2_element (const cl_GV_inner* vec, uintC index) +static const cl_I bits2_element (const cl_GV_inner* vec, std::size_t index) { return (unsigned int)((((const cl_heap_GV_I_bits2 *) outcast(vec))->data[index/(intDsize/2)] >> (2*(index%(intDsize/2)))) & 0x3); } -static void bits2_set_element (cl_GV_inner* vec, uintC index, const cl_I& x) +static void bits2_set_element (cl_GV_inner* vec, std::size_t index, const cl_I& x) { - var uintV xval; + uintV xval; if (fixnump(x)) { xval = FN_to_UV(x); if (xval <= 0x3) { - var uintD* ptr = &((cl_heap_GV_I_bits2 *) outcast(vec))->data[index/(intDsize/2)]; + uintD* ptr = &((cl_heap_GV_I_bits2 *) outcast(vec))->data[index/(intDsize/2)]; index = 2*(index%(intDsize/2)); *ptr = *ptr ^ ((*ptr ^ ((uintD)xval << index)) & ((uintD)0x3 << index)); return; @@ -324,17 +324,17 @@ static void bits2_set_element (cl_GV_inner* vec, uintC index, const cl_I& DEFINE_cl_heap_GV_I_bits(4,uintD) -static const cl_I bits4_element (const cl_GV_inner* vec, uintC index) +static const cl_I bits4_element (const cl_GV_inner* vec, std::size_t index) { return (unsigned int)((((const cl_heap_GV_I_bits4 *) outcast(vec))->data[index/(intDsize/4)] >> (4*(index%(intDsize/4)))) & 0xF); } -static void bits4_set_element (cl_GV_inner* vec, uintC index, const cl_I& x) +static void bits4_set_element (cl_GV_inner* vec, std::size_t index, const cl_I& x) { - var uintV xval; + uintV xval; if (fixnump(x)) { xval = FN_to_UV(x); if (xval <= 0xF) { - var uintD* ptr = &((cl_heap_GV_I_bits4 *) outcast(vec))->data[index/(intDsize/4)]; + uintD* ptr = &((cl_heap_GV_I_bits4 *) outcast(vec))->data[index/(intDsize/4)]; index = 4*(index%(intDsize/4)); *ptr = *ptr ^ ((*ptr ^ ((uintD)xval << index)) & ((uintD)0xF << index)); return; @@ -346,7 +346,7 @@ static void bits4_set_element (cl_GV_inner* vec, uintC index, const cl_I& DEFINE_cl_heap_GV_I_bits(8,uintD) -static const cl_I bits8_element (const cl_GV_inner* vec, uintC index) +static const cl_I bits8_element (const cl_GV_inner* vec, std::size_t index) { #if CL_CPU_BIG_ENDIAN_P return (unsigned int)((((const cl_heap_GV_I_bits8 *) outcast(vec))->data[index/(intDsize/8)] >> (8*(index%(intDsize/8)))) & 0xFF); @@ -355,14 +355,14 @@ static const cl_I bits8_element (const cl_GV_inner* vec, uintC index) return (unsigned int)(((uint8*)(((const cl_heap_GV_I_bits8 *) outcast(vec))->data))[index]); #endif } -static void bits8_set_element (cl_GV_inner* vec, uintC index, const cl_I& x) +static void bits8_set_element (cl_GV_inner* vec, std::size_t index, const cl_I& x) { - var uintV xval; + uintV xval; if (fixnump(x)) { xval = FN_to_UV(x); if (xval <= 0xFF) { #if CL_CPU_BIG_ENDIAN_P - var uintD* ptr = &((cl_heap_GV_I_bits8 *) outcast(vec))->data[index/(intDsize/8)]; + uintD* ptr = &((cl_heap_GV_I_bits8 *) outcast(vec))->data[index/(intDsize/8)]; index = 8*(index%(intDsize/8)); *ptr = *ptr ^ ((*ptr ^ ((uintD)xval << index)) & ((uintD)0xFF << index)); #else @@ -378,7 +378,7 @@ static void bits8_set_element (cl_GV_inner* vec, uintC index, const cl_I& DEFINE_cl_heap_GV_I_bits(16,uintD) -static const cl_I bits16_element (const cl_GV_inner* vec, uintC index) +static const cl_I bits16_element (const cl_GV_inner* vec, std::size_t index) { #if CL_CPU_BIG_ENDIAN_P return (unsigned int)((((const cl_heap_GV_I_bits16 *) outcast(vec))->data[index/(intDsize/16)] >> (16*(index%(intDsize/16)))) & 0xFFFF); @@ -387,14 +387,14 @@ static const cl_I bits16_element (const cl_GV_inner* vec, uintC index) return (unsigned int)(((uint16*)(((const cl_heap_GV_I_bits16 *) outcast(vec))->data))[index]); #endif } -static void bits16_set_element (cl_GV_inner* vec, uintC index, const cl_I& x) +static void bits16_set_element (cl_GV_inner* vec, std::size_t index, const cl_I& x) { - var uintV xval; + uintV xval; if (fixnump(x)) { xval = FN_to_UV(x); if (xval <= 0xFFFF) { #if CL_CPU_BIG_ENDIAN_P - var uintD* ptr = &((cl_heap_GV_I_bits16 *) outcast(vec))->data[index/(intDsize/16)]; + uintD* ptr = &((cl_heap_GV_I_bits16 *) outcast(vec))->data[index/(intDsize/16)]; index = 16*(index%(intDsize/16)); *ptr = *ptr ^ ((*ptr ^ ((uintD)xval << index)) & ((uintD)0xFFFF << index)); #else @@ -410,7 +410,7 @@ static void bits16_set_element (cl_GV_inner* vec, uintC index, const cl_I& DEFINE_cl_heap_GV_I_bits(32,uintD) -static const cl_I bits32_element (const cl_GV_inner* vec, uintC index) +static const cl_I bits32_element (const cl_GV_inner* vec, std::size_t index) { #if (intDsize==32) return (unsigned long)(((const cl_heap_GV_I_bits32 *) outcast(vec))->data[index]); @@ -421,13 +421,13 @@ static const cl_I bits32_element (const cl_GV_inner* vec, uintC index) return (unsigned long)(((uint32*)(((const cl_heap_GV_I_bits32 *) outcast(vec))->data))[index]); #endif } -static void bits32_set_element (cl_GV_inner* vec, uintC index, const cl_I& x) +static void bits32_set_element (cl_GV_inner* vec, std::size_t index, const cl_I& x) { - var uint32 xval = cl_I_to_UL(x); + uint32 xval = cl_I_to_UL(x); #if (intDsize==32) ((cl_heap_GV_I_bits32 *) outcast(vec))->data[index] = xval; #elif CL_CPU_BIG_ENDIAN_P - var uintD* ptr = &((cl_heap_GV_I_bits32 *) outcast(vec))->data[index/(intDsize/32)]; + uintD* ptr = &((cl_heap_GV_I_bits32 *) outcast(vec))->data[index/(intDsize/32)]; index = 32*(index%(intDsize/32)); *ptr = *ptr ^ ((*ptr ^ ((uintD)xval << index)) & ((uintD)0xFFFFFFFF << index)); #else @@ -446,10 +446,10 @@ static cl_GV_I_vectorops* bits_vectorops[6] = { &bits32_vectorops }; -cl_heap_GV_I* cl_make_heap_GV_I (uintC len, sintC m) +cl_heap_GV_I* cl_make_heap_GV_I (std::size_t len, sintC m) { // Determine log2(bits). - var uintL log2_bits; + uintL log2_bits; switch (m) { case 0: case 1: log2_bits = 0; break; @@ -471,14 +471,14 @@ cl_heap_GV_I* cl_make_heap_GV_I (uintC len, sintC m) return cl_make_heap_GV_I(len); } // For room allocation purposes, be pessimistic: assume the uintD case (since intDsize>=32). - var uintC words = // ceiling(len*2^log2_bits,intDsize) + std::size_t words = // ceiling(len*2^log2_bits,intDsize) (((sintC)len-1)>>(log2_intDsize-log2_bits))+1; - var cl_heap_GV_I_bits32* hv = (cl_heap_GV_I_bits32*) malloc_hook(offsetofa(cl_heap_GV_I_bits32,data)+sizeof(uintD)*words); + cl_heap_GV_I_bits32* hv = (cl_heap_GV_I_bits32*) malloc_hook(offsetofa(cl_heap_GV_I_bits32,data)+sizeof(uintD)*words); hv->refcount = 1; hv->type = &cl_class_gvector_integer(); new (&hv->v) cl_GV_inner (len,&bits_vectorops[log2_bits]->ops); - var uintD* ptr = (uintD*)(hv->data); - for (var uintC i = 0; i < words; i++) + uintD* ptr = (uintD*)(hv->data); + for (std::size_t i = 0; i < words; i++) ptr[i] = 0; return (cl_heap_GV_I*) hv; } @@ -498,7 +498,7 @@ int cl_GV_I_init_helper::count = 0; cl_GV_I_init_helper::cl_GV_I_init_helper() { if (count++ == 0) - new ((void *)&cl_null_GV_I) cl_GV_I((uintC)0); + new ((void *)&cl_null_GV_I) cl_GV_I((std::size_t)0); } cl_GV_I_init_helper::~cl_GV_I_init_helper() diff --git a/src/vector/cl_GV_I_copy.cc b/src/vector/cl_GV_I_copy.cc index 9f76c5c..2f1e7d2 100644 --- a/src/vector/cl_GV_I_copy.cc +++ b/src/vector/cl_GV_I_copy.cc @@ -14,9 +14,9 @@ namespace cln { const cl_GV_I copy (const cl_GV_I& v) { - var uintC len = v.size(); - var cl_GV_I w = cl_GV_I(len,v.maxbits()); - cl_GV_I::copy_elements(v,0,w,0,len); + std::size_t len = v.size(); + cl_GV_I w = cl_GV_I(len, v.maxbits()); + cl_GV_I::copy_elements(v, 0, w, 0, len); return w; } diff --git a/src/vector/cl_GV_number.cc b/src/vector/cl_GV_number.cc index 6f51aaf..fecf25f 100644 --- a/src/vector/cl_GV_number.cc +++ b/src/vector/cl_GV_number.cc @@ -56,33 +56,33 @@ struct cl_heap_GV_number_general : public cl_heap_GV_number { cl_heap_GV_number_general (); }; -static const cl_number general_element (const cl_GV_inner* vec, uintC index) +static const cl_number general_element (const cl_GV_inner* vec, std::size_t index) { return ((const cl_heap_GV_number_general *) outcast(vec))->data[index]; } -static void general_set_element (cl_GV_inner* vec, uintC index, const cl_number& x) +static void general_set_element (cl_GV_inner* vec, std::size_t index, const cl_number& x) { ((cl_heap_GV_number_general *) outcast(vec))->data[index] = x; } static void general_do_delete (cl_GV_inner* vec) { - var cl_heap_GV_number_general* hv = (cl_heap_GV_number_general *) outcast(vec); - var uintC len = hv->v.size(); - for (var uintC i = 0; i < len; i++) + cl_heap_GV_number_general* hv = (cl_heap_GV_number_general *) outcast(vec); + std::size_t len = hv->v.size(); + for (std::size_t i = 0; i < len; i++) hv->data[i].~cl_number(); } -static void general_copy_elements (const cl_GV_inner* srcvec, uintC srcindex, cl_GV_inner* destvec, uintC destindex, uintC count) +static void general_copy_elements (const cl_GV_inner* srcvec, std::size_t srcindex, cl_GV_inner* destvec, std::size_t destindex, std::size_t count) { if (count > 0) { - var const cl_heap_GV_number_general* srcv = + const cl_heap_GV_number_general* srcv = (const cl_heap_GV_number_general *) outcast(srcvec); - var cl_heap_GV_number_general* destv = + cl_heap_GV_number_general* destv = (cl_heap_GV_number_general *) outcast(destvec); - var uintC srclen = srcv->v.size(); - var uintC destlen = destv->v.size(); + std::size_t srclen = srcv->v.size(); + std::size_t destlen = destv->v.size(); if (!(srcindex <= srcindex+count && srcindex+count <= srclen)) throw runtime_exception(); if (!(destindex <= destindex+count && destindex+count <= destlen)) @@ -94,7 +94,7 @@ static void general_copy_elements (const cl_GV_inner* srcvec, uintC s } -cl_heap_GV_number* cl_make_heap_GV_number (uintC len) +cl_heap_GV_number* cl_make_heap_GV_number (std::size_t len) { static cl_GV_vectorops general_vectorops = { general_element, @@ -103,11 +103,11 @@ cl_heap_GV_number* cl_make_heap_GV_number (uintC len) general_copy_elements }; - var cl_heap_GV_number_general* hv = (cl_heap_GV_number_general*) malloc_hook(offsetofa(cl_heap_GV_number_general,data)+sizeof(cl_number)*len); + cl_heap_GV_number_general* hv = (cl_heap_GV_number_general*) malloc_hook(offsetofa(cl_heap_GV_number_general,data)+sizeof(cl_number)*len); hv->refcount = 1; hv->type = &cl_class_gvector_number(); new (&hv->v) cl_GV_inner (len,&general_vectorops); - for (var uintC i = 0; i < len; i++) + for (std::size_t i = 0; i < len; i++) init1(cl_number, hv->data[i]) (); return hv; } @@ -120,7 +120,7 @@ int cl_GV_number_init_helper::count = 0; cl_GV_number_init_helper::cl_GV_number_init_helper() { if (count++ == 0) - new ((void *)&cl_null_GV_number) cl_GV_number((uintC)0); + new ((void *)&cl_null_GV_number) cl_GV_number((std::size_t)0); } cl_GV_number_init_helper::~cl_GV_number_init_helper() diff --git a/src/vector/cl_GV_number_copy.cc b/src/vector/cl_GV_number_copy.cc index 715aea1..805e5a0 100644 --- a/src/vector/cl_GV_number_copy.cc +++ b/src/vector/cl_GV_number_copy.cc @@ -14,9 +14,9 @@ namespace cln { const cl_GV_number copy (const cl_GV_number& v) { - var uintC len = v.size(); - var cl_GV_number w = cl_GV_number(len); - cl_GV_number::copy_elements(v,0,w,0,len); + std::size_t len = v.size(); + cl_GV_number w = cl_GV_number(len); + cl_GV_number::copy_elements(v, 0, w, 0, len); return w; } diff --git a/src/vector/cl_SV_copy.cc b/src/vector/cl_SV_copy.cc index f41d0a3..09b333c 100644 --- a/src/vector/cl_SV_copy.cc +++ b/src/vector/cl_SV_copy.cc @@ -16,12 +16,12 @@ namespace cln { const cl_SV_any copy (const cl_SV_any& src) { - var uintC len = src.size(); - var cl_heap_SV_any* hv = (cl_heap_SV_any*) malloc_hook(sizeof(cl_heap_SV_any)+sizeof(cl_gcobject)*len); + std::size_t len = src.size(); + cl_heap_SV_any* hv = (cl_heap_SV_any*) malloc_hook(sizeof(cl_heap_SV_any)+sizeof(cl_gcobject)*len); hv->refcount = 1; hv->type = src.pointer_type(); new (&hv->v) cl_SV_inner (len); - for (var uintC i = 0; i < len; i++) + for (std::size_t i = 0; i < len; i++) init1(cl_gcobject, hv->v[i]) (src[i]); return hv; } diff --git a/src/vector/cl_SV_number.cc b/src/vector/cl_SV_number.cc index 80b99b0..2c29838 100644 --- a/src/vector/cl_SV_number.cc +++ b/src/vector/cl_SV_number.cc @@ -30,9 +30,9 @@ cl_class& cl_class_svector_number() return instance; } -cl_heap_SV_number* cl_make_heap_SV_number_uninit (uintC len) +cl_heap_SV_number* cl_make_heap_SV_number_uninit (std::size_t len) { - var cl_heap_SV_number* hv = (cl_heap_SV_number*) malloc_hook(sizeof(cl_heap_SV_number)+sizeof(cl_number)*len); + cl_heap_SV_number* hv = (cl_heap_SV_number*) malloc_hook(sizeof(cl_heap_SV_number)+sizeof(cl_number)*len); hv->refcount = 1; hv->type = &cl_class_svector_number(); new (&hv->v) cl_SV_inner (len); @@ -40,13 +40,13 @@ cl_heap_SV_number* cl_make_heap_SV_number_uninit (uintC len) return hv; } -cl_heap_SV_number* cl_make_heap_SV_number (uintC len) +cl_heap_SV_number* cl_make_heap_SV_number (std::size_t len) { - var cl_heap_SV_number* hv = (cl_heap_SV_number*) malloc_hook(sizeof(cl_heap_SV_number)+sizeof(cl_number)*len); + cl_heap_SV_number* hv = (cl_heap_SV_number*) malloc_hook(sizeof(cl_heap_SV_number)+sizeof(cl_number)*len); hv->refcount = 1; hv->type = &cl_class_svector_number(); new (&hv->v) cl_SV_inner (len); - for (var uintC i = 0; i < len; i++) + for (std::size_t i = 0; i < len; i++) init1(cl_number, hv->v[i]) (0); return hv; } @@ -59,7 +59,7 @@ int cl_SV_number_init_helper::count = 0; cl_SV_number_init_helper::cl_SV_number_init_helper() { if (count++ == 0) - new ((void *)&cl_null_SV_number) cl_SV_number((uintC)0); + new ((void *)&cl_null_SV_number) cl_SV_number((std::size_t)0); } cl_SV_number_init_helper::~cl_SV_number_init_helper() diff --git a/src/vector/cl_SV_ringelt.cc b/src/vector/cl_SV_ringelt.cc index accb51b..d2bbedc 100644 --- a/src/vector/cl_SV_ringelt.cc +++ b/src/vector/cl_SV_ringelt.cc @@ -31,9 +31,9 @@ cl_class& cl_class_svector_ringelt() return instance; } -cl_heap_SV_ringelt* cl_make_heap_SV_ringelt_uninit (uintC len) +cl_heap_SV_ringelt* cl_make_heap_SV_ringelt_uninit (std::size_t len) { - var cl_heap_SV_ringelt* hv = (cl_heap_SV_ringelt*) malloc_hook(sizeof(cl_heap_SV_ringelt)+sizeof(_cl_ring_element)*len); + cl_heap_SV_ringelt* hv = (cl_heap_SV_ringelt*) malloc_hook(sizeof(cl_heap_SV_ringelt)+sizeof(_cl_ring_element)*len); hv->refcount = 1; hv->type = &cl_class_svector_ringelt(); new (&hv->v) cl_SV_inner<_cl_ring_element> (len); @@ -41,13 +41,13 @@ cl_heap_SV_ringelt* cl_make_heap_SV_ringelt_uninit (uintC len) return hv; } -cl_heap_SV_ringelt* cl_make_heap_SV_ringelt (uintC len) +cl_heap_SV_ringelt* cl_make_heap_SV_ringelt (std::size_t len) { - var cl_heap_SV_ringelt* hv = (cl_heap_SV_ringelt*) malloc_hook(sizeof(cl_heap_SV_ringelt)+sizeof(_cl_ring_element)*len); + cl_heap_SV_ringelt* hv = (cl_heap_SV_ringelt*) malloc_hook(sizeof(cl_heap_SV_ringelt)+sizeof(_cl_ring_element)*len); hv->refcount = 1; hv->type = &cl_class_svector_ringelt(); new (&hv->v) cl_SV_inner<_cl_ring_element> (len); - for (var uintC i = 0; i < len; i++) + for (std::size_t i = 0; i < len; i++) init1(_cl_ring_element, hv->v[i]) (); return hv; } @@ -60,7 +60,7 @@ int cl_SV_ringelt_init_helper::count = 0; cl_SV_ringelt_init_helper::cl_SV_ringelt_init_helper() { if (count++ == 0) - new ((void *)&cl_null_SV_ringelt) cl_SV_ringelt((uintC)0); + new ((void *)&cl_null_SV_ringelt) cl_SV_ringelt((std::size_t)0); } cl_SV_ringelt_init_helper::~cl_SV_ringelt_init_helper() diff --git a/src/vector/output/cl_GV_number_aprint.cc b/src/vector/output/cl_GV_number_aprint.cc index 9991787..79145b5 100644 --- a/src/vector/output/cl_GV_number_aprint.cc +++ b/src/vector/output/cl_GV_number_aprint.cc @@ -19,13 +19,13 @@ namespace cln { void print_vector (std::ostream& stream, const cl_print_flags& flags, void (* printfun) (std::ostream&, const cl_print_flags&, const cl_number&), const cl_GV_number& vector) { - var uintC len = vector.size(); + std::size_t len = vector.size(); if (flags.vector_syntax == vsyntax_commonlisp) { fprintchar(stream,'#'); fprintchar(stream,'('); } else fprintchar(stream,'['); - for (var uintC i = 0; i < len; i++) { + for (std::size_t i = 0; i < len; i++) { if (i > 0) { if (flags.vector_syntax == vsyntax_algebraic) fprintchar(stream,','); diff --git a/src/vector/output/cl_SV_aprint.cc b/src/vector/output/cl_SV_aprint.cc index d1d9d36..41213cd 100644 --- a/src/vector/output/cl_SV_aprint.cc +++ b/src/vector/output/cl_SV_aprint.cc @@ -15,14 +15,14 @@ namespace cln { void fprint (std::ostream& stream, const cl_ring& R, const cl_SV_ringelt& vector) { - var const cl_print_flags& flags = default_print_flags; - var uintC len = vector.size(); + const cl_print_flags& flags = default_print_flags; + std::size_t len = vector.size(); if (flags.vector_syntax == vsyntax_commonlisp) { fprintchar(stream,'#'); fprintchar(stream,'('); } else fprintchar(stream,'['); - for (var uintC i = 0; i < len; i++) { + for (std::size_t i = 0; i < len; i++) { if (i > 0) { if (flags.vector_syntax == vsyntax_algebraic) fprintchar(stream,','); diff --git a/src/vector/output/cl_SV_number_aprint.cc b/src/vector/output/cl_SV_number_aprint.cc index c01d6e8..ef3d277 100644 --- a/src/vector/output/cl_SV_number_aprint.cc +++ b/src/vector/output/cl_SV_number_aprint.cc @@ -19,13 +19,13 @@ namespace cln { void print_vector (std::ostream& stream, const cl_print_flags& flags, void (* printfun) (std::ostream&, const cl_print_flags&, const cl_number&), const cl_SV_number& vector) { - var uintC len = vector.size(); + std::size_t len = vector.size(); if (flags.vector_syntax == vsyntax_commonlisp) { fprintchar(stream,'#'); fprintchar(stream,'('); } else fprintchar(stream,'['); - for (var uintC i = 0; i < len; i++) { + for (std::size_t i = 0; i < len; i++) { if (i > 0) { if (flags.vector_syntax == vsyntax_algebraic) fprintchar(stream,','); -- 2.45.0