ooRexx  4.2.0-source
About: ooRexx (Open Object Rexx) is a free implementation of Object Rexx. Object Rexx is an enhancement of the classic Rexx interpreter; a full-featured programming language with a human-oriented syntax.
  Fossies Dox: ooRexx-4.2.0-source.tar.gz  ("inofficial" and yet experimental doxygen-generated source code documentation)  

ArrayClass.hpp
Go to the documentation of this file.
1 /*----------------------------------------------------------------------------*/
2 /* */
3 /* Copyright (c) 1995, 2004 IBM Corporation. All rights reserved. */
4 /* Copyright (c) 2005-2009 Rexx Language Association. All rights reserved. */
5 /* */
6 /* This program and the accompanying materials are made available under */
7 /* the terms of the Common Public License v1.0 which accompanies this */
8 /* distribution. A copy is also available at the following address: */
9 /* http://www.oorexx.org/license.html */
10 /* */
11 /* Redistribution and use in source and binary forms, with or */
12 /* without modification, are permitted provided that the following */
13 /* conditions are met: */
14 /* */
15 /* Redistributions of source code must retain the above copyright */
16 /* notice, this list of conditions and the following disclaimer. */
17 /* Redistributions in binary form must reproduce the above copyright */
18 /* notice, this list of conditions and the following disclaimer in */
19 /* the documentation and/or other materials provided with the distribution. */
20 /* */
21 /* Neither the name of Rexx Language Association nor the names */
22 /* of its contributors may be used to endorse or promote products */
23 /* derived from this software without specific prior written permission. */
24 /* */
25 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
26 /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
27 /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */
28 /* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */
29 /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */
30 /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */
31 /* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */
32 /* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */
33 /* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */
34 /* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */
35 /* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
36 /* */
37 /*----------------------------------------------------------------------------*/
38 /******************************************************************************/
39 /* REXX Kernel ArrayClass.hpp */
40 /* */
41 /* Primitive Array Class Definitions */
42 /* */
43 /******************************************************************************/
44 #ifndef Included_RexxArray
45 #define Included_RexxArray
46 
47 #define RaiseBoundsNone 0x00000000
48 #define RaiseBoundsUpper 0x00000001
49 #define RaiseBoundsInvalid 0x00000002
50 #define RaiseBoundsTooMany 0x00000004
51 #define RaiseBoundsAll 0x0000000F
52 #define ExtendUpper 0x00000010
53 
54 
55 typedef struct copyElementParm {
60  size_t deltaDimSize;
61  size_t copyElements;
62  size_t skipElements;
66 
68  public:
69  enum {
70  SmallRange = 10 // the size where we revert to an insertion sort
71  };
72 
73  PartitionBounds(size_t l, size_t r) : left(l), right(r) {}
74  PartitionBounds() : left(0), right(0) {}
75 
76  inline bool isSmall() { return (right - left) <= SmallRange; }
77  inline size_t midPoint() { return (left + right) / 2; }
78 
79  size_t left; // start of the range
80  size_t right;
81  };
82 
83 
85  public:
86  inline BaseSortComparator() { }
87 
88  virtual wholenumber_t compare(RexxObject *first, RexxObject *second);
89  };
90 
92  public:
94  virtual wholenumber_t compare(RexxObject *first, RexxObject *second);
95  protected:
97  };
98 
99 
100  class RexxArray : public RexxObject {
101  public:
102 
103  inline void * operator new(size_t size, void *objectPtr) { return objectPtr; };
104  void * operator new(size_t, RexxObject **, size_t, RexxClass *);
105  void * operator new(size_t, RexxObject *);
106  void * operator new(size_t, RexxObject *, RexxObject *);
107  void * operator new(size_t, RexxObject *, RexxObject *, RexxObject *);
108  void * operator new(size_t, RexxObject *, RexxObject *, RexxObject *, RexxObject *);
109  void * operator new(size_t, size_t, RexxObject **);
110  void * operator new(size_t, size_t, size_t, RexxClass *cls = TheArrayClass);
111 
112  inline void operator delete(void *) {;}
113  inline void operator delete(void *, void *) {;}
114  inline void operator delete(void *, RexxObject **, size_t, RexxClass *) {;}
115  inline void operator delete(void *, RexxObject *) {;}
116  inline void operator delete(void *, RexxObject *, RexxObject *) {;}
117  inline void operator delete(void *, RexxObject *, RexxObject *, RexxObject *) {;}
118  inline void operator delete(void *, RexxObject *, RexxObject *, RexxObject *, RexxObject *) {;}
119  inline void operator delete(void *, size_t, RexxObject **) {;}
120  inline void operator delete(void *, size_t, size_t, RexxClass *cls) {;}
121  inline void operator delete(void *, RexxObject **) { ; }
122 
123  inline RexxArray(RESTORETYPE restoreType) { ; };
124  inline RexxArray() { ; };
125  inline ~RexxArray() { ; };
126 
127  void init(size_t, size_t);
128  void live(size_t);
129  void liveGeneral(int reason);
130  void flatten(RexxEnvelope *);
131  RexxObject *copy();
132  RexxArray *makeArray();
133  RexxArray *allItems();
137 // Temporary bypass for BUG #1700606
138 #if 0
140 #endif
141  RexxObject *getRexx(RexxObject **, size_t);
142  RexxObject *getApi(size_t pos);
143  void put(RexxObject * eref, size_t pos);
144  RexxObject *putRexx(RexxObject **, size_t);
145  void putApi(RexxObject * eref, size_t pos);
146  RexxObject *remove(size_t);
147  RexxObject *removeRexx(RexxObject **, size_t);
149  size_t append(RexxObject *);
150  void setExpansion(RexxObject * expansion);
151  RexxInteger *available(size_t position);
152  bool validateIndex(RexxObject **, size_t, size_t, size_t, stringsize_t &);
155  RexxObject *lastRexx();
157  RexxObject *lastItem();
158  size_t lastIndex();
159  RexxObject *nextRexx(RexxObject **, size_t);
160  RexxObject *previousRexx(RexxObject **, size_t);
161  RexxArray *section(size_t, size_t);
163  RexxObject *sectionSubclass(size_t, size_t);
164  bool hasIndexNative(size_t);
165  RexxObject *hasIndexRexx(RexxObject **, size_t);
166  bool hasIndexApi(size_t);
167  size_t items();
171  size_t getDimension();
172  RexxObject *supplier();
174  RexxArray *extend(size_t);
175  void shrink(size_t);
176  size_t indexOf(RexxObject *);
177  RexxArray *extendMulti(RexxObject **, size_t, size_t);
178  void resize();
179  void ensureSpace(size_t newSize);
180  RexxObject *newRexx(RexxObject **, size_t);
181  RexxObject *of(RexxObject **, size_t);
182  RexxObject *empty();
183  RexxObject *isEmpty();
188  wholenumber_t sortCompare(RexxObject *comparator, RexxObject *left, RexxObject *right);
192  size_t insert(RexxObject *_value, size_t index);
194  RexxObject *deleteItem(size_t index);
195 
196  inline size_t addLast(RexxObject *item) { return this->insert(item, this->size() + 1); }
197  inline size_t addFirst(RexxObject *item) { return this->insert(item, 1); }
198  inline size_t insertAfter(RexxObject *item, size_t index) { return this->insert(item, index); }
199  inline RexxArray *array() { return this->makeArray(); }
200  inline size_t size() { return this->expansionArray->arraySize; }
201  inline RexxObject *get(size_t pos) { return (this->data())[pos-1];}
202  inline RexxObject **data() { return this->expansionArray->objects; }
203  inline RexxObject **data(size_t pos) { return &((this->data())[pos-1]);}
204  inline RexxArray *getExpansion() { return this->expansionArray; }
205  size_t findSingleIndexItem(RexxObject *item);
206  RexxObject * indexToArray(size_t idx);
207  RexxObject * convertIndex(size_t idx);
208 
209  inline bool isMultiDimensional() { return this->dimensions != OREF_NULL && this->dimensions->size() != 1; }
210  inline bool isSingleDimensional() { return !isMultiDimensional(); }
211 
212  static RexxArray *createMultidimensional(RexxObject **dims, size_t count, RexxClass *);
213 
214  static void createInstance();
215  // singleton class instance;
218 
219  static const size_t ARRAY_MIN_SIZE;
220  static const size_t ARRAY_DEFAULT_SIZE; // default size for ooRexx allocation
221 
222  protected:
223 
224  void mergeSort(BaseSortComparator &comparator, RexxArray *working, size_t left, size_t right);
225  void merge(BaseSortComparator &comparator, RexxArray *working, size_t left, size_t mid, size_t right);
226  static void arraycopy(RexxArray *source, size_t start, RexxArray *target, size_t index, size_t count);
227  size_t find(BaseSortComparator &comparator, RexxObject *val, int bnd, size_t left, size_t right);
228  void openGap(size_t index, size_t elements);
229  void closeGap(size_t index, size_t elements);
230  inline RexxObject **slotAddress(size_t index) { return &(this->data()[index - 1]); }
231  inline size_t dataSize() { return ((char *)slotAddress(size() + 1)) - ((char *)data()); }
232 
233 
234  static const size_t MAX_FIXEDARRAY_SIZE;
235 
236  size_t arraySize; /* current size of array */
237  size_t maximumSize; /* Maximum size array can grow */
238  size_t lastElement; // location of last set element
239  RexxArray *dimensions; /* Array containing dimensions - null if 1-dimensional */
240  RexxArray *expansionArray; /* actual array containing data */
241  RexxObject *objects[1]; /* Data. */
242  };
243 
244 
245 inline RexxArray *new_externalArray(size_t s, RexxClass *c)
246 {
247  return new (s, RexxArray::ARRAY_DEFAULT_SIZE, c) RexxArray;
248 }
249 
250 inline RexxArray *new_array(size_t s)
251 {
253 }
254 
255 inline RexxArray *new_array(size_t s, RexxObject **o)
256 {
257  return new (s, o) RexxArray;
258 }
259 
261 {
262  return new (o1) RexxArray;
263 }
264 
266 {
267  return new (o1, o2) RexxArray;
268 }
269 
271 {
272  return new (o1, o2, o3) RexxArray;
273 }
274 
276 {
277  return new (o1, o2, o3, o4) RexxArray;
278 }
279 
280  #endif
RexxArray::createMultidimensional
static RexxArray * createMultidimensional(RexxObject **dims, size_t count, RexxClass *)
Definition: ArrayClass.cpp:2316
RexxObject::makeString
RexxString * makeString()
Definition: ObjectClass.cpp:1070
RexxArray::hasItem
RexxObject * hasItem(RexxObject *)
Definition: ArrayClass.cpp:1902
TheArrayClass
#define TheArrayClass
Definition: RexxCore.h:148
RexxArray::insert
size_t insert(RexxObject *_value, size_t index)
Definition: ArrayClass.cpp:2198
RexxArray::getRexx
RexxObject * getRexx(RexxObject **, size_t)
Definition: ArrayClass.cpp:503
RexxArray::getDimension
size_t getDimension()
Definition: ArrayClass.cpp:690
new_array
RexxArray * new_array(size_t s)
Definition: ArrayClass.hpp:250
PartitionBounds::left
size_t left
Definition: ArrayClass.hpp:79
RexxArray
Definition: ArrayClass.hpp:100
RexxArray::validateIndex
bool validateIndex(RexxObject **, size_t, size_t, size_t, stringsize_t &)
Definition: ArrayClass.cpp:832
RexxArray::remove
RexxObject * remove(size_t)
Definition: ArrayClass.cpp:590
RexxArray::live
void live(size_t)
Definition: ArrayClass.cpp:143
copyElementParm::startOld
RexxObject ** startOld
Definition: ArrayClass.hpp:64
RexxArray::hasIndexApi
bool hasIndexApi(size_t)
Definition: ArrayClass.cpp:573
RexxArray::insertRexx
RexxObject * insertRexx(RexxObject *_value, RexxObject *index)
Definition: ArrayClass.cpp:338
RexxArray::classInstance
static RexxClass * classInstance
Definition: ArrayClass.hpp:216
RexxArray::putApi
void putApi(RexxObject *eref, size_t pos)
Definition: ArrayClass.cpp:551
RexxArray::previousRexx
RexxObject * previousRexx(RexxObject **, size_t)
Definition: ArrayClass.cpp:1351
RexxArray::copy
RexxObject * copy()
Definition: ArrayClass.cpp:120
RexxArray::dataSize
size_t dataSize()
Definition: ArrayClass.hpp:231
copyElementParm
Definition: ArrayClass.hpp:55
RexxArray::deleteRexx
RexxObject * deleteRexx(RexxObject *index)
Definition: ArrayClass.cpp:379
RexxArray::data
RexxObject ** data()
Definition: ArrayClass.hpp:202
RexxArray::lastItem
RexxObject * lastItem()
Definition: ArrayClass.cpp:1298
RexxArray::objects
RexxObject * objects[1]
Definition: ArrayClass.hpp:241
RexxArray::array
RexxArray * array()
Definition: ArrayClass.hpp:199
RexxArray::sectionSubclass
RexxObject * sectionSubclass(size_t, size_t)
Definition: ArrayClass.cpp:1179
BaseSortComparator
Definition: ArrayClass.hpp:84
WithSortComparator::WithSortComparator
WithSortComparator(RexxObject *c)
Definition: ArrayClass.hpp:93
RexxArray::sortCompare
wholenumber_t sortCompare(RexxObject *comparator, RexxObject *left, RexxObject *right)
RexxArray::section
RexxArray * section(size_t, size_t)
Definition: ArrayClass.cpp:1075
PartitionBounds::right
size_t right
Definition: ArrayClass.hpp:80
PartitionBounds::midPoint
size_t midPoint()
Definition: ArrayClass.hpp:77
RexxArray::index
RexxObject * index(RexxObject *)
Definition: ArrayClass.cpp:1852
RexxArray::itemsRexx
RexxObject * itemsRexx()
Definition: ArrayClass.cpp:682
RexxArray::indexOf
size_t indexOf(RexxObject *)
Definition: ArrayClass.cpp:1696
RexxArray::fill
RexxObject * fill(RexxObject *)
Definition: ArrayClass.cpp:247
RexxArray::size
size_t size()
Definition: ArrayClass.hpp:200
RexxArray::dimension
RexxObject * dimension(RexxObject *)
Definition: ArrayClass.cpp:726
RexxArray::mergeSort
void mergeSort(BaseSortComparator &comparator, RexxArray *working, size_t left, size_t right)
Definition: ArrayClass.cpp:2371
RexxArray::findSingleIndexItem
size_t findSingleIndexItem(RexxObject *item)
Definition: ArrayClass.cpp:1763
RexxArray::items
size_t items()
Definition: ArrayClass.cpp:660
RexxArray::allIndexes
RexxArray * allIndexes()
Definition: ArrayClass.cpp:1486
PartitionBounds
Definition: ArrayClass.hpp:67
RexxArray::~RexxArray
~RexxArray()
Definition: ArrayClass.hpp:125
RexxArray::liveGeneral
void liveGeneral(int reason)
Definition: ArrayClass.cpp:161
BaseSortComparator::BaseSortComparator
BaseSortComparator()
Definition: ArrayClass.hpp:86
RexxArray::ARRAY_DEFAULT_SIZE
static const size_t ARRAY_DEFAULT_SIZE
Definition: ArrayClass.hpp:220
RexxArray::allItems
RexxArray * allItems()
Definition: ArrayClass.cpp:1459
RexxArray::extend
RexxArray * extend(size_t)
Definition: ArrayClass.cpp:1715
RexxArray::isSingleDimensional
bool isSingleDimensional()
Definition: ArrayClass.hpp:210
PartitionBounds::PartitionBounds
PartitionBounds()
Definition: ArrayClass.hpp:74
copyElementParm::newArray
RexxArray * newArray
Definition: ArrayClass.hpp:57
RexxEnvelope
Definition: RexxEnvelope.hpp:53
COPYELEMENTPARM
struct copyElementParm COPYELEMENTPARM
copyElementParm::copyElements
size_t copyElements
Definition: ArrayClass.hpp:61
RexxArray::openGap
void openGap(size_t index, size_t elements)
Definition: ArrayClass.cpp:406
RexxArray::get
RexxObject * get(size_t pos)
Definition: ArrayClass.hpp:201
RexxArray::ensureSpace
void ensureSpace(size_t newSize)
Definition: ArrayClass.cpp:1042
RexxArray::arraySize
size_t arraySize
Definition: ArrayClass.hpp:236
copyElementParm::deltaDimSize
size_t deltaDimSize
Definition: ArrayClass.hpp:60
RexxArray::removeRexx
RexxObject * removeRexx(RexxObject **, size_t)
Definition: ArrayClass.cpp:623
RexxArray::ARRAY_MIN_SIZE
static const size_t ARRAY_MIN_SIZE
Definition: ArrayClass.hpp:219
RexxArray::supplier
RexxObject * supplier()
Definition: ArrayClass.cpp:783
RexxArray::isEmpty
RexxObject * isEmpty()
Definition: ArrayClass.cpp:295
RexxArray::RexxArray
RexxArray(RESTORETYPE restoreType)
Definition: ArrayClass.hpp:123
RexxArray::nullArray
static RexxArray * nullArray
Definition: ArrayClass.hpp:217
WithSortComparator
Definition: ArrayClass.hpp:91
OREF_NULL
#define OREF_NULL
Definition: RexxCore.h:60
RexxArray::setExpansion
void setExpansion(RexxObject *expansion)
Definition: ArrayClass.cpp:815
RexxArray::data
RexxObject ** data(size_t pos)
Definition: ArrayClass.hpp:203
RexxArray::RexxArray
RexxArray()
Definition: ArrayClass.hpp:124
PartitionBounds::PartitionBounds
PartitionBounds(size_t l, size_t r)
Definition: ArrayClass.hpp:73
RexxArray::slotAddress
RexxObject ** slotAddress(size_t index)
Definition: ArrayClass.hpp:230
RexxObject::init
RexxObject * init()
Definition: ObjectClass.cpp:2257
RexxObject::primitiveMakeString
RexxString * primitiveMakeString()
Definition: ObjectClass.cpp:1095
RexxArray::put
void put(RexxObject *eref, size_t pos)
Definition: ArrayClass.cpp:203
RexxArray::getDimensions
RexxObject * getDimensions()
Definition: ArrayClass.cpp:711
copyElementParm::startNew
RexxObject ** startNew
Definition: ArrayClass.hpp:63
RexxArray::maximumSize
size_t maximumSize
Definition: ArrayClass.hpp:237
RexxClass
Definition: ClassClass.hpp:49
RexxArray::dimensions
RexxArray * dimensions
Definition: ArrayClass.hpp:239
RexxArray::MAX_FIXEDARRAY_SIZE
static const size_t MAX_FIXEDARRAY_SIZE
Definition: ArrayClass.hpp:234
RexxArray::isMultiDimensional
bool isMultiDimensional()
Definition: ArrayClass.hpp:209
RexxArray::arraycopy
static void arraycopy(RexxArray *source, size_t start, RexxArray *target, size_t index, size_t count)
Definition: ArrayClass.cpp:2485
WithSortComparator::compare
virtual wholenumber_t compare(RexxObject *first, RexxObject *second)
Definition: ArrayClass.cpp:2792
RexxArray::convertIndex
RexxObject * convertIndex(size_t idx)
Definition: ArrayClass.cpp:1791
RexxArray::stableSortRexx
RexxArray * stableSortRexx()
Definition: ArrayClass.cpp:2562
RexxArray::closeGap
void closeGap(size_t index, size_t elements)
Definition: ArrayClass.cpp:444
copyElementParm::oldDimArray
RexxArray * oldDimArray
Definition: ArrayClass.hpp:59
WithSortComparator::comparator
RexxObject * comparator
Definition: ArrayClass.hpp:96
RexxArray::flatten
void flatten(RexxEnvelope *)
Definition: ArrayClass.cpp:176
RexxArray::sectionRexx
RexxObject * sectionRexx(RexxObject *, RexxObject *)
Definition: ArrayClass.cpp:1117
RexxArray::getExpansion
RexxArray * getExpansion()
Definition: ArrayClass.hpp:204
RexxArray::getApi
RexxObject * getApi(size_t pos)
Definition: ArrayClass.cpp:533
RexxArray::appendRexx
RexxObject * appendRexx(RexxObject *)
Definition: ArrayClass.cpp:308
RexxArray::append
size_t append(RexxObject *)
Definition: ArrayClass.cpp:482
RexxArray::of
RexxObject * of(RexxObject **, size_t)
Definition: ArrayClass.cpp:2738
RexxArray::merge
void merge(BaseSortComparator &comparator, RexxArray *working, size_t left, size_t mid, size_t right)
Definition: ArrayClass.cpp:2407
RexxArray::addLast
size_t addLast(RexxObject *item)
Definition: ArrayClass.hpp:196
RexxArray::toString
RexxString * toString(RexxString *, RexxString *)
Definition: ArrayClass.cpp:1524
RexxArray::makeArray
RexxArray * makeArray()
Definition: ArrayClass.cpp:1443
RexxArray::join
RexxObject * join(RexxArray *)
Definition: ArrayClass.cpp:1630
PartitionBounds::isSmall
bool isSmall()
Definition: ArrayClass.hpp:76
RexxArray::removeItem
RexxObject * removeItem(RexxObject *)
Definition: ArrayClass.cpp:1876
RexxArray::newRexx
RexxObject * newRexx(RexxObject **, size_t)
Definition: ArrayClass.cpp:2730
wholenumber_t
ssize_t wholenumber_t
Definition: rexx.h:229
RexxArray::indexToArray
RexxObject * indexToArray(size_t idx)
Definition: ArrayClass.cpp:1814
RexxArray::sizeRexx
RexxInteger * sizeRexx()
Definition: ArrayClass.cpp:1059
copyElementParm::firstChangedDimension
size_t firstChangedDimension
Definition: ArrayClass.hpp:56
stringsize_t
size_t stringsize_t
Definition: rexx.h:228
RexxArray::lastElement
size_t lastElement
Definition: ArrayClass.hpp:238
RexxArray::hasIndexRexx
RexxObject * hasIndexRexx(RexxObject **, size_t)
Definition: ArrayClass.cpp:1395
RexxArray::lastRexx
RexxObject * lastRexx()
Definition: ArrayClass.cpp:1251
RexxArray::deleteItem
RexxObject * deleteItem(size_t index)
Definition: ArrayClass.cpp:2216
RexxArray::shrink
void shrink(size_t)
Definition: ArrayClass.cpp:1677
RexxArray::nextRexx
RexxObject * nextRexx(RexxObject **, size_t)
Definition: ArrayClass.cpp:1318
RexxObject::start
RexxMessage * start(RexxObject **, size_t)
Definition: ObjectClass.cpp:1761
RexxArray::firstItem
RexxObject * firstItem()
Definition: ArrayClass.cpp:1272
RexxArray::available
RexxInteger * available(size_t position)
Definition: ArrayClass.cpp:823
new_externalArray
RexxArray * new_externalArray(size_t s, RexxClass *c)
Definition: ArrayClass.hpp:245
copyElementParm::newDimArray
RexxArray * newDimArray
Definition: ArrayClass.hpp:58
RexxArray::expansionArray
RexxArray * expansionArray
Definition: ArrayClass.hpp:240
BaseSortComparator::compare
virtual wholenumber_t compare(RexxObject *first, RexxObject *second)
Definition: ArrayClass.cpp:2786
RexxArray::addFirst
size_t addFirst(RexxObject *item)
Definition: ArrayClass.hpp:197
RexxArray::resize
void resize()
Definition: ArrayClass.cpp:1649
RexxArray::empty
RexxObject * empty()
Definition: ArrayClass.cpp:267
RexxArray::hasIndexNative
bool hasIndexNative(size_t)
Definition: ArrayClass.cpp:1427
RexxArray::createInstance
static void createInstance()
Definition: ArrayClass.cpp:93
RESTORETYPE
RESTORETYPE
Definition: ObjectClass.hpp:80
RexxArray::insertAfter
size_t insertAfter(RexxObject *item, size_t index)
Definition: ArrayClass.hpp:198
RexxArray::extendMulti
RexxArray * extendMulti(RexxObject **, size_t, size_t)
Definition: ArrayClass.cpp:1992
RexxInteger
Definition: IntegerClass.hpp:56
RexxArray::find
size_t find(BaseSortComparator &comparator, RexxObject *val, int bnd, size_t left, size_t right)
Definition: ArrayClass.cpp:2510
RexxArray::stableSortWithRexx
RexxArray * stableSortWithRexx(RexxObject *comparator)
Definition: ArrayClass.cpp:2598
PartitionBounds::SmallRange
Definition: ArrayClass.hpp:70
RexxArray::firstRexx
RexxObject * firstRexx()
Definition: ArrayClass.cpp:1224
copyElementParm::skipElements
size_t skipElements
Definition: ArrayClass.hpp:62
RexxObject
Definition: ObjectClass.hpp:311
RexxString
Definition: StringClass.hpp:119
RexxArray::lastIndex
size_t lastIndex()
Definition: ArrayClass.cpp:1310
RexxArray::putRexx
RexxObject * putRexx(RexxObject **, size_t)
Definition: ArrayClass.cpp:222