/[jscoverage]/trunk/instrument-js.cpp
ViewVC logotype

Diff of /trunk/instrument-js.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 376 by siliconforks, Tue Oct 28 05:30:23 2008 UTC revision 390 by siliconforks, Thu Oct 30 17:53:39 2008 UTC
# Line 22  Line 22 
22  #include "instrument-js.h"  #include "instrument-js.h"
23    
24  #include <assert.h>  #include <assert.h>
25    #include <math.h>
26  #include <stdlib.h>  #include <stdlib.h>
27  #include <string.h>  #include <string.h>
28    
# Line 267  Line 268 
268    }    }
269  }  }
270    
271  static void instrument_expression(JSParseNode * node, Stream * f);  static void output_expression(JSParseNode * node, Stream * f, bool parenthesize_object_literals);
272  static void instrument_statement(JSParseNode * node, Stream * f, int indent, bool is_jscoverage_if);  static void instrument_statement(JSParseNode * node, Stream * f, int indent, bool is_jscoverage_if);
273  static void output_statement(JSParseNode * node, Stream * f, int indent, bool is_jscoverage_if);  static void output_statement(JSParseNode * node, Stream * f, int indent, bool is_jscoverage_if);
274    
# Line 284  Line 285 
285      Stream_write_string(f, "each ");      Stream_write_string(f, "each ");
286    }    }
287    Stream_write_char(f, '(');    Stream_write_char(f, '(');
288    instrument_expression(node->pn_left, f);    output_expression(node->pn_left, f, false);
289    Stream_write_char(f, ')');    Stream_write_char(f, ')');
290  }  }
291    
# Line 311  Line 312 
312      p = p->pn_kid;      p = p->pn_kid;
313    }    }
314    
315    instrument_expression(p, f);    output_expression(p, f, false);
316    p = for_node;    p = for_node;
317    while (p->pn_type == TOK_FOR) {    while (p->pn_type == TOK_FOR) {
318      Stream_write_char(f, ' ');      Stream_write_char(f, ' ');
# Line 320  Line 321 
321    }    }
322    if (if_node) {    if (if_node) {
323      Stream_write_string(f, " if (");      Stream_write_string(f, " if (");
324      instrument_expression(if_node->pn_kid1, f);      output_expression(if_node->pn_kid1, f, false);
325      Stream_write_char(f, ')');      Stream_write_char(f, ')');
326    }    }
327  }  }
# Line 381  Line 382 
382          }          }
383        }        }
384        assert(expression != NULL);        assert(expression != NULL);
385        instrument_expression(expression, f);        output_expression(expression, f, false);
386      }      }
387      else {      else {
388        print_string_atom(param, f);        print_string_atom(param, f);
# Line 414  Line 415 
415      }      }
416    }    }
417    
418    Stream_write_string(f, "}\n");    Stream_write_char(f, '}');
419  }  }
420    
421  static void instrument_function_call(JSParseNode * node, Stream * f) {  static void instrument_function_call(JSParseNode * node, Stream * f) {
# Line 433  Line 434 
434        Stream_write_char(f, ')');        Stream_write_char(f, ')');
435        return;        return;
436      }      }
     else {  
       Stream_write_char(f, '(');  
       instrument_expression(function_node, f);  
       Stream_write_char(f, ')');  
     }  
   }  
   else {  
     instrument_expression(function_node, f);  
437    }    }
438      output_expression(function_node, f, false);
439    Stream_write_char(f, '(');    Stream_write_char(f, '(');
440    for (struct JSParseNode * p = function_node->pn_next; p != NULL; p = p->pn_next) {    for (struct JSParseNode * p = function_node->pn_next; p != NULL; p = p->pn_next) {
441      if (p != node->pn_head->pn_next) {      if (p != node->pn_head->pn_next) {
442        Stream_write_string(f, ", ");        Stream_write_string(f, ", ");
443      }      }
444      instrument_expression(p, f);      output_expression(p, f, false);
445    }    }
446    Stream_write_char(f, ')');    Stream_write_char(f, ')');
447  }  }
# Line 455  Line 449 
449  static void instrument_declarations(JSParseNode * list, Stream * f) {  static void instrument_declarations(JSParseNode * list, Stream * f) {
450    assert(list->pn_arity == PN_LIST);    assert(list->pn_arity == PN_LIST);
451    for (JSParseNode * p = list->pn_head; p != NULL; p = p->pn_next) {    for (JSParseNode * p = list->pn_head; p != NULL; p = p->pn_next) {
452      switch (p->pn_type) {      if (p != list->pn_head) {
453      case TOK_NAME:        Stream_write_string(f, ", ");
       assert(p->pn_arity == PN_NAME);  
       if (p != list->pn_head) {  
         Stream_write_string(f, ", ");  
       }  
       print_string_atom(p->pn_atom, f);  
       if (p->pn_expr != NULL) {  
         Stream_write_string(f, " = ");  
         instrument_expression(p->pn_expr, f);  
       }  
       break;  
     case TOK_ASSIGN:  
       /* destructuring */  
       instrument_expression(p->pn_left, f);  
       Stream_write_string(f, " = ");  
       instrument_expression(p->pn_right, f);  
       break;  
     case TOK_RB:  
     case TOK_RC:  
       /* destructuring */  
       instrument_expression(p, f);  
       break;  
     default:  
       abort();  
       break;  
454      }      }
455        output_expression(p, f, false);
456    }    }
457  }  }
458    
# Line 498  Line 469 
469  TOK_INSTANCEOF  binary  TOK_INSTANCEOF  binary
470  TOK_IN          binary  TOK_IN          binary
471  */  */
472  static void instrument_expression(JSParseNode * node, Stream * f) {  static void output_expression(JSParseNode * node, Stream * f, bool parenthesize_object_literals) {
473    switch (node->pn_type) {    switch (node->pn_type) {
474    case TOK_FUNCTION:    case TOK_FUNCTION:
475        Stream_write_char(f, '(');
476      instrument_function(node, f, 0, FUNCTION_NORMAL);      instrument_function(node, f, 0, FUNCTION_NORMAL);
477        Stream_write_char(f, ')');
478      break;      break;
479    case TOK_COMMA:    case TOK_COMMA:
480      for (struct JSParseNode * p = node->pn_head; p != NULL; p = p->pn_next) {      for (struct JSParseNode * p = node->pn_head; p != NULL; p = p->pn_next) {
481        if (p != node->pn_head) {        if (p != node->pn_head) {
482          Stream_write_string(f, ", ");          Stream_write_string(f, ", ");
483        }        }
484        instrument_expression(p, f);        output_expression(p, f, parenthesize_object_literals);
485      }      }
486      break;      break;
487    case TOK_ASSIGN:    case TOK_ASSIGN:
488      if (node->pn_left->pn_type == TOK_RC) {      output_expression(node->pn_left, f, parenthesize_object_literals);
       /* destructuring assignment with object literal must be in parentheses */  
       Stream_write_char(f, '(');  
       instrument_expression(node->pn_left, f);  
       Stream_write_char(f, ')');  
     }  
     else {  
       instrument_expression(node->pn_left, f);  
     }  
489      Stream_write_char(f, ' ');      Stream_write_char(f, ' ');
490      switch (node->pn_op) {      switch (node->pn_op) {
491      case JSOP_ADD:      case JSOP_ADD:
# Line 541  Line 506 
506        break;        break;
507      }      }
508      Stream_write_string(f, "= ");      Stream_write_string(f, "= ");
509      instrument_expression(node->pn_right, f);      output_expression(node->pn_right, f, false);
510      break;      break;
511    case TOK_HOOK:    case TOK_HOOK:
512      instrument_expression(node->pn_kid1, f);      output_expression(node->pn_kid1, f, parenthesize_object_literals);
513      Stream_write_string(f, "? ");      Stream_write_string(f, "? ");
514      instrument_expression(node->pn_kid2, f);      output_expression(node->pn_kid2, f, false);
515      Stream_write_string(f, ": ");      Stream_write_string(f, ": ");
516      instrument_expression(node->pn_kid3, f);      output_expression(node->pn_kid3, f, false);
517      break;      break;
518    case TOK_OR:    case TOK_OR:
519    case TOK_AND:    case TOK_AND:
# Line 564  Line 529 
529    case TOK_DIVOP:    case TOK_DIVOP:
530      switch (node->pn_arity) {      switch (node->pn_arity) {
531      case PN_BINARY:      case PN_BINARY:
532        instrument_expression(node->pn_left, f);        output_expression(node->pn_left, f, parenthesize_object_literals);
533        Stream_printf(f, " %s ", get_op(node->pn_op));        Stream_printf(f, " %s ", get_op(node->pn_op));
534        instrument_expression(node->pn_right, f);        output_expression(node->pn_right, f, false);
535        break;        break;
536      case PN_LIST:      case PN_LIST:
537        for (struct JSParseNode * p = node->pn_head; p != NULL; p = p->pn_next) {        for (struct JSParseNode * p = node->pn_head; p != NULL; p = p->pn_next) {
538          if (p != node->pn_head) {          if (p == node->pn_head) {
539              output_expression(p, f, parenthesize_object_literals);
540            }
541            else {
542            Stream_printf(f, " %s ", get_op(node->pn_op));            Stream_printf(f, " %s ", get_op(node->pn_op));
543              output_expression(p, f, false);
544          }          }
         instrument_expression(p, f);  
545        }        }
546        break;        break;
547      default:      default:
# Line 583  Line 551 
551    case TOK_UNARYOP:    case TOK_UNARYOP:
552      switch (node->pn_op) {      switch (node->pn_op) {
553      case JSOP_NEG:      case JSOP_NEG:
554        Stream_write_char(f, '-');        Stream_write_string(f, "- ");
555        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, false);
556        break;        break;
557      case JSOP_POS:      case JSOP_POS:
558        Stream_write_char(f, '+');        Stream_write_string(f, "+ ");
559        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, false);
560        break;        break;
561      case JSOP_NOT:      case JSOP_NOT:
562        Stream_write_char(f, '!');        Stream_write_string(f, "! ");
563        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, false);
564        break;        break;
565      case JSOP_BITNOT:      case JSOP_BITNOT:
566        Stream_write_char(f, '~');        Stream_write_string(f, "~ ");
567        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, false);
568        break;        break;
569      case JSOP_TYPEOF:      case JSOP_TYPEOF:
570        Stream_write_string(f, "typeof ");        Stream_write_string(f, "typeof ");
571        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, false);
572        break;        break;
573      case JSOP_VOID:      case JSOP_VOID:
574        Stream_write_string(f, "void ");        Stream_write_string(f, "void ");
575        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, false);
576        break;        break;
577      default:      default:
578        fatal_source(file_id, node->pn_pos.begin.lineno, "unknown operator (%d)", node->pn_op);        fatal_source(file_id, node->pn_pos.begin.lineno, "unknown operator (%d)", node->pn_op);
# Line 621  Line 589 
589      case JSOP_INCPROP:      case JSOP_INCPROP:
590      case JSOP_INCELEM:      case JSOP_INCELEM:
591        Stream_write_string(f, "++");        Stream_write_string(f, "++");
592        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, false);
593        break;        break;
594      case JSOP_DECNAME:      case JSOP_DECNAME:
595      case JSOP_DECPROP:      case JSOP_DECPROP:
596      case JSOP_DECELEM:      case JSOP_DECELEM:
597        Stream_write_string(f, "--");        Stream_write_string(f, "--");
598        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, false);
599        break;        break;
600      case JSOP_NAMEINC:      case JSOP_NAMEINC:
601      case JSOP_PROPINC:      case JSOP_PROPINC:
602      case JSOP_ELEMINC:      case JSOP_ELEMINC:
603        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, parenthesize_object_literals);
604        Stream_write_string(f, "++");        Stream_write_string(f, "++");
605        break;        break;
606      case JSOP_NAMEDEC:      case JSOP_NAMEDEC:
607      case JSOP_PROPDEC:      case JSOP_PROPDEC:
608      case JSOP_ELEMDEC:      case JSOP_ELEMDEC:
609        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, parenthesize_object_literals);
610        Stream_write_string(f, "--");        Stream_write_string(f, "--");
611        break;        break;
612      default:      default:
# Line 652  Line 620 
620      break;      break;
621    case TOK_DELETE:    case TOK_DELETE:
622      Stream_write_string(f, "delete ");      Stream_write_string(f, "delete ");
623      instrument_expression(node->pn_kid, f);      output_expression(node->pn_kid, f, false);
624      break;      break;
625    case TOK_DOT:    case TOK_DOT:
626      /* numeric literals must be parenthesized */      /* numeric literals must be parenthesized */
627      if (node->pn_expr->pn_type == TOK_NUMBER) {      switch (node->pn_expr->pn_type) {
628        case TOK_NUMBER:
629        Stream_write_char(f, '(');        Stream_write_char(f, '(');
630        instrument_expression(node->pn_expr, f);        output_expression(node->pn_expr, f, false);
631        Stream_write_char(f, ')');        Stream_write_char(f, ')');
632      }        break;
633      else {      default:
634        instrument_expression(node->pn_expr, f);        output_expression(node->pn_expr, f, true);
635          break;
636      }      }
637      /*      /*
638      This may have originally been x['foo-bar'].  Because the string 'foo-bar'      This may have originally been x['foo-bar'].  Because the string 'foo-bar'
# Line 697  Line 667 
667      }      }
668      break;      break;
669    case TOK_LB:    case TOK_LB:
670      instrument_expression(node->pn_left, f);      output_expression(node->pn_left, f, false);
671      Stream_write_char(f, '[');      Stream_write_char(f, '[');
672      instrument_expression(node->pn_right, f);      output_expression(node->pn_right, f, false);
673      Stream_write_char(f, ']');      Stream_write_char(f, ']');
674      break;      break;
675    case TOK_LP:    case TOK_LP:
# Line 713  Line 683 
683        }        }
684        /* TOK_COMMA is a special case: a hole in the array */        /* TOK_COMMA is a special case: a hole in the array */
685        if (p->pn_type != TOK_COMMA) {        if (p->pn_type != TOK_COMMA) {
686          instrument_expression(p, f);          output_expression(p, f, false);
687        }        }
688      }      }
689      if (node->pn_extra == PNX_ENDCOMMA) {      if (node->pn_extra == PNX_ENDCOMMA) {
# Line 722  Line 692 
692      Stream_write_char(f, ']');      Stream_write_char(f, ']');
693      break;      break;
694    case TOK_RC:    case TOK_RC:
695        if (parenthesize_object_literals) {
696          Stream_write_char(f, '(');
697        }
698      Stream_write_char(f, '{');      Stream_write_char(f, '{');
699      for (struct JSParseNode * p = node->pn_head; p != NULL; p = p->pn_next) {      for (struct JSParseNode * p = node->pn_head; p != NULL; p = p->pn_next) {
700        if (p->pn_type != TOK_COLON) {        if (p->pn_type != TOK_COLON) {
# Line 741  Line 714 
714          else {          else {
715            Stream_write_string(f, "set ");            Stream_write_string(f, "set ");
716          }          }
717          instrument_expression(p->pn_left, f);          output_expression(p->pn_left, f, false);
718          if (p->pn_right->pn_type != TOK_FUNCTION) {          if (p->pn_right->pn_type != TOK_FUNCTION) {
719            fatal_source(file_id, p->pn_pos.begin.lineno, "expected function");            fatal_source(file_id, p->pn_pos.begin.lineno, "expected function");
720          }          }
721          instrument_function(p->pn_right, f, 0, FUNCTION_GETTER_OR_SETTER);          instrument_function(p->pn_right, f, 0, FUNCTION_GETTER_OR_SETTER);
722          break;          break;
723        default:        default:
724          instrument_expression(p->pn_left, f);          output_expression(p->pn_left, f, false);
725          Stream_write_string(f, ": ");          Stream_write_string(f, ": ");
726          instrument_expression(p->pn_right, f);          output_expression(p->pn_right, f, false);
727          break;          break;
728        }        }
729      }      }
730      Stream_write_char(f, '}');      Stream_write_char(f, '}');
731        if (parenthesize_object_literals) {
732          Stream_write_char(f, ')');
733        }
734      break;      break;
735    case TOK_RP:    case TOK_RP:
736      Stream_write_char(f, '(');      Stream_write_char(f, '(');
737      instrument_expression(node->pn_kid, f);      output_expression(node->pn_kid, f, false);
738      Stream_write_char(f, ')');      Stream_write_char(f, ')');
739      break;      break;
740    case TOK_NAME:    case TOK_NAME:
741      print_string_atom(node->pn_atom, f);      print_string_atom(node->pn_atom, f);
742        if (node->pn_expr != NULL) {
743          Stream_write_string(f, " = ");
744          output_expression(node->pn_expr, f, false);
745        }
746      break;      break;
747    case TOK_STRING:    case TOK_STRING:
748      print_quoted_string_atom(node->pn_atom, f);      print_quoted_string_atom(node->pn_atom, f);
# Line 784  Line 764 
764      To keep the output simple, special-case zero.      To keep the output simple, special-case zero.
765      */      */
766      if (node->pn_dval == 0.0) {      if (node->pn_dval == 0.0) {
767        Stream_write_string(f, "0");        if (signbit(node->pn_dval)) {
768            Stream_write_string(f, "-0");
769          }
770          else {
771            Stream_write_string(f, "0");
772          }
773        }
774        else if (node->pn_dval == INFINITY) {
775          Stream_write_string(f, "Number.POSITIVE_INFINITY");
776        }
777        else if (node->pn_dval == -INFINITY) {
778          Stream_write_string(f, "Number.NEGATIVE_INFINITY");
779        }
780        else if (node->pn_dval == NAN) {
781          Stream_write_string(f, "Number.NaN");
782      }      }
783      else {      else {
784        Stream_printf(f, "%.15g", node->pn_dval);        Stream_printf(f, "%.15g", node->pn_dval);
# Line 810  Line 804 
804      }      }
805      break;      break;
806    case TOK_INSTANCEOF:    case TOK_INSTANCEOF:
807      instrument_expression(node->pn_left, f);      output_expression(node->pn_left, f, parenthesize_object_literals);
808      Stream_write_string(f, " instanceof ");      Stream_write_string(f, " instanceof ");
809      instrument_expression(node->pn_right, f);      output_expression(node->pn_right, f, false);
810      break;      break;
811    case TOK_IN:    case TOK_IN:
812      instrument_expression(node->pn_left, f);      output_expression(node->pn_left, f, false);
813      Stream_write_string(f, " in ");      Stream_write_string(f, " in ");
814      instrument_expression(node->pn_right, f);      output_expression(node->pn_right, f, false);
815      break;      break;
816    case TOK_LEXICALSCOPE:    case TOK_LEXICALSCOPE:
817      assert(node->pn_arity == PN_NAME);      assert(node->pn_arity == PN_NAME);
# Line 828  Line 822 
822      assert(node->pn_expr->pn_left->pn_arity == PN_LIST);      assert(node->pn_expr->pn_left->pn_arity == PN_LIST);
823      instrument_declarations(node->pn_expr->pn_left, f);      instrument_declarations(node->pn_expr->pn_left, f);
824      Stream_write_string(f, ") ");      Stream_write_string(f, ") ");
825      instrument_expression(node->pn_expr->pn_right, f);      output_expression(node->pn_expr->pn_right, f, true);
826      break;      break;
827    case TOK_YIELD:    case TOK_YIELD:
828      assert(node->pn_arity == PN_UNARY);      assert(node->pn_arity == PN_UNARY);
829      Stream_write_string(f, "yield");      Stream_write_string(f, "yield");
830      if (node->pn_kid != NULL) {      if (node->pn_kid != NULL) {
831        Stream_write_char(f, ' ');        Stream_write_char(f, ' ');
832        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, true);
833      }      }
834      break;      break;
835    case TOK_ARRAYCOMP:    case TOK_ARRAYCOMP:
# Line 877  Line 871 
871    switch (node->pn_type) {    switch (node->pn_type) {
872    case TOK_FUNCTION:    case TOK_FUNCTION:
873      instrument_function(node, f, indent, FUNCTION_NORMAL);      instrument_function(node, f, indent, FUNCTION_NORMAL);
874        Stream_write_char(f, '\n');
875      break;      break;
876    case TOK_LC:    case TOK_LC:
877      assert(node->pn_arity == PN_LIST);      assert(node->pn_arity == PN_LIST);
# Line 907  Line 902 
902    
903      Stream_printf(f, "%*s", indent, "");      Stream_printf(f, "%*s", indent, "");
904      Stream_write_string(f, "if (");      Stream_write_string(f, "if (");
905      instrument_expression(node->pn_kid1, f);      output_expression(node->pn_kid1, f, false);
906      Stream_write_string(f, ") {\n");      Stream_write_string(f, ") {\n");
907      if (is_jscoverage_if && node->pn_kid3) {      if (is_jscoverage_if && node->pn_kid3) {
908        uint16_t else_start = node->pn_kid3->pn_pos.begin.lineno;        uint16_t else_start = node->pn_kid3->pn_pos.begin.lineno;
# Line 944  Line 939 
939      assert(node->pn_arity == PN_BINARY);      assert(node->pn_arity == PN_BINARY);
940      Stream_printf(f, "%*s", indent, "");      Stream_printf(f, "%*s", indent, "");
941      Stream_write_string(f, "switch (");      Stream_write_string(f, "switch (");
942      instrument_expression(node->pn_left, f);      output_expression(node->pn_left, f, false);
943      Stream_write_string(f, ") {\n");      Stream_write_string(f, ") {\n");
944      {      {
945        JSParseNode * list = node->pn_right;        JSParseNode * list = node->pn_right;
# Line 956  Line 951 
951          switch (p->pn_type) {          switch (p->pn_type) {
952          case TOK_CASE:          case TOK_CASE:
953            Stream_write_string(f, "case ");            Stream_write_string(f, "case ");
954            instrument_expression(p->pn_left, f);            output_expression(p->pn_left, f, false);
955            Stream_write_string(f, ":\n");            Stream_write_string(f, ":\n");
956            break;            break;
957          case TOK_DEFAULT:          case TOK_DEFAULT:
# Line 980  Line 975 
975      assert(node->pn_arity == PN_BINARY);      assert(node->pn_arity == PN_BINARY);
976      Stream_printf(f, "%*s", indent, "");      Stream_printf(f, "%*s", indent, "");
977      Stream_write_string(f, "while (");      Stream_write_string(f, "while (");
978      instrument_expression(node->pn_left, f);      output_expression(node->pn_left, f, false);
979      Stream_write_string(f, ") {\n");      Stream_write_string(f, ") {\n");
980      instrument_statement(node->pn_right, f, indent + 2, false);      instrument_statement(node->pn_right, f, indent + 2, false);
981      Stream_write_string(f, "}\n");      Stream_write_string(f, "}\n");
# Line 993  Line 988 
988      Stream_write_string(f, "}\n");      Stream_write_string(f, "}\n");
989      Stream_printf(f, "%*s", indent, "");      Stream_printf(f, "%*s", indent, "");
990      Stream_write_string(f, "while (");      Stream_write_string(f, "while (");
991      instrument_expression(node->pn_right, f);      output_expression(node->pn_right, f, false);
992      Stream_write_string(f, ");\n");      Stream_write_string(f, ");\n");
993      break;      break;
994    case TOK_FOR:    case TOK_FOR:
# Line 1010  Line 1005 
1005        assert(node->pn_left->pn_arity == PN_TERNARY);        assert(node->pn_left->pn_arity == PN_TERNARY);
1006        Stream_write_string(f, "for (");        Stream_write_string(f, "for (");
1007        if (node->pn_left->pn_kid1) {        if (node->pn_left->pn_kid1) {
1008          instrument_expression(node->pn_left->pn_kid1, f);          output_expression(node->pn_left->pn_kid1, f, false);
1009        }        }
1010        Stream_write_string(f, ";");        Stream_write_string(f, ";");
1011        if (node->pn_left->pn_kid2) {        if (node->pn_left->pn_kid2) {
1012          Stream_write_char(f, ' ');          Stream_write_char(f, ' ');
1013          instrument_expression(node->pn_left->pn_kid2, f);          output_expression(node->pn_left->pn_kid2, f, false);
1014        }        }
1015        Stream_write_string(f, ";");        Stream_write_string(f, ";");
1016        if (node->pn_left->pn_kid3) {        if (node->pn_left->pn_kid3) {
1017          Stream_write_char(f, ' ');          Stream_write_char(f, ' ');
1018          instrument_expression(node->pn_left->pn_kid3, f);          output_expression(node->pn_left->pn_kid3, f, false);
1019        }        }
1020        Stream_write_char(f, ')');        Stream_write_char(f, ')');
1021        break;        break;
# Line 1036  Line 1031 
1031      assert(node->pn_arity == PN_UNARY);      assert(node->pn_arity == PN_UNARY);
1032      Stream_printf(f, "%*s", indent, "");      Stream_printf(f, "%*s", indent, "");
1033      Stream_write_string(f, "throw ");      Stream_write_string(f, "throw ");
1034      instrument_expression(node->pn_u.unary.kid, f);      output_expression(node->pn_u.unary.kid, f, false);
1035      Stream_write_string(f, ";\n");      Stream_write_string(f, ";\n");
1036      break;      break;
1037    case TOK_TRY:    case TOK_TRY:
# Line 1053  Line 1048 
1048          assert(catch->pn_type == TOK_CATCH);          assert(catch->pn_type == TOK_CATCH);
1049          Stream_printf(f, "%*s", indent, "");          Stream_printf(f, "%*s", indent, "");
1050          Stream_write_string(f, "catch (");          Stream_write_string(f, "catch (");
1051          /* this may not be a name - destructuring assignment */          output_expression(catch->pn_kid1, f, false);
         /*  
         assert(catch->pn_kid1->pn_arity == PN_NAME);  
         print_string_atom(catch->pn_kid1->pn_atom, f);  
         */  
         instrument_expression(catch->pn_kid1, f);  
1052          if (catch->pn_kid2) {          if (catch->pn_kid2) {
1053            Stream_write_string(f, " if ");            Stream_write_string(f, " if ");
1054            instrument_expression(catch->pn_kid2, f);            output_expression(catch->pn_kid2, f, false);
1055          }          }
1056          Stream_write_string(f, ") {\n");          Stream_write_string(f, ") {\n");
1057          instrument_statement(catch->pn_kid3, f, indent + 2, false);          instrument_statement(catch->pn_kid3, f, indent + 2, false);
# Line 1096  Line 1086 
1086      assert(node->pn_arity == PN_BINARY);      assert(node->pn_arity == PN_BINARY);
1087      Stream_printf(f, "%*s", indent, "");      Stream_printf(f, "%*s", indent, "");
1088      Stream_write_string(f, "with (");      Stream_write_string(f, "with (");
1089      instrument_expression(node->pn_left, f);      output_expression(node->pn_left, f, false);
1090      Stream_write_string(f, ") {\n");      Stream_write_string(f, ") {\n");
1091      instrument_statement(node->pn_right, f, indent + 2, false);      instrument_statement(node->pn_right, f, indent + 2, false);
1092      Stream_printf(f, "%*s", indent, "");      Stream_printf(f, "%*s", indent, "");
# Line 1104  Line 1094 
1094      break;      break;
1095    case TOK_VAR:    case TOK_VAR:
1096      Stream_printf(f, "%*s", indent, "");      Stream_printf(f, "%*s", indent, "");
1097      instrument_expression(node, f);      output_expression(node, f, false);
1098      Stream_write_string(f, ";\n");      Stream_write_string(f, ";\n");
1099      break;      break;
1100    case TOK_RETURN:    case TOK_RETURN:
# Line 1113  Line 1103 
1103      Stream_write_string(f, "return");      Stream_write_string(f, "return");
1104      if (node->pn_kid != NULL) {      if (node->pn_kid != NULL) {
1105        Stream_write_char(f, ' ');        Stream_write_char(f, ' ');
1106        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, true);
1107      }      }
1108      Stream_write_string(f, ";\n");      Stream_write_string(f, ";\n");
1109      break;      break;
# Line 1121  Line 1111 
1111      assert(node->pn_arity == PN_UNARY);      assert(node->pn_arity == PN_UNARY);
1112      Stream_printf(f, "%*s", indent, "");      Stream_printf(f, "%*s", indent, "");
1113      if (node->pn_kid != NULL) {      if (node->pn_kid != NULL) {
1114        instrument_expression(node->pn_kid, f);        output_expression(node->pn_kid, f, true);
1115      }      }
1116      Stream_write_string(f, ";\n");      Stream_write_string(f, ";\n");
1117      break;      break;
# Line 1195  Line 1185 
1185      case PN_LIST:      case PN_LIST:
1186        /* let definition */        /* let definition */
1187        Stream_printf(f, "%*s", indent, "");        Stream_printf(f, "%*s", indent, "");
1188        instrument_expression(node, f);        output_expression(node, f, false);
1189        Stream_write_string(f, ";\n");        Stream_write_string(f, ";\n");
1190        break;        break;
1191      default:      default:

Legend:
Removed from v.376  
changed lines
  Added in v.390

  ViewVC Help
Powered by ViewVC 1.1.24