Lines Matching defs:vector
90 static void ANTLR3_CDECL antlr3VectorFree (pANTLR3_VECTOR vector);
91 static void antlr3VectorDel (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry);
92 static void * antlr3VectorGet (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry);
93 static void * antrl3VectorRemove (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry);
94 static void antlr3VectorClear (pANTLR3_VECTOR vector);
95 static ANTLR3_UINT32 antlr3VectorAdd (pANTLR3_VECTOR vector, void * element, void (ANTLR3_CDECL *freeptr)(void *));
96 static ANTLR3_UINT32 antlr3VectorSet (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry, void * element, void (ANTLR3_CDECL *freeptr)(void *), ANTLR3_BOOLEAN freeExisting);
97 static ANTLR3_UINT32 antlr3VectorSize (pANTLR3_VECTOR vector);
98 static ANTLR3_BOOLEAN antlr3VectorSwap (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry1, ANTLR3_UINT32 entry2);
103 static void returnVector (pANTLR3_VECTOR_FACTORY factory, pANTLR3_VECTOR vector);
979 stack->vector = antlr3VectorNew(sizeHint);
982 if (stack->vector == (pANTLR3_VECTOR)ANTLR3_FUNC_PTR(ANTLR3_ERR_NOMEM))
1001 return stack->vector->count;
1010 stack->vector->free(stack->vector);
1011 stack->vector = NULL;
1022 stack->vector->del(stack->vector, stack->vector->count - 1);
1030 stack->top = stack->vector->get(stack->vector, stack->vector->count - 1);
1037 return stack->vector->get(stack->vector, (ANTLR3_UINT32)key);
1050 return (ANTLR3_BOOLEAN)(stack->vector->add(stack->vector, element, freeptr));
1056 pANTLR3_VECTOR vector;
1059 // Allocate memory for the vector structure itself
1061 vector = (pANTLR3_VECTOR) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_VECTOR)));
1063 if (vector == NULL)
1070 antlr3SetVectorApi(vector, sizeHint);
1074 return vector;
1078 antlr3SetVectorApi (pANTLR3_VECTOR vector, ANTLR3_UINT32 sizeHint)
1095 vector->elements = (pANTLR3_VECTOR_ELEMENT)ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_VECTOR_ELEMENT) * initialSize));
1099 vector->elements = vector->internal;
1102 if (vector->elements == NULL)
1104 ANTLR3_FREE(vector);
1110 vector->count = 0; // No entries yet of course
1111 vector->elementsSize = initialSize; // Available entries
1115 vector->add = antlr3VectorAdd;
1116 vector->del = antlr3VectorDel;
1117 vector->get = antlr3VectorGet;
1118 vector->free = antlr3VectorFree;
1119 vector->set = antlr3VectorSet;
1120 vector->remove = antrl3VectorRemove;
1121 vector->clear = antlr3VectorClear;
1122 vector->size = antlr3VectorSize;
1123 vector->swap = antlr3VectorSwap;
1125 vector
1127 vector->factoryMade = ANTLR3_FALSE;
1130 // Clear the entries in a vector.
1131 // Clearing the vector leaves its capacity the same but
1136 antlr3VectorClear (pANTLR3_VECTOR vector)
1140 // We must traverse every entry in the vector and if it has
1144 for (entry = 0; entry < vector->count; entry++)
1146 if (vector->elements[entry].freeptr != NULL)
1148 vector->elements[entry].freeptr(vector->elements[entry].element);
1150 vector->elements[entry].freeptr = NULL;
1151 vector->elements[entry].element = NULL;
1157 vector->count = 0;
1161 void ANTLR3_CDECL antlr3VectorFree (pANTLR3_VECTOR vector)
1165 // We must traverse every entry in the vector and if it has
1169 for (entry = 0; entry < vector->count; entry++)
1171 if (vector->elements[entry].freeptr != NULL)
1173 vector->elements[entry].freeptr(vector->elements[entry].element);
1175 vector->elements[entry].freeptr = NULL;
1176 vector->elements[entry].element = NULL;
1179 if (vector->factoryMade == ANTLR3_FALSE)
1183 if (vector->elementsSize > ANTLR3_VECTOR_INTERNAL_SIZE)
1185 ANTLR3_FREE(vector->elements);
1187 vector->elements = NULL;
1189 // Finally, free the allocation for the vector itself
1191 ANTLR3_FREE(vector);
1195 static void antlr3VectorDel (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry)
1199 if (entry >= vector->count)
1206 if (vector->elements[entry].freeptr != NULL)
1208 vector->elements[entry].freeptr(vector->elements[entry].element);
1209 vector->elements[entry].freeptr = NULL;
1212 if (entry == vector->count - 1)
1217 vector->elements[entry].element = NULL;
1223 ANTLR3_MEMMOVE(vector->elements + entry, vector->elements + entry + 1, sizeof(ANTLR3_VECTOR_ELEMENT) * (vector->count - entry - 1));
1226 // One less entry in the vector now
1228 vector->count--;
1231 static void * antlr3VectorGet (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry)
1235 if (entry < vector->count)
1237 return vector->elements[entry].element;
1247 /// Remove the entry from the vector, but do not free any entry, even if it has
1250 static void * antrl3VectorRemove (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry)
1256 if (entry >= vector->count)
1264 element = vector->elements[entry].element;
1266 if (entry == vector->count - 1)
1271 vector->elements[entry].element = NULL;
1272 vector->elements[entry].freeptr = NULL;
1278 ANTLR3_MEMMOVE(vector->elements + entry, vector->elements + entry + 1, sizeof(ANTLR3_VECTOR_ELEMENT) * (vector->count - entry - 1));
1281 // One less entry in the vector now
1283 vector->count--;
1289 antlr3VectorResize (pANTLR3_VECTOR vector, ANTLR3_UINT32 hint)
1296 if (hint == 0 || hint < vector->elementsSize)
1298 newSize = vector->elementsSize * 2;
1306 // past the built in vector elements or were already past that
1308 if (vector->elementsSize > ANTLR3_VECTOR_INTERNAL_SIZE)
1313 vector->elements = (pANTLR3_VECTOR_ELEMENT)ANTLR3_REALLOC(vector->elements, (sizeof(ANTLR3_VECTOR_ELEMENT)* newSize));
1322 vector->elements = (pANTLR3_VECTOR_ELEMENT)ANTLR3_MALLOC((sizeof(ANTLR3_VECTOR_ELEMENT)* newSize));
1323 ANTLR3_MEMCPY(vector->elements, vector->internal, ANTLR3_VECTOR_INTERNAL_SIZE * sizeof(ANTLR3_VECTOR_ELEMENT));
1326 vector->elementsSize = newSize;
1330 /// expanding the vector if needed.
1332 static ANTLR3_UINT32 antlr3VectorAdd (pANTLR3_VECTOR vector, void * element, void (ANTLR3_CDECL *freeptr)(void *))
1334 // Do we need to resize the vector table?
1336 if (vector->count == vector->elementsSize)
1338 antlr3VectorResize(vector, 0); // Give no hint, we let it add 1024 or double it
1343 vector->elements[vector->count].element = element;
1344 vector->elements[vector->count].freeptr = freeptr;
1346 vector->count++; // One more element counted
1348 return (ANTLR3_UINT32)(vector->count);
1356 antlr3VectorSet (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry, void * element, void (ANTLR3_CDECL *freeptr)(void *), ANTLR3_BOOLEAN freeExisting)
1359 // If the vector is currently not big enough, then we expand it
1361 if (entry >= vector->elementsSize)
1363 antlr3VectorResize(vector, entry); // We will get at least this many
1368 if ( entry < vector->count // If actually replacing an element
1370 && vector->elements[entry].freeptr != NULL // And the existing element has a free pointer
1373 vector->elements[entry].freeptr(vector->elements[entry].element);
1378 vector->elements[entry].freeptr = freeptr;
1379 vector->elements[entry].element = element;
1381 if (entry >= vector->count)
1383 vector->count = entry + 1;
1393 antlr3VectorSwap (pANTLR3_VECTOR vector, ANTLR3_UINT32 entry1, ANTLR3_UINT32 entry2)
1399 // If the vector is currently not big enough, then we do nothing
1401 if (entry1 >= vector->elementsSize || entry2 >= vector->elementsSize)
1408 tempEntry = vector->elements[entry1].element;
1409 freeptr = vector->elements[entry1].freeptr;
1413 vector->elements[entry1].freeptr = vector->elements[entry2].freeptr;
1414 vector->elements[entry1].element = vector->elements[entry2].element;
1416 vector->elements[entry2].freeptr = freeptr;
1417 vector->elements[entry2].element = tempEntry;
1423 static ANTLR3_UINT32 antlr3VectorSize (pANTLR3_VECTOR vector)
1425 return vector->count;
1432 /// Vector factory creation
1448 // Factory memory is good, so create a new vector pool
1478 returnVector (pANTLR3_VECTOR_FACTORY factory, pANTLR3_VECTOR vector)
1480 // First we need to clear out anything that is still in the vector
1482 vector->clear(vector);
1484 // We have a free stack available so we can add the vector we were
1485 // given into the free chain. The vector has to have come from this
1489 factory->freeStack->push(factory->freeStack, vector, NULL);
1491 // TODO: remove this line once happy printf("Returned vector %08X to the pool, stack size is %d\n", vector, factory->freeStack->size(factory->freeStack));
1530 ANTLR3_UINT32 vector;
1540 /* We iterate the vector pools one at a time
1559 for (vector = 0; vector < limit; vector++)
1563 check = pool + vector;
1567 // pointer to be freed. However, because any vector may be in any other
1568 // vector, we don't free the element allocations yet. We do that in a
1569 // a specific pass, coming up next. The vector free function knows that
1570 // this is a factory allocated pool vector and so it won't free things it
1578 /* We iterate the vector pools one at a time once again, but this time
1581 * the vectors all over the place and they may be embedded in this vector pool
1601 for (vector = 0; vector < limit; vector++)
1605 check = pool + vector;
1619 // We can now free this pool allocation as we have called free on every element in every vector
1640 pANTLR3_VECTOR vector;
1644 vector = factory->freeStack->peek(factory->freeStack);
1646 if (vector != NULL)
1652 // TODO: remove this line once happy printf("Reused vector %08X from stack, size is now %d\n", vector, factory->freeStack->size(factory->freeStack));
1653 return vector;
1657 // See if we need a new vector pool before allocating a new
1668 // error checking. Then we can work out what the pointer is to the next vector.
1670 vector = factory->pools[factory->thisPool] + factory->nextVector;
1675 antlr3SetVectorApi(vector, ANTLR3_VECTOR_INTERNAL_SIZE);
1676 vector->factoryMade = ANTLR3_TRUE;
1679 // will start off using their internal entry pointers. We must intialize our pool vector
1682 vector->elements = vector->internal;
1684 // TODO: remove this line once happy printf("Used a new vector at %08X from the pools as nothing on the reusue stack\n", vector);
1688 return vector;
2279 topo->sortVector(topo, myVector); // Sort the vector in place (node numbers are the vector entry numbers)
2534 // First we need a vector to populate with enough
2593 // To sort a vector, we first perform the
2594 // sort to an array, then use the results to reorder the vector
2605 // Used as a lookup index to find the current location in the vector of
2606 // the vector entry that was originally at position [0], [1], [2] etc
2623 // Ensure that the vector we are sorting is at least as big as the
2631 // responsible for ensuring the vector is the correct one and is the
2637 // in the vector as we don't want to duplicate them in a new vector. We
2638 // just use an indirection table to get the vector entry for a particular sequence
2639 // acording to where we moved it last. Then we can just swap vector entries until
2644 // Start index, each vector entry is located where you think it is
2652 // the vector around according to the sort order and the indirection
2653 // table we just created. The index telsl us where in the vector the
2660 // If the vector entry at i is already the one that it
2668 // The vector entry at i, should be replaced with the
2669 // vector entry indicated by topo->sorted[i]. The vector entry
2685 // Having traversed all the entries, we have sorted the vector in place.
2696 // Free the result vector
