Examples of freegressi.tableur.Noeud

freegressi.tableur.Noeud
Les noeuds des arbres d'expression syntaxiques @author marchand

    Utils.insertFunction(jtfs);
    jtfsKeyReleased(null);
  }//GEN-LAST:event_jbFunctionActionPerformed


  private void jtfsKeyReleased(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_jtfsKeyReleased
    Noeud noeud;
    noeud = Verificateur.parseExpressionTendance(jtfs.getText(), xName);
    if (noeud == null) {
      jlError.setText("Vous devez entrer une expression!");
      jtfs.effaceTout();   
    } else {
      if (noeud.getType() == Sym.ERROR || noeud.getType() == Sym.PARSER_ERROR || noeud.getType() == Sym.PARSER_COHERENCE_ERROR) {
        jlError.setText(noeud.getTexteErreur());
        jtfs.souligne(noeud.getColonne(), noeud.getColonne() + 1);
      } else {
        jlError.setText("");
        jtfs.effaceTout();
      }
    }

View Full Code Here

        }
      }
      // Vérifier la cohérence des paramètres
      if (na > 0){
        for (int i = 0; i < racine.getListeArguments().size(); i++){
          Noeud argument = verifieCoherence(racine.getListeArguments().get(i));
          if (argument != null){
            return argument;
          }
        }
        // Vérifier la pertinence des paramètres
        Noeud erreur;
        switch (type){
          case Sym.MOYENNE:
          case Sym.RAND:
          // Aucune vérification à faire
            erreur = checkFilsDroit(racine);
            if (erreur != null) return erreur;
            break;


          case Sym.DERIVEE:
          // le deuxième paramètre doit être un nom de variable
            erreur = checkFilsDroit(racine);
            if (erreur != null) return erreur;
            Noeud arg2 = racine.getListeArguments().get(1);
            if (arg2.getType() != Sym.ID){
              arg2.setType(Sym.PARSER_COHERENCE_ERROR);
              arg2.setTexteErreur("La fonction " + racine.getTexteLexer() +
                      " nécessite une variable comme deuxième argument!");
              return arg2;
            }
            break;
          // retirée du lexer
          case Sym.INTEGRALE:
            erreur = checkFilsDroit(racine);
            if (erreur != null) return erreur;
            // le 4ème paramètre doit être un nom de variable
            Noeud arg4 = racine.getListeArguments().get(3);
            if (arg4.getType() != Sym.ID){
              arg4.setType(Sym.PARSER_COHERENCE_ERROR);
              arg4.setTexteErreur("La fonction " + racine.getTexteLexer() +
                      " nécessite une variable comme 4ème argument!");
              return arg4;
            }
            break;
        }
      }




    }


//    // Le fils gauche du signe égal doit être un identificateur
//    if (type == Sym.EGAL){
//      if (racine.getFilsG() == null || racine.getFilsG().getType() != Sym.ID){
//        racine.setType(Sym.PARSER_COHERENCE_ERROR);
//        racine.setTexteErreur("Erreur : Nom = Expression!");
//        return racine;
//      }
//    }




    // Vérifier la cohérence du fils gauche
    Noeud filsG = verifieCoherence(racine.getFilsG());
    if (filsG != null) {
      return filsG;
    }
    // Vérifier la cohérence du fils droit
    Noeud filsD = verifieCoherence(racine.getFilsD());
    if (filsD != null) {
      return filsD;
    }
    return null;
  }

View Full Code Here

   * @param racine
   * @return
   */
  private Noeud checkFilsDroit(Noeud racine){
    // Cette fonction ne peut avoir de fils droit
    Noeud filsD = racine.getFilsD();
    if (filsD != null){
      filsD.setType(Sym.PARSER_COHERENCE_ERROR);
      filsD.setTexteErreur("Erreur de syntaxe!");
      return filsD;
    }
    return null;
  }

View Full Code Here

   * La méthode publique principale, lance le parsing de la liste de noeuds
   * fournie au constructeur.
   * @return
   */
  public Noeud parser() {
    Noeud noeud = parse(0, null);
    if (noeud == null){
      return noeud;
    }
    if (noeud.getType() == Sym.PARSER_COHERENCE_ERROR){
      return noeud;
    }
    Noeud erreur = verifieCoherence(noeud);
    if (erreur != null) {
      noeud = erreur;
    }
    return noeud;
  }

View Full Code Here

   * @param index du prochain noeud dans la liste
   * @param parG est le noeud "(" si parse est appelée par une parenthèse ouvrante "("
   * @return la racine de l'arbre
   */
  private Noeud parse(int index, Noeud parG) {
    Noeud noeud = getNoeudSuivant();
    Noeud nCourant = null;
    boolean attendArgument = false;
    while (noeud != null) {


      switch (noeud.getType()) {
        case Sym.ERROR:
          noeud.setTexteErreur("Erreur du lexer!");
          return noeud;
          
        case Sym.UNIT:
        case Sym.COMMENT:
        case Sym.COMMENT_TEXT:
        case Sym.UNIT_TEXT:
          attendArgument = false;
          //nCourant = ajouteNoeudTerminal(noeud, nCourant);
          break;
        case Sym.EGAL:
          attendArgument = false;
          nCourant = ajouteNoeudNonTerminal(noeud, nCourant);
          break;
        case Sym.NOMBRE:
          attendArgument = false;
          nCourant = ajouteNoeudTerminal(noeud, nCourant);
          //System.out.print("N");
          break;


        case Sym.PLUS:
        case Sym.MOINS:
        case Sym.FOIS:
        case Sym.DIVISE:
          attendArgument = false;
          nCourant = ajouteNoeudNonTerminal(noeud, nCourant);
          break;


        case Sym.VIRGULE:
          //System.out.println("Virgule : " + noeud.getTexteLexer());
          if (attendArgument){
            nCourant.setType(Sym.PARSER_COHERENCE_ERROR);
            nCourant.setTexteErreur("Attente d'un argument");
            return nCourant;            
          }
          attendArgument = true;
          nCourant = ajouteNoeudNonTerminal(noeud, nCourant);
          break;


        case Sym.PUIS:
          attendArgument = false;
          nCourant = ajouteNoeudNonTerminal(noeud, nCourant);
          //System.out.print("^");
          break;
        case Sym.PUIS2:
          attendArgument = false;
          Noeud n = new Noeud(Sym.NOMBRE, Sym.CATEGORIE_SANS, Sym.PRIORITE_BASSE, 2.0, noeud.getLigne(), noeud.getColonne(), "");
          noeud.setType(Sym.PUIS);
          nCourant = ajouteNoeudNonTerminal(noeud, nCourant); // ajout du noeud PUIS
          nCourant = ajouteNoeudTerminal(n, nCourant); // ajout du noeud NOMBRE : 2
          //System.out.print("^2");
          break;
        case Sym.PUISN:
          attendArgument = false;
          Noeud n1 = new Noeud(Sym.NOMBRE, Sym.CATEGORIE_SANS, Sym.PRIORITE_BASSE, (double) noeud.getPuissance(), noeud.getLigne(), noeud.getColonne(), "");
          //System.out.println(noeud.getPuissance());
          noeud.setType(Sym.PUIS);
          noeud.setCategorie(Sym.CATEGORIE_OPERATEUR);
          noeud.setPriorite(Sym.PRIORITE_HAUTE);
          nCourant = ajouteNoeudNonTerminal(noeud, nCourant); // ajout du noeud PUIS
          nCourant = ajouteNoeudTerminal(n1, nCourant); // ajout du noeud NOMBRE : N
          //System.out.print("^2");
          break;
        case Sym.ID:
        case Sym.PARAMETRE:
          attendArgument = false;
          nCourant = ajouteNoeudTerminal(noeud, nCourant);
          //System.out.print("Id : "+noeud.getNom());
          break;


        case Sym.SIN:
        case Sym.COS:
        case Sym.TAN:
        case Sym.ASIN:
        case Sym.ACOS:
        case Sym.ATAN:
          attendArgument = false;
          nCourant = ajouteNoeudTerminal(noeud, nCourant);
          break;


        case Sym.LOG:
        case Sym.LN:
        case Sym.EXP:
        case Sym.SQR:
        case Sym.SQRT:
        case Sym.ABS:
          attendArgument = false;
          nCourant = ajouteNoeudTerminal(noeud, nCourant);
          break;


        case Sym.PI:
        case Sym.E:
          attendArgument = false;
          nCourant = ajouteNoeudTerminal(noeud, nCourant);
          //System.out.print("ATAN");
          break;


        case Sym.MOYENNE:
          attendArgument = false;
          nCourant = ajouteNoeudTerminal(noeud, nCourant);
          //System.out.print("ATAN");
          break;
        case Sym.DERIVEE:
        case Sym.INTEGRALE:
        case Sym.RAND:
          attendArgument = false;
          nCourant = ajouteNoeudTerminal(noeud, nCourant);
          break;




        case Sym.PARENG:
          //attendArgument = true;
          noeud = parse(indexListe + 1, noeud);


          if (noeud != null && noeud.getType() == Sym.PARSER_COHERENCE_ERROR) {
            return noeud;
          }
          // Mettre les arguments de fonction sous forme de liste
          if (nCourant != null && nCourant.getCategorie() == Sym.CATEGORIE_FONCTION) {
            if (nCourant.getNombreParametres() > 1) { // uniquement pour les fonctions à plusieurs paramètres
              List<Noeud> listeP = new ArrayList<Noeud>();
              int nombreParametres = getListeParametres(noeud, listeP);
              if (nCourant.getNombreParametres() == Integer.MAX_VALUE || nombreParametres == nCourant.getNombreParametres()) {
                ajouteNoeudTerminalArguments(listeP, nCourant);
                break;
              } else {
                nCourant.setType(Sym.PARSER_COHERENCE_ERROR);
                nCourant.setTexteErreur("Cette fonction nécessite " + nCourant.getNombreParametres() + " arguments!");
                return nCourant;
              }
            } else { // fonction à 1 paramètre, vérifier qu'il n'y en a qu'un
              List<Noeud> listeP = new ArrayList<Noeud>();
              int nombreParametres = getListeParametres(noeud, listeP);
              if (nombreParametres != 1){
                nCourant.setType(Sym.PARSER_COHERENCE_ERROR);
                nCourant.setTexteErreur("Cette fonction nécessite 1 seul argument!");
                return nCourant;
              }
            }
          }
          nCourant = ajouteNoeudTerminal(noeud, nCourant);
          attendArgument = false;
          break;
        case Sym.PAREND:
          if (attendArgument){
            nCourant.setType(Sym.PARSER_COHERENCE_ERROR);
            nCourant.setTexteErreur("Attente d'un argument");
            return nCourant;
          }
          
          if (parG == null) { // ici erreur : on détecte une parenthese droite mais il n'y a pas de gauche
            noeud.setType(Sym.PARSER_COHERENCE_ERROR);
            noeud.setTexteErreur("pas de parenthèse ouvrante associée!");
            return noeud;
          }
          if (nCourant == null) {
            Noeud erreur = new Noeud(Sym.PARSER_COHERENCE_ERROR, Sym.CATEGORIE_SANS, Sym.PRIORITE_HAUTE, 0, parG.getColonne(), "");
            erreur.setTexteErreur("Expression vide!");
            return erreur;
          } else {
            attendArgument = false;
            return nCourant.getRacine();
          }

View Full Code Here

   */
  private Noeud ajouteNoeudNonTerminal(Noeud noeud, Noeud nCourant) {
    if (nCourant == null) {
      nCourant = noeud;
    } else {
      Noeud n = getFilsAieulPrioritePlusFaible(noeud.getPriorite(), nCourant);
      insereNoeudAuDessusDe(noeud, n);
    }
    return noeud;
  }

View Full Code Here

   * à celle de noeud
   *
   * @return
   */
  private Noeud getFilsAieulPrioritePlusFaible(int priorite, Noeud nDepart) {
    Noeud n = nDepart;


    while (true) { // pas très joli ça...
      if (n.getPere() == null) { // on arrive à la racine de l'arbre
        return n;
      }
      n = n.getPere();
      if (n.getPriorite() < priorite) { // le pere de n a une priorité plus faible que priorite
        return n.getFilsD();
      }
    }
  }

View Full Code Here

  /**
   * Insere noeud entre noeudBas et noeudBas.getPere()
   * @param noeud
   */
  private void insereNoeudAuDessusDe(Noeud noeud, Noeud noeudBas) {
    Noeud pere = noeudBas.getPere();
    noeudBas.setPere(noeud);
    noeud.setFisG(noeudBas);
    noeud.setPere(pere);
    if (pere != null) {
      /*if (pere.estFilsGaucheLibre()) {
      pere.setFisG(noeud);
      System.err.println("Passe par estFilsGaucheLibre dans insereNoeudAuDessusDe");
      }
      else {*/
      pere.setFilsD(noeud);
      //}
    }
    //nCourant = noeud;
  }

View Full Code Here

    try {
      Lexer lex = new Lexer(new java.io.StringReader(exp), liste);
      lex.yylex();
    } catch (Exception e) {
      System.err.println("Erreur interne du lexer!");
      return new Noeud(Sym.ERROR, "Erreur interne du lexer! Ne devrait pas survenir!");
    }
    // Marquer les noeuds d'ID inconnus comme parametres
    for (Noeud noeud : liste) {
      if (noeud.getType() == Sym.ID) {
        if (!noeud.getNom().equals(nomSerie)) {
          noeud.setType(Sym.PARAMETRE);
          //noeud.setTexteErreur("Identificateur inconnu! : " + noeud.getNom());
          //return noeud;
        }
      }
    }


    // Créer le noeud correspondant à l'expression
    Parser parser = new Parser(liste);
    Noeud racine = parser.parser();


    return racine;


  }

View Full Code Here

    try {
      Lexer lex = new Lexer(new java.io.StringReader(exp), liste);
      lex.yylex();
    } catch (Exception e) {
      System.err.println("Erreur interne du lexer!");
      return new Noeud(Sym.ERROR, "Erreur interne du lexer! Ne devrait pas survenir!");
    }


    // Vérifier que les noeuds ne comprennent pas d'ID inconnus, c.a.d. que
    // tous les noms de variables utilisées sont définis AVANT dans listeSeries
    // et qu'il n'y a pas d'auto-référencement
    for (Noeud noeud : liste) {


      if (noeud.getType() == Sym.ID) {
        if (tableur == null || noeud.getNom().equals(nomSerie)) {
          noeud.setType(Sym.ERROR);
          noeud.setTexteErreur(Sym.ERREUR_AUTOREFERENCE);
          return noeud;
        }
        if (tableur == null || !tableur.estIDConnu(noeud.getNom(), nomSerie)) {
          noeud.setType(Sym.ERROR);
          noeud.setTexteErreur(Sym.ERREUR_NOM_INCONNU + " : " + noeud.getNom());
          return noeud;
        }


      }else{
        if (noeud.getType() == Sym.EGAL || noeud.getType() == Sym.COMMENT || noeud.getType() == Sym.UNIT){
          noeud.setType(Sym.ERROR);
          noeud.setTexteErreur(Sym.ERREUR_CARACTERE_INTERDIT + " : " + noeud.getNom());
          return noeud;
        }
      }
    }




    // Créer le noeud correspondant à l'expression
    Parser parser = new Parser(liste);
    Noeud racine = parser.parser();


    return racine;


  }

View Full Code Here

0 1

TOP

Related Classes of freegressi.tableur.Noeud

freegressi.fit.functions.AnyFunc

freegressi.fit.JDialogFit

freegressi.fit.JPanelTend

freegressi.parser.Lexer

freegressi.parser.Parser

freegressi.parser.Verificateur

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.