00001
00002
00003 #include "ExParser.h"
00004 #include "ExScanner.h"
00005
00006 using namespace Marsyas;
00007
00008 void ExParser::Get() {
00009 for (;;) {
00010 t = la;
00011 la = scanner->Scan();
00012 if (la->kind <= maxT) { ++errDist; break; }
00013
00014 if (dummyToken != t) {
00015 dummyToken->kind = t->kind;
00016 dummyToken->pos = t->pos;
00017 dummyToken->col = t->col;
00018 dummyToken->line = t->line;
00019 dummyToken->next = NULL;
00020 coco_string_delete(dummyToken->val);
00021 dummyToken->val = coco_string_create(t->val);
00022 t = dummyToken;
00023 }
00024 la = t;
00025 }
00026 }
00027
00028 void ExParser::Expect(int n) {
00029 if (la->kind==n) Get(); else { SynErr(n); }
00030 }
00031
00032 void ExParser::ExpectWeak(int n, int follow) {
00033 if (la->kind == n) Get();
00034 else {
00035 SynErr(n);
00036 while (!StartOf(follow)) Get();
00037 }
00038 }
00039
00040 bool ExParser::WeakSeparator(int n, int syFol, int repFol) {
00041 if (la->kind == n) {Get(); return true;}
00042 else if (StartOf(repFol)) {return false;}
00043 else {
00044 SynErr(n);
00045 while (!(StartOf(syFol) || StartOf(repFol) || StartOf(0))) {
00046 Get();
00047 }
00048 return StartOf(syFol);
00049 }
00050 }
00051
00052 void ExParser::Alias(std::string& nm) {
00053 Expect(46);
00054 Name(nm);
00055 }
00056
00057 void ExParser::Name(std::string& nm) {
00058 Expect(5);
00059 nm=t->val;
00060 }
00061
00062 void ExParser::CName(std::string& nm) {
00063 Expect(6);
00064 nm=t->val;
00065 }
00066
00067 void ExParser::AddOp(int& m) {
00068 if (la->kind == 23) {
00069 Get();
00070 m=OP_ADD;
00071 } else if (la->kind == 24) {
00072 Get();
00073 m=OP_SUB;
00074 } else SynErr(62);
00075 }
00076
00077 void ExParser::MulOp(int& m) {
00078 if (la->kind == 25) {
00079 Get();
00080 m=OP_MUL;
00081 } else if (la->kind == 26) {
00082 Get();
00083 m=OP_DIV;
00084 } else if (la->kind == 27) {
00085 Get();
00086 m=OP_MOD;
00087 } else SynErr(63);
00088 }
00089
00090 void ExParser::RelOp(int& m) {
00091 switch (la->kind) {
00092 case 34: {
00093 Get();
00094 m=OP_EQ;
00095 break;
00096 }
00097 case 35: {
00098 Get();
00099 m=OP_NE;
00100 break;
00101 }
00102 case 36: {
00103 Get();
00104 m=OP_GT;
00105 break;
00106 }
00107 case 37: {
00108 Get();
00109 m=OP_GE;
00110 break;
00111 }
00112 case 38: {
00113 Get();
00114 m=OP_LT;
00115 break;
00116 }
00117 case 39: {
00118 Get();
00119 m=OP_LE;
00120 break;
00121 }
00122 default: SynErr(64); break;
00123 }
00124 }
00125
00126 void ExParser::LAsgnOp(int& type) {
00127 switch (la->kind) {
00128 case 14: {
00129 Get();
00130 type=OP_ADD;
00131 break;
00132 }
00133 case 15: {
00134 Get();
00135 type=OP_SUB;
00136 break;
00137 }
00138 case 16: {
00139 Get();
00140 type=OP_MUL;
00141 break;
00142 }
00143 case 17: {
00144 Get();
00145 type=OP_DIV;
00146 break;
00147 }
00148 case 18: {
00149 Get();
00150 type=OP_MOD;
00151 break;
00152 }
00153 case 22: {
00154 Get();
00155 type=OP_OR;
00156 break;
00157 }
00158 case 21: {
00159 Get();
00160 type=OP_AND;
00161 break;
00162 }
00163 default: SynErr(65); break;
00164 }
00165 }
00166
00167 void ExParser::RAsgnOp(int& type) {
00168 switch (la->kind) {
00169 case 9: {
00170 Get();
00171 type=OP_ADD;
00172 break;
00173 }
00174 case 10: {
00175 Get();
00176 type=OP_SUB;
00177 break;
00178 }
00179 case 11: {
00180 Get();
00181 type=OP_MUL;
00182 break;
00183 }
00184 case 12: {
00185 Get();
00186 type=OP_DIV;
00187 break;
00188 }
00189 case 13: {
00190 Get();
00191 type=OP_MOD;
00192 break;
00193 }
00194 case 20: {
00195 Get();
00196 type=OP_OR;
00197 break;
00198 }
00199 case 19: {
00200 Get();
00201 type=OP_AND;
00202 break;
00203 }
00204 default: SynErr(66); break;
00205 }
00206 }
00207
00208 void ExParser::Exprs(ExNode** u) {
00209 ExNode* v=NULL; if(fail)return;
00210 Task(u);
00211 if(fail)return;
00212 while (la->kind == 42) {
00213 Get();
00214 Task(&v);
00215 if(!fail)*u=expr_append(*u,v); else {delete *u;*u=NULL;}
00216 }
00217 }
00218
00219 void ExParser::Task(ExNode** u) {
00220 if (fail) return;
00221 if (IsLAsgn()) {
00222 LAsgn(u);
00223 } else if (IsLink()) {
00224 Link(u);
00225 } else if (StartOf(1)) {
00226 RAsgn(u);
00227 } else SynErr(67);
00228 }
00229
00230 void ExParser::LAsgn(ExNode** u) {
00231 int atype; std::string nm; std::string as; if (fail) return; bool seq=false; ExNode* idx=NULL;
00232 if (la->kind == 51) {
00233 Get();
00234 Expect(47);
00235 Name(nm);
00236 Expect(8);
00237 Condition(u);
00238 if(fail)return;
00239 if(nm=="opn")*u=new ExFun_StreamOutNVal(*u);
00240 else *u=do_property(NULL,"Stream."+nm,*u);
00241 } else if (la->kind == 5) {
00242 Name(nm);
00243 if (la->kind == 48) {
00244 Elem(idx);
00245 seq=true;
00246 }
00247 if (StartOf(2)) {
00248 LAsgnOp(atype);
00249 Condition(u);
00250 if(fail)return;
00251 if(!seq) *u=do_masgn(atype,false,nm,*u);
00252 else *u=do_msetelem(nm,idx,NULL,false,false,atype,*u);
00253 } else if (la->kind == 8) {
00254 Get();
00255 Condition(u);
00256 if(fail)return;
00257 if(!seq) *u=do_asgn(nm,*u);
00258 else *u=do_setelem(nm,idx,NULL,false,*u);
00259 } else SynErr(68);
00260 } else if (la->kind == 6) {
00261 CName(nm);
00262 if (StartOf(2)) {
00263 LAsgnOp(atype);
00264 Condition(u);
00265 if(fail)return;*u=do_cmasgn(atype,false,nm,*u);
00266 } else if (la->kind == 8) {
00267 Get();
00268 Condition(u);
00269 if(fail)return;*u=do_casgn(nm,*u);
00270 } else SynErr(69);
00271 } else if (la->kind == 46) {
00272 Alias(as);
00273 Expect(8);
00274 CName(nm);
00275 *u=do_alias(as,nm);
00276 } else SynErr(70);
00277 }
00278
00279 void ExParser::Link(ExNode** u) {
00280 std::string nm1,nm2; if(fail)return;
00281 CName(nm1);
00282 if (la->kind == 32) {
00283 Get();
00284 CName(nm2);
00285 *u=do_link(nm2,nm1);
00286 } else if (la->kind == 31) {
00287 Get();
00288 CName(nm2);
00289 *u=do_link(nm1,nm2);
00290 } else SynErr(71);
00291 }
00292
00293 void ExParser::RAsgn(ExNode** u) {
00294 int atype; std::string nm; std::string as; if(fail)return;
00295 if (IsCNameRAsgnAlias()) {
00296 CName(nm);
00297 Expect(7);
00298 Alias(as);
00299 *u=do_alias(as,nm);
00300 } else if (StartOf(1)) {
00301 Condition(u);
00302 if(fail)return;
00303 if (StartOf(3)) {
00304 if (la->kind == 7) {
00305 Get();
00306 if (la->kind == 51) {
00307 Get();
00308 Expect(47);
00309 Name(nm);
00310 if(fail)return;
00311 if(nm=="opn")*u=new ExFun_StreamOutNVal(*u);
00312 else *u=do_property(NULL,"Stream."+nm,*u);
00313 } else if (la->kind == 5) {
00314 Name(nm);
00315 if (la->kind == 48) {
00316 ExNode* idx=NULL;
00317 Elem(idx);
00318 *u=do_setelem(nm,idx,NULL,false,*u);return;
00319 }
00320 *u=do_asgn(nm,*u);
00321 } else if (la->kind == 6) {
00322 CName(nm);
00323 *u=do_casgn(nm,*u);
00324 } else SynErr(72);
00325 } else {
00326 RAsgnOp(atype);
00327 if (la->kind == 5) {
00328 Name(nm);
00329 if (la->kind == 48) {
00330 ExNode* idx=NULL;
00331 Elem(idx);
00332 *u=do_msetelem(nm,idx,NULL,false,true,atype,*u);return;
00333 }
00334 *u=do_masgn(atype,true,nm,*u);
00335 } else if (la->kind == 6) {
00336 CName(nm);
00337 *u=do_cmasgn(atype,true,nm,*u);
00338 } else SynErr(73);
00339 }
00340 }
00341 } else SynErr(74);
00342 }
00343
00344 void ExParser::Condition(ExNode** u) {
00345 ExNode* v=NULL; bool neg=false; if (fail) return;
00346 if (la->kind == 33) {
00347 Get();
00348 neg=true;
00349 }
00350 CondTerm(u);
00351 if (fail) return; if (neg) { *u=do_bool_negate(*u); if (fail) return; }
00352 while (la->kind == 41) {
00353 Get();
00354 CondTerm(&v);
00355 if (!fail) *u=do_condop(OP_OR,*u,v); else{delete*u;*u=NULL;}
00356 }
00357 }
00358
00359 void ExParser::CondTerm(ExNode** u) {
00360 ExNode* v=NULL; if (fail) return;
00361 CondFact(u);
00362 if (fail) return;
00363 while (la->kind == 40) {
00364 Get();
00365 CondFact(&v);
00366 if (!fail) *u=do_condop(OP_AND,*u,v); else{delete*u;*u=NULL;}
00367 }
00368 }
00369
00370 void ExParser::CondFact(ExNode** u) {
00371 int m=0; ExNode* v=NULL; if (fail) return;
00372 Expr(u);
00373 if (fail) return;
00374 while (StartOf(4)) {
00375 RelOp(m);
00376 Expr(&v);
00377 if (!fail) *u=do_relop(m,*u,v); else{delete*u;*u=NULL;}
00378 }
00379 }
00380
00381 void ExParser::Expr(ExNode** u) {
00382 int m=0; ExNode* v=NULL; bool neg=false; if (fail) return;
00383 if (la->kind == 24) {
00384 Get();
00385 neg=true;
00386 }
00387 Term(u);
00388 if(fail)return; if (neg) { *u=do_num_negate(*u); if (fail) return; }
00389 while (la->kind == 23 || la->kind == 24) {
00390 AddOp(m);
00391 Term(&v);
00392 if (!fail) *u=do_addop(m,*u,v); else{delete*u;*u=NULL;}
00393 }
00394 }
00395
00396 void ExParser::Term(ExNode** u) {
00397 int m=0; ExNode* v=NULL; if (fail) return;
00398 Property(u);
00399 if (fail) return;
00400 while (la->kind == 25 || la->kind == 26 || la->kind == 27) {
00401 MulOp(m);
00402 Property(&v);
00403 if (!fail) *u=do_mulop(m,*u,v); else{delete*u;*u=NULL;}
00404 }
00405 }
00406
00407 void ExParser::Property(ExNode** u) {
00408 std::string l=""; std::string n; ExNode* ps=NULL;
00409 Factor(l,u);
00410 if (fail) return;
00411 while (la->kind == 47) {
00412 Get();
00413 Name(n);
00414 if (la->kind == 29) {
00415 Get();
00416 if (StartOf(5)) {
00417 Exprs(&ps);
00418 }
00419 Expect(30);
00420 }
00421 if(!fail){*u=do_property(*u,l+n,ps);l="";}else{delete*u;*u=NULL;}
00422 }
00423 }
00424
00425 void ExParser::Factor(std::string& l, ExNode** u) {
00426 std::string nm; if (fail) return;
00427 switch (la->kind) {
00428 case 52: {
00429 Get();
00430 *u=new ExNode(true);
00431 break;
00432 }
00433 case 53: {
00434 Get();
00435 *u=new ExNode(false);
00436 break;
00437 }
00438 case 4: {
00439 Get();
00440 *u=new ExNode(t->val[1]=='t');
00441 break;
00442 }
00443 case 1: {
00444 Get();
00445 *u=new ExNode(atol(t->val));
00446 break;
00447 }
00448 case 2: {
00449 Get();
00450 *u=new ExNode((mrs_real)atof(t->val));
00451 break;
00452 }
00453 case 29: {
00454 Get();
00455 Condition(u);
00456 Expect(30);
00457 break;
00458 }
00459 case 3: case 5: case 6: case 43: case 45: case 48: {
00460 Sequence(l,u);
00461 break;
00462 }
00463 default: SynErr(75); break;
00464 }
00465 }
00466
00467 void ExParser::ListElems(ExNode** u) {
00468 ExNode* v=NULL; std::string type;
00469 Condition(u);
00470 while (la->kind == 42) {
00471 Get();
00472 Condition(&v);
00473 if(!fail)*u=list_append(*u,v);
00474 }
00475 }
00476
00477 void ExParser::Sequence(std::string& l, ExNode** u) {
00478 FactorB(l,u);
00479 if(fail)return;
00480 while (la->kind == 48) {
00481 ElemAccess(u);
00482 if(fail)return;
00483 }
00484 }
00485
00486 void ExParser::ElemAccess(ExNode** u) {
00487 ExNode* lidx=NULL; ExNode* ridx=NULL; bool is_range=false; std::string nm;
00488 Expect(48);
00489 if (la->kind == 1 || la->kind == 5) {
00490 if (la->kind == 1) {
00491 Get();
00492 lidx=new ExNode((mrs_natural)atoi(t->val));
00493 } else {
00494 Name(nm);
00495 lidx=do_name(false,nm,NULL);if(fail)return;
00496 }
00497 if (la->kind == 50) {
00498 Get();
00499 is_range=true;
00500 if (la->kind == 1 || la->kind == 5) {
00501 if (la->kind == 1) {
00502 Get();
00503 ridx=new ExNode((mrs_natural)atoi(t->val));
00504 } else {
00505 Name(nm);
00506 ridx=do_name(false,nm,NULL);if(fail){lidx->deref();return;}
00507 }
00508 }
00509 }
00510 } else if (la->kind == 50) {
00511 Get();
00512 if (la->kind == 1) {
00513 Get();
00514 is_range=true;ridx=new ExNode((mrs_natural)atoi(t->val));
00515 } else if (la->kind == 5) {
00516 Name(nm);
00517 ridx=do_name(false,nm,NULL);if(fail)return;
00518 } else SynErr(76);
00519 } else SynErr(77);
00520 Expect(49);
00521 *u=do_getelem(*u,lidx,ridx,is_range);
00522 }
00523
00524 void ExParser::FactorB(std::string& l, ExNode** u) {
00525 std::string nm; ExNode* ps=NULL; if (fail) return;
00526 switch (la->kind) {
00527 case 5: {
00528 Name(nm);
00529 bool f=false;
00530 if (la->kind == 29) {
00531 Get();
00532 f=true;
00533 if (StartOf(5)) {
00534 Exprs(&ps);
00535 }
00536 Expect(30);
00537 }
00538 if (fail) return;
00539 if (getKind(nm)==T_LIB) { l=nm+"."; *u=NULL; }
00540 else *u=do_name(f,nm,ps);
00541
00542 break;
00543 }
00544 case 6: {
00545 CName(nm);
00546 *u=do_getctrl(nm);
00547 break;
00548 }
00549 case 48: {
00550 Get();
00551 bool mt=true;
00552 if (StartOf(1)) {
00553 ListElems(&ps);
00554 mt=false;
00555 }
00556 Expect(49);
00557 if(fail)return; *u=do_list(mt,ps);
00558 break;
00559 }
00560 case 3: {
00561 Get();
00562 *u=new ExNode(prep_string(t->val));
00563 break;
00564 }
00565 case 45: {
00566 Get();
00567 ExNode* c=NULL; ExNode* ts=NULL; ExNode* es=NULL;
00568 Condition(&c);
00569 if(fail)return;
00570 Expect(50);
00571 Exprs(&ts);
00572 if(fail){if(c)c->deref();return;}
00573 Expect(50);
00574 Exprs(&es);
00575 if(fail){if(c)c->deref();if(ts)ts->deref();return;}
00576 Expect(44);
00577 *u=do_conditional(c,ts,es);
00578 break;
00579 }
00580 case 43: {
00581 Get();
00582 int m=0;std::string var_nm;bool in=false;std::string ary_nm;std::string tp;
00583 if (la->kind == 54) {
00584 Get();
00585 m=1;
00586 } else if (la->kind == 55) {
00587 Get();
00588 m=2;
00589 } else if (la->kind == 56) {
00590 Get();
00591 m=3;
00592 } else if (la->kind == 57) {
00593 Get();
00594 m=4;
00595 } else SynErr(78);
00596 Name(var_nm);
00597 if (la->kind == 58) {
00598 Get();
00599 in=true;
00600 }
00601 if (la->kind == 50) {
00602 Get();
00603 if(!in){
00604 MRSWARN("ExParser::Unexpected : in iterator declaration");
00605 fail=true;
00606 }
00607 else if (m==2) ary_nm="in";
00608 else *u=do_name(false,"in",NULL);
00609
00610 } else if (m==2) {
00611 Name(ary_nm);
00612 Expect(50);
00613 } else if (StartOf(1)) {
00614 Condition(u);
00615 Expect(50);
00616 } else SynErr(79);
00617 if(fail)return;
00618 tp=(m==2) ? tp=getElemType(ary_nm) : (*u)->getElemType();
00619
00620
00621 symbol_table.block_open();
00622 ExVal v=ExValTyped(T_VAR,tp);
00623 symbol_table.setValue(v,var_nm);
00624 Exprs(&ps);
00625 Expect(44);
00626 if(fail){
00627 if(*u){(*u)->deref();*u=NULL;}
00628 } else *u=do_iter(m,var_nm,ary_nm,*u,ps);
00629 symbol_table.block_close();
00630 break;
00631 }
00632 default: SynErr(80); break;
00633 }
00634 }
00635
00636 void ExParser::Elem(ExNode*& idx) {
00637 std::string nm;
00638 Expect(48);
00639 if (la->kind == 1) {
00640 Get();
00641 idx=new ExNode((mrs_natural)atoi(t->val));
00642 } else if (la->kind == 5) {
00643 Name(nm);
00644 idx=do_name(false,nm,NULL);
00645 } else SynErr(81);
00646 Expect(49);
00647 }
00648
00649 void ExParser::Use() {
00650 std::string nm; if(fail)return;
00651 Expect(59);
00652 Name(nm);
00653 symbol_table.import(nm);
00654 Expect(42);
00655 }
00656
00657 void ExParser::Load() {
00658 std::string nm; if(fail)return;
00659 Expect(60);
00660 Name(nm);
00661 Expect(42);
00662 }
00663
00664 void ExParser::UL() {
00665 if (la->kind == 59) {
00666 Use();
00667 } else if (la->kind == 60) {
00668 Load();
00669 } else SynErr(82);
00670 }
00671
00672 void ExParser::Neil() {
00673 tree=NULL; std::string nm;
00674 while (la->kind == 59 || la->kind == 60) {
00675 UL();
00676 }
00677 Exprs(&tree);
00678 if(fail){ delete tree; tree=NULL; }
00679 }
00680
00681
00682
00683 void ExParser::Parse() {
00684 t = NULL; fail=false;
00685 la = dummyToken = new Token();
00686 la->val = coco_string_create("Dummy Token");
00687 Get();
00688 Neil();
00689
00690 if (!fail)
00691 Expect(0);
00692 delete dummyToken;
00693 }
00694 void ExParser::Parse(Scheduler* v, MarSystem* m, ExRecord* est)
00695 {
00696 scheduler_=v;
00697 marsystem_=m;
00698 symbol_table.addTable(est);
00699 Parse();
00700 }
00701 ExParser::ExParser(TmTimer** t, ExScanner *scanner) {
00702 _EOF = 0;
00703 _tnatural = 1;
00704 _treal = 2;
00705 _tstr = 3;
00706 _tbool = 4;
00707 _tname = 5;
00708 _cname = 6;
00709 _rasgn = 7;
00710 _lasgn = 8;
00711 _addrasgn = 9;
00712 _subrasgn = 10;
00713 _mulrasgn = 11;
00714 _divrasgn = 12;
00715 _modrasgn = 13;
00716 _addlasgn = 14;
00717 _sublasgn = 15;
00718 _mullasgn = 16;
00719 _divlasgn = 17;
00720 _modlasgn = 18;
00721 _andrasgn = 19;
00722 _orrasgn = 20;
00723 _andlasgn = 21;
00724 _orlasgn = 22;
00725 _addop = 23;
00726 _subop = 24;
00727 _mulop = 25;
00728 _divop = 26;
00729 _modop = 27;
00730 _power = 28;
00731 _lbrkt = 29;
00732 _rbrkt = 30;
00733 _rlink = 31;
00734 _llink = 32;
00735 _notop = 33;
00736 _eqop = 34;
00737 _neop = 35;
00738 _gtop = 36;
00739 _geop = 37;
00740 _ltop = 38;
00741 _leop = 39;
00742 _andop = 40;
00743 _orop = 41;
00744 _exprbrk = 42;
00745 _blkstart = 43;
00746 _blkend = 44;
00747 _ifblk = 45;
00748 _atsym = 46;
00749 _propsep = 47;
00750 _lsbrkt = 48;
00751 _rsbrkt = 49;
00752 _colon = 50;
00753 _streamlib = 51;
00754 maxT = 61;
00755
00756 timer_=t;
00757 minErrDist = 2; fail=false;
00758 errDist = minErrDist;
00759 this->scanner = scanner;
00760 Init();
00761 }
00762
00763 bool ExParser::StartOf(int s) {
00764 const bool T = true;
00765 const bool x = false;
00766
00767 static bool set[6][63] = {
00768 {T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
00769 {x,T,T,T, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,T,x,x, x,T,x,x, x,x,x,x, x,x,x,T, x,T,x,x, T,x,x,x, T,T,x,x, x,x,x,x, x,x,x},
00770 {x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
00771 {x,x,x,x, x,x,x,T, x,T,T,T, T,T,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
00772 {x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
00773 {x,T,T,T, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,T,x,x, x,T,x,x, x,x,x,x, x,x,x,T, x,T,T,x, T,x,x,T, T,T,x,x, x,x,x,x, x,x,x}
00774 };
00775
00776
00777
00778 return set[s][la->kind];
00779 }
00780
00781 ExParser::~ExParser() {
00782
00783 }
00784 void ExParser::SynErr(int n) {
00785 char* s;
00786 switch (n) {
00787 case 0: s = coco_string_create("EOF expected"); break;
00788 case 1: s = coco_string_create("tnatural expected"); break;
00789 case 2: s = coco_string_create("treal expected"); break;
00790 case 3: s = coco_string_create("tstr expected"); break;
00791 case 4: s = coco_string_create("tbool expected"); break;
00792 case 5: s = coco_string_create("tname expected"); break;
00793 case 6: s = coco_string_create("cname expected"); break;
00794 case 7: s = coco_string_create("rasgn expected"); break;
00795 case 8: s = coco_string_create("lasgn expected"); break;
00796 case 9: s = coco_string_create("addrasgn expected"); break;
00797 case 10: s = coco_string_create("subrasgn expected"); break;
00798 case 11: s = coco_string_create("mulrasgn expected"); break;
00799 case 12: s = coco_string_create("divrasgn expected"); break;
00800 case 13: s = coco_string_create("modrasgn expected"); break;
00801 case 14: s = coco_string_create("addlasgn expected"); break;
00802 case 15: s = coco_string_create("sublasgn expected"); break;
00803 case 16: s = coco_string_create("mullasgn expected"); break;
00804 case 17: s = coco_string_create("divlasgn expected"); break;
00805 case 18: s = coco_string_create("modlasgn expected"); break;
00806 case 19: s = coco_string_create("andrasgn expected"); break;
00807 case 20: s = coco_string_create("orrasgn expected"); break;
00808 case 21: s = coco_string_create("andlasgn expected"); break;
00809 case 22: s = coco_string_create("orlasgn expected"); break;
00810 case 23: s = coco_string_create("addop expected"); break;
00811 case 24: s = coco_string_create("subop expected"); break;
00812 case 25: s = coco_string_create("mulop expected"); break;
00813 case 26: s = coco_string_create("divop expected"); break;
00814 case 27: s = coco_string_create("modop expected"); break;
00815 case 28: s = coco_string_create("power expected"); break;
00816 case 29: s = coco_string_create("lbrkt expected"); break;
00817 case 30: s = coco_string_create("rbrkt expected"); break;
00818 case 31: s = coco_string_create("rlink expected"); break;
00819 case 32: s = coco_string_create("llink expected"); break;
00820 case 33: s = coco_string_create("notop expected"); break;
00821 case 34: s = coco_string_create("eqop expected"); break;
00822 case 35: s = coco_string_create("neop expected"); break;
00823 case 36: s = coco_string_create("gtop expected"); break;
00824 case 37: s = coco_string_create("geop expected"); break;
00825 case 38: s = coco_string_create("ltop expected"); break;
00826 case 39: s = coco_string_create("leop expected"); break;
00827 case 40: s = coco_string_create("andop expected"); break;
00828 case 41: s = coco_string_create("orop expected"); break;
00829 case 42: s = coco_string_create("exprbrk expected"); break;
00830 case 43: s = coco_string_create("blkstart expected"); break;
00831 case 44: s = coco_string_create("blkend expected"); break;
00832 case 45: s = coco_string_create("ifblk expected"); break;
00833 case 46: s = coco_string_create("atsym expected"); break;
00834 case 47: s = coco_string_create("propsep expected"); break;
00835 case 48: s = coco_string_create("lsbrkt expected"); break;
00836 case 49: s = coco_string_create("rsbrkt expected"); break;
00837 case 50: s = coco_string_create("colon expected"); break;
00838 case 51: s = coco_string_create("streamlib expected"); break;
00839 case 52: s = coco_string_create("\"true\" expected"); break;
00840 case 53: s = coco_string_create("\"false\" expected"); break;
00841 case 54: s = coco_string_create("\"map\" expected"); break;
00842 case 55: s = coco_string_create("\"iter\" expected"); break;
00843 case 56: s = coco_string_create("\"for\" expected"); break;
00844 case 57: s = coco_string_create("\"rfor\" expected"); break;
00845 case 58: s = coco_string_create("\"in\" expected"); break;
00846 case 59: s = coco_string_create("\"use\" expected"); break;
00847 case 60: s = coco_string_create("\"load\" expected"); break;
00848 case 61: s = coco_string_create("??? expected"); break;
00849 case 62: s = coco_string_create("invalid AddOp"); break;
00850 case 63: s = coco_string_create("invalid MulOp"); break;
00851 case 64: s = coco_string_create("invalid RelOp"); break;
00852 case 65: s = coco_string_create("invalid LAsgnOp"); break;
00853 case 66: s = coco_string_create("invalid RAsgnOp"); break;
00854 case 67: s = coco_string_create("invalid Task"); break;
00855 case 68: s = coco_string_create("invalid LAsgn"); break;
00856 case 69: s = coco_string_create("invalid LAsgn"); break;
00857 case 70: s = coco_string_create("invalid LAsgn"); break;
00858 case 71: s = coco_string_create("invalid Link"); break;
00859 case 72: s = coco_string_create("invalid RAsgn"); break;
00860 case 73: s = coco_string_create("invalid RAsgn"); break;
00861 case 74: s = coco_string_create("invalid RAsgn"); break;
00862 case 75: s = coco_string_create("invalid Factor"); break;
00863 case 76: s = coco_string_create("invalid ElemAccess"); break;
00864 case 77: s = coco_string_create("invalid ElemAccess"); break;
00865 case 78: s = coco_string_create("invalid FactorB"); break;
00866 case 79: s = coco_string_create("invalid FactorB"); break;
00867 case 80: s = coco_string_create("invalid FactorB"); break;
00868 case 81: s = coco_string_create("invalid Elem"); break;
00869 case 82: s = coco_string_create("invalid UL"); break;
00870
00871 default:
00872 {
00873 char format[20];
00874 coco_sprintf(format, 20, "error %d", n);
00875 s = coco_string_create(format);
00876 }
00877 break;
00878 }
00879 MRSWARN("ExParser: Syntax error - line " +ltos(la->line)+ " col " +ltos(la->col)+ ": " +s);
00880
00881 coco_string_delete(s);
00882 fail=true;
00883 }
00884 void ExParser::SemErr(char* msg) {
00885 MRSWARN("ExParser: Semantic error - line " +ltos(la->line)+ " col " +ltos(la->col)+ ": " +msg);
00886
00887 fail=true;
00888 }
00889
00890
