Showing the changes to src/core/chuck_parse.cpp (1 of 17 files). Show all
Unified · Split
| @@ -278,3 +278,407 @@ t_CKBOOL SyntaxQuery::parseLine( const std::string & line, SyntaxTokenList & tok · 277 unmodified lines | |||
| 278 | 278 | ||
| 279 | return TRUE; | 279 | return TRUE; |
| 280 | } | 280 | } |
| 281 | |||
| 282 | |||
| 283 | |||
| 284 | |||
| 285 | |||
| 286 | //----------------------------------------------------------------------------- | ||
| 287 | // absyn to string functions | ||
| 288 | //----------------------------------------------------------------------------- | ||
| 289 | #include "chuck_type.h" | ||
| 290 | string absyn_exp2str( a_Exp exp, t_CKBOOL iterate = true ); | ||
| 291 | string absyn_binary2str( a_Exp_Binary binary ); | ||
| 292 | string absyn_unary2str( a_Exp_Unary unary ); | ||
| 293 | string absyn_op2str( ae_Operator op ); | ||
| 294 | string absyn_cast2str( a_Exp_Cast cast ); | ||
| 295 | string absyn_postfix2str( a_Exp_Postfix postfix ); | ||
| 296 | string absyn_dur2str( a_Exp_Dur dur ); | ||
| 297 | string absyn_primary2str( a_Exp_Primary primary ); | ||
| 298 | string absyn_array2str( a_Exp_Array array ); | ||
| 299 | string absyn_func_call2str( a_Exp_Func_Call func_call ); | ||
| 300 | string absyn_dot_member2str( a_Exp_Dot_Member dot_member ); | ||
| 301 | string absyn_exp_if2str( a_Exp_If exp_if ); | ||
| 302 | string absyn_decl2str( a_Exp_Decl decl ); | ||
| 303 | |||
| 304 | |||
| 305 | |||
| 306 | |||
| 307 | //----------------------------------------------------------------------------- | ||
| 308 | // name: absyn2str() | ||
| 309 | // desc: convert abstract syntax exp to string | ||
| 310 | //----------------------------------------------------------------------------- | ||
| 311 | string absyn2str( a_Exp exp ) | ||
| 312 | { | ||
| 313 | return absyn_exp2str( exp ) + ";"; | ||
| 314 | } | ||
| 315 | |||
| 316 | |||
| 317 | |||
| 318 | |||
| 319 | //----------------------------------------------------------------------------- | ||
| 320 | // name: absyn_exp2str() | ||
| 321 | // desc: convert abstract syntax exp to string | ||
| 322 | //----------------------------------------------------------------------------- | ||
| 323 | string absyn_exp2str( a_Exp exp, t_CKBOOL iterate ) | ||
| 324 | { | ||
| 325 | string str = ""; | ||
| 326 | |||
| 327 | // loop over | ||
| 328 | while( exp ) | ||
| 329 | { | ||
| 330 | switch( exp->s_type ) | ||
| 331 | { | ||
| 332 | case ae_exp_binary: | ||
| 333 | str += absyn_binary2str( &exp->binary ); | ||
| 334 | break; | ||
| 335 | |||
| 336 | case ae_exp_unary: | ||
| 337 | str += absyn_unary2str( &exp->unary ); | ||
| 338 | break; | ||
| 339 | |||
| 340 | case ae_exp_cast: | ||
| 341 | str += absyn_cast2str( &exp->cast ); | ||
| 342 | break; | ||
| 343 | |||
| 344 | case ae_exp_postfix: | ||
| 345 | str += absyn_postfix2str( &exp->postfix ); | ||
| 346 | break; | ||
| 347 | |||
| 348 | case ae_exp_dur: | ||
| 349 | str += absyn_dur2str( &exp->dur ); | ||
| 350 | break; | ||
| 351 | |||
| 352 | case ae_exp_primary: | ||
| 353 | str += absyn_primary2str( &exp->primary ); | ||
| 354 | break; | ||
| 355 | |||
| 356 | case ae_exp_array: | ||
| 357 | str += absyn_array2str( &exp->array ); | ||
| 358 | break; | ||
| 359 | |||
| 360 | case ae_exp_func_call: | ||
| 361 | str += absyn_func_call2str( &exp->func_call ); | ||
| 362 | break; | ||
| 363 | |||
| 364 | case ae_exp_dot_member: | ||
| 365 | str += absyn_dot_member2str( &exp->dot_member ); | ||
| 366 | break; | ||
| 367 | |||
| 368 | case ae_exp_if: | ||
| 369 | str += absyn_exp_if2str( &exp->exp_if ); | ||
| 370 | break; | ||
| 371 | |||
| 372 | case ae_exp_decl: | ||
| 373 | str += absyn_decl2str( &exp->decl ); | ||
| 374 | break; | ||
| 375 | |||
| 376 | default: | ||
| 377 | return ""; | ||
| 378 | } | ||
| 379 | |||
| 380 | // implicit cast | ||
| 381 | if( exp->cast_to != NULL ) | ||
| 382 | break; | ||
| 383 | |||
| 384 | // break | ||
| 385 | if( !iterate ) break; | ||
| 386 | |||
| 387 | // next | ||
| 388 | exp = exp->next; | ||
| 389 | // if more | ||
| 390 | if( exp ) str += ", "; | ||
| 391 | } | ||
| 392 | |||
| 393 | return str; | ||
| 394 | } | ||
| 395 | |||
| 396 | |||
| 397 | |||
| 398 | |||
| 399 | //----------------------------------------------------------------------------- | ||
| 400 | // name: absyn_op2str() | ||
| 401 | // desc: convert abstract syntax operator to string | ||
| 402 | //----------------------------------------------------------------------------- | ||
| 403 | string absyn_op2str( ae_Operator op ) | ||
| 404 | { | ||
| 405 | string str; | ||
| 406 | // get operation string | ||
| 407 | switch( op ) | ||
| 408 | { | ||
| 409 | case ae_op_plus: str = "+"; break; | ||
| 410 | case ae_op_plus_chuck: str = "+=>"; break; | ||
| 411 | case ae_op_minus: str = "-"; break; | ||
| 412 | case ae_op_minus_chuck: str = "-=>"; break; | ||
| 413 | case ae_op_times: str = "*"; break; | ||
| 414 | case ae_op_times_chuck: str = "*=>"; break; | ||
| 415 | case ae_op_divide: str = "/"; break; | ||
| 416 | case ae_op_divide_chuck: str = "/=>"; break; | ||
| 417 | case ae_op_s_or: str = "|"; break; | ||
| 418 | case ae_op_s_or_chuck: str = "|=>"; break; | ||
| 419 | case ae_op_s_and: str = "&"; break; | ||
| 420 | case ae_op_s_and_chuck: str = "&=>"; break; | ||
| 421 | case ae_op_shift_left: str = "<<"; break; | ||
| 422 | case ae_op_shift_left_chuck: str = "<<=>"; break; | ||
| 423 | case ae_op_shift_right: str = ">>"; break; | ||
| 424 | case ae_op_shift_right_chuck: str = ">>=>"; break; | ||
| 425 | case ae_op_percent: str = "%"; break; | ||
| 426 | case ae_op_percent_chuck: str = "%=>"; break; | ||
| 427 | case ae_op_s_xor: str = "^"; break; | ||
| 428 | case ae_op_s_xor_chuck: str = "^=>"; break; | ||
| 429 | case ae_op_chuck: str = "=>"; break; | ||
| 430 | case ae_op_unchuck: str = "=<"; break; | ||
| 431 | case ae_op_upchuck: str = "=^"; break; | ||
| 432 | case ae_op_at_chuck: str = "@=>"; break; | ||
| 433 | case ae_op_s_chuck: str = ""; break; | ||
| 434 | case ae_op_eq: str = "=="; break; | ||
| 435 | case ae_op_neq: str = "!="; break; | ||
| 436 | case ae_op_lt: str = "<"; break; | ||
| 437 | case ae_op_le: str = "<="; break; | ||
| 438 | case ae_op_gt: str = ">"; break; | ||
| 439 | case ae_op_ge: str = ">="; break; | ||
| 440 | case ae_op_and: str = "&&"; break; | ||
| 441 | case ae_op_or: str = "||"; break; | ||
| 442 | case ae_op_arrow_left: str = "<-"; break; | ||
| 443 | case ae_op_arrow_right: str = "->"; break; | ||
| 444 | |||
| 445 | // unary | ||
| 446 | case ae_op_plusplus: str = "++"; break; | ||
| 447 | case ae_op_minusminus: str = "--"; break; | ||
| 448 | case ae_op_tilda: str = "~"; break; | ||
| 449 | case ae_op_exclamation: str = "!"; break; | ||
| 450 | case ae_op_spork: str = "spork ~"; break; | ||
| 451 | case ae_op_new: str = "new"; break; | ||
| 452 | |||
| 453 | // not used | ||
| 454 | case ae_op_typeof: str = "typeof"; break; | ||
| 455 | case ae_op_sizeof: str = "sizeof"; break; | ||
| 456 | default: str = "[OP]"; break; | ||
| 457 | } | ||
| 458 | return str; | ||
| 459 | } | ||
| 460 | |||
| 461 | |||
| 462 | |||
| 463 | |||
| 464 | //----------------------------------------------------------------------------- | ||
| 465 | // name: absyn_binary2str() | ||
| 466 | // desc: convert abstract syntax binary to string | ||
| 467 | //----------------------------------------------------------------------------- | ||
| 468 | string absyn_binary2str( a_Exp_Binary binary ) | ||
| 469 | { | ||
| 470 | // (lhs OP rhs) | ||
| 471 | return "(" + absyn_exp2str(binary->lhs) | ||
| 472 | + absyn_op2str(binary->op) | ||
| 473 | + absyn_exp2str(binary->rhs) + ")"; | ||
| 474 | } | ||
| 475 | |||
| 476 | |||
| 477 | |||
| 478 | |||
| 479 | //----------------------------------------------------------------------------- | ||
| 480 | // name: absyn_unary2str() | ||
| 481 | // desc: convert abstract syntax unary to string | ||
| 482 | //----------------------------------------------------------------------------- | ||
| 483 | string absyn_unary2str( a_Exp_Unary unary ) | ||
| 484 | { | ||
| 485 | return absyn_op2str(unary->op) + " " + absyn_exp2str(unary->exp); | ||
| 486 | } | ||
| 487 | |||
| 488 | |||
| 489 | |||
| 490 | |||
| 491 | //----------------------------------------------------------------------------- | ||
| 492 | // name: absyn_cast2str() | ||
| 493 | // desc: convert abstract syntax cast to string | ||
| 494 | //----------------------------------------------------------------------------- | ||
| 495 | string absyn_cast2str( a_Exp_Cast cast ) | ||
| 496 | { | ||
| 497 | Chuck_Type * to = cast->self->type; | ||
| 498 | return "$ " + to->name; | ||
| 499 | } | ||
| 500 | |||
| 501 | |||
| 502 | |||
| 503 | |||
| 504 | //----------------------------------------------------------------------------- | ||
| 505 | // name: absyn_cast2str() | ||
| 506 | // desc: convert abstract syntax cast to string | ||
| 507 | //----------------------------------------------------------------------------- | ||
| 508 | string absyn_postfix2str( a_Exp_Postfix postfix ) | ||
| 509 | { | ||
| 510 | return absyn_exp2str( postfix->exp ) + absyn_op2str( postfix->op ); | ||
| 511 | } | ||
| 512 | |||
| 513 | |||
| 514 | |||
| 515 | |||
| 516 | //----------------------------------------------------------------------------- | ||
| 517 | // name: absyn_dur2str() | ||
| 518 | // desc: convert abstract syntax dur to string | ||
| 519 | //----------------------------------------------------------------------------- | ||
| 520 | string absyn_dur2str( a_Exp_Dur dur ) | ||
| 521 | { | ||
| 522 | return absyn_exp2str(dur->base) + "::" + absyn_exp2str(dur->unit); | ||
| 523 | } | ||
| 524 | |||
| 525 | |||
| 526 | |||
| 527 | |||
| 528 | //----------------------------------------------------------------------------- | ||
| 529 | // name: absyn_primary2str() | ||
| 530 | // desc: convert abstract syntax primary to string | ||
| 531 | //----------------------------------------------------------------------------- | ||
| 532 | string absyn_primary2str( a_Exp_Primary primary ) | ||
| 533 | { | ||
| 534 | string str; | ||
| 535 | |||
| 536 | // find out exp | ||
| 537 | switch( primary->s_type ) | ||
| 538 | { | ||
| 539 | case ae_primary_var: str = S_name(primary->var); break; | ||
| 540 | case ae_primary_num: str = to_string(primary->num); break; | ||
| 541 | case ae_primary_float: str = primary->fnum; break; | ||
| 542 | case ae_primary_str: str = primary->str; break; | ||
| 543 | case ae_primary_char: str = primary->chr; break; | ||
| 544 | case ae_primary_array: str = "["+absyn_exp2str(primary->array->exp_list)+"]"; break; | ||
| 545 | case ae_primary_complex: str = "#("+absyn_exp2str(primary->complex->re)+")"; break; | ||
| 546 | case ae_primary_polar: str = "%("+absyn_exp2str(primary->polar->mod)+")"; break; | ||
| 547 | case ae_primary_vec: str = "@("+absyn_exp2str(primary->vec->args)+")"; break; | ||
| 548 | case ae_primary_exp: str = absyn_exp2str(primary->exp); break; | ||
| 549 | case ae_primary_hack: str = "<<< " + absyn_exp2str(primary->exp) + " >>>"; break; | ||
| 550 | case ae_primary_nil: str = "null"; break; | ||
| 551 | default: str ="[PRIMARY]"; break; | ||
| 552 | } | ||
| 553 | |||
| 554 | return str; | ||
| 555 | } | ||
| 556 | |||
| 557 | |||
| 558 | |||
| 559 | |||
| 560 | //----------------------------------------------------------------------------- | ||
| 561 | // name: absyn_array2str() | ||
| 562 | // desc: convert abstract syntax array to string | ||
| 563 | //----------------------------------------------------------------------------- | ||
| 564 | string absyn_array2str( a_Exp_Array array ) | ||
| 565 | { | ||
| 566 | string str; | ||
| 567 | |||
| 568 | t_CKUINT depth = 0; | ||
| 569 | a_Array_Sub sub = NULL; | ||
| 570 | t_CKBOOL is_str = FALSE; | ||
| 571 | |||
| 572 | // get the sub | ||
| 573 | sub = array->indices; | ||
| 574 | // expressions | ||
| 575 | a_Exp e = sub->exp_list; | ||
| 576 | |||
| 577 | // base of the array | ||
| 578 | str = absyn_exp2str(array->base); | ||
| 579 | |||
| 580 | // loop over | ||
| 581 | while( e ) | ||
| 582 | { | ||
| 583 | // each index | ||
| 584 | str += "[" + absyn_exp2str(e,false) + "]"; | ||
| 585 | // advance | ||
| 586 | e = e->next; | ||
| 587 | } | ||
| 588 | |||
| 589 | return str; | ||
| 590 | } | ||
| 591 | |||
| 592 | |||
| 593 | |||
| 594 | |||
| 595 | //----------------------------------------------------------------------------- | ||
| 596 | // name: absyn_func_call2str() | ||
| 597 | // desc: convert abstract syntax func_call to string | ||
| 598 | //----------------------------------------------------------------------------- | ||
| 599 | string absyn_func_call2str( a_Exp_Func_Call func_call ) | ||
| 600 | { | ||
| 601 | string str; | ||
| 602 | // function name | ||
| 603 | str = absyn_exp2str( func_call->func ); | ||
| 604 | // args | ||
| 605 | str += "(" + absyn_exp2str( func_call->args ) + ")"; | ||
| 606 | // done | ||
| 607 | return str; | ||
| 608 | } | ||
| 609 | |||
| 610 | |||
| 611 | |||
| 612 | |||
| 613 | //----------------------------------------------------------------------------- | ||
| 614 | // name: absyn_dot_member2str() | ||
| 615 | // desc: convert abstract syntax dot_member to string | ||
| 616 | //----------------------------------------------------------------------------- | ||
| 617 | string absyn_dot_member2str( a_Exp_Dot_Member dot_member ) | ||
| 618 | { | ||
| 619 | return absyn_exp2str(dot_member->base) + "." + S_name(dot_member->xid); | ||
| 620 | } | ||
| 621 | |||
| 622 | |||
| 623 | |||
| 624 | |||
| 625 | //----------------------------------------------------------------------------- | ||
| 626 | // name: absyn_exp_if2str() | ||
| 627 | // desc: convert abstract syntax exp_if to string | ||
| 628 | //----------------------------------------------------------------------------- | ||
| 629 | string absyn_exp_if2str( a_Exp_If exp_if ) | ||
| 630 | { | ||
| 631 | return "("+absyn_exp2str(exp_if->cond) + "?" + absyn_exp2str(exp_if->if_exp) | ||
| 632 | + ":" + absyn_exp2str(exp_if->else_exp)+")"; | ||
| 633 | } | ||
| 634 | |||
| 635 | |||
| 636 | |||
| 637 | |||
| 638 | //----------------------------------------------------------------------------- | ||
| 639 | // name: absyn_decl2str() | ||
| 640 | // desc: convert abstract syntax decl to string | ||
| 641 | //----------------------------------------------------------------------------- | ||
| 642 | string absyn_decl2str( a_Exp_Decl decl ) | ||
| 643 | { | ||
| 644 | a_Var_Decl_List list = decl->var_decl_list; | ||
| 645 | string str; | ||
| 646 | a_Exp e = NULL; | ||
| 647 | |||
| 648 | if( decl->is_global ) str += "global "; | ||
| 649 | else if( decl->is_static ) str += "static "; | ||
| 650 | |||
| 651 | while( list ) | ||
| 652 | { | ||
| 653 | // type | ||
| 654 | str += list->var_decl->value->type->name + " " + (decl->type->ref ? "@" : "") + list->var_decl->value->name; | ||
| 655 | // array? | ||
| 656 | if( list->var_decl->array ) | ||
| 657 | { | ||
| 658 | e = list->var_decl->array->exp_list; | ||
| 659 | if( e ) | ||
| 660 | { | ||
| 661 | // loop over | ||
| 662 | while( e ) | ||
| 663 | { | ||
| 664 | // each index | ||
| 665 | str += "[" + absyn_exp2str(e,false) + "]"; | ||
| 666 | // advance | ||
| 667 | e = e->next; | ||
| 668 | } | ||
| 669 | } | ||
| 670 | else | ||
| 671 | { | ||
| 672 | for( t_CKINT i = 0; i < list->var_decl->value->type->array_depth; i++ ) | ||
| 673 | { | ||
| 674 | str += "[]"; | ||
| 675 | } | ||
| 676 | } | ||
| 677 | } | ||
| 678 | |||
| 679 | list = list->next; | ||
| 680 | if( list ) str += ","; | ||
| 681 | } | ||
| 682 | |||
| 683 | return str; | ||
| 684 | } | ||