rev 300 - in trunk: . include/prothon pr src
SVN User <[email protected]>
| Newsgroups | gmane.comp.lang.prothon.cvs |
|---|---|
| Message-ID | <[email protected]> |
Author: mark
Date: 2004-04-08 04:05:03 -0400 (Thu, 08 Apr 2004)
New Revision: 300
Added:
trunk/pr/chained.pr
Modified:
trunk/STATUS.txt
trunk/include/prothon/prothon.h
trunk/src/builtins-core.c
trunk/src/interp.c
trunk/src/interp.h
trunk/src/parser.h
trunk/src/parser_routines.c
trunk/src/prothon.y
trunk/src/src.vcproj
trunk/src/symbol.c
Log:
chained compares (a > b > c) are implemented but broken,
(see new chained.pr)
Modified: trunk/STATUS.txt
===================================================================
--- trunk/STATUS.txt 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/STATUS.txt 2004-04-08 08:05:03 UTC (rev 300)
@@ -1,8 +1,6 @@
----------------------- TO-DO (highest priority first) ------------------------
---- add new obj^method() syntax
-
--- add list comprehension
--- a < b < c
Modified: trunk/include/prothon/prothon.h
===================================================================
--- trunk/include/prothon/prothon.h 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/include/prothon/prothon.h 2004-04-08 08:05:03 UTC (rev 300)
@@ -289,18 +289,19 @@
__NEG__,
__INV__,
- __IN__QUES,
- __NOTIN__QUES,
+ __IN__QUES,
+ __NOTIN__QUES,
__IS__QUES,
__ISNOT__QUES,
- CMP,
- __LT__QUES,
- __LE__QUES,
- __GT__QUES,
+
+ __LT__QUES, // __LT__QUES thru __EQ__QUES
+ __LE__QUES, // must stay in this sequence
+ __GT__QUES, // see binary() in parser_routines.c
__GE__QUES,
__NE__QUES,
__EQ__QUES,
+ CMP,
__OR__,
__XOR__,
__AND__,
Added: trunk/pr/chained.pr
===================================================================
--- trunk/pr/chained.pr 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/pr/chained.pr 2004-04-08 08:05:03 UTC (rev 300)
@@ -0,0 +1,35 @@
+
+# chained.pr
+
+print 30 <= 30 >= 30 >= 20
+
+print "these should all be true\n"
+
+print 1 < 2 < 3 < 5 < 199
+
+print 10 < 20 <= 30 <= 30 >= 30 >= 20 > 10
+
+print 1 < 2 > 1 < 2 > 1
+
+print 1 >= 1 == 1 != 2 == 2 > 1 <= 1 <= 2
+
+print "\n\nthese should all be false\n"
+
+print 1 < 2 < 3 < 2 < 199
+
+print 10 < 20 <= 30 <= 29 >= 30 >= 20 > 10
+
+print 1 < 2 > 2 < 2 > 1
+
+print 1 >= 1 == 2 != 2 == 2 > 1 <= 1 <= 2
+
+print "\n\nThis should print 0 1 1 1 2 1 0 2 1 2 2 1\n"
+
+N=[0,0,0]
+def c(x,i):
+ N[i] += 1
+ print i, N[i],
+ return x
+
+c(1,0) < c(2,1) < c(3,2)
+c(1,0) > c(2,1) < c(3,2)
Modified: trunk/src/builtins-core.c
===================================================================
--- trunk/src/builtins-core.c 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/src/builtins-core.c 2004-04-08 08:05:03 UTC (rev 300)
@@ -551,7 +551,7 @@
DEF(Func, clone, NULL) {
obj_p clone = clone_object(ist, self);
- code* p = self->data.ptr;
+ code_p p = self->data.ptr;
size_t len = sizeof(code) + p->len * sizeof(code_t);
clone->data.ptr = pr_malloc(len);
memcpy(clone->data.ptr, p, len);
Modified: trunk/src/interp.c
===================================================================
--- trunk/src/interp.c 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/src/interp.c 2004-04-08 08:05:03 UTC (rev 300)
@@ -72,7 +72,7 @@
static FILE* tfout=NULL;
-static int prt_code_line(exec_frame_t* frame, code* code, int pc, FILE* fout);
+static int prt_code_line(exec_frame_t* frame, code_p code, int pc, FILE* fout);
isp get_ist(access_t access) {
isp ist = pr_malloc(sizeof(interp_state_t));
@@ -97,9 +97,9 @@
//******************************** new_exec_frame *****************************
exec_frame_t* new_exec_frame( isp ist, obj_p syn_self, obj_p self, obj_p globals,
obj_p syn_locals, obj_p dyn_locals, obj_p locals,
- obj_p func_obj, code* code_in ) {
+ obj_p func_obj, code_p code_in ) {
exec_frame_t* frame;
- code* code;
+ code_p code;
size_t flen;
if (func_obj) code = obj_data_p(func_obj);
else code = code_in;
@@ -831,7 +831,7 @@
break;
case OP_EXEC: {
parse_state* state;
- code* code;
+ code_p code;
obj_p str_obj;
exec_frame_t* new_frame;
str_obj = fr_pop;
@@ -1290,7 +1290,7 @@
//******************************** exec_string ********************************
obj_p exec_string(isp ist, char* str, int get_frame, exec_frame_t* *frame_p) {
- code* code;
+ code_p code;
obj_p new_locals;
exec_frame_t *frame, *new_frame;
parse_state* state = parse_file_or_string(ist, NULL, str);
@@ -1346,7 +1346,7 @@
exec_frame_t *frame, *new_frame;
parse_state* state;
char full_doc[1024], *name;
- code* code;
+ code_p code;
int i;
if (!module)
@@ -1460,7 +1460,7 @@
#define CODE_DATA_STR_SIZE 1024
//******************************** codedata ***********************************
-static char* codedata(char* str, code* code, int op, int param, int pc)
+static char* codedata(char* str, code_p code, int op, int param, int pc)
{
int i;
@@ -1479,7 +1479,7 @@
}
//******************************** prt_code_line ******************************
-static int prt_code_line(exec_frame_t* frame, code* code, int pc, FILE* fout)
+static int prt_code_line(exec_frame_t* frame, code_p code, int pc, FILE* fout)
{
char str[CODE_DATA_STR_SIZE];
opcode_t op;
@@ -1595,7 +1595,7 @@
return pc + 1;
}
//******************************** dump_code **********************************
-void dump_code(isp ist, obj_p func, code* code, char* filename){
+void dump_code(isp ist, obj_p func, code_p code, char* filename){
int i, pc=0;
obj_p lbl_value_list;
FILE* fout;
@@ -1606,7 +1606,7 @@
fprintf(fout,"len: %4d\n", code->len);
fprintf(fout,"stack_depth: %4d\n", code->stack_depth);
fprintf(fout,"max_stack_depth: %4d\n", code->max_stack_depth);
- fprintf(fout,"misc_param: %4d\n", code->misc_param);
+ fprintf(fout,"assign_parm_cnt: %4d\n", code->assign_parm_cnt);
if (code->file_path)
fprintf(fout,"file_path: %s\n\n", code->file_path);
if (func && (lbl_value_list = get_attr(ist, func, SYM(__FPARAMS__)))) {
Modified: trunk/src/interp.h
===================================================================
--- trunk/src/interp.h 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/src/interp.h 2004-04-08 08:05:03 UTC (rev 300)
@@ -85,7 +85,7 @@
obj_p locals;
obj_p globals;
int pc;
- code* code;
+ code_p code;
clist_p exc_stack;
int stack_ptr;
obj_p stack[];
@@ -135,6 +135,6 @@
#define fr_push(w) frame->stack[frame->stack_ptr++] = w
#define fr_pop (frame->stack[--frame->stack_ptr])
-void dump_code(isp ist, obj_p func, code* code, char* filename);
+void dump_code(isp ist, obj_p func, code_p code, char* filename);
#endif // #define INTERP_H
Modified: trunk/src/parser.h
===================================================================
--- trunk/src/parser.h 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/src/parser.h 2004-04-08 08:05:03 UTC (rev 300)
@@ -73,13 +73,16 @@
obj_p data;
} code_t;
-typedef struct {
+typedef struct code_s* code_p;
+
+typedef struct code_s {
int len;
int stack_depth;
int max_stack_depth;
- int misc_param;
+ int assign_parm_cnt;
+ code_p cmp_expr;
char* file_path;
- clist_p srcmap;
+ clist_p srcmap;
int doc_flg;
code_t code_data[];
} code;
@@ -101,7 +104,7 @@
int char_ptr;
char old_chars[10];
char* in_buf;
- code* parse_results;
+ code_p parse_results;
int num_errors;
int assert_enbld;
int defdoc_flag;
@@ -126,7 +129,7 @@
clist_p append_import_param(void* param, clist_p list, clist_p iparam);
clist_p append_label_to_import_path(void* param, clist_p list, char* label);
-clist_p append_list(void* param, clist_p list, code* item);
+clist_p append_list(void* param, clist_p list, code_p item);
clist_p append_list_label(void* param, clist_p list, char* label);
clist_p append_list_list(void* param, clist_p list, clist_p item);
clist_p empty_list(void* param);
@@ -135,71 +138,71 @@
clist_p label_to_forrefs(void* param, char* label1, char* label2);
clist_p label_to_import_path(void* param, char* label);
clist_p new_import_param(void* param, clist_p list);
-clist_p new_list(void* param, code* item);
-clist_p new_list2(void* param, code* item1, code* item2);
+clist_p new_list(void* param, code_p item);
+clist_p new_list2(void* param, code_p item1, code_p item2);
clist_p new_list_list(void* param, clist_p params);
-code* amp_label_to_attrref(void* param, char* label);
-code* append_code(void* param, code* p1, code* p3, int size);
-code* assign_cleanup(void* param, code* ass_code);
-code* assign_right(void* param, clist_p right);
-code* at_label_to_attrref(void* param, char* label);
-code* attrref_to_tgtparm(void* param, code* p1);
-code* binary(void* param, code* lparm, int op, code* rparm);
-code* body_except_else_to_tryexcept(void* param, code* body, clist_p except_list, code* els);
-code* break_stmt(void* param, char* label);
-code* caret_label_to_attrref(void* param, char* label);
-code* cond_exc_to_assert(void* param, code* cond, code* exc);
-code* continue_stmt(void* param, char* label);
-code* del_ref(void* param, code* expr);
-code* dot_label_to_attrref(void* param, char* label);
-code* dot_to_obj(void* param);
-code* exceptall(void* param);
-code* exec_expr(void* param, code* expr);
-code* expr_andor_expr(void* param, code* lparm, code* rparm, int andor_flg);
-code* expr_label_body_to_except(void* param, code* expr, char* label, code* body);
-code* expr_to_param(void* param, code* expr);
-code* expr_to_slice(void* param, code* expr);
-code* expr_to_sparm(void* param, code* p1);
-code* float_to_obj(void* param, double num, int imag_flag);
-code* for_tgt_in_expr_body_else(void* param, clist_p locals, code* expr, code* body, code* els);
-code* from_path_import_params(void* param, clist_p path, clist_p iparms);
-code* if_expr_body_elif_else(void* param, code* ifex, code* body, clist_p elif, code* els);
-code* import_params(void* param, clist_p iparms);
-code* int_to_obj(void* param, i64_t num);
-code* label_eq_expr_to_formparm(void* param, char* label, code* expr);
-code* label_eq_expr_to_param(void* param, char* label, code* expr);
-code* label_to_attrref(void* param, char* label);
-code* label_to_formparm(void* param, char* label);
-code* new_dict(void* param, clist_p lst);
-code* new_tuple_list(void* param, clist_p lst, int tuple_flag);
-code* none(void* param);
-code* obj_func_params(void* param, code* obj, clist_p parms);
-code* obj_label_to_attrref(void* param, code* obj, char* label);
-code* op_expr(int op, code* expr, int size);
-code* print_arglist(void* param, clist_p list);
-code* raise_expr(void* param, code* expr);
-code* ref_expr_to_ass_op(void* param, code* ref, code* rparm, int iop, int op);
-code* ref_parm_body_to_def(void* param, code* name, clist_p params, code* self, code* body, int flg) ;
-code* return_expr(void* param, code* expr);
-code* self_func_params(void* param, code* attr_ref, clist_p parms);
-code* unbound_func_params(void* param, code* attr_ref, clist_p parms);
-code* obj_super_label_func_params(void* param, code* attr_ref, char* label, clist_p parms);
-code* sparms_to_slice(void* param, code* p1, code* p2, code* p3, int parm_cnt);
-code* stack_check(void* param, code* stmt);
-code* star_ref_to_formparm(void* param, char* label);
-code* star_seq_to_param(void* param, code* expr);
-code* star_star_dict_to_param(void* param, code* expr);
-code* star_star_ref_to_formparm(void* param, char* label);
-code* string_to_obj(void* param, char* str, int long_flag);
-code* tgt_eq_expr_to_stmt(void* param, clist_p left, clist_p right);
-code* tgt_eq_stmt_to_stmt(void* param, clist_p left, code* right);
-code* tgtparm_to_obj(void* param, code* expr);
-code* tryfinally_body(void* param, code* body, code* final);
-code* unary(void* param, int op, code* parm);
-code* while_expr_body_else(void* param, char* label, code* expr, code* body, code* els);
-code* word_expr_to_param(void* param, obj_p word, code* expr);
-code* yield_expr(void* param, code* expr);
+code_p amp_label_to_attrref(void* param, char* label);
+code_p append_code(void* param, code_p p1, code_p p3, int size);
+code_p assign_cleanup(void* param, code_p ass_code);
+code_p assign_right(void* param, clist_p right);
+code_p at_label_to_attrref(void* param, char* label);
+code_p attrref_to_tgtparm(void* param, code_p p1);
+code_p binary(void* param, code_p lparm, int op, code_p rparm);
+code_p body_except_else_to_tryexcept(void* param, code_p body, clist_p except_list, code_p els);
+code_p break_stmt(void* param, char* label);
+code_p caret_label_to_attrref(void* param, char* label);
+code_p cond_exc_to_assert(void* param, code_p cond, code_p exc);
+code_p continue_stmt(void* param, char* label);
+code_p del_ref(void* param, code_p expr);
+code_p dot_label_to_attrref(void* param, char* label);
+code_p dot_to_obj(void* param);
+code_p exceptall(void* param);
+code_p exec_expr(void* param, code_p expr);
+code_p expr_andor_expr(void* param, code_p lparm, code_p rparm, int andor_flg);
+code_p expr_label_body_to_except(void* param, code_p expr, char* label, code_p body);
+code_p expr_to_param(void* param, code_p expr);
+code_p expr_to_slice(void* param, code_p expr);
+code_p expr_to_sparm(void* param, code_p p1);
+code_p float_to_obj(void* param, double num, int imag_flag);
+code_p for_tgt_in_expr_body_else(void* param, clist_p locals, code_p expr, code_p body, code_p els);
+code_p from_path_import_params(void* param, clist_p path, clist_p iparms);
+code_p if_expr_body_elif_else(void* param, code_p ifex, code_p body, clist_p elif, code_p els);
+code_p import_params(void* param, clist_p iparms);
+code_p int_to_obj(void* param, i64_t num);
+code_p label_eq_expr_to_formparm(void* param, char* label, code_p expr);
+code_p label_eq_expr_to_param(void* param, char* label, code_p expr);
+code_p label_to_attrref(void* param, char* label);
+code_p label_to_formparm(void* param, char* label);
+code_p new_dict(void* param, clist_p lst);
+code_p new_tuple_list(void* param, clist_p lst, int tuple_flag);
+code_p none(void* param);
+code_p obj_func_params(void* param, code_p obj, clist_p parms);
+code_p obj_label_to_attrref(void* param, code_p obj, char* label);
+code_p op_expr(int op, code_p expr, int size);
+code_p print_arglist(void* param, clist_p list);
+code_p raise_expr(void* param, code_p expr);
+code_p ref_expr_to_ass_op(void* param, code_p ref, code_p rparm, int iop, int op);
+code_p ref_parm_body_to_def(void* param, code_p name, clist_p params, code_p self, code_p body, int flg) ;
+code_p return_expr(void* param, code_p expr);
+code_p self_func_params(void* param, code_p attr_ref, clist_p parms);
+code_p unbound_func_params(void* param, code_p attr_ref, clist_p parms);
+code_p obj_super_label_func_params(void* param, code_p attr_ref, char* label, clist_p parms);
+code_p sparms_to_slice(void* param, code_p p1, code_p p2, code_p p3, int parm_cnt);
+code_p stack_check(void* param, code_p stmt);
+code_p star_ref_to_formparm(void* param, char* label);
+code_p star_seq_to_param(void* param, code_p expr);
+code_p star_star_dict_to_param(void* param, code_p expr);
+code_p star_star_ref_to_formparm(void* param, char* label);
+code_p string_to_obj(void* param, char* str, int long_flag);
+code_p tgt_eq_expr_to_stmt(void* param, clist_p left, clist_p right);
+code_p tgt_eq_stmt_to_stmt(void* param, clist_p left, code_p right);
+code_p tgtparm_to_obj(void* param, code_p expr);
+code_p tryfinally_body(void* param, code_p body, code_p final);
+code_p unary(void* param, int op, code_p parm);
+code_p while_expr_body_else(void* param, char* label, code_p expr, code_p body, code_p els);
+code_p word_expr_to_param(void* param, obj_p word, code_p expr);
+code_p yield_expr(void* param, code_p expr);
void calc_code(code *p, int *len, int *stack_depth, int *max_stack_depth);
-void finished(void* param, code* code, int nerrs);
+void finished(void* param, code_p code, int nerrs);
#endif // #define PARSER_H
Modified: trunk/src/parser_routines.c
===================================================================
--- trunk/src/parser_routines.c 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/src/parser_routines.c 2004-04-08 08:05:03 UTC (rev 300)
@@ -61,7 +61,7 @@
#include "bytecodes.h"
#ifdef TRACE_PARSER
-code* debug_retrn(int line_no, code* res){
+code_p debug_retrn(int line_no, code_p res){
printf("******> lin:%4d, len:%3d, dep:%3d, max:%3d\n", line_no, res->len, res->stack_depth, res->max_stack_depth);
return res;
}
@@ -138,26 +138,23 @@
clist_append(((parse_state*)param)->const_objs, obj);
//********************************* new_code **********************************
-code* new_code(void* param, int size, int stk, int max_stk, opcode_t opcode) {
- code* p = pr_malloc(sizeof(code)+size*sizeof(code_t));
+code_p new_code(void* param, int size, int stk, int max_stk, opcode_t opcode) {
+ code_p p = pr_malloc(sizeof(code)+size*sizeof(code_t));
+ memset(p, 0, sizeof(code)+size*sizeof(code_t));
p->len = size;
p->stack_depth = stk;
p->max_stack_depth = max_stk;
- p->file_path = NULL;
- if(size){
- p->code_data[0].num = 0;
+ if(size)
p->code_data[0].bytecode.opcode = opcode;
- }
p->srcmap = new_clist(16);
clist_append_num(p->srcmap, 0);
clist_append_num(p->srcmap, ((parse_state*) param)->line);
clist_append_num(p->srcmap, ((parse_state*) param)->column);
- p->doc_flg = FALSE;
return debug_retrn(__LINE__, p);
}
//********************************* add_all_srcmap ********************************
-void add_all_srcmap(code* dst, code* src, int ofs, int free_flg){
+void add_all_srcmap(code_p dst, code_p src, int ofs, int free_flg){
int i;
clist_p dstmap = dst->srcmap;
clist_p srcmap = src->srcmap;
@@ -177,31 +174,35 @@
}
//********************************* add_code_flg *******************************
-void add_code_flg(code* newcode, code* res, int *k, int free_flg){
+void add_code_flg(code_p newcode, code_p res, int *k, int free_flg){
memcpy(res->code_data + *k, newcode->code_data, newcode->len * sizeof(code_t));
add_all_srcmap(res, newcode, *k, free_flg);
*k += newcode->len;
- if (free_flg) pr_free(newcode);
+ if (free_flg) {
+ if (newcode->cmp_expr)
+ pr_free(newcode->cmp_expr);
+ pr_free(newcode);
+ }
}
//********************************* add_code_to *******************************
-void add_code_to(code* newcode, code* res, int *k){
+void add_code_to(code_p newcode, code_p res, int *k){
add_code_flg(newcode, res, k, TRUE);
}
//********************************* add_code_no_free *******************************
-void add_code_no_free(code* newcode, code* res, int *k){
+void add_code_no_free(code_p newcode, code_p res, int *k){
add_code_flg(newcode, res, k, FALSE);
}
//********************************* parser called routines ********************
-void finished(void* param, code* code, int nerrs){
+void finished(void* param, code_p code, int nerrs){
((parse_state*) param)->parse_results = code;
((parse_state*) param)->num_errors = nerrs;
}
-code* stack_check(void* param, code* stmt){
+code_p stack_check(void* param, code_p stmt){
if (stmt->stack_depth < 0 || stmt->stack_depth > 1){
printf("Parser error, simulated stack value error: %d\n",stmt->stack_depth);
pr_exit(1);
@@ -218,29 +219,29 @@
}
}
if (stmt->stack_depth) {
- code* res = new_code(param, 1, -1, 0, OP_POP);
+ code_p res = new_code(param, 1, -1, 0, OP_POP);
res->code_data[0].bytecode.param = 1;
return debug_retrn(__LINE__, append_code(param, stmt, res, 0));
}
return debug_retrn(__LINE__, stmt);
}
-code* none(void* param){
+code_p none(void* param){
return debug_retrn(__LINE__, new_code(param,0,0,0,0));
}
clist_p empty_list(void* param){
return new_clist(4);
}
-clist_p new_list(void* param, code* item){
+clist_p new_list(void* param, code_p item){
return new_clist_1(item);
}
clist_p new_list_list(void* param, clist_p params){
return new_clist_1(params);
}
-clist_p new_list2(void* param, code* item1, code* item2){
+clist_p new_list2(void* param, code_p item1, code_p item2){
return new_clist_2(item1, item2);
}
-clist_p append_list(void* param, clist_p list, code* item){
+clist_p append_list(void* param, clist_p list, code_p item){
return clist_append(list, item);
}
clist_p append_list_list(void* param, clist_p list, clist_p item){
@@ -255,7 +256,7 @@
(*stack_depth) += p->stack_depth;
}
-code* append_code(void* param, code* p1, code* p3, int size){
+code_p append_code(void* param, code_p p1, code_p p3, int size){
if (p3){
if (p1){
p1 = pr_realloc(p1, sizeof(code) + (p1->len + p3->len + size)*sizeof(code_t));
@@ -265,6 +266,8 @@
p1->max_stack_depth = max(p1->max_stack_depth, p1->stack_depth + p3->max_stack_depth);
p1->stack_depth = p1->stack_depth + p3->stack_depth;
p1->doc_flg = p1->doc_flg || p3->doc_flg;
+ if (p3->cmp_expr)
+ pr_free(p3->cmp_expr);
pr_free(p3);
return debug_retrn(__LINE__, p1);
} else if (size) {
@@ -296,8 +299,8 @@
clist_p append_import_param(void* param, clist_p list, clist_p iparam){
return clist_append(list, iparam);
}
-code* import_params(void* param, clist_p iparms){
- code* p;
+code_p import_params(void* param, clist_p iparms){
+ code_p p;
int i, size=0, j, k=0;
for(i=0; i < clist_len(iparms); i++){
clist_p iparm = clist_item(iparms, i);
@@ -321,8 +324,8 @@
}
return debug_retrn(__LINE__, p);
}
-code* from_path_import_params(void* param, clist_p path, clist_p iparms){
- code* p;
+code_p from_path_import_params(void* param, clist_p path, clist_p iparms){
+ code_p p;
int i, size, j, k=0;
size = 1 + clist_len(path);
for (i=0; i < clist_len(iparms); i++){
@@ -351,8 +354,8 @@
p->code_data[k++].bytecode.opcode = OP_POP;
return debug_retrn(__LINE__, p);
}
-code* label_to_attrref(void* param, char* label){
- code* p;
+code_p label_to_attrref(void* param, char* label){
+ code_p p;
if (*label >= 'A' && *label <= 'Z')
p = new_code(param, 2, 2, 2, OP_PUSH_GLOBAL_REF);
else
@@ -360,31 +363,31 @@
p->code_data[1].data = sym(INTRP, label);
return debug_retrn(__LINE__, p);
}
-code* dot_label_to_attrref(void* param, char* label){
- code* p;
+code_p dot_label_to_attrref(void* param, char* label){
+ code_p p;
p = new_code(param, 2, 2, 2, OP_PUSH_SELF_REF);
p->code_data[1].data = sym(INTRP, label);
return debug_retrn(__LINE__, p);
}
-code* caret_label_to_attrref(void* param, char* label){
- code* p;
+code_p caret_label_to_attrref(void* param, char* label){
+ code_p p;
p = new_code(param, 2, 2, 2, OP_PUSH_SUPER_REF);
p->code_data[1].data = sym(INTRP, label);
return debug_retrn(__LINE__, p);
}
-code* amp_label_to_attrref(void* param, char* label){
- code* p;
+code_p amp_label_to_attrref(void* param, char* label){
+ code_p p;
p = new_code(param, 2, 2, 2, OP_PUSH_SYN_REF);
p->code_data[1].data = sym(INTRP, label);
return debug_retrn(__LINE__, p);
}
-code* at_label_to_attrref(void* param, char* label){
- code* p;
+code_p at_label_to_attrref(void* param, char* label){
+ code_p p;
p = new_code(param, 2, 2, 2, OP_PUSH_DYN_REF);
p->code_data[1].data = sym(INTRP, label);
return debug_retrn(__LINE__, p);
}
-code* obj_label_to_attrref(void* param, code* obj, char* label){
+code_p obj_label_to_attrref(void* param, code_p obj, char* label){
obj->len += 2;
obj = pr_realloc(obj, sizeof(code)+(obj->len)*sizeof(code_t));
obj->code_data[obj->len-2].bytecode.opcode = OP_PUSH;
@@ -394,11 +397,11 @@
obj->max_stack_depth = max(obj->max_stack_depth, obj->stack_depth);
return debug_retrn(__LINE__, obj);
}
-code* attrref_to_tgtparm(void* param, code* p1){
+code_p attrref_to_tgtparm(void* param, code_p p1){
return debug_retrn(__LINE__, p1);
}
-code* obj_func_params(void* param, code* obj, clist_p parms){
- code* res;
+code_p obj_func_params(void* param, code_p obj, clist_p parms){
+ code_p res;
int i, k=0;
int len = obj->len;
int stack_depth = obj->stack_depth;
@@ -416,8 +419,8 @@
assert(k==res->len);
return debug_retrn(__LINE__, res);
}
-code* self_func_params(void* param, code* attr_ref, clist_p parms){
- code* res;
+code_p self_func_params(void* param, code_p attr_ref, clist_p parms){
+ code_p res;
int i, k=0;
int len = attr_ref->len;
int stack_depth = attr_ref->stack_depth;
@@ -435,8 +438,8 @@
assert(k==res->len);
return debug_retrn(__LINE__, res);
}
-code* unbound_func_params(void* param, code* attr_ref, clist_p parms){
- code* res;
+code_p unbound_func_params(void* param, code_p attr_ref, clist_p parms){
+ code_p res;
int i, k=0;
int len = attr_ref->len;
int stack_depth = attr_ref->stack_depth;
@@ -455,8 +458,8 @@
assert(k==res->len);
return debug_retrn(__LINE__, res);
}
-code* obj_super_label_func_params(void* param, code* obj, char* label, clist_p parms) {
- code* res;
+code_p obj_super_label_func_params(void* param, code_p obj, char* label, clist_p parms) {
+ code_p res;
int i, k=0;
int len = obj->len+2;
int stack_depth = obj->stack_depth+1;
@@ -477,14 +480,14 @@
assert(k==res->len);
return debug_retrn(__LINE__, res);
}
-code* label_to_formparm(void* param, char* label){
- code* res = new_code(param, 3, 2, 2, OP_PUSH);
+code_p label_to_formparm(void* param, char* label){
+ code_p res = new_code(param, 3, 2, 2, OP_PUSH);
res->code_data[0].bytecode.param = 3;
res->code_data[1].data = sym(INTRP, label);
res->code_data[2].data = PARAM_NORMAL;
return debug_retrn(__LINE__, res);
}
-code* label_eq_expr_to_formparm(void* param, char* label, code* expr){
+code_p label_eq_expr_to_formparm(void* param, char* label, code_p expr){
expr->len += 2;
expr->stack_depth++;
expr->max_stack_depth++;
@@ -495,24 +498,24 @@
expr->code_data[1].data = sym(INTRP, label);
return debug_retrn(__LINE__, expr);
}
-code* star_ref_to_formparm(void* param, char* label){
- code* res = new_code(param, 3, 2, 2, OP_PUSH);
+code_p star_ref_to_formparm(void* param, char* label){
+ code_p res = new_code(param, 3, 2, 2, OP_PUSH);
res->code_data[0].bytecode.param = 3;
res->code_data[1].data = PARAM_STAR;
res->code_data[2].data = sym(INTRP, label);
return debug_retrn(__LINE__, res);
}
-code* star_star_ref_to_formparm(void* param, char* label){
- code* res = new_code(param, 3, 2, 2, OP_PUSH);
+code_p star_star_ref_to_formparm(void* param, char* label){
+ code_p res = new_code(param, 3, 2, 2, OP_PUSH);
res->code_data[0].bytecode.param = 3;
res->code_data[1].data = PARAM_STAR_STAR;
res->code_data[2].data = sym(INTRP, label);
return debug_retrn(__LINE__, res);
}
-code* expr_to_sparm(void* param, code* p1){
+code_p expr_to_sparm(void* param, code_p p1){
return debug_retrn(__LINE__, p1);
}
-void add_slice_count(code* p, int *len, int *stack_depth, int *max_stack_depth){
+void add_slice_count(code_p p, int *len, int *stack_depth, int *max_stack_depth){
if (p && p->len)
calc_code(p, len, stack_depth, max_stack_depth);
else {
@@ -521,7 +524,7 @@
(*stack_depth)++;
}
}
-void add_slice(code* res, code* p, int *k, int parm_cnt, int count){
+void add_slice(code_p res, code_p p, int *k, int parm_cnt, int count){
if (p && p->len)
add_code_to(p, res, k);
else {
@@ -533,7 +536,7 @@
res->code_data[(*k)++].data = SLICEPARAM_EMPTY;
}
}
-code* sparms_to_slice(void* param, code* p1, code* p2, code* p3, int parm_cnt){
+code_p sparms_to_slice(void* param, code_p p1, code_p p2, code_p p3, int parm_cnt){
code *res;
int k=0, len=1, stack_depth=0, max_stack_depth=0;
add_slice_count(p1, &len, &stack_depth, &max_stack_depth);
@@ -547,7 +550,7 @@
res->stack_depth -= 2;
return debug_retrn(__LINE__, res);
}
-code* expr_to_slice(void* param, code* expr){
+code_p expr_to_slice(void* param, code_p expr){
expr->len += 4;
expr->max_stack_depth = max(expr->max_stack_depth, expr->stack_depth + 2);
expr = pr_realloc(expr, sizeof(code)+(expr->len)*sizeof(code_t));
@@ -558,7 +561,7 @@
expr->code_data[expr->len-1].bytecode.opcode = OP_NEWSLICE;
return debug_retrn(__LINE__, expr);
}
-code* unary(void* param, int op, code* parm){
+code_p unary(void* param, int op, code_p parm){
parm->len += 3;
parm->max_stack_depth = max(parm->max_stack_depth, parm->stack_depth + 1);
parm = pr_realloc(parm, sizeof(code)+(parm->len)*sizeof(code_t));
@@ -569,25 +572,38 @@
parm->code_data[parm->len-1].bytecode.param = 0;
return debug_retrn(__LINE__, parm);
}
-code* binary(void* param, code* lparm, int op, code* rparm){
- int k=0;
- code* res = new_code(param, lparm->len + 3 + rparm->len + 1,
- lparm->stack_depth, max( max( lparm->max_stack_depth,
- lparm->stack_depth+2+rparm->max_stack_depth), 4), 0);
- add_code_to(lparm, res, &k);
- res->code_data[k ].bytecode.opcode = OP_PUSH;
- res->code_data[k++].bytecode.param = 3;
- res->code_data[k++].data = sym_id_table[op].id;
- res->code_data[k++].data = PARAM_NORMAL;
- add_code_to(rparm, res, &k);
- res->code_data[k ].bytecode.opcode = OP_CALL;
- res->code_data[k++].bytecode.param = 1;
- assert(k==res->len);
+code_p binary(void* param, code_p lparm, int op, code_p rparm){
+ code_p res;
+ int k=0, have_cmp_op = (op >= __LT__QUES && op <= __EQ__QUES);
+
+ if (lparm->cmp_expr && have_cmp_op) {
+ code_p and_rparm, bin_lparm = lparm->cmp_expr;
+ lparm->cmp_expr = NULL;
+ and_rparm = binary(param, bin_lparm, op, rparm);
+ res = expr_andor_expr(param, lparm, and_rparm, AND_FLAG);
+ } else {
+ res = new_code( param, lparm->len + 3 + rparm->len + 1,
+ lparm->stack_depth, max( max( lparm->max_stack_depth,
+ lparm->stack_depth+2+rparm->max_stack_depth), 4), 0 );
+ add_code_to(lparm, res, &k);
+ res->code_data[k ].bytecode.opcode = OP_PUSH;
+ res->code_data[k++].bytecode.param = 3;
+ res->code_data[k++].data = sym_id_table[op].id;
+ res->code_data[k++].data = PARAM_NORMAL;
+ if (have_cmp_op) {
+ res->cmp_expr = rparm;
+ add_code_no_free(rparm, res, &k);
+ } else
+ add_code_to(rparm, res, &k);
+ res->code_data[k ].bytecode.opcode = OP_CALL;
+ res->code_data[k++].bytecode.param = 1;
+ assert(k==res->len);
+ }
return debug_retrn(__LINE__, res);
}
-code* expr_andor_expr(void* param, code* lparm, code* rparm, int andor_flg){
+code_p expr_andor_expr(void* param, code_p lparm, code_p rparm, int andor_flg){
int k=0;
- code* res = new_code( param, lparm->len + 7 + rparm->len + 2, 1,
+ code_p res = new_code( param, lparm->len + 7 + rparm->len + 2, 1,
max( max( lparm->max_stack_depth,
lparm->stack_depth+1+rparm->max_stack_depth ), 3 ), 0 );
add_code_to(lparm, res, &k);
@@ -611,7 +627,7 @@
return debug_retrn(__LINE__, res);
}
#define SKIP_CODE1_LEN 6
-void add_skip_code1(code* body, code* res, int* k){
+void add_skip_code1(code_p body, code_p res, int* k){
res->code_data[(*k) ].bytecode.opcode = OP_PUSH;
res->code_data[(*k)++].bytecode.param = 2;
res->code_data[(*k)++].data = SYM(__BOOL__QUES);
@@ -624,14 +640,14 @@
res->code_data[(*k)++].bytecode.param = 1;
}
#define SKIP_CODE2_LEN 2
-void add_skip_code2(int dist, code* res, int* k){
+void add_skip_code2(int dist, code_p res, int* k){
res->code_data[(*k) ].bytecode.opcode = OP_BR;
res->code_data[(*k)++].bytecode.param = dist;
res->code_data[(*k) ].bytecode.opcode = OP_POP;
res->code_data[(*k)++].bytecode.param = 1;
}
-code* if_expr_body_elif_else(void* param, code* ifex, code* body, clist_p elif, code* els){
+code_p if_expr_body_elif_else(void* param, code_p ifex, code_p body, clist_p elif, code_p els){
int i, k=0, len=0, stack_depth=0, max_stack_depth=0;
code *res;
calc_code(ifex, &len, &stack_depth, &max_stack_depth);
@@ -656,8 +672,8 @@
add_skip_code2(res->len - k, res, &k);
for(i=0; i < clist_len(elif); i++){
clist_p eil = clist_item(elif,i);
- code* pexpr = clist_item(eil,0);
- code* pbody = clist_item(eil,1);
+ code_p pexpr = clist_item(eil,0);
+ code_p pbody = clist_item(eil,1);
add_code_to(pexpr, res, &k);
add_skip_code1(pbody, res, &k);
add_code_to(pbody, res, &k);
@@ -669,17 +685,17 @@
return debug_retrn(__LINE__, res);
}
-code* break_stmt(void* param, char* label){
- code* res = new_code(param, 2, 0, 0, OP_BREAK);
+code_p break_stmt(void* param, char* label){
+ code_p res = new_code(param, 2, 0, 0, OP_BREAK);
res->code_data[1].pstr = label;
return debug_retrn(__LINE__, res);
}
-code* continue_stmt(void* param, char* label){
- code* res = new_code(param, 2, 0, 0, OP_CONTINUE);
+code_p continue_stmt(void* param, char* label){
+ code_p res = new_code(param, 2, 0, 0, OP_CONTINUE);
res->code_data[1].pstr = label;
return debug_retrn(__LINE__, res);
}
-void patch_break_continues(char* label, code* body){
+void patch_break_continues(char* label, code_p body){
int p=0;
while(p < body->len){
int opcode = body->code_data[p].bytecode.opcode;
@@ -705,7 +721,7 @@
clist_p label_to_forrefs(void* param, char* label1, char* label2){
return new_clist_2(label1, label2);
}
-code* for_tgt_in_expr_body_else(void* param, clist_p locals, code* expr, code* body, code* els){
+code_p for_tgt_in_expr_body_else(void* param, clist_p locals, code_p expr, code_p body, code_p els){
code *res;
int i, k=0, len=0, stack_depth=0, max_stack_depth=0;
int llen = clist_len(locals), loop_loc, body_loc, els_loc, end_els_loc, end_loc;
@@ -780,7 +796,7 @@
assert(end_loc == k);
return debug_retrn(__LINE__, res);
}
-code* ref_expr_to_ass_op(void* param, code* ref, code* rparm, int iop, int op){
+code_p ref_expr_to_ass_op(void* param, code_p ref, code_p rparm, int iop, int op){
code *res;
int len=0, stack_depth=0, max_stack_depth = 0;
int k=0, end_icall_loc, end_exc_loc, end_loc;
@@ -845,7 +861,7 @@
res->stack_depth -= 7;
return debug_retrn(__LINE__, res);
}
-code* while_expr_body_else(void* param, char* label, code* expr, code* body, code* els){
+code_p while_expr_body_else(void* param, char* label, code_p expr, code_p body, code_p els){
code *res;
int k=0, len=0, stack_depth=0, max_stack_depth = 3;
int loop_loc, body_loc, els_loc, end_loc;
@@ -891,7 +907,7 @@
assert(end_loc == k);
return debug_retrn(__LINE__, res);
}
-code* cond_exc_to_assert(void* param, code* cond, code* exc){
+code_p cond_exc_to_assert(void* param, code_p cond, code_p exc){
int k=0, len=0, stack_depth=0, max_stack_depth=4, pop_loc;
code *res;
if(!((parse_state*) param)->assert_enbld)
@@ -923,7 +939,7 @@
assert(res->len == k);
return debug_retrn(__LINE__, res);
}
-code* ref_parm_body_to_def(void* param, code* name, clist_p params, code* self, code* body, int flg) {
+code_p ref_parm_body_to_def(void* param, code_p name, clist_p params, code_p self, code_p body, int flg) {
code *res;
obj_p func;
int i, code_len, k=0, len=2, stack_depth=0, max_stack_depth=0;
@@ -947,7 +963,7 @@
if (params) {
len++;
for(i=0; i < llen; i++)
- calc_code( (code*)clist_item(params,i),
+ calc_code( (code_p)clist_item(params,i),
&len, &stack_depth, &max_stack_depth );
}
if (self) {
@@ -985,11 +1001,11 @@
set_attr(INTRP, func, SYM(__DOC__), (obj_p)(body->code_data[1].data));
return debug_retrn(__LINE__, res);
}
-code* print_arglist(void* param, clist_p list){
+code_p print_arglist(void* param, clist_p list){
code *res;
int i, k=0, len=0, stack_depth=0, max_stack_depth = 0;
for(i=0; i < clist_len(list); i++){
- code* p = (code*)clist_item(list,i);
+ code_p p = (code_p)clist_item(list,i);
if (p)
calc_code(p, &len, &stack_depth, &max_stack_depth);
else {
@@ -1000,7 +1016,7 @@
}
res = new_code(param, len+1, stack_depth, max_stack_depth, 0);
for(i=0; i < clist_len(list); i++){
- code* p = (code*)clist_item(list,i);
+ code_p p = (code_p)clist_item(list,i);
if(p)
add_code_to(p, res, &k);
else {
@@ -1015,11 +1031,11 @@
assert(res->len == k);
return debug_retrn(__LINE__, res);
}
-code* new_tuple_list(void* param, clist_p lst, int tuple_flag){
+code_p new_tuple_list(void* param, clist_p lst, int tuple_flag){
int i, k=0, len=1, stack_depth=1, max_stack_depth=1;
- code* res;
+ code_p res;
for(i=0; i < clist_len(lst); i++)
- calc_code((code*)clist_item(lst,i), &len, &stack_depth, &max_stack_depth);
+ calc_code((code_p)clist_item(lst,i), &len, &stack_depth, &max_stack_depth);
res = new_code(param, len, stack_depth, max_stack_depth, 0);
for(i=0; i < clist_len(lst); i++)
add_code_to(clist_item(lst,i), res, &k);
@@ -1031,19 +1047,19 @@
assert(res->len == k);
return debug_retrn(__LINE__, res);
}
-code* new_dict(void* param, clist_p lst){
+code_p new_dict(void* param, clist_p lst){
int i, k=0, len=1, stack_depth=1, max_stack_depth=1;
- code* res;
+ code_p res;
for(i=0; i < clist_len(lst); i++) {
clist_p pl = (clist_p)clist_item(lst,i);
- calc_code((code*)clist_item(pl,0), &len, &stack_depth, &max_stack_depth);
- calc_code((code*)clist_item(pl,1), &len, &stack_depth, &max_stack_depth);
+ calc_code((code_p)clist_item(pl,0), &len, &stack_depth, &max_stack_depth);
+ calc_code((code_p)clist_item(pl,1), &len, &stack_depth, &max_stack_depth);
}
res = new_code(param, len, stack_depth, max_stack_depth, 0);
for(i=0; i < clist_len(lst); i++) {
clist_p pl = (clist_p)clist_item(lst,i);
- code* key = (code*)clist_item(pl,0);
- code* val = (code*)clist_item(pl,1);
+ code_p key = (code_p)clist_item(pl,0);
+ code_p val = (code_p)clist_item(pl,1);
add_code_to(key, res, &k);
add_code_to(val, res, &k);
pr_free(pl);
@@ -1055,9 +1071,9 @@
assert(res->len == k);
return debug_retrn(__LINE__, res);
}
-code* word_expr_to_param(void* param, obj_p word, code* expr){
+code_p word_expr_to_param(void* param, obj_p word, code_p expr){
int k=0, len=2, stack_depth=1, max_stack_depth=1;
- code* res;
+ code_p res;
calc_code(expr, &len, &stack_depth, &max_stack_depth);
res = new_code(param, len, stack_depth, max_stack_depth, OP_PUSH);
res->code_data[k++].bytecode.param = 2;
@@ -1066,20 +1082,20 @@
assert(res->len == k);
return debug_retrn(__LINE__, res);
}
-code* expr_to_param(void* param, code* expr){
+code_p expr_to_param(void* param, code_p expr){
return debug_retrn(__LINE__, word_expr_to_param(param, PARAM_NORMAL, expr));
}
-code* label_eq_expr_to_param(void* param, char* label, code* expr){
+code_p label_eq_expr_to_param(void* param, char* label, code_p expr){
return debug_retrn(__LINE__, word_expr_to_param(param, sym(INTRP, label), expr));
}
-code* star_seq_to_param(void* param, code* expr){
+code_p star_seq_to_param(void* param, code_p expr){
return debug_retrn(__LINE__, word_expr_to_param(param, PARAM_STAR, expr));
}
-code* star_star_dict_to_param(void* param, code* expr){
+code_p star_star_dict_to_param(void* param, code_p expr){
return debug_retrn(__LINE__, word_expr_to_param(param, PARAM_STAR_STAR, expr));
}
-code* int_to_obj(void* param, i64_t num){
- code* res;
+code_p int_to_obj(void* param, i64_t num){
+ code_p res;
obj_p obj = new_object(INTRP, OBJ(INT_PROTO));
*((i64_t*) obj_malloc(obj, sizeof(i64_t))) = num;
res = new_code(param, 2, 1, 1, OP_PUSH);
@@ -1088,8 +1104,8 @@
add_to_const_list(param, obj);
return debug_retrn(__LINE__, res);
}
-code* float_to_obj(void* param, double num, int imag_flag){
- code* res;
+code_p float_to_obj(void* param, double num, int imag_flag){
+ code_p res;
obj_p obj = new_object(INTRP,
(imag_flag == NEW_IMAG? OBJ(IMAG_PROTO) : OBJ(FLOAT_PROTO)) );
*((double*) obj_malloc(obj, sizeof(double))) = num;
@@ -1099,8 +1115,8 @@
add_to_const_list(param, obj);
return debug_retrn(__LINE__, res);
}
-code* string_to_obj(void* param, char* str, int long_flag){
- code* p = new_code(param, 2, 1, 1, OP_PUSH);
+code_p string_to_obj(void* param, char* str, int long_flag){
+ code_p p = new_code(param, 2, 1, 1, OP_PUSH);
pr_str_p obj_str;
size_t len = strlen(str);
obj_p obj = new_object(INTRP,
@@ -1122,28 +1138,28 @@
add_to_const_list(param, obj);
return debug_retrn(__LINE__, p);
}
-code* dot_to_obj(void* param){
- code* p = new_code(param, 1, 1, 1, OP_PUSH_SELF);
+code_p dot_to_obj(void* param){
+ code_p p = new_code(param, 1, 1, 1, OP_PUSH_SELF);
return debug_retrn(__LINE__, p);
}
-code* assign_right(void* param, clist_p right){
- code* res;
+code_p assign_right(void* param, clist_p right){
+ code_p res;
int i, k=0, len=0, stack_depth=0, max_stack_depth = 0;
int rlen = clist_len(right);
for(i=0; i < rlen; i++)
calc_code(clist_item(right,i), &len, &stack_depth, &max_stack_depth);
res = new_code(param, len, stack_depth, max_stack_depth, 0);
- res->misc_param = rlen;
+ res->assign_parm_cnt = rlen;
for(i=0; i < rlen; i++)
add_code_to(clist_item(right,i), res, &k);
assert(k==res->len);
return debug_retrn(__LINE__, res);
}
-code* tgt_eq_stmt_to_stmt(void* param, clist_p left, code* right){
- code* res;
+code_p tgt_eq_stmt_to_stmt(void* param, clist_p left, code_p right){
+ code_p res;
int i, k=0, len=0, stack_depth=0, max_stack_depth = 0;
int llen = clist_len(left);
- int rlen = right->misc_param;
+ int rlen = right->assign_parm_cnt;
int seq_expand = (rlen == 1 && llen > 1);
if(llen != rlen && !seq_expand){
printf("Assignment target count not equal to right side expression count\n");
@@ -1153,7 +1169,7 @@
calc_code(clist_item(left,i), &len, &stack_depth, &max_stack_depth);
len += 1;
res = new_code(param, len, stack_depth, max_stack_depth, 0);
- res->misc_param = rlen;
+ res->assign_parm_cnt = rlen;
for(i=0; i < llen; i++)
add_code_to(clist_item(left,i), res, &k);
res->code_data[k ].bytecode.opcode = (seq_expand ? OP_SEQ_ASSIGN : OP_ASSIGN);
@@ -1162,21 +1178,21 @@
assert(k==res->len);
return debug_retrn(__LINE__, append_code(param, right, res, 0));
}
-code* tgt_eq_expr_to_stmt(void* param, clist_p left, clist_p right){
+code_p tgt_eq_expr_to_stmt(void* param, clist_p left, clist_p right){
return debug_retrn(__LINE__, tgt_eq_stmt_to_stmt(param, left, assign_right(param, right)));
}
-code* assign_cleanup(void* param, code* ass_code){
- code* res = new_code(param, 1, -(ass_code->misc_param), 0, OP_POP);
- res->code_data[0].bytecode.param = ass_code->misc_param;
+code_p assign_cleanup(void* param, code_p ass_code){
+ code_p res = new_code(param, 1, -(ass_code->assign_parm_cnt), 0, OP_POP);
+ res->code_data[0].bytecode.param = ass_code->assign_parm_cnt;
return debug_retrn(__LINE__, append_code(param, ass_code, res, 0));
}
-code* exceptall(void* param){
- code* res = new_code(param, 2, 1, 1, OP_PUSH);
+code_p exceptall(void* param){
+ code_p res = new_code(param, 2, 1, 1, OP_PUSH);
res->code_data[0].bytecode.param = 2;
res->code_data[1].data = OBJ(EXCEPTION);
return debug_retrn(__LINE__, res);
}
-code* expr_label_body_to_except(void* param, code* expr, char* label, code* body){
+code_p expr_label_body_to_except(void* param, code_p expr, char* label, code_p body){
code *res;
int k=0, len=3, stack_depth=1, max_stack_depth = 1;
calc_code(expr, &len, &stack_depth, &max_stack_depth);
@@ -1190,7 +1206,7 @@
assert(res->len == k);
return debug_retrn(__LINE__, append_code(param, res, body, 0));
}
-code* body_except_else_to_tryexcept(void* param, code* body, clist_p except_list, code* els){
+code_p body_except_else_to_tryexcept(void* param, code_p body, clist_p except_list, code_p els){
code *res;
int i, k=0, len=0, stack_depth=0, max_stack_depth = 0;
int llen = clist_len(except_list);
@@ -1226,7 +1242,7 @@
assert(end_loc == k);
return debug_retrn(__LINE__, res);
}
-code* tryfinally_body(void* param, code* body, code* final){
+code_p tryfinally_body(void* param, code_p body, code_p final){
code *res;
int k=0, len=2, stack_depth=0, max_stack_depth = 0;
calc_code(body, &len, &stack_depth, &max_stack_depth);
@@ -1239,28 +1255,28 @@
assert(res->len == k);
return debug_retrn(__LINE__, res);
}
-code* op_expr(int op, code* expr, int size){
+code_p op_expr(int op, code_p expr, int size){
expr->len += 1;
expr = pr_realloc(expr, sizeof(code)+(expr->len)*sizeof(code_t));
expr->code_data[expr->len-1].bytecode.opcode = op;
expr->stack_depth -= size;
return debug_retrn(__LINE__, expr);
}
-code* exec_expr(void* param, code* expr){
+code_p exec_expr(void* param, code_p expr){
return debug_retrn(__LINE__, op_expr(OP_EXEC, expr, 1));
}
-code* tgtparm_to_obj(void* param, code* expr){
+code_p tgtparm_to_obj(void* param, code_p expr){
return debug_retrn(__LINE__, op_expr(OP_DEREF, expr, 1));
}
-code* raise_expr(void* param, code* expr){
+code_p raise_expr(void* param, code_p expr){
return debug_retrn(__LINE__, op_expr(OP_RAISE, expr, 1));
}
-code* del_ref(void* param, code* expr){
+code_p del_ref(void* param, code_p expr){
return debug_retrn(__LINE__, op_expr(OP_DEL, expr, 2));
}
-code* yield_expr(void* param, code* expr){
+code_p yield_expr(void* param, code_p expr){
return debug_retrn(__LINE__, op_expr(OP_YIELD, expr, 1));
}
-code* return_expr(void* param, code* expr){
+code_p return_expr(void* param, code_p expr){
return debug_retrn(__LINE__, op_expr(OP_RETURN, expr, 1));
}
Modified: trunk/src/prothon.y
===================================================================
--- trunk/src/prothon.y 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/src/prothon.y 2004-04-08 08:05:03 UTC (rev 300)
@@ -85,7 +85,7 @@
u64_t int_type;
double float_type;
char* str_type;
- code* code_type;
+ code_p code_type;
clist_p list_type;
}
@@ -147,13 +147,15 @@
%nonassoc IN_
%nonassoc NOT_IN
%left IS
-%right NOT
+%right NOT
+
%left '<'
%left LE
%left '>'
-%left GE
+%left GE
%left NE
%left EQ
+
%left '|'
%left '^'
%left '&'
@@ -462,22 +464,22 @@
| NOT expr
{ $$ = unary(yylex_param, __NOT__QUES, $2); }
- | expr '<' expr
+ | expr '<' expr %prec EQ
{ $$ = binary(yylex_param, $1, __LT__QUES, $3); }
- | expr LE expr
+ | expr LE expr %prec EQ
{ $$ = binary(yylex_param, $1, __LE__QUES, $3); }
- | expr '>' expr
+ | expr '>' expr %prec EQ
{ $$ = binary(yylex_param, $1, __GT__QUES , $3); }
- | expr GE expr
+ | expr GE expr %prec EQ
{ $$ = binary(yylex_param, $1, __GE__QUES, $3); }
- | expr NE expr
+ | expr NE expr %prec EQ
{ $$ = binary(yylex_param, $1, __NE__QUES, $3); }
- | expr EQ expr
+ | expr EQ expr %prec EQ
{ $$ = binary(yylex_param, $1, __EQ__QUES, $3); }
| expr '|' expr
Modified: trunk/src/src.vcproj
===================================================================
--- trunk/src/src.vcproj 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/src/src.vcproj 2004-04-08 08:05:03 UTC (rev 300)
@@ -244,6 +244,9 @@
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
<File
+ RelativePath="..\pr\chained.pr">
+ </File>
+ <File
RelativePath="..\pr\defs.pr">
</File>
<File
Modified: trunk/src/symbol.c
===================================================================
--- trunk/src/symbol.c 2004-04-08 01:33:33 UTC (rev 299)
+++ trunk/src/symbol.c 2004-04-08 08:05:03 UTC (rev 300)
@@ -70,13 +70,13 @@
{ "__notin__QUES", 0 },
{ "__is__QUES", 0 },
{ "__isnot__QUES", 0 },
- { "cmp", 0 },
{ "__lt__QUES", 0 },
{ "__le__QUES", 0 },
{ "__gt__QUES", 0 },
{ "__ge__QUES", 0 },
{ "__ne__QUES", 0 },
{ "__eq__QUES", 0 },
+ { "cmp", 0 },
{ "__or__", 0 },
{ "__xor__", 0 },
{ "__and__", 0 },