221 lines
6.3 KiB
Java
221 lines
6.3 KiB
Java
/************************************************************************
|
|
*
|
|
* DeTeXtive.java
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License version 2.1, as published by the Free Software Foundation.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
* Copyright: 2002-2009 by Henrik Just
|
|
*
|
|
* All Rights Reserved.
|
|
*
|
|
* Version 1.2 (2009-06-19)
|
|
*
|
|
*/
|
|
|
|
package org.openoffice.da.comp.writer4latex;
|
|
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.io.IOException;
|
|
import java.util.HashSet;
|
|
|
|
import org.openoffice.da.comp.w2lcommon.tex.tokenizer.Mouth;
|
|
import org.openoffice.da.comp.w2lcommon.tex.tokenizer.Token;
|
|
import org.openoffice.da.comp.w2lcommon.tex.tokenizer.TokenType;
|
|
|
|
/** This class analyzes a stream and detects if it is a TeX stream.
|
|
* Currently it is able to identify LaTeX and XeLaTeX (ConTeXt and plain TeX may be
|
|
* added later).
|
|
*/
|
|
public class DeTeXtive {
|
|
private Mouth mouth;
|
|
private Token token;
|
|
|
|
private HashSet<String> packages;
|
|
|
|
/** Construct a new DeTeXtive
|
|
*/
|
|
public DeTeXtive() {
|
|
}
|
|
|
|
/** Detect the format of a given stream
|
|
*
|
|
* @param is the input stream
|
|
* @return a string representing the detected format; null if the format is unknown.
|
|
* Currently the values "LaTeX", "XeLaTeX" are supported.
|
|
* @throws IOException if we fail to read the stream
|
|
*/
|
|
public String deTeXt(InputStream is) throws IOException {
|
|
// It makes no harm to assume that the stream uses ISO Latin1 - we only consider ASCII characters
|
|
mouth = new Mouth(new InputStreamReader(is,"ISO8859_1"));
|
|
token = mouth.getTokenObject();
|
|
|
|
packages = new HashSet<String>();
|
|
|
|
mouth.getToken();
|
|
|
|
if (parseHeader() && parsePreamble()) {
|
|
if (packages.contains("xunicode")) {
|
|
return "XeLaTeX";
|
|
}
|
|
else {
|
|
return "LaTeX";
|
|
}
|
|
}
|
|
|
|
// Unknown format
|
|
return null;
|
|
|
|
}
|
|
|
|
// The parser!
|
|
|
|
// Parse a LaTeX header such as \documentclass[a4paper]{article}
|
|
// Return true in case of success
|
|
private boolean parseHeader() throws IOException {
|
|
skipBlanks();
|
|
if (token.isCS("documentclass") || token.isCS("documentstyle")) {
|
|
// The first non-blank token is \documentclass or \documentstyle => could be a LaTeX document
|
|
System.out.println("** Found "+token.toString());
|
|
mouth.getToken();
|
|
skipSpaces();
|
|
// Skip options, if any
|
|
if (token.is('[',TokenType.OTHER)) {
|
|
skipOptional();
|
|
skipSpaces();
|
|
}
|
|
if (token.getType()==TokenType.BEGIN_GROUP) {
|
|
// Get class name
|
|
String sClassName = parseArgumentAsString();
|
|
System.out.println("** Found the class name "+sClassName);
|
|
// Accept any class name of one or more characters
|
|
if (sClassName.length()>0) { return true; }
|
|
}
|
|
}
|
|
System.out.println("** Doesn't look like LaTeX; failed to get class name");
|
|
return false;
|
|
}
|
|
|
|
// Parse a LaTeX preamble
|
|
// Return true in case of success (that is, \begin{document} was found)
|
|
private boolean parsePreamble() throws IOException {
|
|
while (token.getType()!=TokenType.ENDINPUT) {
|
|
if (token.isCS("usepackage")) {
|
|
// We collect the names of all used packages, but discard their options
|
|
// (Recall that this is only relevant for LaTeX 2e)
|
|
mouth.getToken();
|
|
skipSpaces();
|
|
if (token.is('[',TokenType.OTHER)) {
|
|
skipOptional();
|
|
skipSpaces();
|
|
}
|
|
String sName = parseArgumentAsString();
|
|
System.out.println("** Found package "+sName);
|
|
packages.add(sName);
|
|
}
|
|
else if (token.getType()==TokenType.BEGIN_GROUP) {
|
|
// We ignore anything inside a group
|
|
skipGroup();
|
|
}
|
|
else if (token.isCS("begin")) {
|
|
// This would usually indicate the end of the preamble
|
|
mouth.getToken();
|
|
skipSpaces();
|
|
if ("document".equals(parseArgumentAsString())) {
|
|
System.out.println("Found \\begin{document}");
|
|
return true;
|
|
}
|
|
}
|
|
else {
|
|
// Any other content in the preamble is simply ignored
|
|
mouth.getToken();
|
|
}
|
|
}
|
|
System.out.println("** Doesn't look like LaTeX; failed to find \\begin{document}");
|
|
return false;
|
|
}
|
|
|
|
private void skipBlanks() throws IOException {
|
|
while (token.getType()==TokenType.SPACE || token.isCS("par")) {
|
|
mouth.getToken();
|
|
}
|
|
}
|
|
|
|
private void skipSpaces() throws IOException {
|
|
// Actually, we will never get two space tokens in a row
|
|
while (token.getType()==TokenType.SPACE) {
|
|
mouth.getToken();
|
|
}
|
|
}
|
|
|
|
private void skipOptional() throws IOException {
|
|
assert token.is('[', TokenType.OTHER);
|
|
|
|
mouth.getToken(); // skip the [
|
|
while (!token.is(']',TokenType.OTHER) && token.getType()!=TokenType.ENDINPUT) {
|
|
if (token.getType()==TokenType.BEGIN_GROUP) {
|
|
skipGroup();
|
|
}
|
|
else {
|
|
mouth.getToken(); // skip this token
|
|
}
|
|
}
|
|
mouth.getToken(); // skip the ]
|
|
}
|
|
|
|
private void skipGroup() throws IOException {
|
|
assert token.getType()==TokenType.BEGIN_GROUP;
|
|
|
|
mouth.getToken(); // skip the {
|
|
while (token.getType()!=TokenType.END_GROUP && token.getType()!=TokenType.ENDINPUT) {
|
|
if (token.getType()==TokenType.BEGIN_GROUP) {
|
|
skipGroup();
|
|
}
|
|
else {
|
|
mouth.getToken(); // skip this token
|
|
}
|
|
}
|
|
mouth.getToken(); // skip the }
|
|
}
|
|
|
|
private String parseArgumentAsString() throws IOException {
|
|
if (token.getType()==TokenType.BEGIN_GROUP) {
|
|
// Argument is contained in a group
|
|
mouth.getToken(); // skip the {
|
|
StringBuilder sb = new StringBuilder();
|
|
while (token.getType()!=TokenType.END_GROUP && token.getType()!=TokenType.ENDINPUT) {
|
|
if (token.getType()!=TokenType.COMMAND_SEQUENCE) {
|
|
// should not include cs, ignore if it happens
|
|
sb.append(token.getChar());
|
|
}
|
|
mouth.getToken();
|
|
}
|
|
mouth.getToken(); // skip the }
|
|
return sb.toString();
|
|
}
|
|
else {
|
|
// Argument is a single token
|
|
String s = "";
|
|
if (token.getType()!=TokenType.COMMAND_SEQUENCE) {
|
|
// should not include cs, ignore if it happens
|
|
s = token.getString();
|
|
}
|
|
mouth.getToken();
|
|
return s;
|
|
}
|
|
}
|
|
|
|
|
|
}
|