Examples of it.halfone.regex.symbol.Symbol

it.halfone.regex.symbol.Symbol
Symbol - 22/set/2011 Classe Immutabile
Un simbolo rappresenta l'unita' fondamentale dell'operazione di costruzione di una Regex.
Intuitivamente, un simbolo � rappresentato dall'insieme di caratteri che egli riconosce; durante la stesura degli algoritmi di parsing pero' s'� reso necessario il poter associare ad un simbolo anche uno o piu' 'eventi' che vanno a modificare il 'contesto' di parsing.
All'inizio, ogni simbolo era associato ad uno e un solo carattere, ed era capace di riconoscere solo quel carattere. In questo senso il simbolo poteva essere benissimo 'scambiato' con la sua rappresentazione, che � il carattere che riconosce.
Per motivi di ottimizzazione e per semplicita', sono stati introdotti dei simboli capaci di riconoscere un insieme di caratteri, piuttosto che uno solo. Per questi simboli la 'rappresentazione' cessa di avere senso, e comincia ad avere senso un'altra loro proprieta': il TIPO. I 'vecchi' simboli (capaci di riconoscere solo un carattere) hanno il TIPO 'CHAR', e la loro 'rappresentazione' coincide col carattere riconosciuto; i nuovi simboli invece hanno un TIPO differente, e per essi la 'rappresentazione' non ha senso.
Il terzo 'upgrade' del concetto di simbolo si e' avuto quando si sono introdotti ulteriori tipi di simboli, da qui in avanti chiamati meta-simboli, adibiti non al riconoscimento di caratteri, ma aventi un significato differente all'interno della regex.
I TIPI possibili sono:
- CHAR: un simbolo che riconosce solo un carattere (uguale al valore della sua rappresentazione)
- ANY: un simbolo che riconosce qualsiasi carattere (la rappresentazione non ha senso)
- DIGIT: un simbolo che riconosce qualsiasi cifra da '0' a '9' (la rappresentazione non ha senso)
- NONDIGIT: un simbolo che riconosce qualsiasi carattere diverso dalle cifre da '0' a '9' (la rappresentazione non ha senso)
- WORD: un simbolo che riconosce qualsiasi carattere alfanumerico (la rappresentazione non ha senso)
- NONWORD: un simbolo che riconosce qualsiasi carattere che non sia alfanumerico (la rappresentazione non ha senso)
- WHITESPACE: un simbolo che riconosce qualsiasi carattere che sia uno 'spazio' (la rappresentazione non ha senso)
- NONWORD: un simbolo che riconosce qualsiasi carattere che non sia uno 'spazio' (la rappresentazione non ha senso)
- ALPHA: un simbolo che riconosce qualsiasi carattere alfabetico (la rappresentazione non ha senso)
- NONALPHA: un simbolo che riconosce qualsiasi carattere che non sia alfabetico (la rappresentazione non ha senso)
@author Andrea La Rosa

   * @return
   */
  public static Regex self() {
    Regex retVal = new Regex();
    retVal.isSelf = true;
    retVal.addSymbol(new Symbol("", Type.OPEN_SELF_START));
    retVal.addSymbol(new Symbol("", Type.OPEN_SELF_END));
    return retVal;
  }

View Full Code Here

    if (isSelf == false) {
      return this;
    }
    Regex retVal = new Regex();


    retVal.addSymbol(new Symbol("", Type.START));
    retVal.addSymbol(new Symbol("", Type.CHECK_IN));
    retVal.addSymbol(this.symbolList.toArray(new Symbol[] {}));
    retVal.addSymbol(new Symbol("", Type.CHECK_OUT));
    retVal.addSymbol(new Symbol("", Type.END));


    for (Integer key : this.connections.keySet()) {
      for (Integer successor : this.connections.get(key)) {
        retVal.addConnection(key + 2, successor + 2);
      }
    }


    for (int i = 0; i < retVal.symbolList.size(); i++) {
      Symbol symbol = retVal.symbolList.get(i);
      if (symbol.getType() == Type.OPEN_SELF_START) {
        retVal.symbolList.set(i, new Symbol("", Type.CLOSED_SELF_START));
        retVal.addConnection(i, 2);
      } else if (symbol.getType() == Type.OPEN_SELF_END) {
        retVal.symbolList.set(i, new Symbol("", Type.CLOSED_SELF_END));
        retVal.addConnection(retVal.symbolList.size() - 3, i);
      }
    }


    retVal.symbolList.set(2, new Symbol("", Type.PUSH));
    retVal.symbolList.set(retVal.symbolList.size() - 3, new Symbol("", Type.POP));


    retVal.addConnection(0, 1);
    retVal.addConnection(1, 2);
    retVal.addConnection(this.symbolList.size() + 1, this.symbolList.size() + 2);
    retVal.addConnection(this.symbolList.size() + 2, this.symbolList.size() + 3);

View Full Code Here

    List<SearchKnot<Tuple<Token, Integer>>> discoveryBoundaryList = new ArrayList<SearchKnot<Tuple<Token, Integer>>>();
    List<Token> discoveryExploredList = new ArrayList<Token>();
    List<SearchKnot<Tuple<Token, Integer>>> discoveryFinalList = new ArrayList<SearchKnot<Tuple<Token, Integer>>>();
    List<SearchKnot<Tuple<Token, Integer>>> newDiscoveryBoundaryList = new ArrayList<SearchKnot<Tuple<Token, Integer>>>();
    for (int i = 0; i < symbolList.size(); i++) {
      Symbol actualSymbol = symbolList.get(i);
      if (actualSymbol.getType() == Type.PUSH || actualSymbol.getType() == Type.POP) {
        SearchKnot<Tuple<Token, Integer>> root = new SearchKnot<Tuple<Token, Integer>>(new Tuple<Token, Integer>(tokens[i], i), null);


        newDiscoveryBoundaryList.clear();
        discoveryFinalList.clear();
        discoveryBoundaryList.clear();
        discoveryBoundaryList.add(root);
        discoveryExploredList.clear();


        while (discoveryBoundaryList.isEmpty() == false) {
          while (discoveryBoundaryList.isEmpty() == false) {
            SearchKnot<Tuple<Token, Integer>> actual = discoveryBoundaryList.remove(0);
            discoveryExploredList.add(actual.getValue().getFirst());


            for (int succ : connectionsMap.get(actual.getValue().getFirst())) {
              Symbol succSymbol = symbolList.get(succ);
              if (succSymbol == actualSymbol) {
                discoveryFinalList.add(new SearchKnot<Tuple<Token, Integer>>(new Tuple<Token, Integer>(tokens[succ], succ), actual));
              } else if (Symbol.isMetaSymbol(succSymbol.getType()) && succ < symbolList.size() - 1) {
                if (discoveryExploredList.contains(tokens[succ]) == false) {
                  newDiscoveryBoundaryList.add(new SearchKnot<Tuple<Token, Integer>>(new Tuple<Token, Integer>(tokens[succ], succ), actual));
                }
              }
            }
          }
          discoveryBoundaryList.clear();
          discoveryBoundaryList.addAll(newDiscoveryBoundaryList);
          newDiscoveryBoundaryList.clear();
        }


        if (discoveryFinalList.isEmpty() == false) {
          List<String> selfIdList = new ArrayList<String>();
          for (SearchKnot<Tuple<Token, Integer>> discoveryFinal : discoveryFinalList) {
            while (discoveryFinal.getParent() != null) {
              Symbol symbol = symbolList.get(discoveryFinal.getValue().getSecond());
              if (symbol.getType() == Type.CLOSED_SELF_START || symbol.getType() == Type.CLOSED_SELF_END) {
                selfIdList.add(closedSelfIdMap.get(discoveryFinal.getValue().getSecond()));
              }
              discoveryFinal = discoveryFinal.getParent();
            }
          }
          StringBuilder sb = new StringBuilder();
          sb.append("(" + selfIdList.get(0));
          for (int j = 1; j < selfIdList.size(); j++) {
            sb.append("|" + selfIdList.get(j));
          }
          sb.append(")*");
          symbolList.set(i, new Symbol("", actualSymbol.getType() == Type.PUSH ? Type.INFINI_PUSH : Type.INFINI_POP));
          String prefix = actualSymbol.getType() == Type.PUSH ? "" : "-";
          infiniLateralStackMap.put(i, prefix + sb.toString());
        } else {
          infiniLateralStackMap.put(i, "");
        }
      }
    }


    for (int i = 0; i < symbolList.size(); i++) {
      Symbol actualSymbol = symbolList.get(i);
      if (i == 0 || (Symbol.isMetaSymbol(actualSymbol.getType()) == false)) {
        boundary.clear();
        boundary.add(new Step(tokens[i], new ArrayList<Event>()));
        explored.clear();
        successorList.clear();


        while (boundary.isEmpty() == false) {
          Step actual = boundary.remove(0);
          explored.add(actual.getDestination());


          for (int succ : connectionsMap.get(actual.getDestination())) {
            Symbol succSymbol = symbolList.get(succ);
            List<Event> eventList = new ArrayList<Event>(actual.getEventList());
            if (succSymbol.getLikeness() != 0) {
              eventList.add(new LikenessEvent(succSymbol.getLikeness()));
            }
            if (succSymbol.getMarkIndex() != 0) {
              eventList.add(new MarkEvent(succSymbol.getMarkIndex() > 0, Math.abs(succSymbol.getMarkIndex()), succSymbol.getMarkName()));
            }
            if (succSymbol.getType() == Type.CHECK_IN || succSymbol.getType() == Type.CHECK_OUT) {
              eventList.add(new CheckEvent(succSymbol.getType() == Type.CHECK_IN));
            }
            if (succSymbol.getType() == Type.CLOSED_SELF_START || succSymbol.getType() == Type.CLOSED_SELF_END) {
              eventList.add(new LateralStepEvent(closedSelfIdMap.get(succ)));
            }
            if (Symbol.isStackRelated(succSymbol.getType())) {
              String minDepth = "";
              String maxDepth = "";
              switch (succSymbol.getType()) {
              case PUSH:
                minDepth = "1";
                maxDepth = "1";
                break;
              case POP:
                minDepth = "-1";
                maxDepth = "-1";
                break;
              case INFINI_PUSH:
                minDepth = "1";
                maxDepth = "+I";
                eventList.add(new LateralStepEvent(infiniLateralStackMap.get(succ)));
                break;
              case INFINI_POP:
                minDepth = "-I";
                maxDepth = "-1";
                eventList.add(new LateralStepEvent(infiniLateralStackMap.get(succ)));
                break;
              }
              eventList.add(new ChangeDepthEvent(minDepth, maxDepth));
            }
            if ((Symbol.isMetaSymbol(succSymbol.getType()) == false) || succ == symbolList.size() - 1) {
              successorList.add(new Step(tokens[succ], eventList));
            } else {
              Step newStep = new Step(tokens[succ], eventList);
              if (explored.contains(tokens[succ]) == false) {
                boundary.add(newStep);

View Full Code Here

0 1

TOP

Related Classes of it.halfone.regex.symbol.Symbol

it.halfone.regex.Regex

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.