void IoLexer_free(IoLexer *self)
{
IoLexer_clear(self);
io_free(self->s);
Stack_free(self->posStack);
Stack_free(self->tokenStack);
List_free(self->tokenStream);
List_free(self->charLineIndex);
if(self->errorDescription) io_free(self->errorDescription);
io_free(self);
}
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;
}
void IoCoroutine_free(IoCoroutine *self)
{
Coro *coro = DATA(self)->cid;
if (coro) Coro_free(coro);
Stack_free(DATA(self)->ioStack);
io_free(DATA(self));
}
void IoCoroutine_free(IoCoroutine *self)
{
//printf("IoCoroutine_free %p\n", (void *)self);
Coro *coro = DATA(self)->cid;
if (coro) Coro_free(coro);
Stack_free(DATA(self)->ioStack);
io_free(DATA(self));
}
void free_IDs(Stack_T unmapped_IDs)
{
uint32_t *ID;
while (!Stack_empty(unmapped_IDs)) {
ID = Stack_pop(unmapped_IDs);
FREE(ID);
}
Stack_free(&unmapped_IDs);
}
/* free the mem */
void free_mem(Mem* myMem)
{
assert(myMem != NULL);
for (int i = 0; i < Seq_length((*myMem)->segs); i++) {
Seg_free(Seq_get((*myMem)->segs, i));
}
Seq_free(&((*myMem)->segs));
Stack_free(&((*myMem)->unmapped));
free(*myMem);
}
void Stack_do_on_(const Stack *self, StackDoOnCallback *callback, void *target)
{
Stack *stack = Stack_newCopyWithNullMarks(self);
int i;
for(i = 0; i < Stack_count(stack) - 1; i ++)
{
void *v = Stack_at_(stack, i);
if (v) (*callback)(target, v);
}
Stack_free(stack);
}
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 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;
}
/**
* @if conly
* @memberof ASTNode_t
* @endif
*/
LIBSBML_EXTERN
ASTNode_t *
SBML_parseFormula (const char *formula)
{
long rule, state, action;
ASTNode_t *node = NULL;
FormulaTokenizer_t *tokenizer = NULL;
Stack_t *stack = NULL;
Token_t *token = NULL;
if (formula == NULL) return NULL;
tokenizer = FormulaTokenizer_createFromFormula(formula);
token = FormulaTokenizer_nextToken(tokenizer);
stack = Stack_create(20);
Stack_push(stack, (void *) START_STATE);
while (1)
{
state = (long) Stack_peek(stack);
action = FormulaParser_getAction(state, token);
if (action == ACCEPT_STATE)
{
node = Stack_peekAt(stack, 1);
break;
}
else if (action == ERROR_STATE)
{
/**
* Free ASTNodes on the Stack, skip the states.
*/
while (Stack_size(stack) > 1)
{
Stack_pop(stack);
ASTNode_free( Stack_pop(stack) );
}
node = NULL;
break;
}
/**
* Shift
*/
else if (action > 0)
{
Stack_push( stack, ASTNode_createFromToken(token) );
Stack_push( stack, (void *) action );
Token_free(token);
token = FormulaTokenizer_nextToken(tokenizer);
}
/**
* Reduce
*/
else if (action < 0)
{
rule = -action;
node = FormulaParser_reduceStackByRule(stack, rule);
state = (long) Stack_peek(stack);
Stack_push( stack, node );
Stack_push( stack, (void *) FormulaParser_getGoto(state, rule) );
}
}
FormulaTokenizer_free(tokenizer);
Stack_free(stack);
Token_free(token);
return node;
}
/* 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);
}
/*
* Input: Mem_T structure
* Output: void
* Purpose: Frees all memory. Frees each segment, the sequence of segments,
* the sequence of reusable indices and the pointer to the memory
* structure
*/
void MemT_free(Mem_T memory){
Mem_arr_free(memory->segment_seq);
Stack_free(memory->reusable_indices);
free(memory);
}
