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 gnu.regexp.RE;
  35 import gnu.regexp.REException;
  36 import gnu.regexp.REMatch;
  37 import multex.Exc;
  38 import multex.Failure;
  39
  40 public class SimpleParser {
  41   private String data;
  42   private int position;
  43
  44   public SimpleParser(String aData) {
  45     data=aData;
  46     position=0;
  47   }
  48
  49   public boolean parses(RE aRegularExpression) throws SimpleParserExc {
  50     REMatch match = aRegularExpression.getMatch(data, position);
  51
  52     return (match!=null && match.getStartIndex()==position) ;
  53   }
  54
  55   public String parse(RE aRegularExpression, String aMessage) throws SimpleParserExc {
  56     REMatch match = aRegularExpression.getMatch(data, position);
  57
  58     if (match==null || match.getStartIndex()!=position)
  59       throw new SimpleParserExc(aMessage+" at position "+position+" in '"+data+"'");
  60
  61     position=match.getEndIndex();
  62
  63     return match.toString();
  64   }
  65
  66   public String parse(RE aRegularExpression) throws SimpleParserExc {
  67     return parse( aRegularExpression, "No match found for '"+aRegularExpression.toString()+"'");
  68   }
  69
  70   public void skip(RE aRegularExpression) throws SimpleParserExc {
  71     REMatch match = aRegularExpression.getMatch(data, position);
  72
  73     if (match!=null && match.getStartIndex()==position)
  74       position=match.getEndIndex();
  75   }
  76
  77   public boolean parses(String anExpression) throws SimpleParserExc {
  78     try {
  79       return parses(new RE(anExpression));
  80     }
  81     catch (SimpleParserExc e) {
  82       throw e;
  83     }
  84     catch (REException e) {
  85       throw new SimpleParserFailure( "Error compiling regular expression '" + anExpression + "': " + e.getMessage(), e);
  86     }
  87     catch (Throwable t) {
  88       throw new SimpleParserFailure( t );
  89     }
  90   }
  91
  92   public String parse(String anExpression) throws SimpleParserExc, SimpleParserFailure {
  93     try {
  94       return parse(new RE(anExpression));
  95     }
  96     catch (SimpleParserExc e) {
  97       throw e;
  98     }
  99     catch (REException e) {
 100       throw new SimpleParserFailure( "Error compiling regular expression '" + anExpression + "': " + e.getMessage(), e);
 101     }
 102     catch (Throwable t) {
 103       throw new SimpleParserFailure( t );
 104     }
 105   }
 106
 107   public String parse(String anExpression, String aMessage) throws SimpleParserExc, SimpleParserFailure {
 108     try {
 109       return parse(new RE(anExpression), aMessage);
 110     }
 111     catch (SimpleParserExc e) {
 112       throw e;
 113     }
 114     catch (REException e) {
 115       throw new SimpleParserFailure( "Error compiling regular expression '" + anExpression + "': " + e.getMessage(), e);
 116     }
 117     catch (Throwable t) {
 118       throw new SimpleParserFailure( t );
 119     }
 120   }
 121
 122   public void skip(String anExpression) throws SimpleParserExc, SimpleParserFailure {
 123     try {
 124       skip(new RE(anExpression));
 125     }
 126     catch (SimpleParserExc e) {
 127       throw e;
 128     }
 129     catch (REException e) {
 130       throw new SimpleParserFailure( "Error compiling regular expression '" + anExpression + "': " + e.getMessage(), e);
 131     }
 132     catch (Throwable t) {
 133       throw new SimpleParserFailure( t );
 134     }
 135   }
 136   public boolean isAtEnd() {
 137     return position>=data.length();
 138   }
 139
 140   public static class SimpleParserFailure extends Failure {
 141     public SimpleParserFailure(Throwable aThrowable) {
 142       super(aThrowable.getMessage(), aThrowable);
 143     }
 144
 145     public SimpleParserFailure(String aMessage, Throwable aThrowable) {
 146       super(aMessage, aThrowable);
 147     }
 148   }
 149
 150   public static class SimpleParserExc extends Exc {
 151     public SimpleParserExc(String aMessage) {
 152       super(aMessage);
 153     }
 154   }
 155 }