예제 #1
0
  @Override
  public SStmCG caseAStartStm(AStartStm node, IRInfo question) throws AnalysisException {
    PType type = node.getType();
    PExp exp = node.getObj();

    if (exp.getType() instanceof ASetType) {

      STypeCG typeCG = type.apply(question.getTypeVisitor(), question);
      SExpCG expCG = exp.apply(question.getExpVisitor(), question);

      AStartlistStmCG s = new AStartlistStmCG();
      s.setType(typeCG);
      s.setExp(expCG);

      return s;
    } else {
      STypeCG typeCG = type.apply(question.getTypeVisitor(), question);
      SExpCG expCG = exp.apply(question.getExpVisitor(), question);

      AStartStmCG thread = new AStartStmCG();
      thread.setType(typeCG);
      thread.setExp(expCG);

      return thread;
    }
  }
예제 #2
0
  // FIXME used in a single class. move it there
  public ValueList getAllValues(List<PType> linkedList, Context ctxt) throws AnalysisException {
    QuantifierList quantifiers = new QuantifierList();
    int n = 0;

    for (PType t : linkedList) {
      LexNameToken name = new LexNameToken("#", String.valueOf(n), t.getLocation());
      PPattern p = AstFactory.newAIdentifierPattern(name);
      Quantifier q = new Quantifier(p, af.createPTypeAssistant().getAllValues(t, ctxt));
      quantifiers.add(q);
    }

    quantifiers.init(ctxt, true);
    ValueList results = new ValueList();

    while (quantifiers.hasNext()) {
      NameValuePairList nvpl = quantifiers.next();
      ValueList list = new ValueList();

      for (NameValuePair nvp : nvpl) {
        list.add(nvp.value);
      }

      results.add(new TupleValue(list));
    }

    return results;
  }
예제 #3
0
 @Override
 public String toString() {
   if (optional) {
     return "[" + type.toString() + "]";
   } else {
     return type.toString();
   }
 }
예제 #4
0
  @Override
  public SStmCG caseACallObjectStm(ACallObjectStm node, IRInfo question) throws AnalysisException {
    PType type = node.getType();
    PObjectDesignator objectDesignator = node.getDesignator();
    ILexNameToken field = node.getField();
    LinkedList<PExp> args = node.getArgs();

    STypeCG typeCg = type.apply(question.getTypeVisitor(), question);
    SObjectDesignatorCG objectDesignatorCg =
        objectDesignator.apply(question.getObjectDesignatorVisitor(), question);

    if (node.getExplicit()) {
      SClassDefinition enclosingClass = node.getAncestor(SClassDefinition.class);

      if (enclosingClass != null) {
        if (!field.getModule().equals(enclosingClass.getName().getName())) {
          // A quoted method call is only supported if the explicit
          // module name is equal to that of the enclosing class. Say A
          // is a sub class of S and 'a' is an instance of A then a.A`op();
          //  is allowed (although it is the same as a.op()). However,
          // a.S`op(); is not allowed.
          question.addUnsupportedNode(
              node,
              "A quoted object call statement is only supported if the explicit module name is equal to that of the enclosing class");
        }
      } else {
        Logger.getLog()
            .printErrorln(
                "Could not find enclosing the statement of call a call object statement.");
      }
    }

    String fieldNameCg = field.getName();

    ACallObjectStmCG callObject = new ACallObjectStmCG();
    callObject.setType(typeCg);
    callObject.setDesignator(objectDesignatorCg);
    callObject.setFieldName(fieldNameCg);

    for (PExp arg : args) {
      SExpCG argCg = arg.apply(question.getExpVisitor(), question);

      if (argCg != null) {
        callObject.getArgs().add(argCg);
      } else {
        return null;
      }
    }

    return callObject;
  }
예제 #5
0
  @Override
  public SStmCG caseABlockSimpleBlockStm(ABlockSimpleBlockStm node, IRInfo question)
      throws AnalysisException {
    ABlockStmCG blockStm = new ABlockStmCG();
    blockStm.setScoped(question.getStmAssistant().isScoped(node));

    LinkedList<AAssignmentDefinition> assignmentDefs = node.getAssignmentDefs();

    for (AAssignmentDefinition def : assignmentDefs) {
      PType type = def.getType();
      String name = def.getName().getName();
      PExp exp = def.getExpression();

      STypeCG typeCg = type.apply(question.getTypeVisitor(), question);
      AIdentifierPatternCG idPattern = new AIdentifierPatternCG();
      idPattern.setName(name);
      SExpCG expCg = exp.apply(question.getExpVisitor(), question);

      AVarDeclCG localDecl =
          question.getDeclAssistant().consLocalVarDecl(def, typeCg, idPattern, expCg);

      if (expCg instanceof AUndefinedExpCG) {
        question.getDeclAssistant().setDefaultValue(localDecl, typeCg);
      } else {
        localDecl.setExp(expCg);
      }

      blockStm.getLocalDefs().add(localDecl);
    }

    LinkedList<PStm> stms = node.getStatements();

    for (PStm pStm : stms) {
      SStmCG stmCg = pStm.apply(question.getStmVisitor(), question);

      if (stmCg != null) {
        blockStm.getStatements().add(stmCg);
      } else {
        return null;
      }
    }

    return blockStm;
  }
예제 #6
0
  @Override
  public SSeqType caseAUnionType(AUnionType type) throws AnalysisException {
    // return AUnionTypeAssistantTC.getSeq(type);
    if (!type.getSeqDone()) {
      type.setSeqDone(true); // Mark early to avoid recursion.
      // type.setSeqType(PTypeAssistantTC.getSeq(AstFactory.newAUnknownType(type.getLocation())));
      type.setSeqType(
          af.createPTypeAssistant().getSeq(AstFactory.newAUnknownType(type.getLocation())));
      PTypeSet set = new PTypeSet(af);

      for (PType t : type.getTypes()) {
        if (af.createPTypeAssistant().isSeq(t)) {
          set.add(t.apply(THIS).getSeqof());
        }
      }

      type.setSeqType(
          set.isEmpty()
              ? null
              : AstFactory.newASeqSeqType(type.getLocation(), set.getType(type.getLocation())));
    }

    return type.getSeqType();
  }
예제 #7
0
  public TupleSelectObligation(PExp exp, PType type, IPOContextStack ctxt, IPogAssistantFactory af)
      throws AnalysisException {
    // not is_(exp, type)
    super(exp, POType.TUPLE_SELECT, ctxt, exp.getLocation(), af);

    ANotUnaryExp notExp = new ANotUnaryExp();
    AIsExp isExp = new AIsExp();

    isExp.setTest(exp.clone());
    isExp.setBasicType(
        type.clone()); // Do we need the type definition instead? If so, the visitor must provide
    // it.

    notExp.setExp(isExp);

    stitch = notExp;
    valuetree.setPredicate(ctxt.getPredWithContext(stitch));
  }
예제 #8
0
  public STypeCG toIrType(IRInfo info) {
    try {
      STypeCG irType = type.apply(info.getTypeVisitor(), info);

      if (irType != null) {
        irType.setOptional(optional);
      }

      return irType;
    } catch (AnalysisException e) {
      Logger.getLog()
          .printErrorln(
              "Problems encountered while attempting "
                  + "to construct the IR type from a VDM type: "
                  + e.getMessage()
                  + " in '"
                  + this.getClass().getSimpleName()
                  + "'");
      e.printStackTrace();
    }

    return null;
  }
예제 #9
0
  @Override
  public SStmCG caseACallStm(ACallStm node, IRInfo question) throws AnalysisException {
    PDefinition rootdef = node.getRootdef();
    LinkedList<PExp> args = node.getArgs();

    List<SExpCG> argsCg = new LinkedList<SExpCG>();

    for (PExp arg : args) {
      SExpCG argCg = arg.apply(question.getExpVisitor(), question);

      if (argCg != null) {
        argsCg.add(argCg);
      } else {
        return null;
      }
    }

    boolean isStaticOrSl =
        Settings.dialect == Dialect.VDM_SL
            || question.getTcFactory().createPDefinitionAssistant().isStatic(rootdef);

    while (rootdef instanceof AInheritedDefinition) {
      rootdef = ((AInheritedDefinition) rootdef).getSuperdef();
    }

    if (rootdef instanceof AExplicitOperationDefinition) {
      AExplicitOperationDefinition op = (AExplicitOperationDefinition) rootdef;

      if (op.getIsConstructor()) {
        String initName = question.getObjectInitializerCall(op);

        APlainCallStmCG callStm = new APlainCallStmCG();
        callStm.setType(new AVoidTypeCG());
        callStm.setClassType(null);
        callStm.setName(initName);
        callStm.setArgs(argsCg);

        return callStm;
      }
    }

    PType type = node.getType();
    ILexNameToken nameToken = node.getName();
    String name = nameToken.getName();

    AClassTypeCG classType = null;

    STypeCG typeCg = type.apply(question.getTypeVisitor(), question);

    if (!isStaticOrSl) {
      ILexNameToken rootDefClassName = node.getRootdef().getClassDefinition().getName();
      ILexNameToken enclosingClassName = node.getAncestor(SClassDefinition.class).getName();

      if (!rootDefClassName.equals(enclosingClassName)) {

        ASuperCallStmCG superCall = new ASuperCallStmCG();
        superCall.setIsStatic(isStaticOrSl);
        superCall.setType(typeCg);
        superCall.setName(name);
        superCall.setArgs(argsCg);

        return superCall;
      }
    } else if (nameToken != null && nameToken.getExplicit() && isStaticOrSl) {
      String className = nameToken.getModule();
      classType = new AClassTypeCG();
      classType.setName(className);
    }

    APlainCallStmCG callStm = new APlainCallStmCG();

    callStm.setType(typeCg);
    callStm.setIsStatic(isStaticOrSl);
    callStm.setName(name);
    callStm.setClassType(classType);
    callStm.setArgs(argsCg);

    return callStm;
  }
예제 #10
0
  public List<AFieldField> readFieldList() throws ParserException, LexException {
    List<AFieldField> list = new Vector<AFieldField>();

    while (lastToken().isNot(VDMToken.END)
        && lastToken().isNot(VDMToken.SEMICOLON)
        && lastToken().isNot(VDMToken.INV)) {
      reader.push();
      LexToken tag = lastToken();
      LexToken separator = nextToken();

      if (separator.is(VDMToken.COLON)) {
        if (tag.isNot(VDMToken.IDENTIFIER)) {
          throwMessage(2071, "Expecting field identifier before ':'");
        }

        nextToken();
        LexIdentifierToken tagid = (LexIdentifierToken) tag;

        if (tagid.isOld()) {
          throwMessage(2295, "Can't use old name here", tag);
        }

        LexNameToken tagname = idToName(tagid);
        list.add(AstFactory.newAFieldField(tagname, tagid.getName(), readType(), false));
        reader.unpush();
      } else if (separator.is(VDMToken.EQABST)) {
        if (tag.isNot(VDMToken.IDENTIFIER)) {
          throwMessage(2072, "Expecting field name before ':-'");
        }

        nextToken();
        LexIdentifierToken tagid = (LexIdentifierToken) tag;

        if (tagid.isOld()) {
          throwMessage(2295, "Can't use old name here", tag);
        }

        LexNameToken tagname = idToName(tagid);
        list.add(AstFactory.newAFieldField(tagname, tagid.getName(), readType(), true));
        reader.unpush();
      } else
      // Anonymous field or end of fields
      {
        try {
          reader.retry();
          String anon = Integer.toString(list.size() + 1);
          PType ftype = readType();
          LexNameToken tagname = new LexNameToken(getCurrentModule(), anon, ftype.getLocation());
          list.add(AstFactory.newAFieldField(tagname, anon, ftype, false));
          reader.unpush();
        } catch (Exception e) {
          // End? EOF? Or badly formed type, fails elsewhere...
          reader.pop();
          break;
        }
      }
    }

    for (PField f1 : list) {
      for (PField f2 : list) {
        if (f1 != f2 && ((AFieldField) f1).getTag().equals(((AFieldField) f2).getTag())) {
          throwMessage(2073, "Duplicate field names in record type");
        }
      }
    }

    return list;
  }