void testStringBubbleSort(char *filename) {
int length;
char **plaetzchenListe;
plaetzchenListe = readRezeptListe(filename);
length = getArrayLength(plaetzchenListe);
printf("---- testStringBubbleSort() -----------------\n\n");
printf("Es sind %i Rezepte in der Liste\n", length);
stringBubbleSort(length, plaetzchenListe);
printStringArray(getArrayLength(plaetzchenListe), plaetzchenListe);
cleanup(plaetzchenListe); // memory leaks vermeiden -- hier zwar nicht
// notwendig aber sinnvoll!
}
/*
P1 e)
Aufräumarbeiten
*/
void cleanup(char **stringArray) {
int n = getArrayLength(stringArray);
for (int i = 0; i < n; i++) {
free(*(stringArray + i));
}
free(stringArray);
}
// From IXmlSource
void CTypeElement::toXml(CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) const
{
if (!isScalar()) {
xmlElement.setAttribute("ArrayLength", getArrayLength());
}
base::toXml(xmlElement, serializingContext);
}
void MetaModelicaArrayValue::retrieveChildren()
{
GDBAdapter *pGDBAdapter = GDBAdapter::instance();
for (int i = 1 ; i <= getArrayLength() ; i++) {
StackFramesWidget *pStackFramesWidget = MainWindow::instance()->getStackFramesWidget();
QByteArray cmd = CommandFactory::getMetaTypeElement(pStackFramesWidget->getSelectedThread(), pStackFramesWidget->getSelectedFrame(),
mpLocalsTreeItem->getName(), i, CommandFactory::array_metaType);
pGDBAdapter->postCommand(cmd, GDBAdapter::BlockUntilResponse, mpLocalsTreeItem, &GDBAdapter::getMetaTypeElementCB);
}
}
// Private methods
void MeetAndroid::processCommand(){
if(buffer[0]-FunctionBufferOffset < FunctionBufferLenght){
void (*H_FuncPtr)(uint8_t, uint8_t) = intFunc[buffer[0]-FunctionBufferOffset];
if (H_FuncPtr != 0) {
H_FuncPtr(buffer[0], getArrayLength());
}
else {
send("Flag not registered: ");
send(buffer[0]);
}
}
else {
if (customErrorFunc)
errorFunc(buffer[0], getArrayLength());
else {
send("Flag out of bounds: ");
send(buffer[0]);
}
}
}
/**
* Creates an object in the embedded JVM whose contents are initialized from a given object in Squawk memory.
* This routine only handles Strings, byte arrays, char arrays and int arrays.
*
* @param object the address of an object in Squawk memory
* @param fill true if the return object should be initialized from the Squawk object
* @return the corresponding object in the embedded JVM
*/
static Address createJVMObject(Address object, boolean fill) {
if (object != 0) {
Address cls = getClass(object);
int id = com_sun_squawk_Klass_id(cls);
Address jvmObject;
if (id == CID_STRING || id == CID_STRING_OF_BYTES) {
jvmObject = createJVMString(object, id, getArrayLength(object));
} else if (id == CID_BYTE_ARRAY) {
jvmObject = createJVMByteArray(object, getArrayLength(object), fill);
} else if (id == CID_CHAR_ARRAY) {
jvmObject = createJVMCharArray(object, getArrayLength(object), fill);
} else if (id == CID_INT_ARRAY) {
jvmObject = createJVMIntArray(object, getArrayLength(object), fill);
} else {
fatalVMError("createJVMObject:: Invalid reference type");
}
return jvmObject;
}
return null;
}
int main(int argc, const char *argv[])
{
int len = getArrayLength(14, 5, 3);
unsigned int *array = getArrayPointer(14, 5, 3);
printf("ArrayLength: %u\n", len);
int i;
for (i = 0; i < len; i += 2) {
printf("0x%03X 0x%08X\n", array[i], array[i+1]);
}
return 0;
}
void testHeap()
{
int length = getArrayLength();
MyHeap<int> heap;
heap.makeMinHeap(arrayList, length);
cout << "make MinHeap : \t";
coutList(arrayList, length);
cout << "sort result : \t";
heap.heapMinSort(arrayList, length);
coutList(arrayList, length);
}
//²âÊÔÁ´±í
void testLinkList()
{
LinkNode<int> *head = new LinkNode<int>();
MyLinkList<int> link(head);
for (int i = 0; i < getArrayLength(); i++){
if (i == 0)
{
head->data = &arrayList[i];
continue;
}
link.insertData(link.getFoot(), &arrayList[i]);
}
cout << "cout linklistData "<<endl;
link.countLink();
cout << "length " << link.getLength()<<endl;
cout << "mid node : " << *(link.getMidNode()->data)<<endl;
}
void getSimpleLink(LinkNode<int> *head,bool hasCircle)
{
static MyLinkList<int> link(head);
for (int i = 0; i < getArrayLength(); i++){
if (i == 0)
{
head->data = &arrayList[i];
continue;
}
link.insertData(link.getFoot(), &arrayList[i]);
}
if (hasCircle)
{
link.getFoot()->next = link.getNode(4);
}
// link.countLink();
}
unsigned int *getArrayPointer(int board, int bus, int support) {
unsigned int hex = 0;
hex += board;
hex += bus << 8;
hex += support << 16;
hex += 0xFF000000;
printf("\n\n0x%X\n", hex);
int i = 0;
int len = getArrayLength(board, bus, support);
while (PHY_REG_1TArray[i] != hex && i < len)
i++;
i += 2; // skip keywords like 0xABCD
int j = 0;
unsigned int *ptr_array = (unsigned int*)malloc(sizeof(int) * len);
for (i; i < len; i += 2) {
const unsigned int v1 = PHY_REG_1TArray[i];
const unsigned int v2 = PHY_REG_1TArray[i+1];
if (v2 != 0xABCD &&
v2 != 0xCDEF &&
v2 != 0xCDCD &&
v2 != 0xDEAD ) {
ptr_array[j++] = v1;
ptr_array[j++] = v2;
} else {
break;
}
}
array_length = j - 1;
return ptr_array;
}
/*!
@brief Clone
*/
OId VariableArrayCursor::clone(TransactionContext &txn,
const AllocateStrategy &allocateStrategy, OId neighborOId) {
if (UNDEF_OID == getBaseOId()) {
return UNDEF_OID;
}
OId currentNeighborOId = neighborOId;
OId linkOId = UNDEF_OID;
uint32_t srcDataLength = getArrayLength();
if (srcDataLength == 0) {
uint8_t *srcObj = getBaseAddr();
Size_t srcObjSize = getObjectManager()->getSize(srcObj);
BaseObject destObject(txn.getPartitionId(), *getObjectManager());
OId destOId = UNDEF_OID;
if (currentNeighborOId != UNDEF_OID) {
destObject.allocateNeighbor<uint8_t>(srcObjSize, allocateStrategy,
destOId, currentNeighborOId, OBJECT_TYPE_VARIANT);
}
else {
destObject.allocate<uint8_t>(
srcObjSize, allocateStrategy, destOId, OBJECT_TYPE_VARIANT);
}
memcpy(destObject.getBaseAddr(), srcObj, srcObjSize);
linkOId = destOId;
}
else {
OId srcOId = UNDEF_OID;
OId destOId = UNDEF_OID;
OId prevOId = UNDEF_OID;
uint8_t *srcObj = NULL;
BaseObject destObject(txn.getPartitionId(), *getObjectManager());
uint8_t *srcElem;
uint32_t srcElemSize;
uint32_t srcCount;
uint8_t *lastElem = NULL;
uint32_t lastElemSize = 0;
while (nextElement()) {
srcObj = data();
srcOId = getElementOId();
srcElem = getElement(srcElemSize, srcCount);
if (srcOId != prevOId) {
Size_t srcObjSize = getObjectManager()->getSize(srcObj);
if (currentNeighborOId != UNDEF_OID) {
destObject.allocateNeighbor<uint8_t>(srcObjSize,
allocateStrategy, destOId, currentNeighborOId,
OBJECT_TYPE_VARIANT);
}
else {
destObject.allocate<uint8_t>(srcObjSize, allocateStrategy,
destOId, OBJECT_TYPE_VARIANT);
}
currentNeighborOId =
destOId;
memcpy(destObject.getBaseAddr(), srcObj, srcObjSize);
if (UNDEF_OID == linkOId) {
linkOId = destOId;
}
else {
assert(lastElem > 0);
uint8_t *linkOIdAddr =
lastElem + lastElemSize +
ValueProcessor::getEncodedVarSize(lastElemSize);
uint64_t encodedOId =
ValueProcessor::encodeVarSizeOId(destOId);
memcpy(linkOIdAddr, &encodedOId, sizeof(uint64_t));
}
prevOId = srcOId;
}
lastElem = destObject.getBaseAddr() + (srcElem - srcObj);
lastElemSize = srcElemSize;
}
}
return linkOId;
}
/* dfsMarkByMode (s, r, m, shc, slw)
*
* Sets all the mark bits in the object graph pointed to by r.
*
* If m is MARK_MODE, it sets the bits to 1.
* If m is UNMARK_MODE, it sets the bits to 0.
*
* If shc, it hash-conses the objects marked.
*
* If slw, it links the weak objects marked.
*
* It returns the total size in bytes of the objects marked.
*/
size_t dfsMarkByMode (GC_state s, pointer root,
GC_markMode mode,
bool shouldHashCons,
bool shouldLinkWeaks) {
GC_header mark; /* Used to set or clear the mark bit. */
size_t size; /* Total number of bytes marked. */
pointer cur; /* The current object being marked. */
pointer prev; /* The previous object on the mark stack. */
pointer next; /* The next object to mark. */
pointer todo; /* A pointer to the pointer in cur to next. */
GC_header header;
GC_header* headerp;
uint16_t bytesNonObjptrs;
uint16_t numObjptrs;
GC_objectTypeTag tag;
uint32_t objptrIndex; /* The i'th pointer in the object (element) being marked. */
GC_header nextHeader;
GC_header* nextHeaderp;
GC_arrayCounter arrayIndex;
pointer top; /* The top of the next stack frame to mark. */
GC_returnAddress returnAddress;
GC_frameLayout frameLayout;
GC_frameOffsets frameOffsets;
if (isPointerMarkedByMode (root, mode))
/* Object has already been marked. */
return 0;
mark = (MARK_MODE == mode) ? MARK_MASK : 0;
size = 0;
cur = root;
prev = NULL;
headerp = getHeaderp (cur);
header = *headerp;
goto mark;
markNext:
/* cur is the object that was being marked.
* prev is the mark stack.
* next is the unmarked object to be marked.
* nextHeaderp points to the header of next.
* nextHeader is the header of next.
* todo is a pointer to the pointer inside cur that points to next.
*/
if (DEBUG_DFS_MARK)
fprintf (stderr,
"markNext"
" cur = "FMTPTR" next = "FMTPTR
" prev = "FMTPTR" todo = "FMTPTR"\n",
(uintptr_t)cur, (uintptr_t)next,
(uintptr_t)prev, (uintptr_t)todo);
assert (not isPointerMarkedByMode (next, mode));
assert (nextHeaderp == getHeaderp (next));
assert (nextHeader == getHeader (next));
// assert (*(pointer*) todo == next);
assert (fetchObjptrToPointer (todo, s->heap.start) == next);
headerp = nextHeaderp;
header = nextHeader;
// *(pointer*)todo = prev;
storeObjptrFromPointer (todo, prev, s->heap.start);
prev = cur;
cur = next;
mark:
if (DEBUG_DFS_MARK)
fprintf (stderr, "mark cur = "FMTPTR" prev = "FMTPTR" mode = %s\n",
(uintptr_t)cur, (uintptr_t)prev,
(mode == MARK_MODE) ? "mark" : "unmark");
/* cur is the object to mark.
* prev is the mark stack.
* headerp points to the header of cur.
* header is the header of cur.
*/
assert (not isPointerMarkedByMode (cur, mode));
assert (header == getHeader (cur));
assert (headerp == getHeaderp (cur));
header ^= MARK_MASK;
/* Store the mark. In the case of an object that contains a pointer to
* itself, it is essential that we store the marked header before marking
* the internal pointers (markInNormal below). If we didn't, then we
* would see the object as unmarked and traverse it again.
*/
*headerp = header;
splitHeader (s, header, &tag, NULL, &bytesNonObjptrs, &numObjptrs);
if (NORMAL_TAG == tag) {
size +=
GC_NORMAL_HEADER_SIZE
+ bytesNonObjptrs
+ (numObjptrs * OBJPTR_SIZE);
if (0 == numObjptrs) {
/* There is nothing to mark. */
normalDone:
if (shouldHashCons)
cur = hashConsPointer (s, cur, TRUE);
goto ret;
}
todo = cur + bytesNonObjptrs;
objptrIndex = 0;
markInNormal:
if (DEBUG_DFS_MARK)
fprintf (stderr, "markInNormal objptrIndex = %"PRIu32"\n", objptrIndex);
assert (objptrIndex < numObjptrs);
// next = *(pointer*)todo;
next = fetchObjptrToPointer (todo, s->heap.start);
if (not isPointer (next)) {
markNextInNormal:
assert (objptrIndex < numObjptrs);
objptrIndex++;
if (objptrIndex == numObjptrs) {
/* Done. Clear out the counters and return. */
*headerp = header & ~COUNTER_MASK;
goto normalDone;
}
todo += OBJPTR_SIZE;
goto markInNormal;
}
nextHeaderp = getHeaderp (next);
nextHeader = *nextHeaderp;
if (mark == (nextHeader & MARK_MASK)) {
if (shouldHashCons)
shareObjptr (s, (objptr*)todo);
goto markNextInNormal;
}
*headerp = (header & ~COUNTER_MASK) | (objptrIndex << COUNTER_SHIFT);
goto markNext;
} else if (WEAK_TAG == tag) {
/* Store the marked header and don't follow any pointers. */
if (shouldLinkWeaks) {
GC_weak w;
w = (GC_weak)(cur + offsetofWeak (s));
if (DEBUG_WEAK)
fprintf (stderr, "marking weak "FMTPTR" ",
(uintptr_t)w);
if (isObjptr (w->objptr)) {
if (DEBUG_WEAK)
fprintf (stderr, "linking\n");
w->link = s->weaks;
s->weaks = w;
} else {
if (DEBUG_WEAK)
fprintf (stderr, "not linking\n");
}
}
goto ret;
} else if (ARRAY_TAG == tag) {
/* When marking arrays:
* arrayIndex is the index of the element to mark.
* cur is the pointer to the array.
* objptrIndex is the index of the pointer within the element
* (i.e. the i'th pointer is at index i).
* todo is the start of the element.
*/
size +=
GC_ARRAY_HEADER_SIZE
+ sizeofArrayNoHeader (s, getArrayLength (cur), bytesNonObjptrs, numObjptrs);
if (0 == numObjptrs or 0 == getArrayLength (cur)) {
/* There is nothing to mark. */
arrayDone:
if (shouldHashCons)
cur = hashConsPointer (s, cur, TRUE);
goto ret;
}
/* Begin marking first element. */
arrayIndex = 0;
todo = cur;
markArrayElt:
assert (arrayIndex < getArrayLength (cur));
objptrIndex = 0;
/* Skip to the first pointer. */
todo += bytesNonObjptrs;
markInArray:
if (DEBUG_DFS_MARK)
fprintf (stderr, "markInArray arrayIndex = %"PRIxARRCTR" objptrIndex = %"PRIu32"\n",
arrayIndex, objptrIndex);
assert (arrayIndex < getArrayLength (cur));
assert (objptrIndex < numObjptrs);
assert (todo == indexArrayAtObjptrIndex (s, cur, arrayIndex, objptrIndex));
// next = *(pointer*)todo;
next = fetchObjptrToPointer (todo, s->heap.start);
if (not (isPointer(next))) {
markNextInArray:
assert (arrayIndex < getArrayLength (cur));
assert (objptrIndex < numObjptrs);
assert (todo == indexArrayAtObjptrIndex (s, cur, arrayIndex, objptrIndex));
todo += OBJPTR_SIZE;
objptrIndex++;
if (objptrIndex < numObjptrs)
goto markInArray;
arrayIndex++;
if (arrayIndex < getArrayLength (cur))
goto markArrayElt;
/* Done. Clear out the counters and return. */
*getArrayCounterp (cur) = 0;
*headerp = header & ~COUNTER_MASK;
goto arrayDone;
}
nextHeaderp = getHeaderp (next);
nextHeader = *nextHeaderp;
if (mark == (nextHeader & MARK_MASK)) {
if (shouldHashCons)
shareObjptr (s, (objptr*)todo);
goto markNextInArray;
}
/* Recur and mark next. */
*getArrayCounterp (cur) = arrayIndex;
*headerp = (header & ~COUNTER_MASK) | (objptrIndex << COUNTER_SHIFT);
goto markNext;
} else {
assert (STACK_TAG == tag);
size +=
GC_STACK_HEADER_SIZE
+ sizeof (struct GC_stack) + ((GC_stack)cur)->reserved;
top = getStackTop (s, (GC_stack)cur);
assert (((GC_stack)cur)->used <= ((GC_stack)cur)->reserved);
markInStack:
/* Invariant: top points just past the return address of the frame
* to be marked.
*/
assert (getStackBottom (s, (GC_stack)cur) <= top);
if (DEBUG_DFS_MARK)
fprintf (stderr, "markInStack top = %"PRIuMAX"\n",
(uintmax_t)(top - getStackBottom (s, (GC_stack)cur)));
if (top == getStackBottom (s, (GC_stack)(cur)))
goto ret;
objptrIndex = 0;
returnAddress = *(GC_returnAddress*) (top - GC_RETURNADDRESS_SIZE);
frameLayout = getFrameLayoutFromReturnAddress (s, returnAddress);
frameOffsets = frameLayout->offsets;
((GC_stack)cur)->markTop = top;
markInFrame:
if (objptrIndex == frameOffsets [0]) {
top -= frameLayout->size;
goto markInStack;
}
todo = top - frameLayout->size + frameOffsets [objptrIndex + 1];
// next = *(pointer*)todo;
next = fetchObjptrToPointer (todo, s->heap.start);
if (DEBUG_DFS_MARK)
fprintf (stderr,
" offset %u todo "FMTPTR" next = "FMTPTR"\n",
frameOffsets [objptrIndex + 1],
(uintptr_t)todo, (uintptr_t)next);
if (not isPointer (next)) {
objptrIndex++;
goto markInFrame;
}
nextHeaderp = getHeaderp (next);
nextHeader = *nextHeaderp;
if (mark == (nextHeader & MARK_MASK)) {
objptrIndex++;
if (shouldHashCons)
shareObjptr (s, (objptr*)todo);
goto markInFrame;
}
((GC_stack)cur)->markIndex = objptrIndex;
goto markNext;
}
assert (FALSE);
ret:
/* Done marking cur, continue with prev.
* Need to set the pointer in the prev object that pointed to cur
* to point back to prev, and restore prev.
*/
if (DEBUG_DFS_MARK)
fprintf (stderr, "return cur = "FMTPTR" prev = "FMTPTR"\n",
(uintptr_t)cur, (uintptr_t)prev);
assert (isPointerMarkedByMode (cur, mode));
if (NULL == prev)
return size;
next = cur;
cur = prev;
headerp = getHeaderp (cur);
header = *headerp;
splitHeader (s, header, &tag, NULL, &bytesNonObjptrs, &numObjptrs);
/* It's impossible to get a WEAK_TAG here, since we would never
* follow the weak object pointer.
*/
assert (WEAK_TAG != tag);
if (NORMAL_TAG == tag) {
todo = cur + bytesNonObjptrs;
objptrIndex = (header & COUNTER_MASK) >> COUNTER_SHIFT;
todo += objptrIndex * OBJPTR_SIZE;
// prev = *(pointer*)todo;
prev = fetchObjptrToPointer (todo, s->heap.start);
// *(pointer*)todo = next;
storeObjptrFromPointer (todo, next, s->heap.start);
if (shouldHashCons)
markIntergenerationalPointer (s, (pointer*)todo);
goto markNextInNormal;
} else if (ARRAY_TAG == tag) {
QString MetaModelicaArrayValue::getValueString()
{
return QString("<%1 item%2>").arg(getArrayLength()).arg(getArrayLength() > 1 ? "s" : "");
}
uintmax_t GC_getArrayLength (pointer a) {
return ((uintmax_t)(getArrayLength (a)));
}