Back to index

wims  3.65+svn20090927
Formula.java
Go to the documentation of this file.
00001 /*
00002 $Id: Formula.java,v 1.4 2003/02/18 11:48:47 sander Exp $
00003 */
00004 
00005 
00006 /*
00007 Copyright (C) 2001-2002 Mainline Project (I3S - ESSI - CNRS -UNSA)
00008 
00009 This library is free software; you can redistribute it and/or
00010 modify it under the terms of the GNU Lesser General Public
00011 License as published by the Free Software Foundation; either
00012 version 2.1 of the License, or (at your option) any later version.
00013 
00014 This library is distributed in the hope that it will be useful,
00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public
00020 License along with this library; if not, write to the Free Software
00021 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 
00023 For further information on the GNU Lesser General Public License,
00024 see: http://www.gnu.org/copyleft/lesser.html
00025 For further information on this library, contact: mainline@essi.fr
00026 */
00027 
00028 
00029 package fr.ove.openmath.jome.model;
00030 
00031 import java.util.*;
00032 import java.awt.*;
00033 
00034 import fr.ove.openmath.jome.model.*;
00035 import fr.ove.openmath.jome.model.processor.*;
00036 import fr.ove.openmath.jome.model.events.ModelEvent;
00037 import fr.ove.openmath.jome.model.evaluation.*;
00038 import fr.ove.openmath.jome.behaviour.Modifiable;
00039 import fr.ove.openmath.jome.ctrl.linear.events.*;
00040 import fr.ove.utils.Factory;
00041 
00049 public class Formula extends FormulaTreeStructure implements LinearParserListener {
00053     public FormulaTreeStructure current;
00054     
00063     // On maintient une pile qui va contenir les instances qui ont besoin d'être "fermées".
00064     // Par exemple les parenthèses, les listes, ...
00065     // Nécessaire de faire ça à cause des inclusions mutuelles d'opérateurs du même type.
00066     private Stack openingStack = new Stack();
00067     
00073     private boolean doProcessing = false;
00074     
00079     private Processor processor = null;
00080 
00084     public Formula () {
00085         setResourceIdentifier("FORMULA");
00086         setAsOperatorPriority(resourcesManager.getAsOperatorPriority("formulaPriorities"));
00087         setAsOperandPriority(resourcesManager.getAsOperandPriority("formulaPriorities"));
00088         current = this;
00089     }
00090     
00095     public boolean isOperator() {
00096         return false;
00097     }
00098     
00105     public FormulaTreeStructure insert(FormulaTreeStructure current) {
00106         // On ne devrait pas insérer de formule !!
00107         // A voir, peut être utile pour le drag'n drop d'une nouvelle formule;
00108         return null;
00109     }
00110 
00114     public String createLinear(String linear) {
00115         if (getNbChildren() > 0)
00116             linear = ((FormulaTreeStructure) getChild(0)).createLinear(linear);
00117             
00118         return linear;
00119     }
00120     
00124     public void clear() {
00125         // On enlève tous les enfants de la FTS.
00126         removeAll();
00127         // On remet la position courante d'insertion sur la racine de la FTS
00128         current = this;
00129     }
00130     
00134     public String getLinear() {
00135         return createLinear("");
00136     }
00137 
00149     public String evaluate() {
00150         if (getNbChildren() > 0)
00151             return ((FormulaTreeStructure) getChild(0)).evaluate();
00152         else
00153             return "";
00154     }
00155     
00160     public void consumeLinearParserEvent(LinearParserEvent linearParserEvent) {
00161         int identifier = linearParserEvent.getIdentifier();
00162         String value = linearParserEvent.getValue();
00163         ModelEvent modelEvent;
00164         
00165         switch (identifier) {
00166             case LinearParserEvent.START_EXPRESSION :
00167                 clear();
00168                 openingStack.setSize(0);
00169                 modelEvent = new ModelEvent(this);
00170                 modelEvent.setAction(ModelEvent.CLEAR, null);
00171                 fireModelEvent(modelEvent);
00172                 break;
00173                 
00174             case LinearParserEvent.END_EXPRESSION :
00175                 // Le modèle de la formule est entièrement construit.
00176                 // On regarde d'abord les éventuels traitements à effectuer sur le modèle
00177                 // avant la construction des displays.
00178                 if (doProcessing && (processor != null)) {
00179                          // Initialisation du processeur si besoin est.
00180                          processor.init();
00181                     processor.doProcess();
00182                 }
00183                 
00184                 modelEvent = new ModelEvent(this);
00185                 modelEvent.setAction(ModelEvent.CREATE, null);
00186                 fireModelEvent(modelEvent);
00187                 break;
00188                 
00189             default :
00190                 String strIdentifier = linearParserEvent.getIdentifierAsString();
00191                 String className = resourcesManager.getClassName(strIdentifier);
00192                 FormulaTreeStructure newFts = null;
00193 
00194                 if (className.equals("null")) {
00195                     if (identifier == linearParserEvent.SEPARATOR) {
00196                         //current = current.goTo(FormulaTreeStructure.SLOT_AS_OPERATOR_PRIORITY);
00197                         current = current.goTo(resourcesManager.getAsOperatorPriority("slotPriorities"));
00198                         
00199                         // current est maintenant une instance de Slot, on récupère son père pour lui
00200                         // ajouter un nouvel élément.
00201                         NaryOperator2 currentFather = (NaryOperator2) current.getFather();
00202                         current = currentFather.addElement();
00203                     }
00204                     else {
00205                         // Alors c'est forcément un linearParserEvent.CLOSE_*
00206                         if (!openingStack.isEmpty()) {
00207                             current = (FormulaTreeStructure) openingStack.pop();
00208                             // Et remonte encore d'un cran à cause des priorités des opérateurs
00209                             // (surtout en ce qui concerne les parenthèses)
00210                             current = (FormulaTreeStructure) current.getFather();
00211                         }
00212                     }
00213                 }
00214                 else {
00215                     if (className.equals("refine")) {
00216                         String[] properties = resourcesManager.getResourceStrings(value);
00217                         if (properties.length != 0)
00218                             strIdentifier = value; // On a trouvé qque chose correspondant à value
00219                         else {
00220                             if (identifier == linearParserEvent.RESERVED) 
00221                                 // Il n'existe pas de mot réservé défini dans le modèle correspondant à value.
00222                                 // On considère donc value comme une variable.
00223                                 strIdentifier = "VARIABLE";
00224                             else
00225                                 // Si ce n'est pas un mot réservé, c'est une fonction.
00226                                 // Il n'existe pas de fonction spéciale définie correspondant à value.
00227                                 // On considère donc value comme une fonction par défaut ayant pour nom value.
00228                                 strIdentifier = "defaultFunction";
00229                         }
00230                     }
00231                     
00232                     newFts = (FormulaTreeStructure) Factory.getClassInstance(resourcesManager.getClassName(strIdentifier));
00233                     newFts.setResourceIdentifier(strIdentifier);
00234                     String prioritiesId = resourcesManager.getPrioritiesIdentifier(strIdentifier);
00235                     newFts.setAsOperatorPriority(resourcesManager.getAsOperatorPriority(prioritiesId));
00236                     newFts.setAsOperandPriority(resourcesManager.getAsOperandPriority(prioritiesId));
00237                     
00238                     if (value != null)
00239                         newFts.setValue(value);
00240                         
00241                     Integer arity = resourcesManager.getArity(strIdentifier);
00242                     if (arity != null)
00243                         ((KaryOperator) newFts).setOperatorArity(arity.intValue());
00244                     
00245                     switch (identifier) {
00246                         case LinearParserEvent.FUNCTION :
00247                         case LinearParserEvent.OPEN_PAREN :
00248                         case LinearParserEvent.OPEN_BRACKET :
00249                         case LinearParserEvent.OPEN_CURLY :
00250                             openingStack.push(newFts);
00251                     }
00252                     
00253                     current = newFts.insert(current);
00254                 }
00255         }
00256     }
00257     
00263     public void setDoProcessing(boolean doProcessing) {
00264         this.doProcessing = doProcessing;
00265     }
00266     
00271     public boolean getDoProcessing() {
00272         return doProcessing;
00273     }
00274     
00279     public void setProcessor(Processor processor) {
00280         this.processor = processor;
00281     }
00282     
00286     public Processor getProcessor() {
00287         return processor;
00288     }
00289     
00293     public void doProcess() {
00294         if (doProcessing && (processor != null))
00295             processor.doProcess();
00296     }
00297     
00298     public static void main(String args[]) {
00299         String exp = "sum(i^n,0,sum(i^n,0,5))t";
00300         Formula formula = new Formula();
00301         fr.ove.openmath.jome.ctrl.linear.LinearParser linearParser = new fr.ove.openmath.jome.ctrl.linear.LinearParser();
00302         linearParser.addLinearParserListener(formula);
00303         linearParser.parse(exp);
00304         System.out.println("la formule saisie est : \t\t" + exp);
00305         System.out.println("la formule construite est : \t\t" + formula.getLinear());
00306         
00307         try {
00308             Thread.sleep(5000);
00309         }
00310         catch (Exception e) {
00311             e.printStackTrace();
00312         }
00313     }
00314 
00315 }