Type Type::get_function_returning(const ObjectList<Type>& type_list,
const ObjectList<Type>& nonadjusted_type_list,
bool has_ellipsis,
ref_qualifier_t reference_qualifier)
{
int i;
parameter_info_t *parameters_list;
int num_parameters = type_list.size();
parameters_list = NEW_VEC(parameter_info_t,
num_parameters + has_ellipsis);
for (i=0; i<num_parameters; i++)
{
parameters_list[i].is_ellipsis = 0;
parameters_list[i].type_info = type_list[i]._type_info;
parameters_list[i].nonadjusted_type_info = nonadjusted_type_list[i]._type_info;
}
if (has_ellipsis)
{
num_parameters++;
parameters_list[i].is_ellipsis = 1;
parameters_list[i].type_info = get_ellipsis_type();
parameters_list[i].nonadjusted_type_info = NULL;
}
return (Type(get_new_function_type(_type_info, parameters_list, num_parameters, reference_qualifier)));
}
int main()
{
// TestCase Group1:
MemPool objMemPool;
MemPool *pMemPool = &objMemPool;
int32_t nCount = 10;
char *pszArray = NEW_VEC(pMemPool, char, nCount);
int32_t *pnArray = NEW_VEC(pMemPool, int32_t, nCount);
float *pfArray = NEW_VEC(pMemPool, float, nCount);
for (int i = 0; i < nCount; i++) {
pszArray[i] = 'a' + i;
pnArray[i] = i;
pfArray[i] = 1.0 * i;
}
for (int i = 0; i < nCount; i++) {
fprintf(stdout, "pszArray[%d]:\t%c\n", i, pszArray[i]);
fprintf(stdout, "pnArray[%d]:\t%d\n", i, pnArray[i]);
fprintf(stdout, "pfArray[%d]:\t%f\n", i, pfArray[i]);
}
pMemPool->reset();
// TestCase Group2:
MemPool objMemPool2;
MemPool *pMemPool2 = &objMemPool2;
int32_t nCount2 = 10;
MyClass *pMyClass = NEW(pMemPool2, MyClass);
fprintf(stdout, "pMyClass:\t%d\n", pMyClass->getCount());
MyClass *pMyClass2 = NEW(pMemPool2, MyClass)(100);
fprintf(stdout, "pMyClass2:\t%d\n", pMyClass2->getCount());
MyClass *pMyClassArray = NEW_ARRAY(pMemPool2, MyClass, nCount2);
for (int i = 0; i < nCount2; i++) {
fprintf(stdout, "pMyClassArray[%d]:\t%d\n", i, pMyClassArray[i].getCount());
}
pMemPool2->reset();
// TestCase Group3:
MemPool objMemPool3;
MemPool *pMemPool3 = &objMemPool3;
MemMonitor memMonitor(pMemPool3, 1);
pMemPool3->setMonitor(&memMonitor);
memMonitor.enableException();
int32_t nCount3 = 1;
char *pszArray3 = NEW_VEC(pMemPool3, char, nCount3);
if (!pszArray3) {
printf("pszArray3 NEW_VEC Err!\n");
}
nCount3 = 1024;
int32_t *pnArray3 = NEW_VEC(pMemPool3, int32_t, nCount3);
if (!pnArray3) {
printf("pnArray3 NEW_VEC Err!\n");
}
float *pfArray3 = NEW_VEC(pMemPool3, float, nCount3);
if (!pfArray3) {
printf("pfArray3 NEW_VEC Err!\n");
}
for (int i = 0; i < nCount3; i++) {
pszArray3[i] = 'a' + i;
pnArray3[i] = i;
pfArray3[i] = 1.0 * i;
}
for (int i = 0; i < nCount3; i++) {
fprintf(stdout, "pszArray3[%d]:\t%c\n", i, pszArray3[i]);
fprintf(stdout, "pnArray3[%d]:\t%d\n", i, pnArray3[i]);
fprintf(stdout, "pfArray3[%d]:\t%f\n", i, pfArray3[i]);
}
pMemPool3->reset();
// TestCase Group4:
MemPool objMemPool4;
MemPool *pMemPool4 = &objMemPool4;
MemMonitor memMonitor4(pMemPool4, 1);
pMemPool4->setMonitor(&memMonitor4);
memMonitor4.enableException();
int32_t nCountsz4 = 1024;
char *pszArraysz4 = NEW_VEC(pMemPool4, char, nCountsz4);
if (!pszArraysz4) {
printf("pszArraysz4 is NULL\n");
}
MyClass *pMyClass4 = NEW(pMemPool4, MyClass);
if (!pMyClass4) {
printf("pMyClass4 is NULL\n");
}
fprintf(stdout, "pMyClass4:\t%d\n", pMyClass4->getCount());
int32_t nCountsz4_1 = 1024;
char *pszArraysz4_1 = NEW_VEC(pMemPool4, char, nCountsz4_1);
if (!pszArraysz4_1) {
printf("pszArraysz4_1 is NULL\n");
}
MyClass *pMyClass4_1 = NEW(pMemPool4, MyClass)(100);
if (!pMyClass4_1) {
printf("pMyClass4_1 is NULL\n");
}
fprintf(stdout, "pMyClass4_1:\t%d\n", pMyClass4_1->getCount());
int32_t nCountsz4_2 = 1024;
char *pszArraysz4_2 = NEW_VEC(pMemPool4, char, nCountsz4_2);
if (!pszArraysz4_2) {
printf("pszArraysz4_2 is NULL\n");
}
int32_t nCount4_2 = 1;
MyClass *pMyClassArray4_2 = NEW_ARRAY(pMemPool4, MyClass, nCount4_2);
if (!pMyClassArray4_2) {
printf("pMyClassArray4_2 is NULL\n");
}
for (int i = 0; i < nCount4_2; i++) {
fprintf(stdout, "pMyClassArray4_2[%d]:\t%d\n", i, pMyClassArray4_2[i].getCount());
}
pMemPool4->reset();
return 0;
}
/* LIB7_Poll:
*
* The version of the polling operation for systems that provide BSD select.
*/
static lib7_val_t LIB7_Poll (lib7_state_t *lib7_state, lib7_val_t poll_list, struct timeval *timeout)
{
fd_set rset, wset, eset;
fd_set *rfds, *wfds, *efds;
int maxFD, status, fd, flag;
lib7_val_t l, item;
/*printf("src/runtime/c-libs/posix-os/poll.c: Using 'select' implementation\n");*/
rfds = wfds = efds = NULL;
maxFD = 0;
for (l = poll_list; l != LIST_nil; l = LIST_tl(l)) {
item = LIST_hd(l);
fd = REC_SELINT(item, 0);
flag = REC_SELINT(item, 1);
if ((flag & READABLE_BIT) != 0) {
/*int fd_flags = fcntl(fd,F_GETFL,0);*/
if (rfds == NULL) {
rfds = &rset;
FD_ZERO(rfds);
}
/*printf("src/runtime/c-libs/posix-os/poll.c: Will check fd %d for readability. fd flags x=%x O_NONBLOCK x=%x\n",fd,fd_flags,O_NONBLOCK);*/
FD_SET (fd, rfds);
}
if ((flag & WRITABLE_BIT) != 0) {
if (wfds == NULL) {
wfds = &wset;
FD_ZERO(wfds);
}
/*printf("src/runtime/c-libs/posix-os/poll.c: Will check fd %d for writability.\n",fd);*/
FD_SET (fd, wfds);
}
if ((flag & OOBDABLE_BIT) != 0) {
if (efds == NULL) {
efds = &eset;
FD_ZERO(efds);
}
/*printf("src/runtime/c-libs/posix-os/poll.c: Will check fd %d for oobdability.\n",fd);*/
FD_SET (fd, efds);
}
if (fd > maxFD) maxFD = fd;
}
/*printf("src/runtime/c-libs/posix-os/poll.c: maxFD d=%d timeout x=%x.\n",maxFD,timeout);*/
/* do { */ /* Backed out 2010-02-26 CrT: See discussion at bottom of src/runtime/c-libs/lib7-socket/connect.c */
status = select (maxFD+1, rfds, wfds, efds, timeout);
/* } while (status < 0 && errno == EINTR); */ /* Restart if interrupted by a SIGALRM or SIGCHLD or whatever. */
/*printf("src/runtime/c-libs/posix-os/poll.c: result status d=%d.\n",status);*/
if (status < 0)
return RAISE_SYSERR(lib7_state, status);
else if (status == 0)
return LIST_nil;
else {
lib7_val_t *resVec = NEW_VEC(lib7_val_t, status);
int i;
int resFlag;
for (i = 0, l = poll_list; l != LIST_nil; l = LIST_tl(l)) {
item = LIST_hd(l);
fd = REC_SELINT(item, 0);
flag = REC_SELINT(item, 1);
resFlag = 0;
if (((flag & READABLE_BIT) != 0) && FD_ISSET(fd, rfds)) {
/*int fd_flags = fcntl(fd,F_GETFL,0);*/
/*printf("src/runtime/c-libs/posix-os/poll.c: fd d=%d is in fact readable. fd flags x=%x O_NONBLOCK x=%x\n",fd,fd_flags,O_NONBLOCK);*/
resFlag |= READABLE_BIT;
}
if (((flag & WRITABLE_BIT) != 0) && FD_ISSET(fd, wfds)) {
/*printf("src/runtime/c-libs/posix-os/poll.c: fd d=%d is in fact writable.\n",fd);*/
resFlag |= WRITABLE_BIT;
}
if (((flag & OOBDABLE_BIT) != 0) && FD_ISSET(fd, efds)) {
/*printf("src/runtime/c-libs/posix-os/poll.c: fd d=%d is in fact oobdable.\n",fd);*/
resFlag |= OOBDABLE_BIT;
}
if (resFlag != 0) {
REC_ALLOC2 (lib7_state, item, INT_CtoLib7(fd), INT_CtoLib7(resFlag));
resVec[i++] = item;
}
}
ASSERT(i == status);
for (i = status-1, l = LIST_nil; i >= 0; i--) {
item = resVec[i];
LIST_cons (lib7_state, l, item, l);
}
FREE(resVec);
return l;
}
} /* end of LIB7_Poll */
static void read_heap ( inbuf_t* bp,
lib7_heap_hdr_t* header,
lib7_state_t* lib7_state,
lib7_val_t* externs
)
{
heap_t* heap = lib7_state->lib7_heap;
heap_arena_hdr_t *arenaHdrs, *p, *q;
int arenaHdrsSize;
int i, j, k;
long prevSzB[NUM_ARENAS], size;
bibop_t oldBIBOP;
Addr_t addrOffset[MAX_NUM_GENS][NUM_ARENAS];
bo_region_reloc_t *boRelocInfo;
addr_table_t *boRegionTable;
/* Allocate a BIBOP for the imported
* heap image's address space:
*/
#ifdef TWO_LEVEL_MAP
# error two level map not supported
#else
oldBIBOP = NEW_VEC (aid_t, BIBOP_SZ);
#endif
/* Read in the big-chunk region descriptors
* for the old address space:
*/
{
int size;
bo_region_info_t* boRgnHdr;
boRegionTable = MakeAddrTable(BIBOP_SHIFT+1, header->numBORegions);
size = header->numBORegions * sizeof(bo_region_info_t);
boRgnHdr = (bo_region_info_t *) MALLOC (size);
HeapIO_ReadBlock (bp, boRgnHdr, size);
boRelocInfo = NEW_VEC(bo_region_reloc_t, header->numBORegions);
for (i = 0; i < header->numBORegions; i++) {
MarkRegion(oldBIBOP,
(lib7_val_t *)(boRgnHdr[i].baseAddr),
RND_HEAP_CHUNK_SZB(boRgnHdr[i].sizeB),
AID_BIGCHUNK(1)
);
oldBIBOP[BIBOP_ADDR_TO_INDEX(boRgnHdr[i].baseAddr)] = AID_BIGCHUNK_HDR(MAX_NUM_GENS);
boRelocInfo[i].firstPage = boRgnHdr[i].firstPage;
boRelocInfo[i].nPages
=
(boRgnHdr[i].sizeB - (boRgnHdr[i].firstPage - boRgnHdr[i].baseAddr))
>>
BIGCHUNK_PAGE_SHIFT;
boRelocInfo[i].chunkMap = NEW_VEC(bo_reloc_t *, boRelocInfo[i].nPages);
for (j = 0; j < boRelocInfo[i].nPages; j++) {
boRelocInfo[i].chunkMap[j] = NULL;
}
AddrTableInsert (boRegionTable, boRgnHdr[i].baseAddr, &(boRelocInfo[i]));
}
FREE (boRgnHdr);
}
/* Read the arena headers: */
arenaHdrsSize = header->numGens * NUM_CHUNK_KINDS * sizeof(heap_arena_hdr_t);
arenaHdrs = (heap_arena_hdr_t *) MALLOC (arenaHdrsSize);
HeapIO_ReadBlock (bp, arenaHdrs, arenaHdrsSize);
for (i = 0; i < NUM_ARENAS; i++) {
prevSzB[i] = heap->allocSzB;
}
/* Allocate the arenas and read in the heap image: */
for (p = arenaHdrs, i = 0; i < header->numGens; i++) {
gen_t *gen = heap->gen[i];
/* Compute the space required for this generation,
* and mark the oldBIBOP to reflect the old address space:
*/
for (q = p, j = 0; j < NUM_ARENAS; j++) {
MarkRegion (oldBIBOP,
(lib7_val_t *)(q->info.o.baseAddr),
RND_HEAP_CHUNK_SZB(q->info.o.sizeB),
gen->arena[j]->id);
size = q->info.o.sizeB + prevSzB[j];
if ((j == PAIR_INDEX) && (size > 0))
size += 2*WORD_SZB;
gen->arena[j]->tospSizeB = RND_HEAP_CHUNK_SZB(size);
prevSzB[j] = q->info.o.sizeB;
q++;
}
/* Allocate space for the generation: */
if (NewGeneration(gen) == FAILURE) {
Die ("unable to allocated space for generation %d\n", i+1);
}
if (isACTIVE(gen->arena[ARRAY_INDEX])) {
NewDirtyVector (gen);
}
/* Read in the arenas for this generation
* and initialize the address offset table:
*/
for (j = 0; j < NUM_ARENAS; j++) {
arena_t* ap = gen->arena[j];
if (p->info.o.sizeB > 0) {
addrOffset[i][j] = (Addr_t)(ap->tospBase) - (Addr_t)(p->info.o.baseAddr);
HeapIO_Seek (bp, (long)(p->offset));
HeapIO_ReadBlock(bp, (ap->tospBase), p->info.o.sizeB);
ap->nextw = (lib7_val_t *)((Addr_t)(ap->tospBase) + p->info.o.sizeB);
ap->oldTop = ap->tospBase;
} else if (isACTIVE(ap)) {
ap->oldTop = ap->tospBase;
}
if (verbosity > 0) say(".");
p++;
}
/* Read in the big-chunk arenas: */
for (j = 0; j < NUM_BIGCHUNK_KINDS; j++) {
Addr_t totSizeB;
bigchunk_desc_t *freeChunk, *bdp;
bigchunk_region_t *freeRegion;
bigchunk_hdr_t *boHdrs;
int boHdrSizeB, index;
bo_region_reloc_t *region;
if (p->info.bo.numBOPages > 0) {
totSizeB = p->info.bo.numBOPages << BIGCHUNK_PAGE_SHIFT;
freeChunk = BO_AllocRegion (heap, totSizeB);
freeRegion = freeChunk->region;
freeRegion->minGen = i;
MarkRegion (BIBOP, (lib7_val_t *)freeRegion,
HEAP_CHUNK_SZB( freeRegion->heap_chunk ), AID_BIGCHUNK(i));
BIBOP[BIBOP_ADDR_TO_INDEX(freeRegion)] = AID_BIGCHUNK_HDR(i);
/* Read in the big-chunk headers */
boHdrSizeB = p->info.bo.numBigChunks * sizeof(bigchunk_hdr_t);
boHdrs = (bigchunk_hdr_t *) MALLOC (boHdrSizeB);
HeapIO_ReadBlock (bp, boHdrs, boHdrSizeB);
/* Read in the big-chunks: */
HeapIO_ReadBlock (bp, (void *)(freeChunk->chunk), totSizeB);
if (j == CODE_INDEX) {
FlushICache ((void *)(freeChunk->chunk), totSizeB);
}
/* Set up the big-chunk descriptors
* and per-chunk relocation info:
*/
for (k = 0; k < p->info.bo.numBigChunks; k++) {
/* find the region relocation info for the chunk's region in
* the exported heap.
*/
for (index = BIBOP_ADDR_TO_INDEX(boHdrs[k].baseAddr);
!BO_IS_HDR(oldBIBOP[index]);
index--)
continue;
region = LookupBORegion (boRegionTable, index);
/* Allocate the big-chunk descriptor for
* the chunk and link it into the list
* of big-chunks for its generation.
*/
bdp = AllocBODesc (freeChunk, &(boHdrs[k]), region);
bdp->next = gen->bigChunks[j];
gen->bigChunks[j] = bdp;
ASSERT(bdp->gen == i+1);
if (show_code_chunk_comments && (j == CODE_INDEX)) {
/* Dump the comment string of the code chunk: */
char* namestring;
if ((namestring = BO_GetCodeChunkTag(bdp))) {
SayDebug ("[%6d bytes] %s\n", bdp->sizeB, namestring);
}
}
}
if (freeChunk != bdp) {
/* There was some extra space left in the region: */
ADD_BODESC(heap->freeBigChunks, freeChunk);
}
FREE (boHdrs);
}
if (verbosity > 0) say(".");
p++;
}
}
repair_heap (heap, oldBIBOP, addrOffset, boRegionTable, externs);
/* Adjust the run-time globals
* that point into the heap:
*/
*PTR_LIB7toC(lib7_val_t, PervasiveStruct) = repair_word (
*PTR_LIB7toC(lib7_val_t, PervasiveStruct),
oldBIBOP, addrOffset, boRegionTable, externs);
runtimeCompileUnit = repair_word( runtimeCompileUnit, oldBIBOP, addrOffset, boRegionTable, externs );
#ifdef ASM_MATH
MathVec = repair_word (MathVec, oldBIBOP, addrOffset, boRegionTable, externs);
#endif
/* Adjust the Lib7 registers to the new address space */
ASSIGN(Lib7SignalHandler, repair_word (
DEREF(Lib7SignalHandler), oldBIBOP, addrOffset, boRegionTable, externs)
);
lib7_state->lib7_argument = repair_word (
lib7_state->lib7_argument, oldBIBOP, addrOffset, boRegionTable, externs
);
lib7_state->lib7_fate = repair_word (
lib7_state->lib7_fate, oldBIBOP, addrOffset, boRegionTable, externs
);
lib7_state->lib7_closure = repair_word (
lib7_state->lib7_closure, oldBIBOP, addrOffset, boRegionTable, externs
);
lib7_state->lib7_program_counter = repair_word (
lib7_state->lib7_program_counter, oldBIBOP, addrOffset, boRegionTable, externs
);
lib7_state->lib7_link_register = repair_word (
lib7_state->lib7_link_register, oldBIBOP, addrOffset, boRegionTable, externs
);
lib7_state->lib7_exception_fate = repair_word (
lib7_state->lib7_exception_fate, oldBIBOP, addrOffset, boRegionTable, externs
);
lib7_state->lib7_current_thread = repair_word (
lib7_state->lib7_current_thread, oldBIBOP, addrOffset, boRegionTable, externs
);
lib7_state->lib7_calleeSave[0] = repair_word (
lib7_state->lib7_calleeSave[0], oldBIBOP, addrOffset, boRegionTable, externs
);
lib7_state->lib7_calleeSave[1] = repair_word (
lib7_state->lib7_calleeSave[1], oldBIBOP, addrOffset, boRegionTable, externs
);
lib7_state->lib7_calleeSave[2] = repair_word (
lib7_state->lib7_calleeSave[2], oldBIBOP, addrOffset, boRegionTable, externs
);
/* Release storage: */
for (i = 0; i < header->numBORegions; i++) {
bo_reloc_t *p;
for (p = NULL, j = 0; j < boRelocInfo[i].nPages; j++) {
if ((boRelocInfo[i].chunkMap[j] != NULL)
&& (boRelocInfo[i].chunkMap[j] != p)) {
FREE (boRelocInfo[i].chunkMap[j]);
p = boRelocInfo[i].chunkMap[j];
}
}
}
FreeAddrTable (boRegionTable, FALSE);
FREE (boRelocInfo);
FREE (arenaHdrs);
FREE (oldBIBOP);
/* Reset the sweep_nextw pointers: */
for (i = 0; i < heap->numGens; i++) {
gen_t *gen = heap->gen[i];
for (j = 0; j < NUM_ARENAS; j++) {
arena_t *ap = gen->arena[j];
if (isACTIVE(ap))
ap->sweep_nextw = ap->nextw;
}
}
} /* read_heap. */
