source/mir/util/SimpleParser.java

   1 /*
   2  * Copyright (C) 2001, 2002  The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with the com.oreilly.servlet library, any library
  22  * licensed under the Apache Software License, The Sun (tm) Java Advanced
  23  * Imaging library (JAI), The Sun JIMI library (or with modified versions of
  24  * the above that use the same license as the above), and distribute linked
  25  * combinations including the two.  You must obey the GNU General Public
  26  * License in all respects for all of the code used other than the above
  27  * mentioned libraries.  If you modify this file, you may extend this exception
  28  * to your version of the file, but you are not obligated to do so.  If you do
  29  * not wish to do so, delete this exception statement from your version.
  30  */
  31
  32 package mir.util;
  33
  34 import java.util.*;
  35 import gnu.regexp.*;
  36 import multex.Exc;
  37 import multex.Failure;
  38
  39 public class SimpleParser {
  40   private String data;
  41   private int position;
  42
  43   public SimpleParser(String aData) {
  44     data=aData;
  45     position=0;
  46   }
  47
  48   public boolean parses(RE aRegularExpression) throws SimpleParserExc {
  49     REMatch match = aRegularExpression.getMatch(data, position);
  50
  51     return (match!=null && match.getStartIndex()==position) ;
  52   }
  53
  54   public String parse(RE aRegularExpression, String aMessage) throws SimpleParserExc {
  55     REMatch match = aRegularExpression.getMatch(data, position);
  56
  57     if (match==null || match.getStartIndex()!=position)
  58       throw new SimpleParserExc(aMessage+" at position "+position+" in '"+data+"'");
  59
  60     position=match.getEndIndex();
  61
  62     return match.toString();
  63   }
  64
  65   public String parse(RE aRegularExpression) throws SimpleParserExc {
  66     return parse( aRegularExpression, "No match found for '"+aRegularExpression.toString()+"'");
  67   }
  68
  69   public void skip(RE aRegularExpression) throws SimpleParserExc {
  70     REMatch match = aRegularExpression.getMatch(data, position);
  71
  72     if (match!=null && match.getStartIndex()==position)
  73       position=match.getEndIndex();
  74   }
  75
  76   public boolean parses(String anExpression) throws SimpleParserExc {
  77     try {
  78       return parses(new RE(anExpression));
  79     }
  80     catch (SimpleParserExc e) {
  81       throw e;
  82     }
  83     catch (REException e) {
  84       throw new SimpleParserFailure( "Error compiling regular expression '" + anExpression + "': " + e.getMessage(), e);
  85     }
  86     catch (Throwable t) {
  87       throw new SimpleParserFailure( t );
  88     }
  89   }
  90
  91   public String parse(String anExpression) throws SimpleParserExc, SimpleParserFailure {
  92     try {
  93       return parse(new RE(anExpression));
  94     }
  95     catch (SimpleParserExc e) {
  96       throw e;
  97     }
  98     catch (REException e) {
  99       throw new SimpleParserFailure( "Error compiling regular expression '" + anExpression + "': " + e.getMessage(), e);
 100     }
 101     catch (Throwable t) {
 102       throw new SimpleParserFailure( t );
 103     }
 104   }
 105
 106   public String parse(String anExpression, String aMessage) throws SimpleParserExc, SimpleParserFailure {
 107     try {
 108       return parse(new RE(anExpression), aMessage);
 109     }
 110     catch (SimpleParserExc e) {
 111       throw e;
 112     }
 113     catch (REException e) {
 114       throw new SimpleParserFailure( "Error compiling regular expression '" + anExpression + "': " + e.getMessage(), e);
 115     }
 116     catch (Throwable t) {
 117       throw new SimpleParserFailure( t );
 118     }
 119   }
 120
 121   public void skip(String anExpression) throws SimpleParserExc, SimpleParserFailure {
 122     try {
 123       skip(new RE(anExpression));
 124     }
 125     catch (SimpleParserExc e) {
 126       throw e;
 127     }
 128     catch (REException e) {
 129       throw new SimpleParserFailure( "Error compiling regular expression '" + anExpression + "': " + e.getMessage(), e);
 130     }
 131     catch (Throwable t) {
 132       throw new SimpleParserFailure( t );
 133     }
 134   }
 135   public boolean isAtEnd() {
 136     return position>=data.length();
 137   }
 138
 139   public static class SimpleParserFailure extends Failure {
 140     public SimpleParserFailure(Throwable aThrowable) {
 141       super(aThrowable.getMessage(), aThrowable);
 142     }
 143
 144     public SimpleParserFailure(String aMessage, Throwable aThrowable) {
 145       super(aMessage, aThrowable);
 146     }
 147   }
 148
 149   public static class SimpleParserExc extends Exc {
 150     public SimpleParserExc(String aMessage) {
 151       super(aMessage);
 152     }
 153   }
 154 }