int main(void)
{
struct Stack *psStack1;
struct Stack *psStack2;
int iSuccessful;
/* Use a Stack object referenced by psStack1. */
psStack1 = Stack_new();
if (psStack1 == NULL) handleMemoryError();
iSuccessful = Stack_push(psStack1, 1.1);
if (! iSuccessful) handleMemoryError();
iSuccessful = Stack_push(psStack1, 2.2);
if (! iSuccessful) handleMemoryError();
iSuccessful = Stack_push(psStack1, 3.3);
if (! iSuccessful) handleMemoryError();
while (! Stack_isEmpty(psStack1))
printf("%g\n", Stack_pop(psStack1));
/***********************************************/
/* Cannot access the fields of *psStack1 here. */
/***********************************************/
Stack_free(psStack1);
/* Use a Stack object referenced by psStack2. */
psStack2 = Stack_new();
if (psStack2 == NULL) handleMemoryError();
iSuccessful = Stack_push(psStack2, 4.4);
if (! iSuccessful) handleMemoryError();
iSuccessful = Stack_push(psStack2, 5.5);
if (! iSuccessful) handleMemoryError();
iSuccessful = Stack_push(psStack2, 6.6);
if (! iSuccessful) handleMemoryError();
while (! Stack_isEmpty(psStack2))
printf("%g\n", Stack_pop(psStack2));
/***********************************************/
/* Cannot access the fields of *psStack2 here. */
/***********************************************/
Stack_free(psStack2);
return 0;
}
IoLexer *IoLexer_new(void)
{
IoLexer *self = (IoLexer *)io_calloc(1, sizeof(IoLexer));
self->s = (char *)io_calloc(1, 1);
self->s[0] = 0;
self->posStack = Stack_new();
self->tokenStack = Stack_new();
self->tokenStream = List_new();
self->charLineIndex = List_new();
return self;
}
Stack* Stack_push(HuffNode * newNode, Stack* old)
{
if(old == NULL)
{
return Stack_new(newNode);
}
Stack * NewStack = Stack_new(newNode);
NewStack -> next = old;
return NewStack;
}
int main(int argc, char *argv[]){
struct Stack *stack = Stack_new(10);
int i=0;
Stack_push(stack, 5);
Stack_push(stack, 50);
Stack_push(stack, 1000);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
Stack_push(stack, 25);
for(i=0; i < stack->pos; i++){
printf("Popped %d from the stack (pos %d)\n", stack->store[i], i);
}
Stack_destroy(stack);
return 0;
}
StrList* StrList_new() {
StrList* list = malloc(sizeof(StrList));
list->stack = Stack_new();
return list;
}
int handleDefsyscpunums( void *fcb, int systemcpunumberarraydim,
const int *systemcpunumberarray ) {
int a = 0;
int i = 0;
((fcbT*)fcb)->processcount = 0;
for( i = 0; i < systemcpunumberarraydim; i++)
for( a = 0; a < systemcpunumberarray[i]; a++)
((fcbT*)fcb)->processcount++;
/* create cpu array (needed for threadnums and carrying the names) */
((fcbT*)fcb)->processes = ( processT** ) malloc ( sizeof( processT* )
* ((fcbT*)fcb)->processcount );
((fcbT*)fcb)->threadnums = (int*) malloc( sizeof( int )
* ((fcbT*)fcb)->processcount );
for( i = 0; i < ((fcbT*)fcb)->processcount; i++) {
((fcbT*)fcb)->threadnums[i] = 1;
((fcbT*)fcb)->processes[i] = ( processT* ) malloc ( sizeof (processT) );
((fcbT*)fcb)->processes[i][0].stack = Stack_new();
((fcbT*)fcb)->processes[i][0].name = 0;
((fcbT*)fcb)->processes[i][0].filepos= 0;
((fcbT*)fcb)->processes[i][0].fileIObegin = (uint64_t) -1; /* invalid timestamp */
((fcbT*)fcb)->processes[i][0].fileIObufferpos = 0;
((fcbT*)fcb)->processes[i][0].fileIObufferlen = 0;
}
return 0;
}
int main(int argc, char *argv[])
{
struct Stack *s = Stack_new(5);
push(s, 5);
push(s, 3);
push(s, 2);
pop(s);
Stack_print(s);
return 0;
}
IoCoroutine *IoCoroutine_rawClone(IoCoroutine *proto)
{
IoObject *self = IoObject_rawClonePrimitive(proto);
IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoCoroutineData)));
DATA(self)->ioStack = Stack_new();
#ifdef STACK_POP_CALLBACK
Stack_popCallback_(DATA(self)->ioStack, IoObject_freeIfUnreferenced);
#endif
DATA(self)->cid = (Coro *)NULL;
return self;
}
/* initialize the new mem and return it */
Mem new_mem(Segment_T program)
{
Mem myMem = malloc(sizeof(*myMem));
assert(myMem != NULL);
myMem->segs = Seq_new(2);
assert(myMem->segs != NULL);
Seq_addlo(myMem->segs, (void*) program);
myMem->unmapped = Stack_new();
myMem->prog_counter = 0;
return myMem;
}
void create_UM()
{
NEW(um);
um->registers = UArray_new(NUM_REGS, sizeof(uint32_t));
um->unmapped_IDs = Stack_new();
um->memory = Segments_new(1);
assert(um->registers);
assert(um->unmapped_IDs);
assert(um->memory);
registers_to_zero(um);
um->instr_ctr = 0;
}
IoCoroutine *IoCoroutine_proto(void *state)
{
IoObject *self = IoObject_new(state);
IoObject_tag_(self, IoCoroutine_newTag(state));
IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoCoroutineData)));
DATA(self)->ioStack = Stack_new();
#ifdef STACK_POP_CALLBACK
Stack_popCallback_(DATA(self)->ioStack, IoObject_freeIfUnreferenced);
#endif
IoState_registerProtoWithFunc_((IoState *)state, self, IoCoroutine_proto);
/* init Coroutine proto's coro as the main one */
{
Coro *coro = Coro_new();
DATA(self)->cid = coro;
Coro_initializeMainCoro(coro);
}
return self;
}
void TestData_stack_uint_test(TestData _test)
{
Stack _stk = Stack_new(Vptr);
Stack stk = Stack_Init(_stk, Uint32);
uint i = 0;
for (; i < _test->count; i++)
{
_test->data[i].uint32_var = i;
}
for (i = 0; i < _test->count; i++)
{
Stack_push(stk, _test->data[i]);
}
for (i = 0; i < _test->count; i++)
{
if (Stack_find(stk, i)->uint32_var != _test->data[i].uint32_var)
{
printf("data error");
getchar();
exit(0);
}
}
for (i = _test->count - 1; i; i--)
{
var tmp;
Stack_pop(stk, &tmp);
if (tmp.uint32_var != _test->data[i].uint32_var)
{
printf("data error");
getchar();
exit(0);
}
}
Stack_Dest(stk);
printf("test succ\n");
}
void IoState_new_atAddress(void *address)
{
IoState *self = (IoState *)address;
IoCFunction *cFunctionProto;
IoSeq *seqProto;
// collector
self->collector = Collector_new();
IoState_pushCollectorPause(self);
Collector_setMarkFunc_(self->collector, (CollectorMarkFunc *)IoObject_mark);
Collector_setWillFreeFunc_(self->collector, (CollectorWillFreeFunc *)IoObject_willFree);
Collector_setFreeFunc_(self->collector, (CollectorFreeFunc *)IoObject_free);
self->mainArgs = MainArgs_new();
self->primitives = PHash_new();
self->recycledObjects = List_new();
self->maxRecycledObjects = IOSTATE_DEFAULT_MAX_RECYCLED_OBJECTS;
// Sandbox
self->messageCount = 0;
self->messageCountLimit = 0;
self->endTime = 0;
// symbol table
self->symbols = SHash_new();
SHash_setKeysEqualCallback(self->symbols, (SHashKeysEqualCallback *)UArray_equalsWithHashCheck_);
SHash_setHashForKeyCallback(self->symbols, (SHashHashforKeyCallback *)UArray_hash);
/*
Problem:
- there are some interdependencies here:
- creating instances requires a retain stack
- we need a Coroutine to use for our retainStack
- defining any primitive methods requires Strings and CFunctions
Solution:
- create a temporary fake stack
- create Object, CFunction and String protos sans methods.
- then add methods to Object, CFunction and String
*/
self->currentIoStack = Stack_new(); // temp retain stack until coro is up
self->objectProto = IoObject_proto(self); // need to do this first, so we have a retain stack
//IoState_retain_(self, self->objectProto);
self->mainCoroutine = IoCoroutine_proto(self);
Stack_free(self->currentIoStack);
self->currentIoStack = NULL;
IoState_setCurrentCoroutine_(self, self->mainCoroutine);
seqProto = IoSeq_proto(self);
IoState_setupQuickAccessSymbols(self);
IoObject_rawSetProto_(seqProto, self->objectProto);
cFunctionProto = IoCFunction_proto(self);
self->localsUpdateSlotCFunc = IoState_retain_(self,
IoCFunction_newWithFunctionPointer_tag_name_(self,
IoObject_localsUpdateSlot, NULL, "localsUpdate"));
IoSeq_protoFinish(seqProto);
IoObject_protoFinish(self);
IoCFunction_protoFinish(self);
IoCoroutine_protoFinish(self->mainCoroutine);
self->setSlotBlock = IoState_retain_(self, IoObject_getSlot_(self->objectProto, SIOSYMBOL("setSlot")));
// setup lobby
{
IoObject *objectProto = self->objectProto;
IoObject *protos = IOCLONE(objectProto);
IoObject *core = IOCLONE(objectProto);
self->core = core;
self->lobby = IOCLONE(objectProto);
IoState_retain_(self, self->lobby);
IoState_retain_(self, self->core);
// setup namespace
IoObject_setSlot_to_(self->lobby, SIOSYMBOL("Lobby"), self->lobby);
IoObject_setSlot_to_(self->lobby, SIOSYMBOL("Protos"), protos);
IoObject_setSlot_to_(protos, SIOSYMBOL("Core"), core);
IoObject_setSlot_to_(protos, SIOSYMBOL("Addons"), IOCLONE(objectProto));
IoObject_setSlot_to_(core, SIOSYMBOL("Compiler"), IoCompiler_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Collector"), IoCollector_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Exception"), IOCLONE(objectProto));
// setup proto chain
IoObject_rawSetProto_(objectProto, self->lobby);
IoObject_rawSetProto_(self->lobby, protos);
IoObject_rawSetProto_(protos, core);
// add protos to namespace
IoObject_setSlot_to_(core, SIOSYMBOL("Object"), objectProto);
IoObject_setSlot_to_(core, SIOSYMBOL("Sequence"), seqProto);
IoObject_setSlot_to_(core, SIOSYMBOL("Number"), IoNumber_proto(self));
IoState_setupCachedNumbers(self);
{
IoObject *systemProto = IoSystem_proto(self);
IoObject_setSlot_to_(core, SIOSYMBOL("System"), systemProto);
}
IoState_setupSingletons(self);
IoState_setupCachedMessages(self);
{
self->debugger = IoState_retain_(self, IoDebugger_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Debugger"), self->debugger);
self->vmWillSendMessage = IoMessage_newWithName_(self, SIOSYMBOL("vmWillSendMessage"));
IoMessage_cachedResult_(self->nilMessage, self->ioNil);
IoState_retain_(self, self->vmWillSendMessage);
}
IoObject_setSlot_to_(core, SIOSYMBOL("Block"), IoBlock_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("List"), IoList_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Map"), IoMap_proto(self));
//IoObject_setSlot_to_(core, SIOSYMBOL("Range"), IoRange_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Coroutine"), self->mainCoroutine);
IoObject_setSlot_to_(core, SIOSYMBOL("Error"), IoError_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("File"), IoFile_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Directory"), IoDirectory_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Date"), IoDate_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Duration"), IoDuration_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("WeakLink"), IoWeakLink_proto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Sandbox"), IoSandbox_proto(self));
//IoObject_setSlot_to_(core, SIOSYMBOL("EditLine"), IoEditLine_proto(self));
#if !defined(__SYMBIAN32__)
IoObject_setSlot_to_(core, SIOSYMBOL("DynLib"), IoDynLib_proto(self));
#endif
//self->store =
//IoObject_setSlot_to_(core, SIOSYMBOL("Store"), self->store);
IoObject_setSlot_to_(core, SIOSYMBOL("CFunction"), cFunctionProto);
self->localsProto = IoState_retain_(self, IoObject_localsProto(self));
IoObject_setSlot_to_(core, SIOSYMBOL("Locals"), self->localsProto);
self->stopStatus = MESSAGE_STOP_STATUS_NORMAL;
self->returnValue = self->ioNil;
IoState_clearRetainStack(self);
IoState_popCollectorPause(self);
//Collector_collect(self->collector);
//io_show_mem("before IoVMCodeInit");
IoVMCodeInit(core);
//io_show_mem("after IoVMCodeInit");
//Collector_collect(self->collector);
//io_show_mem("after Collector_collect");
// IoState_popCollectorPause(self);
IoState_clearRetainStack(self);
Collector_collect(self->collector);
//io_show_mem("after IoState_clearRetainStack and Collector_collect");
IoState_setupUserInterruptHandler(self);
}
}
int handleDefthreadnums( void *fcb, int threadnumarraydim,
const int *threadnumarray ) {
int i;
int a;
processT **processestmp;
if ( 0 == ((fcbT*)fcb)->processes ) {
fprintf( stderr, "ERROR: Missing NCPU record\n" );
exit(1);
}
/* copy threadnumarray */
free( ((fcbT*)fcb)->threadnums );
((fcbT*)fcb)->threadnums = (int*) malloc( sizeof( int )
* threadnumarraydim );
memcpy( ((fcbT*)fcb)->threadnums, threadnumarray, sizeof( int )
* threadnumarraydim );
processestmp = ( processT** ) malloc ( sizeof( processT* )
* ((fcbT*)fcb)->processcount );
for( i = 0; i < threadnumarraydim; ++i ) {
processestmp[i] = ( processT* ) malloc ( sizeof (processT)
* threadnumarray[i]);
processestmp[i][0].stack = ((fcbT*)fcb)->processes[i][0].stack;
processestmp[i][0].name = ((fcbT*)fcb)->processes[i][0].name;
processestmp[i][0].fileIObegin = (uint64_t) -1;
processestmp[i][0].filepos = 0;
processestmp[i][0].fileIObufferpos = 0;
processestmp[i][0].fileIObufferlen = 0;
/* remove pointers from original array (to prevent free errors later )*/
((fcbT*)fcb)->processes[i][0].name = 0;
((fcbT*)fcb)->processes[i][0].stack = 0;
/* init the threads */
for( a = 1; a < threadnumarray[i]; ++a ) {
processestmp[i][a].stack = Stack_new();
processestmp[i][a].name = 0;
processestmp[i][a].fileIObegin = (uint64_t) -1; /* invalid timestamp */
processestmp[i][a].filepos = 0;
processestmp[i][a].fileIObufferpos = 0;
processestmp[i][a].fileIObufferlen = 0;
}
}
/* delete old processarray */
for( i = 0; i < ((fcbT*)fcb)->processcount; ++i ) {
free( ((fcbT*)fcb)->processes[i] );
}
free( ((fcbT*)fcb)->processes );
((fcbT*)fcb)->processes = processestmp;
((fcbT*)fcb)->processcount = threadnumarraydim;
return 0;
}
int init_thread(Thread *thread)
{
thread->Priority = THREAD_PRIORITY_NORMAL;
thread->frameStack = Stack_new(64); // FIXME What's the appropriate size?
return true;
}
int main(int argc, char *argv[]) {
int c;
sp = Stack_new();
Fmt_register('D', AP_fmt);
while ((c = getchar()) != EOF)
switch (c) {
case ' ': case '\t': case '\n': case '\f': case '\r':
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
char buf[512];
{
int i = 0;
for ( ; c != EOF && isdigit(c); c = getchar(), i++)
if (i < (int)sizeof (buf) - 1)
buf[i] = c;
if (i > (int)sizeof (buf) - 1) {
i = (int)sizeof (buf) - 1;
Fmt_fprint(stderr,
"?integer constant exceeds %d digits\n", i);
}
buf[i] = 0;
if (c != EOF)
ungetc(c, stdin);
}
Stack_push(sp, AP_fromstr(buf, 10, NULL));
break;
}
case '+': {
AP_T y = pop(), x = pop();
Stack_push(sp, AP_add(x, y));
AP_free(&x);
AP_free(&y);
break;
}
case '-': {
AP_T y = pop(), x = pop();
Stack_push(sp, AP_sub(x, y));
AP_free(&x);
AP_free(&y);
break;
}
case '*': {
AP_T y = pop(), x = pop();
Stack_push(sp, AP_mul(x, y));
AP_free(&x);
AP_free(&y);
break;
}
case '/': {
AP_T y = pop(), x = pop();
if (AP_cmpi(y, 0) == 0) {
Fmt_fprint(stderr, "?/ by 0\n");
Stack_push(sp, AP_new(0));
} else
Stack_push(sp, AP_div(x, y));
AP_free(&x);
AP_free(&y);
break;
}
case '%': {
AP_T y = pop(), x = pop();
if (AP_cmpi(y, 0) == 0) {
Fmt_fprint(stderr, "?%% by 0\n");
Stack_push(sp, AP_new(0));
} else
Stack_push(sp, AP_mod(x, y));
AP_free(&x);
AP_free(&y);
break;
}
case '^': {
AP_T y = pop(), x = pop();
if (AP_cmpi(y, 0) <= 0) {
Fmt_fprint(stderr, "?nonpositive power\n");
Stack_push(sp, AP_new(0));
} else
Stack_push(sp, AP_pow(x, y, NULL));
AP_free(&x);
AP_free(&y);
break;
}
case 'd': {
AP_T x = pop();
Stack_push(sp, x);
Stack_push(sp, AP_addi(x, 0));
break;
}
case 'p': {
AP_T x = pop();
Fmt_print("%D\n", x);
Stack_push(sp, x);
break;
}
case 'f':
if (!Stack_empty(sp)) {
Stack_T tmp = Stack_new();
while (!Stack_empty(sp)) {
AP_T x = pop();
Fmt_print("%D\n", x);
Stack_push(tmp, x);
}
while (!Stack_empty(tmp))
Stack_push(sp, Stack_pop(tmp));
Stack_free(&tmp);
}
break;
case '~': {
AP_T x = pop();
Stack_push(sp, AP_neg(x));
AP_free(&x);
break;
}
case 'c': while (!Stack_empty(sp)) {
AP_T x = Stack_pop(sp);
AP_free(&x);
} break;
case 'q': while (!Stack_empty(sp)) {
AP_T x = Stack_pop(sp);
AP_free(&x);
}
Stack_free(&sp);
return EXIT_SUCCESS;
default:
if (isprint(c))
Fmt_fprint(stderr, "?'%c'", c);
else
Fmt_fprint(stderr, "?'\\%03o'", c);
Fmt_fprint(stderr, " is unimplemented\n");
break;
}
while (!Stack_empty(sp)) {
AP_T x = Stack_pop(sp);
AP_free(&x);
}
Stack_free(&sp);
return EXIT_SUCCESS;
}
/* EVALUATE THE EXPRESSION: */
static void evaluate(Token_T* oTokens, int length) {
Stack_T oStack1;
Stack_T oStack2;
int i;
/* Create and use a Stack of tokens. */
assert(oTokens != NULL);
oStack1 = Stack_new();
oStack2 = Stack_new();
for (i = 0; i < length; i++) {
if (Token_getType(oTokens[i]) == VALUE)
Stack_push(oStack1, oTokens[i]);
else if (Stack_isEmpty(oStack2))
Stack_push(oStack2, oTokens[i]);
else if (precedence(oTokens[i], Stack_top(oStack2)))
Stack_push(oStack2, oTokens[i]);
else { /*ERROR HANDLING?*/
int result;
Token_T value_1 = (Token_T)Stack_top(oStack1);
Stack_pop(oStack1);
Token_T operator = (Token_T)Stack_top(oStack2);
Stack_pop(oStack2);
Token_T value_2 = (Token_T)Stack_top(oStack1);
Stack_pop(oStack1);
switch (Token_getType(operator))
{ /*LEFT TO RIGHT EVALUATION*/
case MULT:
result = Token_getValue(value_1) * Token_getValue(value_2);
break;
case DIV:
result = Token_getValue(value_2) / Token_getValue(value_1);
break;
case PLUS:
result = Token_getValue(value_1) + Token_getValue(value_2);
break;
case MINUS:
result = Token_getValue(value_2) - Token_getValue(value_1);
break;
default:
assert(0);
}
Stack_push(oStack1, Token_newToken(VALUE, result));
Stack_push(oStack2, oTokens[i]);
}
}
while (!Stack_isEmpty(oStack2)) { /*ERROR HANDLING? + MODULARITY MUCH????*/
int result;
Token_T value_1 = (Token_T)Stack_top(oStack1);
Stack_pop(oStack1);
Token_T operator = (Token_T)Stack_top(oStack2);
Stack_pop(oStack2);
Token_T value_2 = (Token_T)Stack_top(oStack1);
Stack_pop(oStack1);
switch (Token_getType(operator))
{ /*LEFT TO RIGHT EVALUATION*/
case MULT:
result = Token_getValue(value_1) * Token_getValue(value_2);
break;
case DIV:
result = Token_getValue(value_2) / Token_getValue(value_1);
break;
case PLUS:
result = Token_getValue(value_1) + Token_getValue(value_2);
break;
case MINUS:
result = Token_getValue(value_2) - Token_getValue(value_1);
break;
default:
assert(1);
}
Stack_push(oStack1, Token_newToken(VALUE, result));
}
printf("%d\n", Token_getValue((Token_T)Stack_top(oStack1)));
Stack_free(oStack1);
Stack_free(oStack2);
}
