Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    ***** BEGIN LICENSE BLOCK *****
3
    * Version: CPL 1.0/GPL 2.0/LGPL 2.1
4
    *
5
    * The contents of this file are subject to the Common Public
6
    * License Version 1.0 (the "License"); you may not use this file
7
    * except in compliance with the License. You may obtain a copy of
8
    * the License at http://www.eclipse.org/legal/cpl-v10.html
9
    *
10
   * Software distributed under the License is distributed on an "AS
11
   * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
12
   * implied. See the License for the specific language governing
13
   * rights and limitations under the License.
14
   *
15
   * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr>
16
   * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
17
   * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
18
   * Copyright (C) 2004 Charles O Nutter <headius@headius.com>
19
   * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org>
20
   * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
21
   * Copyright (C) 2006-2007 Mirko Stocker <me@misto.ch>
22
   * Copyright (C) 2006 Thomas Corbat <tcorbat@hsr.ch>
23
   * 
24
   * Alternatively, the contents of this file may be used under the terms of
25
   * either of the GNU General Public License Version 2 or later (the "GPL"),
26
   * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27
   * in which case the provisions of the GPL or the LGPL are applicable instead
28
   * of those above. If you wish to allow use of your version of this file only
29
   * under the terms of either the GPL or the LGPL, and not to allow others to
30
   * use your version of this file under the terms of the CPL, indicate your
31
   * decision by deleting the provisions above and replace them with the notice
32
   * and other provisions required by the GPL or the LGPL. If you do not delete
33
   * the provisions above, a recipient may use your version of this file under
34
   * the terms of any one of the CPL, the GPL or the LGPL.
35
   ***** END LICENSE BLOCK *****/
36
  package org.jruby.parser;
37
  
190
 
191
 public class ParserSupport {
192
     // Parser states:
193
     protected StaticScope currentScope;
194
 
195
     protected RubyYaccLexer lexer;
196
     
197
     // Is the parser current within a singleton (value is number of nested singletons)
198
     private int inSingleton;
199
     
200
     // Is the parser currently within a method definition
201
     private boolean inDefinition;
202
 
203
     protected IRubyWarnings warnings;
204
 
205
     protected ParserConfiguration configuration;
206
     private RubyParserResult result;
207
 
208
     public void reset() {
209
          = 0;
210
          = false;
211
     }
212
     
213
     public void allowDubyExtension(ISourcePosition position) {
214
         throw new SyntaxException(., position,
215
                 .getCurrentLine(), "Duby extensions not configured");
216
     }
217
     
218
     public StaticScope getCurrentScope() {
219
         return ;
220
     }
221
     
223
         return ;
224
     }
225
     
226
     public void popCurrentScope() {
228
     }
229
     
230
     public void pushBlockScope() {
232
     }
233
     
234
     public void pushLocalScope() {
236
     }
237
     
238
     public Node arg_concat(ISourcePosition position, Node node1, Node node2) {
239
         return node2 == null ? node1 : new ArgsCatNode(position, node1, node2);
240
     }
241
 
242
     public Node arg_blk_pass(Node firstNode, BlockPassNode secondNode) {
243
         if (secondNode != null) {
244
             secondNode.setArgsNode(firstNode);
245
             return secondNode;
246
         }
247
         return firstNode;
248
     }

    
We know for callers of this that it cannot be any of the specials checked in gettable.

Parameters:
node to check its variable type
Returns:
an AST node representing this new variable
255
 
256
     public Node gettable2(Node node) {
257
         switch (node.getNodeType()) {
258
         case : // LOCALVAR
259
         case :
260
             return .declare(node.getPosition(), ((INameNode) node).getName());
261
         case : // CONSTANT
262
             return new ConstNode(node.getPosition(), ((INameNode) node).getName());
263
         case : // INSTANCE VARIABLE
264
             return new InstVarNode(node.getPosition(), ((INameNode) node).getName());
265
         case :
266
         case :
267
             return new ClassVarNode(node.getPosition(), ((INameNode) node).getName());
268
         case :
269
             return new GlobalVarNode(node.getPosition(), ((INameNode) node).getName());
270
         }
271
 
272
         getterIdentifierError(node.getPosition(), ((INameNode) node).getName());
273
         return null;
274
     }
    
    
Create AST node representing variable type it represents.

Parameters:
token to check its variable type
Returns:
an AST node representing this new variable
281
 
282
     public Node gettable(Token token) {
283
         switch (token.getType()) {
284
         case .:
285
             return new SelfNode(token.getPosition());
286
         case .:
287
             return new NilNode(token.getPosition());
288
         case .:
289
             return new TrueNode(token.getPosition());
290
         case .:
291
             return new FalseNode(token.getPosition());
292
         case .:
293
             return new FileNode(token.getPosition(), new ByteList(token.getPosition().getFile().getBytes(),
294
                     getConfiguration().getRuntime().getEncodingService().getLocaleEncoding()));
295
         case .:
296
             return new FixnumNode(token.getPosition(), token.getPosition().getStartLine()+1);
297
         case .:
298
             return new EncodingNode(token.getPosition(), .getEncoding());
299
         case .:
300
             return .declare(token.getPosition(), (String) token.getValue());
301
         case .:
302
             return new ConstNode(token.getPosition(), (String) token.getValue());
303
         case .:
304
             return new InstVarNode(token.getPosition(), (String) token.getValue());
305
         case .:
306
             return new ClassVarNode(token.getPosition(), (String) token.getValue());
307
         case .:
308
             return new GlobalVarNode(token.getPosition(), (String) token.getValue());
309
         }
310
 
311
         getterIdentifierError(token.getPosition(), (String) token.getValue());
312
         return null;
313
     }
314
     
315
     protected void getterIdentifierError(ISourcePosition position, String identifier) {
316
         throw new SyntaxException(., position, .getCurrentLine(),
317
                 "identifier " + identifier + " is not valid", identifier);
318
     }
319
     
320
     public AssignableNode assignable(Token lhs, Node value) {
321
         checkExpression(value);
322
 
323
         switch (lhs.getType()) {
324
             case .:
325
                 throw new SyntaxException(., lhs.getPosition(),
326
                         .getCurrentLine(), "Can't change the value of self");
327
             case .:
328
                 throw new SyntaxException(., lhs.getPosition(),
329
                         .getCurrentLine(), "Can't assign to nil", "nil");
330
             case .:
331
                 throw new SyntaxException(., lhs.getPosition(),
332
                         .getCurrentLine(), "Can't assign to true", "true");
333
             case .:
334
                 throw new SyntaxException(., lhs.getPosition(),
335
                         .getCurrentLine(), "Can't assign to false", "false");
336
             case .:
337
                 throw new SyntaxException(., lhs.getPosition(),
338
                         .getCurrentLine(), "Can't assign to __FILE__", "__FILE__");
339
             case .:
340
                 throw new SyntaxException(., lhs.getPosition(),
341
                         .getCurrentLine(), "Can't assign to __LINE__", "__LINE__");
342
             case .:
343
                 return .assign(lhs.getPosition(), (String) lhs.getValue(), makeNullNil(value));
344
             case .:
345
                 if (isInDef() || isInSingle()) {
346
                     throw new SyntaxException(., lhs.getPosition(),
347
                             .getCurrentLine(), "dynamic constant assignment");
348
                 }
349
                 return new ConstDeclNode(lhs.getPosition(), (String) lhs.getValue(), null, value);
350
             case .:
351
                 return new InstAsgnNode(lhs.getPosition(), (String) lhs.getValue(), value);
352
             case .:
353
                 if (isInDef() || isInSingle()) {
354
                     return new ClassVarAsgnNode(lhs.getPosition(), (String) lhs.getValue(), value);
355
                 }
356
                 return new ClassVarDeclNode(lhs.getPosition(), (String) lhs.getValue(), value);
357
             case .:
358
                 return new GlobalAsgnNode(lhs.getPosition(), (String) lhs.getValue(), value);
359
         }
360
 
361
         throw new SyntaxException(., lhs.getPosition(), .getCurrentLine(),
362
                 "identifier " + (String) lhs.getValue() + " is not valid", lhs.getValue());
363
     }

    
Wraps node with NEWLINE node.

Parameters:
node
Returns:
a NewlineNode or null if node is null.
370
 
371
     public Node newline_node(Node node, ISourcePosition position) {
372
         if (node == null) return null;
373
 
374
         .coverLine(position.getStartLine());
375
         
376
         return node instanceof NewlineNode ? node : new NewlineNode(position, node); 
377
     }
378
     
379
     public Node addRootNode(Node topOfAST, ISourcePosition position) {
380
         position = topOfAST != null ? topOfAST.getPosition() : position;
381
 
382
         if (.getBeginNodes().isEmpty()) {
383
             if (topOfAST == null) topOfAST = .;
384
             
385
             return new RootNode(position, .getScope(), topOfAST);
386
         }
387
         
388
         BlockNode newTopOfAST = new BlockNode(position);
389
         for (Node beginNode: .getBeginNodes()) {
390
             appendToBlock(newTopOfAST, beginNode);
391
         }
392
         
393
         // Add real top to new top (unless this top is empty [only begin/end nodes or truly empty])
394
         if (topOfAST != null) newTopOfAST.add(topOfAST);
395
         
396
         return new RootNode(position, .getScope(), newTopOfAST);
397
     }
398
     
399
     /* MRI: block_append */
400
     public Node appendToBlock(Node head, Node tail) {
401
         if (tail == null) return head;
402
         if (head == null) return tail;
403
 
404
         // Reduces overhead in interp by not set position every single line we encounter. 
405
         if (!.hasExtraPositionInformation()) {
406
             head = compactNewlines(head);
407
         }
408
 
409
         if (!(head instanceof BlockNode)) {
410
             head = new BlockNode(head.getPosition()).add(head);
411
         }
412
 
413
         if (.isVerbose() && isBreakStatement(((ListNode) head).getLast())) {
414
             .warning(., tail.getPosition(), "Statement not reached.");
415
         }
416
 
417
         // Assumption: tail is never a list node
418
         ((ListNode) head).addAll(tail);
419
         return head;
420
     }
421
 
422
     public Node getOperatorCallNode(Node firstNode, String operator) {
423
         checkExpression(firstNode);
424
 
425
         return new CallNoArgNode(firstNode.getPosition(), firstNode, operator);
426
     }
427
     
428
     public Node getOperatorCallNode(Node firstNode, String operator, Node secondNode) {
429
         return getOperatorCallNode(firstNode, operator, secondNode, null);
430
     }
431
 
432
     public Node getOperatorCallNode(Node firstNode, String operator, Node secondNode, ISourcePosition defaultPosition) {
433
         if (defaultPosition != null) {
434
             firstNode = checkForNilNode(firstNode, defaultPosition);
435
             secondNode = checkForNilNode(secondNode, defaultPosition);
436
         }
437
         
438
         checkExpression(firstNode);
439
         checkExpression(secondNode);
440
 
441
         return new_call_one_arg(firstNode.getPosition(), firstNode, operator, secondNode);
442
 //        return new CallOneArgNode(firstNode.getPosition(), firstNode, operator, new ArrayNode(secondNode.getPosition(), secondNode));
443
     }
444
 
445
     public Node getMatchNode(Node firstNode, Node secondNode) {
446
         if (firstNode instanceof DRegexpNode || firstNode instanceof RegexpNode) {
447
             return new Match2Node(firstNode.getPosition(), firstNode, secondNode);
448
         } else if (secondNode instanceof DRegexpNode || secondNode instanceof RegexpNode) {
449
             return new Match3Node(firstNode.getPosition(), secondNode, firstNode);
450
         } 
451
 
452
         return getOperatorCallNode(firstNode, "=~", secondNode);
453
     }

    
Define an array set condition so we can return lhs

Parameters:
receiver array being set
index node which should evalute to index of array set
Returns:
an AttrAssignNode
461
 
462
     public Node aryset(Node receiver, Node index) {
463
         checkExpression(receiver);
464
 
465
         return new_attrassign(receiver.getPosition(), receiver, "[]=", index);
466
     }

    
Define an attribute set condition so we can return lhs

Parameters:
receiver object which contains attribute
name of the attribute being set
Returns:
an AttrAssignNode
474
 
475
     public Node attrset(Node receiver, String name) {
476
         checkExpression(receiver);
477
 
478
         return new_attrassign(receiver.getPosition(), receiver, name + "=", null);
479
     }
480
 
481
     public void backrefAssignError(Node node) {
482
         if (node instanceof NthRefNode) {
483
             String varName = "$" + ((NthRefNode) node).getMatchNumber();
484
             throw new SyntaxException(., node.getPosition(), 
485
                     "Can't set variable " + varName + '.', varName);
486
         } else if (node instanceof BackRefNode) {
487
             String varName = "$" + ((BackRefNode) node).getType();
488
             throw new SyntaxException(., node.getPosition(), "Can't set variable " + varName + '.', varName);
489
         }
490
     }
491
 
492
     public Node arg_add(ISourcePosition position, Node node1, Node node2) {
493
         if (node1 == null) {
494
             if (node2 == null) {
495
                 return new ArrayNode(position, .);
496
             } else {
497
                 return new ArrayNode(node2.getPosition(), node2);
498
             }
499
         }
500
         if (node1 instanceof ArrayNode) return ((ArrayNode) node1).add(node2);
501
         
502
         return new ArgsPushNode(position, node1, node2);
503
     }
    

Fixme:
position
507
 
508
     public Node node_assign(Node lhs, Node rhs) {
509
         if (lhs == null) return null;
510
 
511
         Node newNode = lhs;
512
 
513
         checkExpression(rhs);
514
         if (lhs instanceof AssignableNode) {
515
     	    ((AssignableNode) lhs).setValueNode(rhs);
516
         } else if (lhs instanceof IArgumentNode) {
517
             IArgumentNode invokableNode = (IArgumentNode) lhs;
518
             
519
             return invokableNode.setArgsNode(arg_add(lhs.getPosition(), invokableNode.getArgsNode(), rhs));
520
         }
521
         
522
         return newNode;
523
     }
524
     
525
     public Node ret_args(Node node, ISourcePosition position) {
526
         if (node != null) {
527
             if (node instanceof BlockPassNode) {
528
                 throw new SyntaxException(., position,
529
                         .getCurrentLine(), "Dynamic constant assignment.");
530
             } else if (node instanceof ArrayNode && ((ArrayNode)node).size() == 1) {
531
                 node = ((ArrayNode)node).get(0);
532
             } else if (node instanceof SplatNode) {
533
                 node = newSValueNode(position, node);
534
             }
535
         }
536
         
537
         return node;
538
     }

    
Is the supplied node a break/control statement?

Parameters:
node to be checked
Returns:
true if a control node, false otherwise
545
 
546
     public boolean isBreakStatement(Node node) {
547
         breakLoop: do {
548
             if (node == null) return false;
549
 
550
             switch (node.getNodeType()) {
551
             case :
552
                 node = ((NewlineNode) node).getNextNode();
553
                 continue breakLoop;
554
             case : case : case :
555
             case : case :
556
                 return true;
557
             default:
558
                 return false;
559
             }
560
         } while (true);                    
561
     }
562
     
563
     public void warnUnlessEOption(ID id, Node node, String message) {
564
         if (!.isInlineSource()) {
565
             .warn(id, node.getPosition(), message);
566
         }
567
     }
568
 
569
     public void warningUnlessEOption(ID id, Node node, String message) {
570
         if (.isVerbose() && !.isInlineSource()) {
571
             .warning(id, node.getPosition(), message);
572
         }
573
     }
574
 
575
     private Node compactNewlines(Node head) {
576
         while (head instanceof NewlineNode) {
577
             Node nextNode = ((NewlineNode) head).getNextNode();
578
 
579
             if (!(nextNode instanceof NewlineNode)) {
580
                 break;
581
             }
582
             head = nextNode;
583
         }
584
         return head;
585
     }
586
 
587
     // logical equivalent to value_expr in MRI
588
     public boolean checkExpression(Node node) {
589
         boolean conditional = false;
590
 
591
         while (node != null) {
592
             switch (node.getNodeType()) {
593
             case : case :
594
                 .warning(., node.getPosition(),
595
                         "void value expression");
596
                 return false;
597
             case : case : case : case :
598
             case :
599
                 if (!conditional) {
600
                     throw new SyntaxException(.,
601
                             node.getPosition(), .getCurrentLine(),
602
                             "void value expression");
603
                 }
604
                 return false;
605
             case :
606
                 node = ((BlockNode) node).getLast();
607
                 break;
608
             case :
609
                 node = ((BeginNode) node).getBodyNode();
610
                 break;
611
             case :
612
                 if (!checkExpression(((IfNode) node).getThenBody())) return false;
613
                 node = ((IfNode) node).getElseBody();
614
                 break;
615
             case : case :
616
                 conditional = true;
617
                 node = ((BinaryOperatorNode) node).getSecondNode();
618
                 break;
619
             case :
620
                 node = ((NewlineNode) node).getNextNode();
621
                 break;
622
             default: // Node
623
                 return true;
624
             }
625
         }
626
 
627
         return true;
628
     }
    
    
Is this a literal in the sense that MRI has a NODE_LIT for. This is different than ILiteralNode. We should pick a different name since ILiteralNode is something we created which is similiar but used for a slightly different condition (can I do singleton things).

Parameters:
node to be tested
Returns:
true if it is a literal
637
 
638
     public boolean isLiteral(Node node) {
639
         return node != null && (node instanceof FixnumNode || node instanceof BignumNode || 
640
                 node instanceof FloatNode || node instanceof SymbolNode || 
641
                 (node instanceof RegexpNode && ((RegexpNode) node).getOptions().toJoniOptions() == 0));
642
     }
643
 
644
     private void handleUselessWarn(Node node, String useless) {
645
         .warn(., node.getPosition(), "Useless use of " + useless + " in void context.");
646
     }

    
Check to see if current node is an useless statement. If useless a warning if printed.

Parameters:
node to be checked.
652
 
653
     public void checkUselessStatement(Node node) {
654
         if (!.isVerbose() || (!.isInlineSource() && .isEvalParse())) return;
655
         
656
         uselessLoop: do {
657
             if (node == null) return;
658
             
659
             switch (node.getNodeType()) {
660
             case :
661
                 node = ((NewlineNode) node).getNextNode();
662
                 continue uselessLoop;
663
             case : {
664
                 String name = ((CallNode) node).getName();
665
                 
666
                 if (name == "+" || name == "-" || name == "*" || name == "/" || name == "%" || 
667
                     name == "**" || name == "+@" || name == "-@" || name == "|" || name == "^" || 
668
                     name == "&" || name == "<=>" || name == ">" || name == ">=" || name == "<" || 
669
                     name == "<=" || name == "==" || name == "!=") {
670
                     handleUselessWarn(node, name);
671
                 }
672
                 return;
673
             }
674
             case : case : case :
675
             case : case : case :
676
             case :
677
                 handleUselessWarn(node, "a variable"); return;
678
             // FIXME: Temporarily disabling because this fires way too much running Rails tests. JRUBY-518
679
             /*case CONSTNODE:
680
                 handleUselessWarn(node, "a constant"); return;*/
681
             case : case : case : case :
682
             case : case : case :
683
             case : case :
684
                 handleUselessWarn(node, "a literal"); return;
685
             // FIXME: Temporarily disabling because this fires way too much running Rails tests. JRUBY-518
686
             /*case CLASSNODE: case COLON2NODE:
687
                 handleUselessWarn(node, "::"); return;*/
688
             case :
689
                 handleUselessWarn(node, ((DotNode) node).isExclusive() ? "..." : ".."); return;
690
             case :
691
                 handleUselessWarn(node, "defined?"); return;
692
             case :
693
                 handleUselessWarn(node, "false"); return;
694
             case : 
695
                 handleUselessWarn(node, "nil"); return;
696
             // FIXME: Temporarily disabling because this fires way too much running Rails tests. JRUBY-518
697
             /*case SELFNODE:
698
                 handleUselessWarn(node, "self"); return;*/
699
             case :
700
                 handleUselessWarn(node, "true"); return;
701
             default: return;
702
             }
703
         } while (true);
704
     }

    
Check all nodes but the last one in a BlockNode for useless (void context) statements.

Parameters:
blockNode to be checked.
710
 
711
     public void checkUselessStatements(BlockNode blockNode) {
712
         if (.isVerbose()) {
713
             Node lastNode = blockNode.getLast();
714
 
715
             for (int i = 0; i < blockNode.size(); i++) {
716
                 Node currentNode = blockNode.get(i);
717
         		
718
                 if (lastNode != currentNode ) {
719
                     checkUselessStatement(currentNode);
720
                 }
721
             }
722
         }
723
     }
assign_in_cond 
727
 
728
     private boolean checkAssignmentInCondition(Node node) {
729
         if (node instanceof MultipleAsgnNode) {
730
             throw new SyntaxException(., node.getPosition(),
731
                     .getCurrentLine(), "Multiple assignment in conditional.");
732
         } else if (node instanceof LocalAsgnNode || node instanceof DAsgnNode || node instanceof GlobalAsgnNode || node instanceof InstAsgnNode) {
733
             Node valueNode = ((AssignableNode) node).getValueNode();
734
             if (valueNode instanceof ILiteralNode || valueNode instanceof NilNode || valueNode instanceof TrueNode || valueNode instanceof FalseNode) {
735
                 .warn(., node.getPosition(), "Found '=' in conditional, should be '=='.");
736
             }
737
             return true;
738
         } 
739
 
740
         return false;
741
     }
742
     
743
     protected Node makeNullNil(Node node) {
744
         return node == null ? . : node;
745
     }
746
 
747
     private Node cond0(Node node) {
748
         checkAssignmentInCondition(node);
749
         
750
         Node leftNode = null;
751
         Node rightNode = null;
752
 
753
         // FIXME: DSTR,EVSTR,STR: warning "string literal in condition"
754
         switch(node.getNodeType()) {
755
         case : {
756
             ISourcePosition position = node.getPosition();
757
 
758
             return new Match2Node(position, node, new GlobalVarNode(position, "$_"));
759
         }
760
         case :
761
             leftNode = cond0(((AndNode) node).getFirstNode());
762
             rightNode = cond0(((AndNode) node).getSecondNode());
763
             
764
             return new AndNode(node.getPosition(), makeNullNil(leftNode), makeNullNil(rightNode));
765
         case :
766
             leftNode = cond0(((OrNode) node).getFirstNode());
767
             rightNode = cond0(((OrNode) node).getSecondNode());
768
             
769
             return new OrNode(node.getPosition(), makeNullNil(leftNode), makeNullNil(rightNode));
770
         case : {
771
             DotNode dotNode = (DotNode) node;
772
             if (dotNode.isLiteral()) return node; 
773
             
774
             String label = String.valueOf("FLIP" + node.hashCode());
775
             .getLocalScope().addVariable(label);
776
             int slot = .isDefined(label);
777
             
778
             return new FlipNode(node.getPosition(),
779
                     getFlipConditionNode(((DotNode) node).getBeginNode()),
780
                     getFlipConditionNode(((DotNode) node).getEndNode()),
781
                     dotNode.isExclusive(), slot);
782
         }
783
         case :
784
             warningUnlessEOption(., node, "regex literal in condition");
785
             
786
             return new MatchNode(node.getPosition(), node);
787
         }
788
 
789
         return node;
790
     }
791
 
792
     public Node getConditionNode(Node node) {
793
         if (node == null) return .;
794
 
795
         if (node instanceof NewlineNode) {
796
             return new NewlineNode(node.getPosition(), cond0(((NewlineNode) node).getNextNode()));
797
         } 
798
 
799
         return cond0(node);
800
     }
801
 
802
     /* MRI: range_op */
803
     private Node getFlipConditionNode(Node node) {
804
         if (!.isInlineSource()) return node;
805
         
806
         node = getConditionNode(node);
807
 
808
         if (node instanceof NewlineNode) return ((NewlineNode) node).getNextNode();
809
         
810
         if (node instanceof FixnumNode) {
811
             warnUnlessEOption(., node, "integer literal in conditional range");
812
             return getOperatorCallNode(node, "==", new GlobalVarNode(node.getPosition(), "$."));
813
         } 
814
 
815
         return node;
816
     }
817
 
818
     public SValueNode newSValueNode(ISourcePosition position, Node node) {
819
         return new SValueNode(position, node);
820
     }
821
     
822
     public SplatNode newSplatNode(ISourcePosition position, Node node) {
823
         return new SplatNode(position, makeNullNil(node));
824
     }
825
     
826
     public ArrayNode newArrayNode(ISourcePosition position, Node firstNode) {
827
         return new ArrayNode(position, makeNullNil(firstNode));
828
     }
829
 
831
         return one == null ? two.getPosition() : one.getPosition();
832
     }
833
 
834
     public AndNode newAndNode(ISourcePosition position, Node left, Node right) {
835
         checkExpression(left);
836
         
837
         if (left == null && right == null) return new AndNode(position, makeNullNil(left), makeNullNil(right));
838
         
839
         return new AndNode(position(left, right), makeNullNil(left), makeNullNil(right));
840
     }
841
 
842
     public OrNode newOrNode(ISourcePosition position, Node left, Node right) {
843
         checkExpression(left);
844
 
845
         if (left == null && right == null) return new OrNode(position, makeNullNil(left), makeNullNil(right));
846
         
847
         return new OrNode(position(left, right), makeNullNil(left), makeNullNil(right));
848
     }

    
Ok I admit that this is somewhat ugly. We post-process a chain of when nodes and analyze them to re-insert them back into our new CaseNode the way we want. The grammar is being difficult and until I go back into the depths of that this is where things are.

Parameters:
expression of the case node (e.g. case foo)
firstWhenNode first when (which could also be the else)
Returns:
a new case node
858
 
859
     public CaseNode newCaseNode(ISourcePosition position, Node expression, Node firstWhenNode) {
860
         ArrayNode cases = new ArrayNode(firstWhenNode != null ? firstWhenNode.getPosition() : position);
861
         CaseNode caseNode = new CaseNode(position, expression, cases);
862
 
863
         for (Node current = firstWhenNode; current != null; current = ((WhenNode) current).getNextCase()) {
864
             if (current instanceof WhenOneArgNode) {
865
                 cases.add(current);
866
             } else if (current instanceof WhenNode) {
867
                 simplifyMultipleArgumentWhenNodes((WhenNode) current, cases);
868
             } else {
869
                 caseNode.setElseNode(current);
870
                 break;
871
             }
872
         }
873
 
874
         return caseNode;
875
     }
876
 
877
     /*
878
      * This method exists for us to break up multiple expression when nodes (e.g. when 1,2,3:)
879
      * into individual whenNodes.  The primary reason for this is to ensure lazy evaluation of
880
      * the arguments (when foo,bar,gar:) to prevent side-effects.  In the old code this was done
881
      * using nested when statements, which was awful for interpreter and compilation.
882
      *
883
      * Notes: This has semantic equivalence but will not be lexically equivalent.  Compiler
884
      * needs to detect same bodies to simplify bytecode generated.
885
      */
886
     private void simplifyMultipleArgumentWhenNodes(WhenNode sourceWhen, ArrayNode cases) {
887
         Node expressionNodes = sourceWhen.getExpressionNodes();
888
 
889
         if (expressionNodes instanceof SplatNode || expressionNodes instanceof ArgsCatNode) {
890
             cases.add(sourceWhen);
891
             return;
892
         }
893
 
894
         if (expressionNodes instanceof ListNode) {
895
             ListNode list = (ListNode) expressionNodes;
896
             ISourcePosition position = sourceWhen.getPosition();
897
             Node bodyNode = sourceWhen.getBodyNode();
898
 
899
             for (int i = 0; i < list.size(); i++) {
900
                 Node expression = list.get(i);
901
 
902
                 if (expression instanceof SplatNode || expression instanceof ArgsCatNode) {
903
                     cases.add(new WhenNode(position, expression, bodyNode, null));
904
                 } else {
905
                     cases.add(new WhenOneArgNode(position, expression, bodyNode, null));
906
                 }
907
             }
908
         } else {
909
             cases.add(sourceWhen);
910
         }
911
     }
912
     
913
     public WhenNode newWhenNode(ISourcePosition position, Node expressionNodes, Node bodyNode, Node nextCase) {
914
         if (bodyNode == null) bodyNode = .;
915
 
916
         if (expressionNodes instanceof SplatNode || expressionNodes instanceof ArgsCatNode || expressionNodes instanceof ArgsPushNode) {
917
             return new WhenNode(position, expressionNodes, bodyNode, nextCase);
918
         }
919
 
920
         ListNode list = (ListNode) expressionNodes;
921
 
922
         if (list.size() == 1) {
923
             Node element = list.get(0);
924
             
925
             if (!(element instanceof SplatNode)) {
926
                 return new WhenOneArgNode(position, element, bodyNode, nextCase);
927
             }
928
         }
929
 
930
         return new WhenNode(position, expressionNodes, bodyNode, nextCase);
931
     }
932
 
933
     public Node getReturnArgsNode(Node node) {
934
         if (node instanceof ArrayNode && ((ArrayNode) node).size() == 1) { 
935
             return ((ListNode) node).get(0);
936
         } else if (node instanceof BlockPassNode) {
937
             throw new SyntaxException(., node.getPosition(),
938
                     .getCurrentLine(), "Block argument should not be given.");
939
         }
940
         return node;
941
     }
942
     
943
     public Node new_opElementAsgnNode(ISourcePosition position, Node receiverNode, String operatorName, Node argsNode, Node valueNode) {
944
         if (argsNode instanceof ArrayNode) {
945
             ArrayNode array = (ArrayNode) argsNode;
946
             
947
             if (array.size() == 1) {
948
                 if (operatorName.equals("||")) {
949
                     return new OpElementOneArgOrAsgnNode(position, receiverNode, operatorName, array, valueNode);
950
                 } else if (operatorName.equals("&&")) {
951
                     return new OpElementOneArgAndAsgnNode(position, receiverNode, operatorName, array, valueNode);                    
952
                 } else {
953
                     return new OpElementOneArgAsgnNode(position, receiverNode, operatorName, array, valueNode);
954
                 }
955
             }
956
         }
957
         return new OpElementAsgnNode(position, receiverNode, operatorName, argsNode, valueNode);
958
     }
959
     
960
     public Node new_attrassign(ISourcePosition position, Node receiver, String name, Node args) {
961
         if (!(args instanceof ArrayNode)) return new AttrAssignNode(position, receiver, name, args);
962
         
963
         ArrayNode argsNode = (ArrayNode) args;
964
         
965
         switch (argsNode.size()) {
966
             case 1:
967
                 return new AttrAssignOneArgNode(position, receiver, name, argsNode);
968
             case 2:
969
                 return new AttrAssignTwoArgNode(position, receiver, name, argsNode);
970
             case 3:
971
                 return new AttrAssignThreeArgNode(position, receiver, name, argsNode);
972
             default:
973
                 return new AttrAssignNode(position, receiver, name, argsNode);
974
         }
975
     }
976
     
977
     private Node new_call_noargs(Node receiver, Token name, IterNode iter) {
978
         ISourcePosition position = position(receiver, name);
979
         
980
         if (receiver == null) receiver = .;
981
         
982
         if (iter != null) return new CallNoArgBlockNode(position, receiver, (String) name.getValue(), iter);
983
         
984
         return new CallNoArgNode(position, receiver, (String) name.getValue());
985
     }
986
     
987
     private Node new_call_complexargs(Node receiver, Token name, Node args, Node iter) {
988
         if (args instanceof BlockPassNode) {
989
             // Block and block pass passed in at same time....uh oh
990
             if (iter != null) {
991
                 throw new SyntaxException(., iter.getPosition(),
992
                         .getCurrentLine(), "Both block arg and actual block given.");
993
             }
994
 
995
             return new_call_blockpass(receiver, name, (BlockPassNode) args);
996
         }
997
 
998
         if (iter != null) return new CallSpecialArgBlockNode(position(receiver, args), receiver,(String) name.getValue(), args, (IterNode) iter);
999
 
1000
        return new CallSpecialArgNode(position(receiver, args), receiver, (String) name.getValue(), args);
1001
    }
1002
    
1003
    private Node new_call_blockpass(Node receiver, Token operation, BlockPassNode blockPass) {
1004
        ISourcePosition position = position(receiver, blockPass);
1005
        String name = (String) operation.getValue();
1006
        Node args = blockPass.getArgsNode();
1007
        
1008
        if (args == null) return new CallNoArgBlockPassNode(position, receiver, name, args, blockPass);
1009
        if (!(args instanceof ArrayNode)) return new CallSpecialArgBlockPassNode(position, receiver, name, args, blockPass);
1010
        
1011
        switch (((ArrayNode) args).size()) {
1012
            case 0:  // foo()
1013
                return new CallNoArgBlockPassNode(position, receiver, name, args, blockPass);
1014
            case 1:
1015
                return new CallOneArgBlockPassNode(position, receiver, name, (ArrayNode) args, blockPass);
1016
            case 2:
1017
                return new CallTwoArgBlockPassNode(position, receiver, name, (ArrayNode) args, blockPass);
1018
            case 3:
1019
                return new CallThreeArgBlockPassNode(position, receiver, name, (ArrayNode) args, blockPass);
1020
            default:
1021
                return new CallManyArgsBlockPassNode(position, receiver, name, args, blockPass);
1022
        } 
1023
    }
1024
    
1025
    private boolean isNumericOperator(String name) {
1026
        if (name.length() == 1) {
1027
            switch (name.charAt(0)) {
1028
                case '+': case '-': case '*': case '/': case '<': case '>':
1029
                    return true;
1030
            }
1031
        } else if (name.length() == 2) {
1032
            switch (name.charAt(0)) {
1033
            case '<': case '>': case '=':
1034
                switch (name.charAt(1)) {
1035
                case '=': case '<':
1036
                    return true;
1037
                }
1038
            }
1039
        }