TempNewImagePackage/src/java/org/apache/xmlgraphics/ps/dsc/DSCParser.java - xmlgraphics-commons - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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.
  */

 /* $Id$ */

 package org.apache.xmlgraphics.ps.dsc;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import java.util.NoSuchElementException;

 import org.apache.xmlgraphics.ps.DSCConstants;
 import org.apache.xmlgraphics.ps.PSGenerator;
 import org.apache.xmlgraphics.ps.dsc.events.DSCAtend;
 import org.apache.xmlgraphics.ps.dsc.events.DSCComment;
 import org.apache.xmlgraphics.ps.dsc.events.DSCEvent;
 import org.apache.xmlgraphics.ps.dsc.events.DSCHeaderComment;
 import org.apache.xmlgraphics.ps.dsc.events.PostScriptComment;
 import org.apache.xmlgraphics.ps.dsc.events.PostScriptLine;
 import org.apache.xmlgraphics.ps.dsc.events.UnparsedDSCComment;
 import org.apache.xmlgraphics.ps.dsc.tools.DSCTools;

 /**
  * Parser for DSC-compliant PostScript files (DSC = Document Structuring Conventions). The parser
  * is implemented as a pull parser but has the ability to act as a push parser through the
  * DSCHandler interface.
  */
 public class DSCParser implements DSCParserConstants {

     private InputStream in;
     private BufferedReader reader;
     private boolean eofFound = false;
     private boolean checkEOF = true;
     private DSCEvent currentEvent;
     private DSCEvent nextEvent;
     private DSCFilter filter;
     private NestedDocumentHandler nestedDocumentHandler;

     /**
      * Creates a new DSC parser.
      * @param in InputStream to read the PostScript file from
      *              (the stream is not closed by this class, the caller is responsible for that)
      * @throws IOException In case of an I/O error
      * @throws DSCException In case of a violation of the DSC spec
      */
     public DSCParser(InputStream in) throws IOException, DSCException {
         if (in.markSupported()) {
             this.in = in;
         } else {
             //Decorate for better performance
             this.in = new java.io.BufferedInputStream(this.in);
         }
         String encoding = "US-ASCII";
         try {
             this.reader = new java.io.BufferedReader(
                     new java.io.InputStreamReader(this.in, encoding));
         } catch (UnsupportedEncodingException e) {
             throw new RuntimeException("Incompatible VM! " + e.getMessage());
         }
         parseNext();
     }

     /**
      * Returns the InputStream the PostScript code is read from.
      * @return the InputStream the PostScript code is read from
      */
     public InputStream getInputStream() {
         return this.in;
     }

     /**
      * This method is used to write out warning messages for the parsing process. Subclass to
      * override this method. The default implementation writes to System.err.
      * @param msg the warning message
      */
     protected void warn(String msg) {
         System.err.println(msg);
     }

     /**
      * Reads one line from the input file
      * @return the line or null if there are no more lines
      * @throws IOException In case of an I/O error
      * @throws DSCException In case of a violation of the DSC spec
      */
     protected String readLine() throws IOException, DSCException {
         String line;
         line = this.reader.readLine();
         checkLine(line);

         return line;
     }

     private void checkLine(String line) throws DSCException {
         if (line == null) {
             if (!eofFound) {
                 throw new DSCException("%%EOF not found. File is not well-formed.");
             }
         } else if (line.length() > 255) {
             warn("Line longer than 255 characters. This file is not fully PostScript conforming.");
         }
     }

     private final boolean isWhitespace(char c) {
         return c == ' ' || c == '\t';
     }

     private DSCComment parseDSCLine(String line) throws IOException, DSCException {
         int colon = line.indexOf(':');
         String name;
         String value = "";
         if (colon > 0) {
             name = line.substring(2, colon);
             int startOfValue = colon + 1;
             if (startOfValue < line.length()) {
                 if (isWhitespace(line.charAt(startOfValue))) {
                     startOfValue++;
                 }
                 value = line.substring(startOfValue).trim();
                 if (value.equals(DSCConstants.ATEND.toString())) {
                     return new DSCAtend(name);
                 }
             }
             String nextLine;
             while (true) {
                 this.reader.mark(512);
                 nextLine = readLine();
                 if (nextLine == null) {
                     break;
                 } else if (!nextLine.startsWith("%%+")) {
                     break;
                 }
                 value = value + nextLine.substring(3);
             }
             this.reader.reset();
         } else {
             name = line.substring(2);
             value = null;
         }
         return parseDSCComment(name, value);
     }

     private DSCComment parseDSCComment(String name, String value) {
         DSCComment parsed = DSCCommentFactory.createDSCCommentFor(name);
         if (parsed != null) {
             try {
                 parsed.parseValue(value);
                 return parsed;
             } catch (Exception e) {
                 //ignore and fall back to unparsed DSC comment
             }
         }
         UnparsedDSCComment unparsed = new UnparsedDSCComment(name);
         unparsed.parseValue(value);
         return unparsed;
     }

     /**
      * Starts the parser in push parsing mode sending events to the DSCHandler instance.
      * @param handler the DSCHandler instance to send the events to
      * @throws IOException In case of an I/O error
      * @throws DSCException In case of a violation of the DSC spec
      */
     public void parse(DSCHandler handler) throws IOException, DSCException {
         DSCHeaderComment header = DSCTools.checkAndSkipDSC30Header(this);
         handler.startDocument("%!" + header.getComment());
         DSCEvent event;
         while (hasNext()) {
             event = nextEvent();
             switch (event.getEventType()) {
             case HEADER_COMMENT:
                 handler.startDocument("%!" + ((DSCHeaderComment)event).getComment());
                 break;
             case DSC_COMMENT:
                 handler.handleDSCComment(event.asDSCComment());
                 break;
             case COMMENT:
                 handler.comment(((PostScriptComment)event).getComment());
                 break;
             case LINE:
                 handler.line(getLine());
                 break;
             case EOF:
                 if (isCheckEOF()) {
                     this.eofFound = true;
                 }
                 handler.endDocument();
                 break;
             default:
                 throw new IllegalStateException("Illegal event type: " + event.getEventType());
             }
         }
     }

     /**
      * Indicates whether there are additional items.
      * @return true if there are additonal items, false if the end of the file has been reached
      */
     public boolean hasNext() {
         return (this.nextEvent != null);
     }

     /**
      * Steps to the next item indicating the type of event.
      * @return the type of event (See {@link DSCParserConstants})
      * @throws IOException In case of an I/O error
      * @throws DSCException In case of a violation of the DSC spec
      * @throws NoSuchElementException If an attempt was made to advance beyond the end of the file
      */
     public int next() throws IOException, DSCException {
         if (hasNext()) {
             this.currentEvent = nextEvent;
             parseNext();
             if (this.nestedDocumentHandler != null) {
                 this.nestedDocumentHandler.handle(this.currentEvent, this);
             }
             return this.currentEvent.getEventType();
         } else {
             throw new NoSuchElementException("There are no more events");
         }
     }

     /**
      * Steps to the next item returning the new event.
      * @return the new event
      * @throws IOException In case of an I/O error
      * @throws DSCException In case of a violation of the DSC spec
      */
     public DSCEvent nextEvent() throws IOException, DSCException {
         next();
         return getCurrentEvent();
     }

     /**
      * Returns the current event.
      * @return the current event
      */
     public DSCEvent getCurrentEvent() {
         return this.currentEvent;
     }

     /**
      * Returns the next event without moving the cursor to the next event.
      * @return the next event
      */
     public DSCEvent peek() {
         return this.nextEvent;
     }

     /**
      * Parses the next event.
      * @throws IOException In case of an I/O error
      * @throws DSCException In case of a violation of the DSC spec
      */
     protected void parseNext() throws IOException, DSCException {
         String line = readLine();
         if (line != null) {
             if (eofFound && (line.length() > 0)) {
                 throw new DSCException("Content found after EOF");
             }
             if (line.startsWith("%%")) {
                 DSCComment comment = parseDSCLine(line);
                 if (comment.getEventType() == EOF && isCheckEOF()) {
                     this.eofFound = true;
                 }
                 this.nextEvent = comment;
             } else if (line.startsWith("%!")) {
                 this.nextEvent = new DSCHeaderComment(line.substring(2));
             } else if (line.startsWith("%")) {
                 this.nextEvent = new PostScriptComment(line.substring(1));
             } else {
                 this.nextEvent = new PostScriptLine(line);
             }
             if (this.filter != null && !filter.accept(this.nextEvent)) {
                 parseNext(); //skip
             }
         } else {
             this.nextEvent = null;
         }
     }

     /**
      * Returns the current PostScript line.
      * @return the current PostScript line
      * @throws IllegalStateException if the current event is not a normal PostScript line
      */
     public String getLine() {
         if (this.currentEvent.getEventType() == LINE) {
             return ((PostScriptLine)this.currentEvent).getLine();
         } else {
             throw new IllegalStateException("Current event is not a PostScript line");
         }
     }

     /**
      * Advances to the next DSC comment with the given name.
      * @param name the name of the DSC comment
      * @return the requested DSC comment or null if the end of the file is reached
      * @throws IOException In case of an I/O error
      * @throws DSCException In case of a violation of the DSC spec
      */
     public DSCComment nextDSCComment(String name)
                 throws IOException, DSCException {
         return nextDSCComment(name, null);
     }

     /**
      * Advances to the next DSC comment with the given name.
      * @param name the name of the DSC comment
      * @param gen PSGenerator to pass the skipped events though to
      * @return the requested DSC comment or null if the end of the file is reached
      * @throws IOException In case of an I/O error
      * @throws DSCException In case of a violation of the DSC spec
      */
     public DSCComment nextDSCComment(String name, PSGenerator gen)
                 throws IOException, DSCException {
         while (hasNext()) {
             DSCEvent event = nextEvent();
             if (event.isDSCComment()) {
                 DSCComment comment = event.asDSCComment();
                 if (name.equals(comment.getName())) {
                     return comment;
                 }
             }
             if (gen != null) {
                 event.generate(gen); //Pipe through to PSGenerator
             }
         }
         return null;
     }

     /**
      * Advances to the next PostScript comment with the given prefix. This is used to find
      * comments following the DSC extension mechanism.
      * <p>
      * Example: To find FOP's custom comments, pass in "FOP" as a prefix. This will find comments
      * like "%FOPFontSetup".
      * @param prefix the prefix of the extension comment
      * @param gen PSGenerator to pass the skipped events though to
      * @return the requested PostScript comment or null if the end of the file is reached
      * @throws IOException In case of an I/O error
      * @throws DSCException In case of a violation of the DSC spec
      */
     public PostScriptComment nextPSComment(String prefix, PSGenerator gen)
                     throws IOException, DSCException {
             while (hasNext()) {
                 DSCEvent event = nextEvent();
                 if (event.isComment()) {
                     PostScriptComment comment = (PostScriptComment)event;
                     if (comment.getComment().startsWith(prefix)) {
                         return comment;
                     }
                 }
                 if (gen != null) {
                     event.generate(gen); //Pipe through to PSGenerator
                 }
             }
             return null;
     }

     /**
      * Sets a filter for DSC events.
      * @param filter the filter to use or null to disable filtering
      */
     public void setFilter(DSCFilter filter) {
         this.filter = filter;
     }

     /**
      * Sets a NestedDocumentHandler which is used to skip nested documents like embedded EPS files.
      * You can also process those parts in a special way.
      * @param handler the NestedDocumentHandler instance or null to disable the feature
      */
     public void setNestedDocumentHandler(NestedDocumentHandler handler) {
         this.nestedDocumentHandler = handler;
     }

     /**
      * Tells the parser whether to check for content after the EOF comment.
      * This can be disabled to skip nested documents.
      * @param value true if the check is enabled
      */
     public void setCheckEOF(boolean value) {
         this.checkEOF = value;
     }

     /**
      * Indicates whether the parser is configured to check for content after the EOF comment.
      * @return true if the check is enabled.
      */
     public boolean isCheckEOF() {
         return this.checkEOF;
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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.
	*/

	/* $Id$ */

	package org.apache.xmlgraphics.ps.dsc;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.UnsupportedEncodingException;
	import java.util.NoSuchElementException;

	import org.apache.xmlgraphics.ps.DSCConstants;
	import org.apache.xmlgraphics.ps.PSGenerator;
	import org.apache.xmlgraphics.ps.dsc.events.DSCAtend;
	import org.apache.xmlgraphics.ps.dsc.events.DSCComment;
	import org.apache.xmlgraphics.ps.dsc.events.DSCEvent;
	import org.apache.xmlgraphics.ps.dsc.events.DSCHeaderComment;
	import org.apache.xmlgraphics.ps.dsc.events.PostScriptComment;
	import org.apache.xmlgraphics.ps.dsc.events.PostScriptLine;
	import org.apache.xmlgraphics.ps.dsc.events.UnparsedDSCComment;
	import org.apache.xmlgraphics.ps.dsc.tools.DSCTools;

	/**
	* Parser for DSC-compliant PostScript files (DSC = Document Structuring Conventions). The parser
	* is implemented as a pull parser but has the ability to act as a push parser through the
	* DSCHandler interface.
	*/
	public class DSCParser implements DSCParserConstants {

	private InputStream in;
	private BufferedReader reader;
	private boolean eofFound = false;
	private boolean checkEOF = true;
	private DSCEvent currentEvent;
	private DSCEvent nextEvent;
	private DSCFilter filter;
	private NestedDocumentHandler nestedDocumentHandler;

	/**
	* Creates a new DSC parser.
	* @param in InputStream to read the PostScript file from
	* (the stream is not closed by this class, the caller is responsible for that)
	* @throws IOException In case of an I/O error
	* @throws DSCException In case of a violation of the DSC spec
	*/
	public DSCParser(InputStream in) throws IOException, DSCException {
	if (in.markSupported()) {
	this.in = in;
	} else {
	//Decorate for better performance
	this.in = new java.io.BufferedInputStream(this.in);
	}
	String encoding = "US-ASCII";
	try {
	this.reader = new java.io.BufferedReader(
	new java.io.InputStreamReader(this.in, encoding));
	} catch (UnsupportedEncodingException e) {
	throw new RuntimeException("Incompatible VM! " + e.getMessage());
	}
	parseNext();
	}

	/**
	* Returns the InputStream the PostScript code is read from.
	* @return the InputStream the PostScript code is read from
	*/
	public InputStream getInputStream() {
	return this.in;
	}

	/**
	* This method is used to write out warning messages for the parsing process. Subclass to
	* override this method. The default implementation writes to System.err.
	* @param msg the warning message
	*/
	protected void warn(String msg) {
	System.err.println(msg);
	}

	/**
	* Reads one line from the input file
	* @return the line or null if there are no more lines
	* @throws IOException In case of an I/O error
	* @throws DSCException In case of a violation of the DSC spec
	*/
	protected String readLine() throws IOException, DSCException {
	String line;
	line = this.reader.readLine();
	checkLine(line);

	return line;
	}

	private void checkLine(String line) throws DSCException {
	if (line == null) {
	if (!eofFound) {
	throw new DSCException("%%EOF not found. File is not well-formed.");
	}
	} else if (line.length() > 255) {
	warn("Line longer than 255 characters. This file is not fully PostScript conforming.");
	}
	}

	private final boolean isWhitespace(char c) {
	return c == ' ' \|\| c == '\t';
	}

	private DSCComment parseDSCLine(String line) throws IOException, DSCException {
	int colon = line.indexOf(':');
	String name;
	String value = "";
	if (colon > 0) {
	name = line.substring(2, colon);
	int startOfValue = colon + 1;
	if (startOfValue < line.length()) {
	if (isWhitespace(line.charAt(startOfValue))) {
	startOfValue++;
	}
	value = line.substring(startOfValue).trim();
	if (value.equals(DSCConstants.ATEND.toString())) {
	return new DSCAtend(name);
	}
	}
	String nextLine;
	while (true) {
	this.reader.mark(512);
	nextLine = readLine();
	if (nextLine == null) {
	break;
	} else if (!nextLine.startsWith("%%+")) {
	break;
	}
	value = value + nextLine.substring(3);
	}
	this.reader.reset();
	} else {
	name = line.substring(2);
	value = null;
	}
	return parseDSCComment(name, value);
	}

	private DSCComment parseDSCComment(String name, String value) {
	DSCComment parsed = DSCCommentFactory.createDSCCommentFor(name);
	if (parsed != null) {
	try {
	parsed.parseValue(value);
	return parsed;
	} catch (Exception e) {
	//ignore and fall back to unparsed DSC comment
	}
	}
	UnparsedDSCComment unparsed = new UnparsedDSCComment(name);
	unparsed.parseValue(value);
	return unparsed;
	}

	/**
	* Starts the parser in push parsing mode sending events to the DSCHandler instance.
	* @param handler the DSCHandler instance to send the events to
	* @throws IOException In case of an I/O error
	* @throws DSCException In case of a violation of the DSC spec
	*/
	public void parse(DSCHandler handler) throws IOException, DSCException {
	DSCHeaderComment header = DSCTools.checkAndSkipDSC30Header(this);
	handler.startDocument("%!" + header.getComment());
	DSCEvent event;
	while (hasNext()) {
	event = nextEvent();
	switch (event.getEventType()) {
	case HEADER_COMMENT:
	handler.startDocument("%!" + ((DSCHeaderComment)event).getComment());
	break;
	case DSC_COMMENT:
	handler.handleDSCComment(event.asDSCComment());
	break;
	case COMMENT:
	handler.comment(((PostScriptComment)event).getComment());
	break;
	case LINE:
	handler.line(getLine());
	break;
	case EOF:
	if (isCheckEOF()) {
	this.eofFound = true;
	}
	handler.endDocument();
	break;
	default:
	throw new IllegalStateException("Illegal event type: " + event.getEventType());
	}
	}
	}

	/**
	* Indicates whether there are additional items.
	* @return true if there are additonal items, false if the end of the file has been reached
	*/
	public boolean hasNext() {
	return (this.nextEvent != null);
	}

	/**
	* Steps to the next item indicating the type of event.
	* @return the type of event (See {@link DSCParserConstants})
	* @throws IOException In case of an I/O error
	* @throws DSCException In case of a violation of the DSC spec
	* @throws NoSuchElementException If an attempt was made to advance beyond the end of the file
	*/
	public int next() throws IOException, DSCException {
	if (hasNext()) {
	this.currentEvent = nextEvent;
	parseNext();
	if (this.nestedDocumentHandler != null) {
	this.nestedDocumentHandler.handle(this.currentEvent, this);
	}
	return this.currentEvent.getEventType();
	} else {
	throw new NoSuchElementException("There are no more events");
	}
	}

	/**
	* Steps to the next item returning the new event.
	* @return the new event
	* @throws IOException In case of an I/O error
	* @throws DSCException In case of a violation of the DSC spec
	*/
	public DSCEvent nextEvent() throws IOException, DSCException {
	next();
	return getCurrentEvent();
	}

	/**
	* Returns the current event.
	* @return the current event
	*/
	public DSCEvent getCurrentEvent() {
	return this.currentEvent;
	}

	/**
	* Returns the next event without moving the cursor to the next event.
	* @return the next event
	*/
	public DSCEvent peek() {
	return this.nextEvent;
	}

	/**
	* Parses the next event.
	* @throws IOException In case of an I/O error
	* @throws DSCException In case of a violation of the DSC spec
	*/
	protected void parseNext() throws IOException, DSCException {
	String line = readLine();
	if (line != null) {
	if (eofFound && (line.length() > 0)) {
	throw new DSCException("Content found after EOF");
	}
	if (line.startsWith("%%")) {
	DSCComment comment = parseDSCLine(line);
	if (comment.getEventType() == EOF && isCheckEOF()) {
	this.eofFound = true;
	}
	this.nextEvent = comment;
	} else if (line.startsWith("%!")) {
	this.nextEvent = new DSCHeaderComment(line.substring(2));
	} else if (line.startsWith("%")) {
	this.nextEvent = new PostScriptComment(line.substring(1));
	} else {
	this.nextEvent = new PostScriptLine(line);
	}
	if (this.filter != null && !filter.accept(this.nextEvent)) {
	parseNext(); //skip
	}
	} else {
	this.nextEvent = null;
	}
	}

	/**
	* Returns the current PostScript line.
	* @return the current PostScript line
	* @throws IllegalStateException if the current event is not a normal PostScript line
	*/
	public String getLine() {
	if (this.currentEvent.getEventType() == LINE) {
	return ((PostScriptLine)this.currentEvent).getLine();
	} else {
	throw new IllegalStateException("Current event is not a PostScript line");
	}
	}

	/**
	* Advances to the next DSC comment with the given name.
	* @param name the name of the DSC comment
	* @return the requested DSC comment or null if the end of the file is reached
	* @throws IOException In case of an I/O error
	* @throws DSCException In case of a violation of the DSC spec
	*/
	public DSCComment nextDSCComment(String name)
	throws IOException, DSCException {
	return nextDSCComment(name, null);
	}

	/**
	* Advances to the next DSC comment with the given name.
	* @param name the name of the DSC comment
	* @param gen PSGenerator to pass the skipped events though to
	* @return the requested DSC comment or null if the end of the file is reached
	* @throws IOException In case of an I/O error
	* @throws DSCException In case of a violation of the DSC spec
	*/
	public DSCComment nextDSCComment(String name, PSGenerator gen)
	throws IOException, DSCException {
	while (hasNext()) {
	DSCEvent event = nextEvent();
	if (event.isDSCComment()) {
	DSCComment comment = event.asDSCComment();
	if (name.equals(comment.getName())) {
	return comment;
	}
	}
	if (gen != null) {
	event.generate(gen); //Pipe through to PSGenerator
	}
	}
	return null;
	}

	/**
	* Advances to the next PostScript comment with the given prefix. This is used to find
	* comments following the DSC extension mechanism.
	* <p>
	* Example: To find FOP's custom comments, pass in "FOP" as a prefix. This will find comments
	* like "%FOPFontSetup".
	* @param prefix the prefix of the extension comment
	* @param gen PSGenerator to pass the skipped events though to
	* @return the requested PostScript comment or null if the end of the file is reached
	* @throws IOException In case of an I/O error
	* @throws DSCException In case of a violation of the DSC spec
	*/
	public PostScriptComment nextPSComment(String prefix, PSGenerator gen)
	throws IOException, DSCException {
	while (hasNext()) {
	DSCEvent event = nextEvent();
	if (event.isComment()) {
	PostScriptComment comment = (PostScriptComment)event;
	if (comment.getComment().startsWith(prefix)) {
	return comment;
	}
	}
	if (gen != null) {
	event.generate(gen); //Pipe through to PSGenerator
	}
	}
	return null;
	}

	/**
	* Sets a filter for DSC events.
	* @param filter the filter to use or null to disable filtering
	*/
	public void setFilter(DSCFilter filter) {
	this.filter = filter;
	}

	/**
	* Sets a NestedDocumentHandler which is used to skip nested documents like embedded EPS files.
	* You can also process those parts in a special way.
	* @param handler the NestedDocumentHandler instance or null to disable the feature
	*/
	public void setNestedDocumentHandler(NestedDocumentHandler handler) {
	this.nestedDocumentHandler = handler;
	}

	/**
	* Tells the parser whether to check for content after the EOF comment.
	* This can be disabled to skip nested documents.
	* @param value true if the check is enabled
	*/
	public void setCheckEOF(boolean value) {
	this.checkEOF = value;
	}

	/**
	* Indicates whether the parser is configured to check for content after the EOF comment.
	* @return true if the check is enabled.
	*/
	public boolean isCheckEOF() {
	return this.checkEOF;
	}

	}