Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* ************************************************************************
  #
  #  DivConq
  #
  #  http://divconq.com/
  #
  #  Copyright:
  #    Copyright 2014 eTimeline, LLC. All rights reserved.
  #
 #  License:
 #    See the license.txt file in the project's top-level directory for details.
 #
 #  Authors:
 #    * Andy White
 #
 ************************************************************************ */
 
 /*
  * Parser.java February 2001
  *
  * Copyright (C) 2001, Niall Gallagher <niallg@users.sf.net>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
  * implied. See the License for the specific language governing 
  * permissions and limitations under the License.
  */
  
 package divconq.www.util.parse;

This Parser object is to be used as a simple template for parsing uncomplicated expressions. This object is used to parse a String. This provides a few methods that can be used to store and track the reading of data from a buffer. There are two abstract methods provided to allow this to be subclassed to create a Parser for a given String.

Author(s):
Niall Gallagher
 
 public abstract class Parser {

   
This is the buffer that is being parsed.
 
    protected char[] buf;

   
This represents the current read offset.
 
    protected int off;   

   
This represents the length of the buffer.
 
    protected int count;
  
   
This is a no argument constructor for the Parser. This will be invoked by each subclass of this object. It will set the buffer to a zero length buffer so that when the ensureCapacity method is used the buf's length can be checked.
 
    protected Parser(){
       this. = new char[0];
    }
   
   
This is used to parse the String given to it. This will ensure that the char buffer has enough space to contain the characters from the String. This will firstly ensure that the buffer is resized if nessecary. The second step in this parse method is to initialize the Parser object so that multiple parse invocations can be made. The init method will reset this to an prepared state. Then finally the parse method is called to parse the char buffer.

Parameters:
text the String to be parsed with this Parser
     
    public void parse(String text){
       if(text != null){ 
          ensureCapacity(text.length());
           = text.length();
          text.getChars(0, ,0);
          init(); 
          parse();
       }
    }
   
   
This ensure that there is enough space in the buffer to allow for more char's to be added. If the buffer is already larger than min then the buffer will not be expanded at all.

Parameters:
min the minimum size needed to accommodate the characters
     
   protected void ensureCapacity(int min) {
      if(. < min) {
         int size = . * 2;
         int max = Math.max(minsize);
         char[] temp = new char[max];         
          = temp;
      }
   }
   
   
This is used to determine if a given ISO-8859-1 character is a space character. That is a whitespace character this sees the, space, carriage return and line feed characters as whitespace characters.

Parameters:
c the character that is being determined by this
Returns:
true if the character given it is a space character
   protected boolean space(char c) {
      switch(c){
      case ' 'case '\t':
      case '\n'case '\r':
         return true;
      default:
         return false;
      }
   } 
   
   
This is used to determine weather or not a given character is a digit character. It assumes iso-8859-1 encoding to compare.

Parameters:
c the character being determined by this method
Returns:
true if the character given is a digit character
      
   protected boolean digit(char c){
      return c <= '9' && '0' <= c;
   }
   
   
This takes a unicode character and assumes an encoding of ISO-8859-1. This then checks to see if the given character is uppercase if it is it converts it into is ISO-8859-1 lowercase char.

Parameters:
c the char to be converted to lowercase
Returns:
the lowercase ISO-8859-1 of the given character
   protected char toLower(char c) {
      if(c >= 'A' && c <= 'Z') {
         return (char)((c - 'A') + 'a');
      }
      return c;
   }

   
This is used to skip an arbitrary String within the char buf. It checks the length of the String first to ensure that it will not go out of bounds. A comparison is then made with the buffers contents and the String if the reigon in the buffer matched the String then the offset within the buffer is increased by the String's length so that it has effectively skipped it.

Parameters:
text this is the String value to be skipped
Returns:
true if the String was skipped
   protected boolean skip(String text){
      int size = text.length();
      int read = 0;
      
      if( + size > ){
         return false;
      }
      while(read < size){
         char a = text.charAt(read);
         char b = [ + read++];
         
         if(toLower(a) != toLower(b)){            
            return false;
         }
      }
       += size;
      return true;
   }

   
This will initialize the Parser when it is ready to parse a new String. This will reset the Parser to a ready state. The init method is invoked by the Parser when the parse method is invoked.
   protected abstract void init();
   
   
This is the method that should be implemented to read the buf. This method should attempt to extract tokens from the buffer so that thes tokens may some how be used to determine the semantics. This method is invoked after the init method is invoked.
   protected abstract void parse();
New to GrepCode? Check out our FAQ X