public boolean endvisit(TypeDeclaration type) throws Exception {
    if (type instanceof NamespaceDeclaration) {
      NamespaceDeclaration namespaceDecl = (NamespaceDeclaration) type;
      while (deferredNamespacedDeclarations != null && !deferredNamespacedDeclarations.isEmpty()) {
        final ASTNode[] declarations =
            deferredNamespacedDeclarations.toArray(
                new ASTNode[deferredNamespacedDeclarations.size()]);
        deferredNamespacedDeclarations.clear();

        for (ASTNode deferred : declarations) {
          deferred.traverse(this);
        }
      }
      fLastNamespace = null; // there are no nested namespaces
      if (namespaceDecl.isGlobal()) {
        return true;
      }
    }

    declarations.pop();

    // resolve more type member declarations
    resolveMagicMembers(type);

    for (PHPSourceElementRequestorExtension visitor : extensions) {
      visitor.endvisit(type);
    }

    return super.endvisit(type);
  }
Exemplo n.º 2
0
  public boolean endvisit(TypeDeclaration type) throws Exception {
    if (type instanceof NamespaceDeclaration) {
      NamespaceDeclaration namespaceDecl = (NamespaceDeclaration) type;
      while (deferredNamespacedDeclarations != null && !deferredNamespacedDeclarations.isEmpty()) {
        final ASTNode[] declarations =
            deferredNamespacedDeclarations.toArray(
                new ASTNode[deferredNamespacedDeclarations.size()]);
        deferredNamespacedDeclarations.clear();

        for (ASTNode deferred : declarations) {
          deferred.traverse(this);
        }
      }

      fCurrentNamespace = null; // there are no nested namespaces
      fCurrentQualifier = null;
      fLastUseParts.clear();
      if (namespaceDecl.isGlobal()) {
        return visitGeneral(type);
      }
    } else {
      fCurrentParent = null;
    }
    declarations.pop();

    // resolve more type member declarations
    resolveMagicMembers(type);

    for (PhpIndexingVisitorExtension visitor : extensions) {
      visitor.endvisit(type);
    }

    endvisitGeneral(type);
    return true;
  }
Exemplo n.º 3
0
 private void parseIf(IfContext context, IfStatement ifStatement) throws IfStatementError {
   ifStatement.acceptCondition(parseCondition(context));
   if (context.isEOF()) {
     throw new IfStatementError(
         Messages.TclIfProcessor_missingThenBlock, context.start(), context.end());
   }
   if (checkKeyword(context, THEN)) {
     if (context.isEOF()) {
       throw new IfStatementError(
           Messages.TclIfProcessor_missingThenBlock, context.start(), context.end());
     }
   }
   ifStatement.acceptThen(parseBranch(context, true, Messages.TclIfProcessor_incorrectThenBlock));
   if (!context.isEOF()) {
     if (checkKeyword(context, ELSEIF)) {
       final ASTNode elseIfKeyword = context.get(context.index - 1);
       final IfStatement nestedIf = new IfStatement(elseIfKeyword.sourceStart(), context.end());
       parseIf(context, nestedIf);
       ifStatement.acceptElse(nestedIf);
     } else {
       if (checkKeyword(context, ELSE)) {
         if (context.isEOF()) {
           throw new IfStatementError(
               Messages.TclIfProcessor_incorrectElse, context.start(), context.end());
         }
       }
       ifStatement.acceptElse(
           parseBranch(context, false, Messages.TclIfProcessor_incorrectElseBlock));
     }
   }
 }
Exemplo n.º 4
0
  protected Map<String, String> createInitialParameters(ASTNode s) throws Exception {
    Map<String, String> parameters = new LinkedHashMap<String, String>();

    // Print offset information:
    parameters.put("start", Integer.toString(s.sourceStart()));
    parameters.put("end", Integer.toString(s.sourceEnd()));

    // Print modifiers:
    if (s instanceof Declaration) {
      Declaration declaration = (Declaration) s;
      StringBuilder buf = new StringBuilder();
      if (declaration.isAbstract()) {
        buf.append(",abstract");
      }
      if (declaration.isFinal()) {
        buf.append(",final");
      }
      if (declaration.isPrivate()) {
        buf.append(",private");
      }
      if (declaration.isProtected()) {
        buf.append(",protected");
      }
      if (declaration.isPublic()) {
        buf.append(",public");
      }
      if (declaration.isStatic()) {
        buf.append(",static");
      }
      String modifiers = buf.toString();
      parameters.put("modifiers", modifiers.length() > 0 ? modifiers.substring(1) : modifiers);
    }

    return parameters;
  }
Exemplo n.º 5
0
 private ASTNode parseCondition(IfContext context) throws IfStatementError {
   if (context.isEOF()) {
     throw new IfStatementError(
         Messages.TclIfProcessor_missingCondition, context.start(), context.end());
   }
   ASTNode node = context.get();
   if (node instanceof TclBlockExpression) {
     TclBlockExpression bl = (TclBlockExpression) node;
     List parseBlock = bl.parseBlockSimple(false);
     ASTListNode list = new ASTListNode(bl.sourceStart() + 1, bl.sourceEnd() - 1);
     for (int j = 0; j < parseBlock.size(); j++) {
       Object st = parseBlock.get(j);
       if (st instanceof TclStatement) {
         List expressions = ((TclStatement) st).getExpressions();
         for (int k = 0; k < expressions.size(); k++) {
           ASTNode expr = (ASTNode) expressions.get(k);
           list.addNode(expr);
         }
       }
     }
     return list;
   } else if (node instanceof SimpleReference) {
     return node;
   } else if (node instanceof TclAdvancedExecuteExpression) {
     TclAdvancedExecuteExpression ex = (TclAdvancedExecuteExpression) node;
     List childs = ex.getChilds();
     return new ASTListNode(node.sourceStart(), node.sourceEnd(), childs);
   } else if (node instanceof TclExecuteExpression) {
     return node;
   } else if (node instanceof Block) {
     return node;
   }
   throw new IfStatementError(Messages.TclIfProcessor_incorrectCondition, node);
 }
Exemplo n.º 6
0
 private void selectionOnVariable(ModuleDeclaration parsedUnit, VariableReference e) {
   String name = e.getName();
   if (name.startsWith("@")) { // $NON-NLS-1$
     IField[] fields =
         RubyModelUtils.findFields(mixinModel, sourceModule, parsedUnit, name, e.sourceStart());
     addArrayToCollection(fields, selectionElements);
   } else {
     /*
      * local vars (legacy, saved for speed reasons: we don't need to use
      * mixin model for local vars)
      */
     ASTNode parentScope = null;
     for (int i = wayToNode.length; --i >= 0; ) {
       final ASTNode node = wayToNode[i];
       if (node instanceof MethodDeclaration
           || node instanceof TypeDeclaration
           || node instanceof ModuleDeclaration
           || node instanceof RubyForStatement2) {
         parentScope = node;
         break;
       }
     }
     if (parentScope != null) {
       RubyAssignment[] assignments =
           RubyTypeInferencingUtils.findLocalVariableAssignments(parentScope, e, name);
       if (assignments.length > 0) {
         final ASTNode left = assignments[0].getLeft();
         selectionElements.add(createLocalVariable(name, left.sourceStart(), left.sourceEnd()));
       } else {
         selectionElements.add(createLocalVariable(name, e.sourceStart(), e.sourceEnd()));
       }
     }
   }
 }
Exemplo n.º 7
0
 /**
  * Tests if the specified node is located at the same location.
  *
  * @param other
  * @return
  */
 public boolean locationMatches(ASTNode other) {
   if (other == this) return true;
   if (other == null) {
     return false;
   }
   return other.sourceEnd() >= 0
       && other.sourceStart() >= 0
       && sourceStart() == other.sourceStart()
       && sourceEnd() == other.sourceEnd();
 }
Exemplo n.º 8
0
  private Statement parseBranch(IfContext context, boolean wrapAsBlock, String message)
      throws IfStatementError {
    final ASTNode node = context.get();
    if (node instanceof TclBlockExpression) {
      final Block block = new Block(node.sourceStart(), node.sourceEnd());
      parseBlock(context.parser, block, (TclBlockExpression) node);
      return block;
    } else if (node instanceof SimpleReference) {
      final Block block = new Block(node.sourceStart(), node.sourceEnd());
      block.addStatement(node);
      return block;
    } else if (node instanceof TclStatement) {
      if (wrapAsBlock) {
        final Block block = new Block(node.sourceStart(), node.sourceEnd());
        block.addStatement(node);
        return block;
      } else {
        return (TclStatement) node;
      }
    } else if (node instanceof TclExecuteExpression) {
      if (wrapAsBlock) {
        final Block block = new Block(node.sourceStart(), node.sourceEnd());
        block.addStatement(node);
        return block;
      } else {
        return (TclExecuteExpression) node;
      }

    } else if (node instanceof Block) {
      return (Block) node;
    } else {
      throw new IfStatementError(message, context.start(), context.end());
    }
  }
Exemplo n.º 9
0
 public CompletionOnVariable(
     String completionToken,
     ASTNode completionNode,
     ASTNode node,
     ASTNode inNode,
     boolean canHandleEmpty) {
   super(completionNode.sourceStart(), completionNode.sourceEnd(), completionToken);
   this.parentNode = node;
   this.completionNode = completionNode;
   this.inNode = inNode;
   this.canHandleEmpty = canHandleEmpty;
 }
Exemplo n.º 10
0
 private boolean isStringLiteralNeeded(ASTNode node) {
   if (stack.empty()) {
     return true;
   }
   final ASTNode top = stack.peek();
   if (top instanceof RubyDRegexpExpression) {
     return false;
   }
   if (top instanceof RubyDynamicStringExpression) {
     return node.sourceStart() >= top.sourceStart() && node.sourceEnd() <= top.sourceEnd();
   }
   return true;
 }
Exemplo n.º 11
0
 private void handleEvaluatableExpression(ASTNode node) {
   int start = node.sourceStart();
   int end = node.sourceEnd();
   if (content[start] == '#' && content[start + 1] == '{') {
     if (content[end - 1] == '\r') {
       // FIXME JRuby bug
       --end;
     }
     if (content[end - 1] == '}') {
       requestor.addPosition(start, start + 2, HL_EVAL_EXPR);
       requestor.addPosition(end - 1, end - 0, HL_EVAL_EXPR);
     }
   }
 }
  public boolean endvisit(ModuleDeclaration declaration) throws Exception {
    for (PHPSourceElementRequestorExtension visitor : extensions) {
      visitor.endvisit(declaration);
    }

    while (deferredDeclarations != null && !deferredDeclarations.isEmpty()) {
      final ASTNode[] declarations =
          deferredDeclarations.toArray(new ASTNode[deferredDeclarations.size()]);
      deferredDeclarations.clear();

      for (ASTNode deferred : declarations) {
        deferred.traverse(this);
      }
    }
    fLastUseParts.clear();
    return super.endvisit(declaration);
  }
  @Override
  public boolean visitGeneral(ASTNode node) throws Exception {
    if (node instanceof org.eclipse.dltk.ast.statements.Block) {
      node.traverse(new TwigIndexingVisitor(requestor, sourceModule));
    }

    return super.visitGeneral(node);
  }
Exemplo n.º 14
0
  public boolean endvisit(ModuleDeclaration declaration) throws Exception {
    while (deferredDeclarations != null && !deferredDeclarations.isEmpty()) {
      final ASTNode[] declarations =
          deferredDeclarations.toArray(new ASTNode[deferredDeclarations.size()]);
      deferredDeclarations.clear();

      for (ASTNode deferred : declarations) {
        deferred.traverse(this);
      }
    }

    for (PhpIndexingVisitorExtension visitor : extensions) {
      visitor.endvisit(declaration);
    }

    fLastUseParts.clear();
    endvisitGeneral(declaration);
    return true;
  }
Exemplo n.º 15
0
  public static String toXMLString(ASTNode node) {
    try {
      ByteArrayOutputStream out = new ByteArrayOutputStream();
      ASTPrintVisitor printVisitor = new ASTPrintVisitor(out);
      node.traverse(printVisitor);
      printVisitor.close();
      return out.toString("UTF-8");

    } catch (Exception e) {
      return e.toString();
    }
  }
Exemplo n.º 16
0
 private void handleRegexp(ASTNode node) {
   int start = node.sourceStart();
   int end = node.sourceEnd();
   if (start >= 1 && content[start - 1] == '/') {
     --start;
     if (end < content.length && content[end] == '/') {
       ++end;
     }
     while (end < content.length && RubySyntaxUtils.isValidRegexpModifier(content[end])) {
       ++end;
     }
   } else if (start >= 3 && content[start - 3] == '%' && content[start - 2] == 'r') {
     char terminator = RubySyntaxUtils.getPercentStringTerminator(content[start - 1]);
     if (terminator != 0 && end < content.length && content[end] == terminator) {
       start -= 3;
       ++end;
       while (end < content.length && RubySyntaxUtils.isValidRegexpModifier(content[end])) {
         ++end;
       }
     }
   }
   requestor.addPosition(start, end, HL_REGEXP);
 }
Exemplo n.º 17
0
 public ASTNode process(TclStatement statement, ITclParser parser, ASTNode parent) {
   final IfContext context = new IfContext(parser, statement);
   IfStatement ifStatement = new IfStatement(context.start(), context.end());
   addToParent(parent, ifStatement);
   try {
     parseIf(context, ifStatement);
     if (!context.isEOF()) {
       final ASTNode extraBegin = context.get(context.index);
       final ASTNode extraEnd = context.get(context.size() - 1);
       report(
           parser,
           Messages.TclIfProcessor_unexpectedStatements,
           extraBegin.sourceStart(),
           extraEnd.sourceEnd(),
           ProblemSeverities.Error);
     }
   } catch (IfStatementError e) {
     // if (DLTKCore.DEBUG) {
     // e.printStackTrace();
     // }
     report(parser, e.getMessage(), e.start, e.end, ProblemSeverities.Error);
   }
   return ifStatement;
 }
 public boolean visitGeneral(ASTNode e) throws Exception {
   return e.sourceStart() <= offset || variableName != null;
 }
Exemplo n.º 19
0
 /**
  * @param message
  * @param node
  */
 public IfStatementError(String message, ASTNode node) {
   this(message, node.sourceStart(), node.sourceEnd());
 }
Exemplo n.º 20
0
 @Override
 public boolean visitGeneral(ASTNode node) throws Exception {
   if (!ACTIVE) {
     return true;
   }
   if (node instanceof RubyRegexpExpression || node instanceof RubyDRegexpExpression) {
     handleRegexp(node);
   } else if (node instanceof RubySymbolReference) {
     requestor.addPosition(node.sourceStart(), node.sourceEnd(), HL_SYMBOL);
   } else if (node instanceof VariableReference) {
     handleVariableReference((VariableReference) node);
   } else if (node instanceof RubyDVarExpression) {
     requestor.addPosition(node.sourceStart(), node.sourceEnd(), HL_LOCAL_VARIABLE);
   } else if (node instanceof RubyDAssgnExpression) {
     ASTNode var = ((RubyDAssgnExpression) node).getLeft();
     requestor.addPosition(var.sourceStart(), var.sourceEnd(), HL_LOCAL_VARIABLE);
   } else if (node instanceof StringLiteral) {
     if (isStringLiteralNeeded(node)) {
       requestor.addPosition(node.sourceStart(), node.sourceEnd(), HL_STRING);
     }
   } else if (node instanceof NumericLiteral
       || node instanceof FloatNumericLiteral
       || node instanceof BigNumericLiteral) {
     requestor.addPosition(node.sourceStart(), node.sourceEnd(), HL_NUMBER);
   } else if (node instanceof RubyEvaluatableStringExpression) {
     handleEvaluatableExpression(node);
   } else if (node instanceof CallExpression) {
     final CallExpression call = (CallExpression) node;
     if (!(RubySyntaxUtils.isRubyOperator(call.getName())
         || call.getReceiver() == null && RubyCodeScanner.isPseudoKeyword(call.getName()))) {
       final SimpleReference callName = call.getCallName();
       if (callName.sourceStart() >= 0 && callName.sourceEnd() > callName.sourceStart()) {
         requestor.addPosition(callName.sourceStart(), callName.sourceEnd(), HL_DEFAULT);
       }
     }
   } else if (node instanceof Declaration) {
     final Declaration declaration = (Declaration) node;
     requestor.addPosition(declaration.getNameStart(), declaration.getNameEnd(), HL_DEFAULT);
   } else if (node instanceof RubyConstantDeclaration) {
     final RubyConstantDeclaration declaration = (RubyConstantDeclaration) node;
     final SimpleReference name = declaration.getName();
     requestor.addPosition(name.sourceStart(), name.sourceEnd(), HL_CONST);
   }
   stack.push(node);
   return true;
 }