Examples of PrologPlusCG.cg.Concept

PrologPlusCG.cg.Concept

      // CGOper(G1, C1, G2, C2, G3, C3) or subsume(G1, C1, G2, C2)
      // CGOper(G1, G2, G3) or subsume(G1, G2)
      CG G3 = null;
      int nivG1 = 0;
      int nivG2 = 0;
      Concept C1 = null;
      Concept C2 = null;
      PrologData DonRes = null;
      PrologData DonResBis = null;


      ASSERT(
          ((pTermRes.pTerm.size() == 7)
              || (pTermRes.pTerm.size() == 4)
              || ((pTermRes.pTerm.size() == 5) && IdPred
                  .equals("subsume")) || ((pTermRes.pTerm
              .size() == 3) && IdPred.equals("subsume"))),
          "Error: Wrong number of arguments for the CG operation.\n");


      if ((pTermRes.pTerm.size() == 7) || (pTermRes.pTerm.size() == 5)) {
        // presence des points d'entree
        Arg1 = env.unification.valueFromUnifStack(pTermRes.pTerm
            .getAt(1), pTermRes.index);
        ASSERT(
            ((Arg1.pData != null) && (Arg1.pData.typeOfData == uCG)),
            "Error: the first argument of the CG operation must be a CG.\n");
        G1 = (CG) Arg1.pData.data;
        nivG1 = Arg1.index;


        Arg2 = env.unification.valueFromUnifStack(pTermRes.pTerm
            .getAt(2), pTermRes.index);


        if ((Arg2.pData != null) && (Arg2.pData.typeOfData == uConcept)) {
          C1 = (Concept) Arg2.pData.data;
        } else {
          ASSERT(false,
              "Error: The second argument of the CG operation should be a concept.\n");
        }


        PrologDataIndexPair Arg3 = env.unification.valueFromUnifStack(
            pTermRes.pTerm.getAt(3), pTermRes.index);
        ASSERT(
            ((Arg3.pData != null) && (Arg3.pData.typeOfData == uCG)),
            "Error: the third argument of the CG operation must be a CG.\n");
        G2 = (CG) Arg3.pData.data;
        nivG2 = Arg3.index;


        PrologDataIndexPair Arg4 = env.unification.valueFromUnifStack(
            pTermRes.pTerm.getAt(4), pTermRes.index);


        if ((Arg4.pData != null) && (Arg4.pData.typeOfData == uConcept)) {
          C2 = (Concept) Arg4.pData.data;
        } else {
          ASSERT(false,
              "Error: The fourth argument of the CG operation should be a concept.\n");
        }


        if (pTermRes.pTerm.size() == 7) {
          PrologDataIndexPair Arg5 = env.unification
              .valueFromUnifStack(pTermRes.pTerm.getAt(5),
                  pTermRes.index);
          ASSERT((Arg5.pData == null),
              "Error: the fifth argument of the CG operation must be a free variable.\n");
          G3 = new CG();
          DonRes = pTermRes.pTerm.getAt(5);


          PrologDataIndexPair Arg6 = env.unification
              .valueFromUnifStack(pTermRes.pTerm.getAt(6),
                  pTermRes.index);
          ASSERT((Arg6.pData == null),
              "Error: the sixth argument of the CG operation must be a free variable.\n");
          DonResBis = pTermRes.pTerm.getAt(6);
        }
      } else { // les cas : CGOper(G1, G2, G3) or subsume(G1, G2)
        Arg1 = env.unification.valueFromUnifStack(pTermRes.pTerm
            .getAt(1), pTermRes.index);
        ASSERT(
            ((Arg1.pData != null) && (Arg1.pData.typeOfData == uCG)),
            "Error: the first argument of the CG operation must be a CG.\n");
        G1 = (CG) Arg1.pData.data;
        nivG1 = Arg1.index;


        Arg2 = env.unification.valueFromUnifStack(pTermRes.pTerm
            .getAt(2), pTermRes.index);
        ASSERT(
            ((Arg2.pData != null) && (Arg2.pData.typeOfData == uCG)),
            "Error: the second argument of the CG operation must be a CG.\n");
        G2 = (CG) Arg2.pData.data;
        nivG2 = Arg2.index;


        if (pTermRes.pTerm.size() == 4) {
          PrologDataIndexPair Arg3 = env.unification
              .valueFromUnifStack(pTermRes.pTerm.getAt(3),
                  pTermRes.index);
          ASSERT((Arg3.pData == null),
              "Error: the third argument of the CG operation must be a free variable.\n");
          G3 = new CG();
          DonRes = pTermRes.pTerm.getAt(3);
        }
      }


      // Les arguments sont a present prets, en tenant compte des
      // differentes posibilites
      // Appel de l'operation de matching matchCG
      CGMatchResult resMatchCG = new CGMatchResult(G3, null);
      CGOperation uneOperGC = new CGOperation(env);
      resultat = uneOperGC.matchCG(CGOperation.convertToByte(IdPred, G3),
          C1, G1, nivG1, C2, G2, nivG2, resMatchCG);
      uneOperGC.corefMatchVec_MakeEmpty();
      uneOperGC = null;
      env.unification.Unif_Stack.pushEmptyRecord();


      if (resultat && (DonRes != null)) {
        PrologData donTmp = new PrologData(uCG, resMatchCG.G3);
        resultat = env.unification.unify(DonRes, pTermRes.index,
            donTmp, pTermRes.index);
      }


      if (resultat && (DonResBis != null)) {
        resultat = env.unification
            .unify(DonResBis, pTermRes.index, new PrologData(
                uConcept, resMatchCG.E3), pTermRes.index);
      }


      if (resultat) {
        pTermRes.pos = -1;


        Return_Stack.push(Exec_Stack.pop());
      } else {
        if (resMatchCG.G3 != null) {
          resMatchCG.G3.myDestroy();
        }


        if (resMatchCG.E3 != null) {
          resMatchCG.E3 = null;
        }


        env.unification.Unif_Stack.pop();
      }


      resMatchCG = null;
    } else if (IdPred.equals("length")) {
      ASSERT((pTermRes.pTerm.size() == 3),
          "Error: length takes two arguments.\n");
      Arg1 = env.unification.valueFromUnifStack(pTermRes.pTerm.getAt(1),
          pTermRes.index);
      ASSERT(((Arg1.pData != null) && (Arg1.pData.typeOfData == uList)),
          "Error: The first argument of length must be a list.\n");
      Arg2 = env.unification.valueFromUnifStack(pTermRes.pTerm.getAt(2),
          pTermRes.index);
      ASSERT(
          ((Arg2.pData == null) || (Arg2.pData.typeOfData == uNumber)),
          "Error: The second argument of length must be an integer or a free variable.\n");
      pLstPrlg = (PrologList) Arg1.pData.data;


      int taille = 0;


      if (pLstPrlg != null) {
        taille = pLstPrlg.size();


        PrologDataIndexPair ValVarList = null;
        PrologData uneDonTmp = null;
        boolean finished = false;
        int Arg1Niv = Arg1.index;


        while (!finished) {
          try {
            uneDonTmp = (PrologData) pLstPrlg.lastElement();
          } catch (NoSuchElementException nsex) {
            // This could possibly happen
          }


          if (uneDonTmp.typeOfData == uVarList) {
            ValVarList = env.unification.valueFromUnifStack(
                uneDonTmp, Arg1Niv);
            Arg1Niv = ValVarList.index;


            if ((ValVarList.pData != null)
                && (ValVarList.pData.typeOfData != uList)) {
              throw new ExecException(
                  "The value of the variable after | should be a list.\n");
            } else if (ValVarList.pData != null) {
              pLstPrlg = (PrologList) ValVarList.pData.data;
              taille--; // decremente la taille de -1 car |x ne
                    // doit pas etre compte


              if (pLstPrlg == null) {
                finished = true;
              } else {
                taille = taille + pLstPrlg.size();
              }
            } else {
              throw new ExecException(
                  "Warning : The length of the list can not be determined since it is partially specified; the variable after | is free.\n");
            }
          } else {
            finished = true;
          }
        }
      }


      env.unification.Unif_Stack.pushEmptyRecord();
      resultat = env.unification.unify(new PrologData(uNumber,
          new Long(taille)), pTermRes.index, pTermRes.pTerm
          .getAt(2), pTermRes.index);


      if (resultat) {
        pTermRes.pos = -1;


        Return_Stack.push(Exec_Stack.pop());
      } else {
        env.unification.Unif_Stack.pop();
      }
    } else if (IdPred.equals("stringToLetters")
        || IdPred.equals("identToLetters")) {
      byte typeMot = 0;


      if (IdPred.equals("stringToLetters")) {
        typeMot = uString;
      } else {
        typeMot = uIdentifier;
      }


      ASSERT((pTermRes.pTerm.size() == 3), "Error: " + IdPred
          + " takes two arguments.\n");
      Arg1 = env.unification.valueFromUnifStack(pTermRes.pTerm.getAt(1),
          pTermRes.index);
      ASSERT(
          ((Arg1.pData == null) || (Arg1.pData.typeOfData == typeMot)),
          "Error: The first argument of " + IdPred
              + " must be a string/ident or a free variable.\n");


      Arg2 = env.unification.valueFromUnifStack(pTermRes.pTerm.getAt(2),
          pTermRes.index);
      ASSERT(((Arg2.pData == null) || (Arg2.pData.typeOfData == uList)),
          "Error: The second argument of " + IdPred
              + " must be a list or a free variable.\n");
      ASSERT(((Arg1.pData != null) || (Arg2.pData != null)),
          "Error: At least one of the two arguments of " + IdPred
              + " must be bound.\n");


      if (Arg1.pData != null) { // le mot est fourni, passer au cars


        String mot = (String) Arg1.pData.data;


        // Construire la liste des lettres qui compose la chaine
        // String.valueOf(char) ==> String
        int tailleMot = mot.length();
        int i = 0;


        if (IdPred.equals("stringToLetters")) {
          // Ignorer les doubles quotes du string
          i++;
          tailleMot--;
        }


        String carToString = null;
        pLstPrlg = new PrologList();


        PrologData uneDon;


        for (; i < tailleMot; i++) {
          carToString = "\"" + String.valueOf(mot.charAt(i)) + "\"";
          uneDon = new PrologData(uString, carToString);
          pLstPrlg.addData(uneDon);
        }


        env.unification.Unif_Stack.pushEmptyRecord();
        uneDon = new PrologData(uList, pLstPrlg);
        resultat = env.unification.unify(uneDon, pTermRes.index,
            pTermRes.pTerm.getAt(2), pTermRes.index);
      } else { // le mot n'est pas fourni, le composer


        // La liste des cars est fournie
        // 1. Former un vecteur de char ? partir de la liste des
        // chaines/cars
        // 2. Former le mot ? partir du vecteur form? pr?c?demment
        pLstPrlg = (PrologList) Arg2.pData.data;
        pLstPrlg = copyAllOfTheListWithUnification(pLstPrlg, Arg2.index);


        int tailleVect = pLstPrlg.size();
        int i = 0;
        char[] vectCars = null;


        if (IdPred.equals("stringToLetters")) {
          tailleVect = tailleVect + 2;
          vectCars = new char[tailleVect];
          vectCars[0] = '\"';
          vectCars[tailleVect - 1] = '\"';
          i = 1;
        } else {
          vectCars = new char[tailleVect];
        }


        PrologData uneDon;
        String s = null;


        for (Enumeration<PrologData> e = pLstPrlg.elements(); e
            .hasMoreElements(); i++) {
          uneDon = (PrologData) e.nextElement();
          s = (String) uneDon.data;
          vectCars[i] = s.charAt(1);
        }


        String mot = new String(vectCars);
        uneDon = new PrologData(typeMot, mot);
        env.unification.Unif_Stack.pushEmptyRecord();
        resultat = env.unification.unify(pTermRes.pTerm.getAt(1),
            pTermRes.index, uneDon, pTermRes.index);
      }


      if (resultat) {
        pTermRes.pos = -1;


        Return_Stack.push(Exec_Stack.pop());
      } else {
        env.unification.Unif_Stack.pop();
      }
    } else if (IdPred.equals("concat")) {
      ASSERT((pTermRes.pTerm.size() == 4), "Error: " + IdPred
          + " takes three arguments.\n");
      Arg1 = env.unification.valueFromUnifStack(pTermRes.pTerm.getAt(1),
          pTermRes.index);
      ASSERT(
          ((Arg1.pData == null) || (typeIsPrimitive(Arg1.pData.typeOfData))),
          "Error: The first argument of " + IdPred
              + " must be a number, a boolean, an identifier, a string, or a free variable.\n");
      int nNoOfFreeArguments = 0;
      if (Arg1.pData == null) {
        nNoOfFreeArguments++;
      }


      Arg2 = env.unification.valueFromUnifStack(pTermRes.pTerm.getAt(2),
          pTermRes.index);
      ASSERT(
          ((Arg2.pData == null) || (typeIsPrimitive(Arg2.pData.typeOfData))),
          "Error: The second argument of " + IdPred
              + " must be a number, a boolean, an identifier, a string, or a free variable.\n");
      if (Arg2.pData == null) {
        nNoOfFreeArguments++;
      }


      PrologDataIndexPair Arg3 = env.unification.valueFromUnifStack(
          pTermRes.pTerm.getAt(3), pTermRes.index);
      ASSERT(
          ((Arg3.pData == null) || (Arg3.pData.typeOfData == uString)),
          "Error: The third argument of " + IdPred
              + " must be a string or a free variable.\n");


      if (Arg3.pData == null) {
        nNoOfFreeArguments++;
      }


      ASSERT(
          (nNoOfFreeArguments == 1) || (nNoOfFreeArguments == 0),
          "Error: "
              + IdPred
              + " must have either two or three bound arguments.\n");


      if (Arg3.pData == null || nNoOfFreeArguments == 0) {
        // We are concat'ing the easy case of Arg1 + Arg2
        String s1 = primitiveTypeToString(Arg1.pData);
        String s2 = primitiveTypeToString(Arg2.pData);


        String s3 = "\"" + s1.substring(1, s1.length() - 1)
            + s2.substring(1, s2.length() - 1) + "\"";


        PrologData uneDon = new PrologData(uString, s3);


        env.unification.Unif_Stack.pushEmptyRecord();
        resultat = env.unification.unify(uneDon, pTermRes.index,
            pTermRes.pTerm.getAt(3), pTermRes.index);


      } else if (Arg2.pData == null) {
        // Arg3 is not null, and nNoOfArguments == 1
        String s1 = primitiveTypeToString(Arg1.pData);
        String s3 = primitiveTypeToString(Arg3.pData);


        String s1stripped = s1.substring(1, s1.length() - 1);
        String s3stripped = s3.substring(1, s3.length() - 1);


        resultat = s3stripped.startsWith(s1stripped);
        if (!resultat) {
          env.unification.Unif_Stack.pushEmptyRecord();
        } else {
          int s1strippedLength = s1stripped.length();
          String s2 = "\""
              + s3stripped.substring(s1strippedLength, s3stripped
                  .length()) + "\"";


          PrologData uneDon = new PrologData(uString, s2);


          env.unification.Unif_Stack.pushEmptyRecord();
          resultat = env.unification.unify(uneDon, pTermRes.index,
              pTermRes.pTerm.getAt(2), pTermRes.index);
        }
      } else {
        // Arg1.pDonnee is null, and nNoOfFreeArguments == 1
        String s2 = primitiveTypeToString(Arg2.pData);
        String s3 = primitiveTypeToString(Arg3.pData);


        String s2stripped = s2.substring(1, s2.length() - 1);
        String s3stripped = s3.substring(1, s3.length() - 1);


        resultat = s3stripped.endsWith(s2stripped);
        if (!resultat) {
          env.unification.Unif_Stack.pushEmptyRecord();
        } else {
          int s2strippedLength = s2stripped.length();
          String s1 = "\""
              + s3stripped.substring(0, s3stripped.length()
                  - s2strippedLength) + "\"";


          PrologData uneDon = new PrologData(uString, s1);


          env.unification.Unif_Stack.pushEmptyRecord();
          resultat = env.unification.unify(uneDon, pTermRes.index,
              pTermRes.pTerm.getAt(1), pTermRes.index);
        }
      }


      if (resultat) {
        pTermRes.pos = -1;


        Return_Stack.push(Exec_Stack.pop());
      } else {
        env.unification.Unif_Stack.pop();
      }
    } else if (IdPred.equals("branchOfCG")) { // branchOfCG(CG_Branch, CG)


      // on le traitera de la meme maniere que member : on parcourt le CG,
      // similaire en cela a une liste de branchs
      // et on tentera d'unifier notre branch arg1 avec la branch courante
      // dans CG


      // branchOfCG must have two arguments
      ASSERT((pTermRes.pTerm.size() == 3),
          "Error: branchOfCG takes two arguments.\n");
      Arg2 = env.unification.valueFromUnifStack(pTermRes.pTerm.getAt(2),
          pTermRes.index);
      ASSERT(((Arg2.pData != null) && (Arg2.pData.typeOfData == uCG)),
          "Error: The second argument of branchOfCG must be a CG.\n");


      CG unGC = (CG) Arg2.pData.data;
      Vector<Relation> vctRels = unGC.m_vctRelations;
      int nbreBranch = vctRels.size();


      while ((pTermRes.pos < nbreBranch) && !resultat) {
        env.unification.Unif_Stack.pushEmptyRecord();


        // Creer un CG a partir de la branche/relation courante dans le
        // CG arg2
        // Remplir branchCadre
        CG unGCBranch = createCGBranch((Relation) vctRels
            .elementAt(pTermRes.pos));


        // Inverser les arg de unifier comme pour la primitive "eq"
        resultat = env.unification.unify(
            new PrologData(uCG, unGCBranch), Arg2.index,
            pTermRes.pTerm.getAt(1), pTermRes.index);
        pTermRes.pos++;


        if (resultat) {
          Return_Stack.push(Exec_Stack.pop());
        } else {
          env.unification.Unif_Stack.pop();
        }
      }
    } else if (IdPred.equals("concOfCG")) { // concOfCG(ConceptOUVar, CG)
      ASSERT((pTermRes.pTerm.size() == 3),
          "Error: concOfCG takes two arguments.\n");
      Arg2 = env.unification.valueFromUnifStack(pTermRes.pTerm.getAt(2),
          pTermRes.index);
      ASSERT(((Arg2.pData != null) && (Arg2.pData.typeOfData == uCG)),
          "Error: The second argument of concOfCG must be a CG.\n");


      CG unGC = (CG) Arg2.pData.data;
      Vector<Concept> vctConcepts = unGC.m_vctConcepts;
      int nbreConcs = vctConcepts.size();
      resultat = false;


      Arg1 = env.unification.valueFromUnifStack(pTermRes.pTerm.getAt(1),
          pTermRes.index);


      while ((pTermRes.pos < nbreConcs) && !resultat) {
        env.unification.Unif_Stack.pushEmptyRecord();


        Concept concCour = (Concept) vctConcepts
            .elementAt(pTermRes.pos);


        // Is Arg1 a free variable?
        if (Arg1.pData == null) {
          // Yes, it was a free variable.

View Full Code Here

          pTermRes.pTerm.getAt(1), pTermRes.index);


      while ((pTermRes.pos < nbreConcs) && !resultat) {
        env.unification.Unif_Stack.pushEmptyRecord();


        Concept concCour = (Concept) vctConcepts
            .elementAt(pTermRes.pos);


        // Is Arg1 a free variable?
        if (Arg1.pData == null) {
          // Yes, it was a free variable.

View Full Code Here

  CG createCGBranch(Relation rel) {
    // 1. Creer le CG cadre
    Relation newRelation = new Relation();
    newRelation.m_pdRelationName = rel.m_pdRelationName;


    Concept concSrce = rel.m_concSource;
    Concept newConcSrce = new Concept(concSrce.m_pdType,
              concSrce.m_pdReferent, concSrce.m_pdValue,
              env);
    newConcSrce.addOutgoingRelation(newRelation);
    newRelation.m_concSource = newConcSrce;


    Concept concDest = rel.m_concDestination;
    Concept newConcDest = new Concept(concDest.m_pdType,
              concDest.m_pdReferent, concDest.m_pdValue,
              env);
    newConcDest.addIncomingRelation(newRelation);
    newRelation.m_concDestination = newConcDest;


    Vector<Concept> nouvVctConcs = new Vector<Concept>(2);
    nouvVctConcs.addElement(newConcSrce);
    nouvVctConcs.addElement(newConcDest);

View Full Code Here

        throw new CompileException("Error in the concept at line " +
            curLineNumber);
      }
    }
    
    Concept conc = null;
    
    if (bGenerateCode) {
      boolean trouve = false;
      
      for (Enumeration<Concept> e = unGC.m_vctConcepts.elements();
      e.hasMoreElements() && !trouve;) {
        conc = (Concept) e.nextElement();
        
        if ((conc.m_pdReferent != null) && (Ref != null) &&
            (conc.m_pdReferent.data instanceof String) &&
            (Ref.data instanceof String) &&
            Ref.valString().equals(conc.m_pdReferent.valString())) {
          trouve = true;
        } else if ((conc.m_pdReferent != null) && (Ref != null) &&
            (conc.m_pdReferent.typeOfData == Ref.typeOfData) &&
            (conc.m_pdReferent.typeOfData == uSet) &&
            setsAreEqual((PrologList) conc.m_pdReferent.data,
                (PrologList) Ref.data)) {
          trouve = true;
        }
      }
      
      if (!trouve) {
          conc = new Concept(Type, Ref, Val, env);
        unGC.addConcept(conc);
      }
    }
    
    return conc;

View Full Code Here

    readToken(bGenerateCode);
  }
  
  Concept tGC(boolean bGenerateCode, CG unGC) throws CompileException {
    // L'token qui suit un CG est lu par ce dernier
    Concept conc = tConcept(bGenerateCode, unGC);
    
    try {
      readToken(bGenerateCode);
    } catch (CompileException ceGC) {
      if (!ceGC.getMessage().equals("End Of Text")) {

View Full Code Here

    if ((nTokenType != uOpenBracket) && (nTokenType != uVariable)) {
      throw new CompileException("Error: A CG is expected at line " +
          curLineNumber);
    }
    
    Concept concCble = tGC(bGenerateCode, unGC);
    
    if (bGenerateCode) {
      Relation nouvRel = new Relation(new PrologData(typIdRel, idRel),
          concSrce, concCble);
      unGC.addRelation(nouvRel);

View Full Code Here

    if ((nTokenType != uOpenBracket) && (nTokenType != uVariable)) {
      throw new CompileException("Error: A CG is expected at line " +
          curLineNumber);
    }
    
    Concept concSrce = tGC(bGenerateCode, unGC);
    
    if (bGenerateCode) {
      Relation nouvRel = new Relation(new PrologData(typIdRel, idRel),
          concSrce, concCble);
      unGC.addRelation(nouvRel);

View Full Code Here

  
  public void printCG(CG aCG, int level, Vector<Concept> vctConcsVisite,
      Vector<Relation> vctImprPrevuRels) {
    // 1. Chercher s'il y a un concept qui n'a pas d'entrees
    boolean bFound = false;
    Concept conc = null;
    
    for (Enumeration<Concept> e = aCG.m_vctConcepts.elements();
    e.hasMoreElements() && !bFound;) {
      conc = (Concept) e.nextElement();

View Full Code Here

  
  public void printRelation(Relation rel, boolean estRelSort, CG unGC, int niv,
      Vector<Concept> vctConcsVisite, Vector<Relation> vctImprPrevuRels) {
    String DelOuv = null;
    String DelFerm = null;
    Concept conc = null;
    
    if (estRelSort) {
      DelOuv = "-";
      DelFerm = "->";
      conc = rel.m_concDestination;

View Full Code Here


    // ------------------------------------------------------------------
    boolean computeEntryPointsAndUnify(CG G1, int levelG1, CG G2, int levelG2)
        throws ExecException {
        boolean bResult = false;
        Concept C1;
        Concept C2;


        if ((G1.m_vctConcepts.size() == 1) && G1.m_vctRelations.isEmpty()) {
            C1 = (Concept) G1.m_vctConcepts.firstElement();


            for (Enumeration<Concept> e = G2.m_vctConcepts.elements();

View Full Code Here

0 1

TOP

Related Classes of PrologPlusCG.cg.Concept

PrologPlusCG.cg.CG

PrologPlusCG.prolog.Compile

PrologPlusCG.prolog.Printer

PrologPlusCG.prolog.PrologDataIndexPair

PrologPlusCG.prolog.Resolution

PrologPlusCG.prolog.UnifyCG

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.