static int parse_avt(elcgen *gen, xmlNodePtr n, const char *attr,
expression **expr, int required, expression *pnode)
{
char *value;
char *tmp;
assert(pnode->xmlnode == n);
if (!xmlHasProp(n,attr)) {
*expr = NULL;
if (required)
return gen_error(gen,"%s element missing %s attribute",n->name,attr);
else
return 1;
}
value = xmlGetProp(n,attr);
if (gen->ispattern && (!strncmp(value,"#E",2))) {
*expr = new_expression(XPATH_DSVAR);
(*expr)->str = strdup(value+1);
}
else {
tmp = (char*)malloc(strlen(value)+3);
sprintf(tmp,"}%s{",value);
*expr = parse_xpath(gen,pnode,tmp);
free(tmp);
}
free(value);
return (NULL != *expr);
}
struct expression *new_var_expression(int var_id)
{
struct expression *exp = new_expression();
exp->type = VarExp;
exp->u.var_id = var_id;
return exp;
}
expression *new_expression2(int type, expression *left, expression *right)
{
expression *expr = new_expression(type);
expr->r.left = left;
expr->r.right = right;
return expr;
}
struct expression *new_op_expression(expression_type type,
struct expression * left,
struct expression *right)
{
struct expression *exp = new_expression();
exp->type = type;
exp->u.left = left;
exp->u.right = right;
return exp;
}
/*
* parse a comma separated expression list like a, b, c
* return 0 on success, -1 on error
* parsed expressions are returned in **e
*/
static int parse_expression_list(char *str, expression **e)
{
int start=0, i=-1, j=-1, apost=0;
char str2[EXPRESSION_LENGTH];
expression *e1=NULL, *e2;
if (!str || !e) return -1;
*e = NULL;
do {
i++;
switch(str[i]) {
case '"': apost = !apost;
break;
case ',': if (apost) break;
case '\0': /* word found */
while ((str[start] == ' ') || (str[start] == '\t')) start++;
if (str[start] == '"') start++;
j = i-1;
while ((0 < j) && ((str[j] == ' ') || (str[j] == '\t'))) j--;
if ((0 < j) && (str[j] == '"')) j--;
if (start<=j) {
/* valid word */
if (j-start+1 >= EXPRESSION_LENGTH) {
/* error */
LOG(L_ERR, "ERROR: parse_expression_list(): " \
"too long expression, increase EXPRESSION_LENGTH\n");
goto error;
}
strncpy(str2, str+start, j-start+1);
str2[j-start+1] = '\0';
e2 = new_expression(str2);
if (!e2) {
/* memory error */
LOG(L_ERR, "ERROR: parse_expression_list(): " \
"not enough memory\n");
goto error;
}
if (e1) {
/* it is not the first */
e1->next = e2;
e1 = e2;
} else {
/* it is the first */
*e = e1 = e2;
}
} else {
/* parsing error */
LOG(L_ERR, "ERROR: parse_expression_list(): " \
"expression parsing error\n");
goto error;
}
/* for the next word */
start = i+1;
}
} while (str[i] != '\0');
return 0;
error:
if (*e) {
free_expression(*e);
*e = NULL;
}
return -1;
}
struct expression_s *
parse (FILE *input)
{
int ch;
do {
ch = getc (input);
if ( ch == '#' )
while ( ch != '\n' && ch != EOF )
ch = getc (input);
} while ( ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' );
if ( ch == '`' )
{
struct expression_s *rator = parse (input);
struct expression_s *rand = parse (input);
struct expression_s *expr = new_expression ();
expr->t = EXPRESSION_APPLICATION;
init_ptr (&expr->d.expression_application_v.rator, rator);
init_ptr (&expr->d.expression_application_v.rand, rand);
#if 0 /* Harmless but not necessary */
free_expression (rator);
free_expression (rand);
#endif
return expr;
}
else if ( ch == 'i' || ch == 'I' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_I;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == 'k' || ch == 'K' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_K;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == 's' || ch == 'S' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_S;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == 'v' || ch == 'V' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_V;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == 'd' || ch == 'D' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_D;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == 'e' || ch == 'E' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_E;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == 'p' || ch == 'P' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_P;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == 'f' || ch == 'F' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_F;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == 'r' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_DOT;
fun->d.function_dot_v = '\n';
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == '.' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
int ch2;
fun->t = FUNCTION_DOT;
ch2 = getc (input);
if ( ch2 == EOF )
goto ueof;
fun->d.function_dot_v = ch2;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == '@' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_AT;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == '?' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
int ch2;
fun->t = FUNCTION_QUES;
ch2 = getc (input);
if ( ch2 == EOF )
goto ueof;
fun->d.function_ques_v = ch2;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == '|' )
{
struct function_s *fun = new_function ();
struct expression_s *expr = new_expression ();
fun->t = FUNCTION_PIPE;
expr->t = EXPRESSION_FUNCTION;
init_ptr (&expr->d.expression_function_v, fun);
#if 0 /* Harmless but not necessary */
free_function (fun);
#endif
return expr;
}
else if ( ch == EOF )
{
ueof:
fprintf (stderr, "Unexpected end of file\n");
exit (1);
}
else
{
fprintf (stderr, "Character not recognized: %c\n", ch);
exit (1);
}
return NULL;
}
struct task_s *
apply (struct function_s *rator, struct function_s *rand,
struct continuation_s *cont)
{
switch ( rator->t )
{
case FUNCTION_I:
return invoke (cont, rand);
case FUNCTION_DOT:
putchar (rator->d.function_dot_v);
return invoke (cont, rand);
case FUNCTION_K1:
return invoke (cont, rator->d.function_k1_v);
case FUNCTION_K:
{
struct function_s *val = new_function ();
struct task_s *task;
val->t = FUNCTION_K1;
init_ptr (&val->d.function_k1_v, rand);
task = invoke (cont, val);
free_function (val);
return task;
}
case FUNCTION_S2:
{
struct expression_s *e_x = new_expression ();
struct expression_s *e_y = new_expression ();
struct expression_s *e_z = new_expression ();
struct expression_s *e1 = new_expression ();
struct expression_s *e2 = new_expression ();
struct expression_s *e = new_expression ();
struct task_s *task = new_task ();
e_x->t = EXPRESSION_FUNCTION;
init_ptr (&e_x->d.expression_function_v, rator->d.function_s2_v.x);
e_y->t = EXPRESSION_FUNCTION;
init_ptr (&e_y->d.expression_function_v, rator->d.function_s2_v.y);
e_z->t = EXPRESSION_FUNCTION;
init_ptr (&e_z->d.expression_function_v, rand);
e1->t = EXPRESSION_APPLICATION;
init_ptr (&e1->d.expression_application_v.rator, e_x);
init_ptr (&e1->d.expression_application_v.rand, e_z);
e2->t = EXPRESSION_APPLICATION;
init_ptr (&e2->d.expression_application_v.rator, e_y);
init_ptr (&e2->d.expression_application_v.rand, e_z);
e->t = EXPRESSION_APPLICATION;
init_ptr (&e->d.expression_application_v.rator, e1);
init_ptr (&e->d.expression_application_v.rand, e2);
task->t = TASK_EVAL;
init_ptr (&task->d.task_eval_v.expr, e);
init_ptr (&task->d.task_eval_v.cont, cont);
#if 0 /* Harmless but not necessary */
free_expression (e_x);
free_expression (e_y);
free_expression (e_z);
free_expression (e1);
free_expression (e2);
free_expression (e);
#endif
return task;
}
case FUNCTION_S1:
{
struct function_s *val = new_function ();
struct task_s *task;
val->t = FUNCTION_S2;
init_ptr (&val->d.function_s2_v.x, rator->d.function_s1_v);
init_ptr (&val->d.function_s2_v.y, rand);
task = invoke (cont, val);
free_function (val);
return task;
}
case FUNCTION_S:
{
struct function_s *val = new_function ();
struct task_s *task;
val->t = FUNCTION_S1;
init_ptr (&val->d.function_s1_v, rand);
task = invoke (cont, val);
free_function (val);
return task;
}
case FUNCTION_V:
return invoke (cont, rator);
case FUNCTION_D1:
{
struct continuation_s *ncont = new_continuation ();
struct task_s *task = new_task ();
ncont->t = CONTINUATION_DEL;
init_ptr (&ncont->d.continuation_del_v.erand, rand);
init_ptr (&ncont->d.continuation_del_v.cont, cont);
task->t = TASK_EVAL;
init_ptr (&task->d.task_eval_v.expr, rator->d.function_d1_v);
init_ptr (&task->d.task_eval_v.cont, ncont);
#if 0 /* Harmless but not necessary */
free_continuation (ncont);
#endif
return task;
}
case FUNCTION_D:
{
struct expression_s *promise = new_expression ();
struct function_s *val = new_function ();
struct task_s *task;
promise->t = EXPRESSION_FUNCTION;
init_ptr (&promise->d.expression_function_v, rand);
val->t = FUNCTION_D1;
init_ptr (&val->d.function_d1_v, promise);
task = invoke (cont, val);
free_continuation (cont);
free_function (val);
return task;
}
case FUNCTION_CONT:
return invoke (rator->d.function_cont_v, rand);
case FUNCTION_DCONT:
{
struct function_s *val = new_function ();
struct task_s *task = new_task ();
struct continuation_s *ncont = new_continuation ();
push_cont (cont);
val->t = FUNCTION_CONT;
init_ptr (&val->d.function_cont_v, rator->d.function_cont_v);
task->t = TASK_APP;
ncont->t = CONTINUATION_ABORT;
init_ptr (&task->d.task_app_v.erator, val);
init_ptr (&task->d.task_app_v.erand, rand);
init_ptr (&task->d.task_app_v.cont, ncont);
return task;
}
case FUNCTION_P:
{
struct function_s *val = new_function ();
struct task_s *task = new_task ();
struct continuation_s *ncont = new_continuation ();
push_cont (cont);
val->t = FUNCTION_I;
task->t = TASK_APP;
ncont->t = CONTINUATION_ABORT;
init_ptr (&task->d.task_app_v.erator, rand);
init_ptr (&task->d.task_app_v.erand, val);
init_ptr (&task->d.task_app_v.cont, ncont);
return task;
}
case FUNCTION_F:
{
struct function_s *val = new_function ();
struct task_s *task = new_task ();
struct continuation_s *ncont = new_continuation ();
val->t = FUNCTION_DCONT;
init_ptr (&val->d.function_cont_v, cont);
task->t = TASK_APP;
ncont->t = CONTINUATION_ABORT;
init_ptr (&task->d.task_app_v.erator, rand);
init_ptr (&task->d.task_app_v.erand, val);
init_ptr (&task->d.task_app_v.cont, ncont);
return task;
}
case FUNCTION_E:
{
struct task_s *task = new_task ();
task->t = TASK_FINAL;
return task;
}
case FUNCTION_AT:
{
struct function_s *val = new_function ();
struct task_s *task = new_task ();
current_ch = getchar ();
val->t = (current_ch != EOF ? FUNCTION_I : FUNCTION_V);
task->t = TASK_APP;
init_ptr (&task->d.task_app_v.erator, rand);
init_ptr (&task->d.task_app_v.erand, val);
init_ptr (&task->d.task_app_v.cont, cont);
#if 0 /* Harmless but not necessary */
free_function (val);
#endif
return task;
}
case FUNCTION_QUES:
{
struct function_s *val = new_function ();
struct task_s *task = new_task ();
val->t = (current_ch == rator->d.function_ques_v
? FUNCTION_I : FUNCTION_V);
task->t = TASK_APP;
init_ptr (&task->d.task_app_v.erator, rand);
init_ptr (&task->d.task_app_v.erand, val);
init_ptr (&task->d.task_app_v.cont, cont);
#if 0 /* Harmless but not necessary */
free_function (val);
#endif
return task;
}
case FUNCTION_PIPE:
{
struct function_s *val = new_function ();
struct task_s *task = new_task ();
if ( current_ch != EOF )
{
val->t = FUNCTION_DOT;
val->d.function_dot_v = current_ch;
}
else
val->t = FUNCTION_V;
task->t = TASK_APP;
init_ptr (&task->d.task_app_v.erator, rand);
init_ptr (&task->d.task_app_v.erand, val);
init_ptr (&task->d.task_app_v.cont, cont);
#if 0 /* Harmless but not necessary */
free_function (val);
#endif
return task;
}
}
fprintf (stderr, "INTERNAL ERROR: apply() surprised!\n");
return NULL;
}
int main(int argc, char **argv){
if(argc <= 0){
return -1;
}
/*
char* filename = argv[1];
char* ssss;
ssss = filename;
*/
FILE *pInputFile;
//pInputFile = fopen(filename, "r");
pInputFile = fopen("input/test.bfc", "r");
//fp = fopen("/etc/vim/vimrc", "r");
if (pInputFile == NULL){
exit(EXIT_FAILURE);
}
FILE *pOutputFile;
pOutputFile = fopen("output/out.asm", "w");
cstring* data;
data = (cstring*) malloc(sizeof(cstring) * 1000);
int dataIdx = 0;
cstring* text;
text = (cstring*) malloc(sizeof(cstring) * 1000);
int textIdx = 0;
int levelsDeep = 0;
char* line = (char*) malloc(sizeof(char) * MAX_LINE_LENGTH);
//array of 15 pointers
//char** tokens = (char**) malloc(15);
tokens = (token*) malloc(sizeof(token) * 15);
currToken = 0;
//char** functionStack = (char**) malloc(50);
//char* pNull = "NULL";
cstring* functionStack = (cstring*) malloc(sizeof(cstring) * 50);
functionStack = new_cstring(10);
functionStack->i = "NULL";
functionStack++;
//TODO no point in going line by line anymore, just grab tokens...
while(fgets(line, MAX_LINE_LENGTH, pInputFile)){
token* token = getNextToken(&line);
while(token != NULL){
printf("%s\n", token->str.i);
//handle token
//remove brackets, semicolons, etc
//clean(&(token->str));
tokens[currToken++] = *token;
token = getNextToken(&line);
}
}
determineTokenType();
//should combine tokens into expressions, ex
//char* my_str; is four tokens but one 'expression'
//printf("hello world");
//is two expressions, expression has return value
//but still need expression tree
//this is so messy my god help
tree* expTrees = new (tree*) malloc(sizeof(tree) * MAX_NUM_LINES);
tree* currTree = expTrees;
token* currLine = *tokenLines;
int i;
for(i = 0; i < currLine; i++){
if(currTree == NULL){
expression* root = new_expression();
root->type = ROOT;
currTree = new_tree(root);
}
token curr = *currLine;
if(curr.type == TYPE){
//this and next are expression
//recursive procedure to attach next tokens as expression to current tree
//this way we can have func( x+y, func2(y*z) )
//if we need to attach root expression node, perhaps each line should root
//node
}
}
fclose(pInputFile);
exit(EXIT_SUCCESS);
}
