Пример #1
0
  /**
   * Determine the operator that will be used with this operator node. The method gets the operand
   * types of this node and determines the operator, that will need the least implicit type casts
   * using the operands' types (this is done via {@link Operator#getNearest(int, TypeNode[])}). If
   * no such operator is found, an error message is reported.
   *
   * @return The proper operator for this node, <code>null</code> otherwise.
   */
  private OperatorSignature computeOperator() {
    OperatorSignature operator = null;
    int n = children.size();
    TypeNode[] argTypes = new TypeNode[n];

    for (int i = 0; i < n; i++) {
      ExprNode op = children.get(i);
      TypeNode type = op.getType();
      if (type instanceof NodeTypeNode || type instanceof EdgeTypeNode)
        type = OperatorSignature.TYPE;
      if (type instanceof ExternalTypeNode && argTypes.length < 3) // keep real ext type for cond
      type = OperatorSignature.TYPE;
      if (type instanceof ByteTypeNode || type instanceof ShortTypeNode)
        if (n < 3) type = BasicTypeNode.intType;
      argTypes[i] = type;
    }

    operator = OperatorSignature.getNearest(opId, argTypes);
    if (!operator.isValid()) {
      StringBuffer params = new StringBuffer();
      boolean errorReported = false;

      params.append('(');
      for (int i = 0; i < n; i++) {
        if (argTypes[i].isEqual(BasicTypeNode.errorType)) {
          errorReported = true;
        } else {
          params.append((i > 0 ? ", " : "") + argTypes[i].toString());
        }
      }
      params.append(')');

      if (!errorReported) {
        reportError("No such operator " + OperatorSignature.getName(opId) + params);
      }
    } else {
      // Insert implicit type casts for the arguments that need them.
      TypeNode[] opTypes = operator.getOperandTypes();
      assert (opTypes.length == argTypes.length);
      for (int i = 0; i < argTypes.length; i++) {
        if (!argTypes[i].isEqual(opTypes[i])) {
          ExprNode child = children.get(i);
          ExprNode adjusted = child.adjustType(opTypes[i]);
          becomeParent(adjusted);
          children.set(i, adjusted);
        }
      }
    }

    return operator;
  }
Пример #2
0
  /** @see de.unika.ipd.grgen.ast.BaseNode#checkLocal() */
  @Override
  protected boolean checkLocal() {
    boolean res = true;
    TypeNode type = getType();
    int arity = OperatorSignature.getArity(opId);

    if (children.size() != arity) {
      reportError("Wrong operator arity: " + children.size());
      res = false;
    }

    // Here the error must have been already reported
    if (type.isEqual(BasicTypeNode.errorType)) res = false;

    return res;
  }