| /* parse.cc */ | |
| /* | |
| Copyright (C) 2003 Unique Software Designs | |
| This file is part of the program "lambda". | |
| The program "lambda" is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 2 of the License, or | |
| (at your option) any later version. | |
| The program "lambda" is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with "lambda"; if not, write to the Free Software | |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| A copy of the GNU General Public License may also be found at: | |
| http://www.gnu.org/copyleft/gpl.html | |
| */ | |
| #if HAVE_CONFIG_H | |
| # include "config.h" | |
| #endif | |
| #ifdef __MVS__ | |
| #include <strings.h> | |
| #endif | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <stdarg.h> | |
| #include <config.h> | |
| #include "token_stream.h" | |
| #include "node.h" | |
| #include "parse.h" | |
| int trace_lambda = 0; | |
| int step_lambda = 0; | |
| int print_symbols = 1; | |
| int applicative_order = 0; | |
| int reduce_body = 0; | |
| int brief_print = 1; | |
| int step_thru = 0; | |
| int extract_eta = 1; | |
| int extract_app = 0; | |
| int reduce_fully = 1; | |
| lambda_expression_parser:: | |
| lambda_expression_parser(token_stream* tokstr) | |
| { | |
| tokstr_v = tokstr; | |
| paren_nest_level_v = 0; | |
| } | |
| lambda_expression_parser:: | |
| ~lambda_expression_parser() | |
| { | |
| } | |
| exp_node* lambda_expression_parser:: | |
| expression(arglst_node** penv) | |
| { | |
| exp_node* exp = 0; | |
| if( !tokstr_v ) return exp; | |
| token_stream::token_type tok; | |
| char* ptok; | |
| token_stream::header_type htype; | |
| tok = tokstr_v->get_token(&ptok); | |
| htype = tokstr_v->is_header(tok,ptok); | |
| if( htype != token_stream::NOTHDR){ | |
| switch(htype){ | |
| case token_stream::QUIT: | |
| exp = (exp_node*)new arg_node("QUIT", 0); | |
| break; | |
| case token_stream::DEF: | |
| definition(penv); | |
| break; | |
| case token_stream::LOAD: | |
| load(penv); | |
| break; | |
| case token_stream::SAVE: | |
| break; | |
| case token_stream::LIST: | |
| if( penv && *penv) (*penv)->list(); | |
| break; | |
| case token_stream::SET: | |
| { | |
| int do_list = 0; | |
| int cnt = 0; | |
| for( tok = tokstr_v->get_token(&ptok); | |
| tok!=token_stream::EOE; | |
| tok = tokstr_v->get_token(&ptok) ) | |
| { | |
| if( tok==token_stream::NAME ){ | |
| if( 0==strcasecmp("trace", ptok) ){ | |
| trace_lambda = (!trace_lambda); | |
| }else | |
| if( 0==strcasecmp("step", ptok) ){ | |
| step_lambda = (!step_lambda); | |
| if( step_lambda ) step_thru = 0; | |
| }else | |
| if( 0==strcasecmp("thru", ptok) ){ | |
| step_thru = (!step_thru); | |
| if( step_thru ) step_lambda = 0; | |
| }else | |
| if( 0==strcasecmp("sym", ptok) ){ | |
| print_symbols = (!print_symbols); | |
| }else | |
| if( 0==strcasecmp("app", ptok) ){ | |
| applicative_order = (!applicative_order); | |
| }else | |
| if( 0==strcasecmp("body", ptok) ){ | |
| reduce_body = (!reduce_body); | |
| }else | |
| if( 0==strcasecmp("brief", ptok) ){ | |
| brief_print = (!brief_print); | |
| }else | |
| if( 0==strcasecmp("eta", ptok) ){ | |
| extract_eta = (!extract_eta); | |
| }else | |
| if( 0==strcasecmp("xapp", ptok) ){ | |
| extract_app = (!extract_app); | |
| }else | |
| if( 0==strcasecmp("full", ptok) ){ | |
| reduce_fully = (!reduce_fully); | |
| }else{ | |
| do_list = 1; | |
| } | |
| }else do_list =1; | |
| cnt = 1; | |
| } | |
| if( do_list || !cnt ){ | |
| printf(">trace = %d\n",trace_lambda); | |
| printf(">step = %d\n",step_lambda); | |
| printf(">thru = %d\n",step_thru); | |
| printf(">app = %d\n",applicative_order); | |
| printf(">body = %d\n",reduce_body); | |
| printf(">brief = %d\n",brief_print); | |
| printf(">sym = %d\n",print_symbols); | |
| printf(">eta = %d\n",extract_eta); | |
| printf(">xapp = %d\n",extract_app); | |
| printf(">full = %d\n",reduce_fully); | |
| } | |
| } | |
| break; | |
| case token_stream::EXT: | |
| { | |
| int inp = 0; | |
| if( extract_eta ) inp |= node::DO_EXTRACT_ETA; | |
| if( extract_app ) inp |= node::DO_EXTRACT_APP; | |
| exp_node* exp = extraction(penv,inp); | |
| arglst_node* env = 0; | |
| if( penv ) env = *penv; | |
| if( exp ) | |
| { | |
| int inp = 0; | |
| if( brief_print ) | |
| inp |= node::DO_PRINT_BRIEF; | |
| exp->print(env,inp); | |
| printf("\n"); | |
| delete exp; | |
| } | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| }else{ | |
| tokstr_v->push_token(tok,ptok ); | |
| exp = application(); | |
| } | |
| if( tokstr_v ) tokstr_v->reset_token(); | |
| node::reset(); | |
| return exp; | |
| } | |
| exp_node* lambda_expression_parser:: | |
| application() | |
| { | |
| exp_node* exp = 0; | |
| if( !tokstr_v ) return exp; | |
| token_stream::token_type tok; | |
| char* ptok; | |
| exp_node* left = 0; | |
| exp_node* right = 0; | |
| tok = tokstr_v->get_token(&ptok); | |
| switch( tok ){ | |
| case token_stream::LAMBDA: | |
| tokstr_v->push_token(tok,ptok ); | |
| exp = lambda(); | |
| break; | |
| case token_stream::NAME: | |
| case token_stream::LPAREN: | |
| tokstr_v->push_token(tok,ptok ); | |
| left = alist(); | |
| right = lambda(); | |
| if( !right ){ | |
| exp = left; | |
| }else{ | |
| exp = (exp_node*)new app_node(left,right,True); | |
| } | |
| case token_stream::EOE: | |
| break; | |
| default: | |
| dderrmsg("expresion expected: got %s", ptok?ptok:"(*null*)" ); | |
| //tokstr_v->push_token(tok,ptok ); | |
| } | |
| return exp; | |
| } | |
| exp_node* lambda_expression_parser:: | |
| lambda() | |
| { | |
| exp_node* exp = 0; | |
| if( !tokstr_v ) return exp; | |
| token_stream::token_type tok; | |
| char* ptok; | |
| arg_node* arg = 0; | |
| exp_node* body = 0; | |
| tok = tokstr_v->get_token(&ptok); | |
| if( token_stream::LAMBDA!=tok ){ | |
| //dderrmsg("^ expected: got %s", ptok?ptok:"(*null*)" ); | |
| if( token_stream::EOE!=tok ) | |
| tokstr_v->push_token(tok,ptok ); | |
| return exp; | |
| } | |
| tok = tokstr_v->get_token(&ptok); | |
| if( token_stream::NAME!=tok ){ | |
| dderrmsg("NAME expected: got %s", ptok?ptok:"(*null*)" ); | |
| //tokstr_v->push_token(tok,ptok ); | |
| return exp; | |
| } | |
| arg = new arg_node(ptok,0); | |
| tok = tokstr_v->get_token(&ptok); | |
| if( token_stream::PERIOD!=tok ){ | |
| dderrmsg("PERIOD expected: got %s", ptok?ptok:"(*null*)" ); | |
| //tokstr_v->push_token(tok,ptok ); | |
| return exp; | |
| } | |
| body = application(); //expression(); | |
| if( !body ) { | |
| delete arg; | |
| }else{ | |
| exp = new lam_node(arg,body,True); | |
| } | |
| return exp; | |
| } | |
| exp_node* lambda_expression_parser:: | |
| alist() | |
| { | |
| exp_node* exp = 0; | |
| if( !tokstr_v ) return exp; | |
| token_stream::token_type tok; | |
| char* ptok; | |
| for( tok = tokstr_v->get_token(&ptok); | |
| token_stream::NAME==tok || | |
| token_stream::LPAREN==tok; | |
| tok = tokstr_v->get_token(&ptok) ) | |
| { | |
| tokstr_v->push_token(tok,ptok); | |
| exp_node* anode = atom(); | |
| if( anode ){ | |
| if( exp ) | |
| { | |
| exp = (exp_node*) | |
| new app_node( exp, anode, True); | |
| }else exp = anode; | |
| } | |
| } | |
| tokstr_v->push_token(tok,ptok ); | |
| return exp; | |
| } | |
| exp_node* lambda_expression_parser:: | |
| atom() | |
| { | |
| exp_node* exp = 0; | |
| if( !tokstr_v ) return exp; | |
| token_stream::token_type tok; | |
| char* ptok; | |
| tok = tokstr_v->get_token(&ptok); | |
| switch(tok) | |
| { | |
| case token_stream::LPAREN: | |
| exp = application();//expression(); | |
| tok = tokstr_v->get_token(&ptok); | |
| if( token_stream::RPAREN!=tok ){ | |
| dderrmsg(") expected: got %s", ptok?ptok:"(*null*)" ); | |
| //if( token_stream::EOE!=tok ) | |
| // tokstr_v->push_token(tok,ptok ); | |
| } | |
| break; | |
| case token_stream::NAME: | |
| exp = (exp_node*)new var_node(ptok); | |
| break; | |
| default: | |
| tokstr_v->push_token(tok,ptok ); | |
| } | |
| return exp; | |
| } | |
| ///////////////////////////////////////////////////////////////////// | |
| arglst_node* lambda_expression_parser:: | |
| definition(arglst_node** penv) | |
| { | |
| arglst_node* arglst = 0; | |
| if( !tokstr_v ) return arglst; | |
| token_stream::token_type tok; | |
| char* ptok; | |
| tok = tokstr_v->get_token(&ptok); | |
| if( token_stream::NAME==tok ){ | |
| arg_node* arg= new arg_node(ptok, 0); | |
| exp_node* exp= expression(); | |
| if( penv ){ | |
| #define APPEND_DEFS | |
| #undef APPEND_DEFS | |
| #ifdef APPEND_DEFS | |
| if( arg ) arg->import_value(&exp); | |
| if( *penv ){ | |
| arglst = (arglst_node*)((*penv)->add(arg,True)); | |
| *penv = arglst; | |
| } | |
| else{ | |
| arglst = new arglst_node(arg,0,True); | |
| *penv = arglst; | |
| } | |
| #else | |
| if( *penv ){ | |
| arg_node* old = (*penv)->find(arg); | |
| if( old ){ | |
| old->import_value(&exp); | |
| if( arg ) delete arg;// arg not used! | |
| }else{ | |
| if( arg ) arg->import_value(&exp); | |
| arglst = new arglst_node(arg,*penv,True); | |
| *penv = arglst; | |
| definition_env = arglst; | |
| } | |
| }else{ | |
| if( arg ) arg->import_value(&exp); | |
| arglst = new arglst_node(arg,0,True); | |
| *penv = arglst; | |
| definition_env = arglst; | |
| } | |
| #endif | |
| } | |
| } | |
| return arglst; | |
| } | |
| arglst_node* lambda_expression_parser:: | |
| load(arglst_node** penv) | |
| { | |
| arglst_node* arglst = 0; | |
| if( !tokstr_v ) return arglst; | |
| token_stream::token_type tok; | |
| char* ptok; | |
| tok = tokstr_v->get_token(&ptok); | |
| if( token_stream::STRING==tok ){ | |
| char* tk = strtok( ptok, "\"" ); | |
| if( tk ) ptok = tk; | |
| tok = token_stream::NAME; | |
| } | |
| if( token_stream::NAME==tok ){ | |
| token_stream* loadstr = new token_stream(ptok); | |
| if( loadstr ){ | |
| lambda_expression_parser parse(loadstr); | |
| while( !loadstr->get_read_EOF() | |
| && !loadstr->get_read_error() ) | |
| parse.expression(penv); | |
| delete loadstr; | |
| } | |
| } | |
| return arglst; | |
| } | |
| exp_node* lambda_expression_parser:: | |
| extraction(arglst_node** penv,int inp) | |
| { | |
| exp_node* exp = 0; | |
| if( !tokstr_v ) return exp; | |
| token_stream::token_type tok; | |
| char* ptok; | |
| tok = tokstr_v->get_token(&ptok); | |
| if( token_stream::NAME==tok | |
| || token_stream::LAMBDA==tok ) | |
| { | |
| char* nm = 0; | |
| if( token_stream::NAME==tok | |
| && 0 != strcmp(ptok, "~" ) ) | |
| { | |
| nm = new char[strlen(ptok)+1]; | |
| strcpy(nm,ptok); | |
| } | |
| exp_node* exp1 = expression(); | |
| if( exp1 ) | |
| { | |
| exp = exp1->extract(nm,inp); | |
| delete exp1; | |
| } | |
| if( nm ) delete nm; | |
| } | |
| return exp; | |
| } | |
| ///////////////////////////////////////////////////////////////////// | |
| void lambda_expression_parser:: | |
| set_tok_str(token_stream* tokstr) | |
| { | |
| tokstr_v = tokstr; | |
| } | |
| void lambda_expression_parser:: | |
| reset() | |
| { | |
| paren_nest_level_v = 0; | |
| } | |
| void lambda_expression_parser:: | |
| dderrmsg(char* format,...) | |
| { | |
| va_list args; | |
| va_start(args, format); | |
| //format = va_arg(args,char*); | |
| #if defined _WINDOWS | |
| char msg[512]; | |
| sprintf(msg, "***line %d:\n", linenum); | |
| vsprintf(msg+strlen(msg), format, args ); | |
| AfxMessageBox(msg); | |
| #else | |
| if(tokstr_v->get_linenum()>=0) | |
| printf("\n*** line %d: ", | |
| tokstr_v->get_linenum()); | |
| vfprintf(stdout,format,args); | |
| printf("\n"); | |
| #endif | |
| va_end(args); | |
| fflush(stderr); | |
| } |