git-svn-id: svn://svn.code.sf.net/p/writer2latex/code/trunk@26 f0f2a975-2e09-46c8-9428-3b39399b9f3c
This commit is contained in:
henrikjust
parent
574e550311
commit
9e78c8fc3d
11 changed files with 932 additions and 34 deletions
Binary file not shown.
|
|
@ -0,0 +1,333 @@
|
|||
/************************************************************************
|
||||
*
|
||||
* Mouth.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-18)
|
||||
*
|
||||
*/
|
||||
|
||||
package org.openoffice.da.comp.w2lcommon.tex.tokenizer;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.IOException;
|
||||
import java.io.Reader;
|
||||
|
||||
enum State {
|
||||
N, // new line
|
||||
M, // middle of line
|
||||
S; // ignoring spaces
|
||||
}
|
||||
|
||||
/** <p>The Mouth is the main class of this package. It is a tokenizer to TeX files: According to "The TeXBook", the
|
||||
* "eyes" and "mouth" of TeX are responsible for turning the input to TeX into a sequence of tokens.
|
||||
* We are not going to reimplement TeX, but rather providing a service for parsing high-level languages based on
|
||||
* TeX (eg. LaTeX, ConTeXt). For this reason the tokenizer deviates slightly from TeX: We're not reading a stream
|
||||
* of bytes but rather a stream of characters (which makes no difference for ASCII files).</p>
|
||||
*
|
||||
* <p>In tribute to Donald E. Knuths digestive metaphors, we divide the process in four levels</p>
|
||||
* <ul>
|
||||
* <li>The parser should provide a <em>pair of glasses</em> to translate the stream of bytes into a stream of characters</li>
|
||||
* <li>The <em>eyes</em> sees the stream of characters as a sequence of lines</li>
|
||||
* <li>The <em>mouth</em> chews a bit on the characters to turn them into tokens</li>
|
||||
* <li>The <em>tongue</em> reports the "taste" of the token to the parser</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class Mouth {
|
||||
private Reader reader; // The input
|
||||
private CatcodeTable catcodes; // The current catcode table
|
||||
private char cEndlinechar; // The current value of \endlinechar
|
||||
private Token token; // The token object
|
||||
private State state; // The current state of the tokenizer
|
||||
private Eyes eyes; // sic!
|
||||
|
||||
/** Construct a new <code>Mouth</code> based on a character stream
|
||||
*
|
||||
* @param reader the character stream to tokenize
|
||||
* @throws IOException if we fail to read the character stream
|
||||
*/
|
||||
public Mouth(Reader reader) throws IOException {
|
||||
this.reader = reader;
|
||||
catcodes = new CatcodeTable();
|
||||
cEndlinechar = '\r';
|
||||
token = new Token();
|
||||
state = State.N;
|
||||
eyes = new Eyes();
|
||||
}
|
||||
|
||||
private class Eyes {
|
||||
private BufferedReader br; // The inpuy
|
||||
private String sLine; // The current line
|
||||
private int nLen; // The length of the current line
|
||||
private int nIndex; // The current index in the current line
|
||||
|
||||
Eyes() throws IOException {
|
||||
br = new BufferedReader(reader);
|
||||
nextLine();
|
||||
}
|
||||
|
||||
/** Start looking at the next line of input
|
||||
*
|
||||
* @throws IOException if we fail to read the underlying stream
|
||||
*/
|
||||
void nextLine() throws IOException {
|
||||
sLine = br.readLine();
|
||||
if (sLine!=null) {
|
||||
nLen = sLine.length();
|
||||
nIndex = 0;
|
||||
// Delete trailing spaces
|
||||
while (nLen>0 && sLine.charAt(nLen-1)==' ') { nLen--; }
|
||||
}
|
||||
else { // end of stream
|
||||
nLen = 0;
|
||||
nIndex = 1;
|
||||
}
|
||||
}
|
||||
|
||||
/** Test whether the eyes are looking at a character
|
||||
*
|
||||
* @return true if the current line still has characters to look at
|
||||
*/
|
||||
boolean lookingAtChar() {
|
||||
return nIndex<=nLen;
|
||||
}
|
||||
|
||||
/** Test whether the eyes a looking at a line
|
||||
*
|
||||
* @return true if a current line is available
|
||||
*/
|
||||
boolean lookingAtLine() {
|
||||
return sLine!=null;
|
||||
}
|
||||
|
||||
/** Get the character that the eyes currently sees
|
||||
*
|
||||
* @return the character or U+FFFF if the eyes are not looking at a character
|
||||
*/
|
||||
char peekChar() {
|
||||
return getChar(false);
|
||||
}
|
||||
|
||||
/** Get the character that the eyes currently sees and start looking at the next character
|
||||
*
|
||||
* @return the character or U+FFFF if the eyes are not looking at a character
|
||||
*/
|
||||
char getChar() {
|
||||
return getChar(true);
|
||||
}
|
||||
|
||||
private char getChar(boolean bMove) {
|
||||
if (nIndex<nLen) {
|
||||
char c = sLine.charAt(nIndex);
|
||||
if (catcodes.get(c)==Catcode.SUPERSCRIPT && nIndex+2<nLen && catcodes.get(sLine.charAt(nIndex+1))==Catcode.SUPERSCRIPT) {
|
||||
// Found ^^ and at least one more character
|
||||
char c1 = sLine.charAt(nIndex+2);
|
||||
if (nIndex+3<nLen && isHex(c1)) {
|
||||
char c2 = sLine.charAt(nIndex+3);
|
||||
if (isHex(c2)) {
|
||||
// Found ^^ and a lower case hexidecimal number
|
||||
if (bMove) { nIndex+=4; }
|
||||
char[] digits = {c1, c2};
|
||||
return (char) Integer.parseInt(new String(digits), 16);
|
||||
}
|
||||
}
|
||||
else if (c1<128) {
|
||||
// Found ^^ and an ASCII character
|
||||
if (bMove) { nIndex+=3; }
|
||||
if (c1<64) { return (char)(c1+64); }
|
||||
else { return (char)(c1-64); }
|
||||
}
|
||||
}
|
||||
// Found an ordinary character!
|
||||
if (bMove) { nIndex++; }
|
||||
return c;
|
||||
}
|
||||
else if (nIndex==nLen) {
|
||||
// Add \endlinechar at the end of the line
|
||||
if (bMove) { nIndex++; }
|
||||
return cEndlinechar;
|
||||
}
|
||||
else {
|
||||
// No more characters on the current line
|
||||
return '\uFFFF';
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isHex(char c) {
|
||||
return ('0'<=c && c<='9') || ('a'<=c && c<='z');
|
||||
}
|
||||
}
|
||||
|
||||
/** Get the currently used catcode table
|
||||
*
|
||||
* @return the table
|
||||
*/
|
||||
public CatcodeTable getCatcodes() {
|
||||
return catcodes;
|
||||
}
|
||||
|
||||
/** Set the catcode table. The catcode table can be changed at any time during tokenization.
|
||||
*
|
||||
* @param catcodes the table
|
||||
*/
|
||||
public void setCatcodes(CatcodeTable catcodes) {
|
||||
this.catcodes = catcodes;
|
||||
}
|
||||
|
||||
/** Return the current value of the \endlinechar (the character added to the end of each input line)
|
||||
*
|
||||
* @return the character
|
||||
*/
|
||||
public char getEndlinechar() {
|
||||
return cEndlinechar;
|
||||
}
|
||||
|
||||
/** Set a new \endlinechar (the character added to the end of each input line). The character can be changed at
|
||||
* any time during tokenization.
|
||||
*
|
||||
* @param c the character
|
||||
*/
|
||||
public void setEndlinechar(char c) {
|
||||
cEndlinechar = c;
|
||||
}
|
||||
|
||||
/** Return the object used to store the current token (the "tongue" of TeX).
|
||||
* The same object is reused for all tokens, so for convenience the parser can keep a reference to the object.
|
||||
* If on the other hand the parser needs to store a token list, it must explicitly clone all tokens.
|
||||
*
|
||||
* @return the token
|
||||
*/
|
||||
public Token getTokenObject() {
|
||||
return token;
|
||||
}
|
||||
|
||||
/** Get the next token
|
||||
*
|
||||
* @return the token (for convenince; the same object is returned by {@link Mouth#getTokenObject}).
|
||||
* @throws IOException if we fail to read the underlying stream
|
||||
*/
|
||||
public Token getToken() throws IOException {
|
||||
while (eyes.lookingAtLine()) {
|
||||
while (eyes.lookingAtChar()) {
|
||||
char c = eyes.getChar();
|
||||
switch (catcodes.get(c)) {
|
||||
case ESCAPE:
|
||||
token.setType(TokenType.COMMAND_SEQUENCE);
|
||||
token.clearChars();
|
||||
// TODO: The description in the TeXBook is not completely clear,
|
||||
// (as long as \r and no other character has catcode END_OF_LINE this should be correct)
|
||||
if (catcodes.get(eyes.peekChar())==Catcode.LETTER) {
|
||||
state = State.S;
|
||||
while (eyes.lookingAtChar() && catcodes.get(eyes.peekChar())==Catcode.LETTER) {
|
||||
token.addChar(eyes.getChar());
|
||||
}
|
||||
}
|
||||
else if (catcodes.get(eyes.peekChar())==Catcode.SPACE) {
|
||||
state = State.S;
|
||||
token.setChar(eyes.getChar());
|
||||
}
|
||||
else if (catcodes.get(eyes.peekChar())!=Catcode.END_OF_LINE) {
|
||||
state = State.M;
|
||||
token.setChar(eyes.getChar());
|
||||
}
|
||||
else {
|
||||
// Empty control sequence
|
||||
state = State.M;
|
||||
}
|
||||
return token;
|
||||
case BEGIN_GROUP:
|
||||
token.set(c, TokenType.BEGIN_GROUP);
|
||||
return token;
|
||||
case END_GROUP:
|
||||
token.set(c, TokenType.END_GROUP);
|
||||
return token;
|
||||
case MATH_SHIFT:
|
||||
token.set(c, TokenType.MATH_SHIFT);
|
||||
return token;
|
||||
case ALIGNMENT_TAB:
|
||||
token.set(c, TokenType.ALIGNMENT_TAB);
|
||||
return token;
|
||||
case END_OF_LINE:
|
||||
// Skip rest of line
|
||||
while (eyes.lookingAtChar()) { eyes.getChar(); }
|
||||
switch (state) {
|
||||
case N:
|
||||
// This terminates an empty line -> insert a \par
|
||||
token.setType(TokenType.COMMAND_SEQUENCE);
|
||||
token.clearChars();
|
||||
token.addChar('p');
|
||||
token.addChar('a');
|
||||
token.addChar('r');
|
||||
return token;
|
||||
case M:
|
||||
// Replace with a space token
|
||||
token.set(' ', TokenType.SPACE);
|
||||
return token;
|
||||
case S:
|
||||
// ignore the character
|
||||
}
|
||||
break;
|
||||
case PARAMETER:
|
||||
token.set(c, TokenType.PARAMETER);
|
||||
return token;
|
||||
case SUPERSCRIPT:
|
||||
token.set(c, TokenType.SUPERSCRIPT);
|
||||
return token;
|
||||
case SUBSCRIPT:
|
||||
token.set(c, TokenType.SUBSCRIPT);
|
||||
return token;
|
||||
case IGNORED:
|
||||
// ignore this character
|
||||
break;
|
||||
case SPACE:
|
||||
if (state==State.M) {
|
||||
state=State.S;
|
||||
token.set(' ', TokenType.SPACE);
|
||||
return token;
|
||||
}
|
||||
// In state N and S the space character is ignored
|
||||
break;
|
||||
case LETTER:
|
||||
token.set(c, TokenType.LETTER);
|
||||
return token;
|
||||
case OTHER:
|
||||
token.set(c, TokenType.OTHER);
|
||||
return token;
|
||||
case ACTIVE:
|
||||
token.set(c, TokenType.ACTIVE);
|
||||
return token;
|
||||
case COMMENT:
|
||||
// Skip rest of line
|
||||
while (eyes.lookingAtChar()) { eyes.getChar(); }
|
||||
break;
|
||||
case INVALID:
|
||||
// ignore this character (should issue an error message, but we ignore that)
|
||||
}
|
||||
}
|
||||
eyes.nextLine();
|
||||
state = State.N;
|
||||
}
|
||||
// Nothing more to read
|
||||
token.setType(TokenType.ENDINPUT);
|
||||
token.clearChars();
|
||||
return token;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,157 @@
|
|||
/************************************************************************
|
||||
*
|
||||
* Token.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-18)
|
||||
*
|
||||
*/
|
||||
|
||||
package org.openoffice.da.comp.w2lcommon.tex.tokenizer;
|
||||
|
||||
/** This class represent a token in TeX
|
||||
*/
|
||||
public class Token implements Cloneable {
|
||||
private TokenType type;
|
||||
private char[] tokenChars;
|
||||
private int nTokenLen;
|
||||
private int nCapacity;
|
||||
|
||||
/** Construct a new <code>Token</code>, initialized as a <code>TokenTYPE.ENDINPUT</code>-token
|
||||
*/
|
||||
public Token() {
|
||||
type = TokenType.ENDINPUT;
|
||||
tokenChars = new char[25];
|
||||
nCapacity = 25;
|
||||
nTokenLen = 0;
|
||||
}
|
||||
|
||||
/** Set the type of this token to a specific <code>TokenType</code>
|
||||
* (the character content is not changed)
|
||||
*
|
||||
* @param type the new <code>TokenType</code>
|
||||
*/
|
||||
protected void setType(TokenType type) {
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
/** Set the character content of this token to a single character
|
||||
* (the type of the token is not changed)
|
||||
*
|
||||
* @param c the character
|
||||
*/
|
||||
protected void setChar(char c) {
|
||||
tokenChars[0] = c;
|
||||
nTokenLen = 1;
|
||||
}
|
||||
|
||||
/** Set this token as a character token with a specific <code>TokenType</code>
|
||||
*
|
||||
* @param c the character
|
||||
* @param type the <code>TokenType</code> to use
|
||||
*/
|
||||
protected void set(char c, TokenType type) {
|
||||
setType(type);
|
||||
setChar(c);
|
||||
}
|
||||
|
||||
/** Delete the character content of this token
|
||||
*/
|
||||
protected void clearChars() {
|
||||
nTokenLen = 0;
|
||||
}
|
||||
|
||||
/** Append a character to the character content of this token
|
||||
*
|
||||
* @param c the character to be appended
|
||||
*/
|
||||
protected void addChar(char c) {
|
||||
if (nTokenLen == nCapacity) {
|
||||
char[] temp = tokenChars;
|
||||
nCapacity+=25;
|
||||
tokenChars = new char[nCapacity];
|
||||
System.arraycopy(temp, 0, tokenChars, 0, temp.length);
|
||||
}
|
||||
tokenChars[nTokenLen++] = c;
|
||||
}
|
||||
|
||||
/** Test wether this token is a character token of the given type (that is, a single character
|
||||
* with a token type that is neither <code>COMMAND_SEQUENCE</code> nor <code>ENDINPUT</code>)
|
||||
*
|
||||
* @param c the character to test
|
||||
* @param type the <code>TokenType</code> to test
|
||||
* @return true if the test was successful
|
||||
*/
|
||||
public boolean is(char c, TokenType type) {
|
||||
return this.type==type && type!=TokenType.COMMAND_SEQUENCE && type!=TokenType.ENDINPUT &&
|
||||
nTokenLen==1 && tokenChars[0]==c;
|
||||
}
|
||||
|
||||
/** Test wether this token is a <code>COMMAND_SEQUENCE</code> token with a given name
|
||||
*
|
||||
* @param sName the name of the command sequence
|
||||
* @return true if the test was successful
|
||||
*/
|
||||
public boolean isCS(String sName) {
|
||||
if (type==TokenType.COMMAND_SEQUENCE && sName.length()==nTokenLen) {
|
||||
for (int i=0; i<nTokenLen; i++) {
|
||||
if (sName.charAt(i)!=tokenChars[i]) { return false; }
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Get the <code>TokenType</code> of this token
|
||||
*
|
||||
* @return the type
|
||||
*/
|
||||
public TokenType getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
/** Get the first character in this token
|
||||
*
|
||||
* @return the character or U+FFFF is no characters exist
|
||||
*/
|
||||
public char getChar() {
|
||||
return nTokenLen>0 ? tokenChars[0] : '\uFFFF';
|
||||
}
|
||||
|
||||
/** Get the character content of this token as a string
|
||||
*
|
||||
* @return the character content
|
||||
*/
|
||||
public String getString() {
|
||||
return new String(tokenChars,0,nTokenLen);
|
||||
}
|
||||
|
||||
@Override public String toString() {
|
||||
switch (type) {
|
||||
case COMMAND_SEQUENCE:
|
||||
return "\\"+getString();
|
||||
case ENDINPUT:
|
||||
return "<EOF>";
|
||||
default:
|
||||
return Character.toString(getChar());
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
*
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Version 1.2 (2009-05-01)
|
||||
* Version 1.2 (2009-06-19)
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -268,7 +268,7 @@ public final class ConfigurationDialog
|
|||
externalApps.setApplication(ExternalApps.DVIPS, "dvips", "%s");
|
||||
externalApps.setApplication(ExternalApps.BIBTEX, "bibtex", "%s");
|
||||
externalApps.setApplication(ExternalApps.MAKEINDEX, "makeindex", "%s");
|
||||
externalApps.setApplication(ExternalApps.MK4HT, "mk4ht", "oolatex %s");
|
||||
externalApps.setApplication(ExternalApps.MK4HT, "mk4ht", "%c %s");
|
||||
externalApps.setApplication(ExternalApps.DVIVIEWER, "yap", "--single-instance %s");
|
||||
// And assume gsview for pdf and ps
|
||||
// gsview32 may not be in the path, but at least this helps a bit
|
||||
|
|
@ -282,7 +282,7 @@ public final class ConfigurationDialog
|
|||
configureApp(ExternalApps.DVIPS, "dvips", "%s");
|
||||
configureApp(ExternalApps.BIBTEX, "bibtex", "%s");
|
||||
configureApp(ExternalApps.MAKEINDEX, "makeindex", "%s");
|
||||
configureApp(ExternalApps.MK4HT, "mk4ht", "oolatex %s");
|
||||
configureApp(ExternalApps.MK4HT, "mk4ht", "%c %s");
|
||||
// We have several possible viewers
|
||||
String[] sDviViewers = {"evince", "okular", "xdvi"};
|
||||
configureApp(ExternalApps.DVIVIEWER, sDviViewers, "%s");
|
||||
|
|
|
|||
221
source/java/org/openoffice/da/comp/writer4latex/DeTeXtive.java
Normal file
221
source/java/org/openoffice/da/comp/writer4latex/DeTeXtive.java
Normal file
|
|
@ -0,0 +1,221 @@
|
|||
/************************************************************************
|
||||
*
|
||||
* 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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
*
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Version 1.2 (2009-03-30)
|
||||
* Version 1.2 (2009-06-19)
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -95,7 +95,7 @@ public class ExternalApps {
|
|||
public String[] getApplication(String sAppName) {
|
||||
return apps.get(sAppName);
|
||||
}
|
||||
|
||||
|
||||
/** Execute an external application
|
||||
* @param sAppName the name of the application to execute
|
||||
* @param sFileName the file name to use
|
||||
|
|
@ -104,6 +104,18 @@ public class ExternalApps {
|
|||
* @return error code
|
||||
*/
|
||||
public int execute(String sAppName, String sFileName, File workDir, boolean bWaitFor) {
|
||||
return execute(sAppName, "", sFileName, workDir, bWaitFor);
|
||||
}
|
||||
|
||||
/** Execute an external application
|
||||
* @param sAppName the name of the application to execute
|
||||
* @param sCommand subcommand/option to pass to the command
|
||||
* @param sFileName the file name to use
|
||||
* @param workDir the working directory to use
|
||||
* @param bWaitFor true if the method should wait for the execution to finish
|
||||
* @return error code
|
||||
*/
|
||||
public int execute(String sAppName, String sCommand, String sFileName, File workDir, boolean bWaitFor) {
|
||||
// Assemble the command
|
||||
String[] sApp = getApplication(sAppName);
|
||||
if (sApp==null) { return 1; }
|
||||
|
|
@ -113,19 +125,13 @@ public class ExternalApps {
|
|||
command.add(sApp[0]);
|
||||
String[] sArguments = sApp[1].split(" ");
|
||||
for (String s : sArguments) {
|
||||
command.add(s.replace("%s",sFileName));
|
||||
command.add(s.replace("%c",sCommand).replace("%s",sFileName));
|
||||
}
|
||||
|
||||
ProcessBuilder pb = new ProcessBuilder(command);
|
||||
//Map<String, String> env = pb.environment();
|
||||
//env.put("VAR1", "myValue");
|
||||
pb.directory(workDir);
|
||||
Process proc = pb.start();
|
||||
|
||||
|
||||
//Runtime rt = Runtime.getRuntime();
|
||||
//Process proc = rt.exec(sCommand, new String[0], workDir);
|
||||
|
||||
// Gobble the error stream of the application
|
||||
StreamGobbler errorGobbler = new
|
||||
StreamGobbler(proc.getErrorStream(), "ERROR");
|
||||
|
|
|
|||
|
|
@ -20,25 +20,33 @@
|
|||
*
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Version 1.2 (2009-05-20)
|
||||
* Version 1.2 (2009-06-19)
|
||||
*
|
||||
*/
|
||||
|
||||
package org.openoffice.da.comp.writer4latex;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import com.sun.star.lib.uno.adapter.XInputStreamToInputStreamAdapter;
|
||||
import com.sun.star.lib.uno.helper.WeakBase;
|
||||
|
||||
import com.sun.star.beans.PropertyValue;
|
||||
import com.sun.star.document.XExtendedFilterDetection;
|
||||
import com.sun.star.task.XStatusIndicator;
|
||||
import com.sun.star.lang.XServiceInfo;
|
||||
import com.sun.star.io.XInputStream;
|
||||
import com.sun.star.ucb.XSimpleFileAccess2;
|
||||
import com.sun.star.uno.AnyConverter;
|
||||
import com.sun.star.uno.UnoRuntime;
|
||||
import com.sun.star.uno.XComponentContext;
|
||||
|
||||
|
||||
|
||||
/** This class provides detect services for TeX documents
|
||||
* It is thus an implementation of the service com.sun.star.document.ExtendedTypeDetection
|
||||
*/
|
||||
|
||||
public class TeXDetectService extends WeakBase implements XExtendedFilterDetection {
|
||||
public class TeXDetectService extends WeakBase implements XExtendedFilterDetection, XServiceInfo {
|
||||
|
||||
// Constants
|
||||
|
||||
|
|
@ -47,17 +55,40 @@ public class TeXDetectService extends WeakBase implements XExtendedFilterDetecti
|
|||
public static final String __serviceName = "com.sun.star.document.ExtendedTypeDetection";
|
||||
private static final String[] m_serviceNames = { __serviceName };
|
||||
|
||||
// The type names
|
||||
private static final String LATEX_FILE = "org.openoffice.da.writer4latex.LaTeX_File";
|
||||
private static final String XELATEX_FILE = "org.openoffice.da.writer4latex.XeLaTeX_File";
|
||||
|
||||
// From constructor+initialization
|
||||
private final XComponentContext m_xContext;
|
||||
private final XComponentContext m_xContext;
|
||||
|
||||
/** Construct a new <code>TeXDetectService</code>
|
||||
*
|
||||
* @param xContext The Component Context
|
||||
*/
|
||||
public TeXDetectService( XComponentContext xContext ) {
|
||||
m_xContext = xContext;
|
||||
}
|
||||
m_xContext = xContext;
|
||||
}
|
||||
|
||||
// Implement com.sun.star.lang.XServiceInfo:
|
||||
public String getImplementationName() {
|
||||
return __implementationName;
|
||||
}
|
||||
|
||||
public boolean supportsService( String sService ) {
|
||||
int len = m_serviceNames.length;
|
||||
|
||||
for(int i=0; i < len; i++) {
|
||||
if (sService.equals(m_serviceNames[i]))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public String[] getSupportedServiceNames() {
|
||||
return m_serviceNames;
|
||||
}
|
||||
|
||||
// Implement XExtendedFilterDetection
|
||||
public String detect(PropertyValue[][] mediaDescriptor) {
|
||||
// Read the media properties
|
||||
|
|
@ -80,10 +111,66 @@ public class TeXDetectService extends WeakBase implements XExtendedFilterDetecti
|
|||
}
|
||||
}
|
||||
|
||||
if ("org.openoffice.da.writer4latex.LaTeX_File".equals(sTypeName)) {
|
||||
return sTypeName;
|
||||
// If there's no URL, we cannot verify the type (this should never happen on proper use of the service)
|
||||
if (sURL==null) {
|
||||
System.out.println("No URL given!");
|
||||
return "";
|
||||
}
|
||||
else {
|
||||
|
||||
System.out.println("Asked to verify the type "+sTypeName);
|
||||
// Also, we can only verify LaTeX and XeLaTeX
|
||||
if (sTypeName==null || !(sTypeName.equals(LATEX_FILE) || sTypeName.equals(XELATEX_FILE))) {
|
||||
return "";
|
||||
}
|
||||
|
||||
// Initialise the file access
|
||||
XSimpleFileAccess2 sfa2 = null;
|
||||
try {
|
||||
Object sfaObject = m_xContext.getServiceManager().createInstanceWithContext(
|
||||
"com.sun.star.ucb.SimpleFileAccess", m_xContext);
|
||||
sfa2 = (XSimpleFileAccess2) UnoRuntime.queryInterface(XSimpleFileAccess2.class, sfaObject);
|
||||
}
|
||||
catch (com.sun.star.uno.Exception e) {
|
||||
// failed to get SimpleFileAccess service (should not happen)
|
||||
System.out.println("Failed to get SFA service");
|
||||
return "";
|
||||
}
|
||||
|
||||
// Get the input stream
|
||||
XInputStreamToInputStreamAdapter is = null;
|
||||
try {
|
||||
XInputStream xis = sfa2.openFileRead(sURL);
|
||||
is = new XInputStreamToInputStreamAdapter(xis);
|
||||
}
|
||||
catch (com.sun.star.ucb.CommandAbortedException e) {
|
||||
// Failed to create input stream, cannot verify the type
|
||||
System.out.println("Failed to get input stream");
|
||||
return "";
|
||||
}
|
||||
catch (com.sun.star.uno.Exception e) {
|
||||
// Failed to create input stream, cannot verify the type
|
||||
System.out.println("Failed to get input stream");
|
||||
return "";
|
||||
}
|
||||
|
||||
// Ask the deTeXtive
|
||||
DeTeXtive deTeXtive = new DeTeXtive();
|
||||
try {
|
||||
String sType = deTeXtive.deTeXt(is);
|
||||
System.out.println("The DeTeXtive returned the type "+sType);
|
||||
if ("LaTeX".equals(sType)) {
|
||||
return LATEX_FILE;
|
||||
}
|
||||
else if ("XeLaTeX".equals(sType)) {
|
||||
return XELATEX_FILE;
|
||||
}
|
||||
else {
|
||||
return "";
|
||||
}
|
||||
}
|
||||
catch (IOException e) {
|
||||
// Failed to read the stream, cannot verify the type
|
||||
System.out.println("Failed to read the input stream");
|
||||
return "";
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@
|
|||
*
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Version 1.2 (2009-05-19)
|
||||
* Version 1.2 (2009-06-19)
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -32,6 +32,7 @@ import java.net.URI;
|
|||
|
||||
import com.sun.star.lib.uno.helper.WeakBase;
|
||||
import com.sun.star.document.XDocumentInsertable;
|
||||
import com.sun.star.lang.XServiceInfo;
|
||||
import com.sun.star.task.XStatusIndicator;
|
||||
import com.sun.star.text.XTextCursor;
|
||||
import com.sun.star.text.XTextDocument;
|
||||
|
|
@ -48,7 +49,7 @@ import com.sun.star.document.XFilter;
|
|||
/** This class implements an import filter for TeX documents using TeX4ht
|
||||
* It is thus an implementation of the service com.sun.star.document.ImportFilter
|
||||
*/
|
||||
public class TeXImportFilter extends WeakBase implements XInitialization, XNamed, XImporter, XFilter {
|
||||
public class TeXImportFilter extends WeakBase implements XInitialization, XNamed, XImporter, XFilter, XServiceInfo {
|
||||
|
||||
// Constants
|
||||
|
||||
|
|
@ -282,7 +283,15 @@ public class TeXImportFilter extends WeakBase implements XInitialization, XNamed
|
|||
|
||||
if (xStatus!=null) { xStatus.setValue(++nStep); }
|
||||
|
||||
externalApps.execute(ExternalApps.MK4HT, file.getName(), file.getParentFile(), true);
|
||||
// Default is the filter org.openoffice.da.writer4latex.latex
|
||||
String sCommand = "oolatex";
|
||||
if ("org.openoffice.da.writer4latex.xelatex".equals(m_sFilterName)) {
|
||||
sCommand = "ooxelatex";
|
||||
}
|
||||
|
||||
System.out.println("Executing tex4ht with command "+sCommand+" on file "+file.getName());
|
||||
|
||||
externalApps.execute(ExternalApps.MK4HT, sCommand, file.getName(), file.getParentFile(), true);
|
||||
|
||||
if (xStatus!=null) { nStep+=5; xStatus.setValue(nStep); }
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@
|
|||
*
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Version 1.2 (2009-05-18)
|
||||
* Version 1.2 (2009-06-19)
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -505,17 +505,78 @@ public final class Writer4LaTeX extends WeakBase
|
|||
String sResult = "";
|
||||
for (int i=0; i<sArgument.length(); i++) {
|
||||
char c = sArgument.charAt(i);
|
||||
if ((c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9') || c=='-' || c=='.') {
|
||||
if ((c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9')) {
|
||||
sResult += Character.toString(c);
|
||||
}
|
||||
// TODO: Create replacement table for other latin characters..
|
||||
else if (c==' ') { sResult += "-"; }
|
||||
else if (c=='\u00c6') { sResult += "AE"; }
|
||||
else if (c=='\u00d8') { sResult += "OE"; }
|
||||
else if (c=='\u00c5') { sResult += "AA"; }
|
||||
else if (c=='\u00e6') { sResult += "ae"; }
|
||||
else if (c=='\u00f8') { sResult += "oe"; }
|
||||
else if (c=='\u00e5') { sResult += "aa"; }
|
||||
else {
|
||||
switch (c) {
|
||||
case '.': sResult += "."; break;
|
||||
case '-': sResult += "-"; break;
|
||||
case ' ' : sResult += "-"; break;
|
||||
case '_' : sResult += "-"; break;
|
||||
// Replace accented and national characters
|
||||
case '\u00c0' : sResult += "A"; break;
|
||||
case '\u00c1' : sResult += "A"; break;
|
||||
case '\u00c2' : sResult += "A"; break;
|
||||
case '\u00c3' : sResult += "A"; break;
|
||||
case '\u00c4' : sResult += "AE"; break;
|
||||
case '\u00c5' : sResult += "AA"; break;
|
||||
case '\u00c6' : sResult += "AE"; break;
|
||||
case '\u00c7' : sResult += "C"; break;
|
||||
case '\u00c8' : sResult += "E"; break;
|
||||
case '\u00c9' : sResult += "E"; break;
|
||||
case '\u00ca' : sResult += "E"; break;
|
||||
case '\u00cb' : sResult += "E"; break;
|
||||
case '\u00cc' : sResult += "I"; break;
|
||||
case '\u00cd' : sResult += "I"; break;
|
||||
case '\u00ce' : sResult += "I"; break;
|
||||
case '\u00cf' : sResult += "I"; break;
|
||||
case '\u00d0' : sResult += "D"; break;
|
||||
case '\u00d1' : sResult += "N"; break;
|
||||
case '\u00d2' : sResult += "O"; break;
|
||||
case '\u00d3' : sResult += "O"; break;
|
||||
case '\u00d4' : sResult += "O"; break;
|
||||
case '\u00d5' : sResult += "O"; break;
|
||||
case '\u00d6' : sResult += "OE"; break;
|
||||
case '\u00d8' : sResult += "OE"; break;
|
||||
case '\u00d9' : sResult += "U"; break;
|
||||
case '\u00da' : sResult += "U"; break;
|
||||
case '\u00db' : sResult += "U"; break;
|
||||
case '\u00dc' : sResult += "UE"; break;
|
||||
case '\u00dd' : sResult += "Y"; break;
|
||||
case '\u00df' : sResult += "sz"; break;
|
||||
case '\u00e0' : sResult += "a"; break;
|
||||
case '\u00e1' : sResult += "a"; break;
|
||||
case '\u00e2' : sResult += "a"; break;
|
||||
case '\u00e3' : sResult += "a"; break;
|
||||
case '\u00e4' : sResult += "ae"; break;
|
||||
case '\u00e5' : sResult += "aa"; break;
|
||||
case '\u00e6' : sResult += "ae"; break;
|
||||
case '\u00e7' : sResult += "c"; break;
|
||||
case '\u00e8' : sResult += "e"; break;
|
||||
case '\u00e9' : sResult += "e"; break;
|
||||
case '\u00ea' : sResult += "e"; break;
|
||||
case '\u00eb' : sResult += "e"; break;
|
||||
case '\u00ec' : sResult += "i"; break;
|
||||
case '\u00ed' : sResult += "i"; break;
|
||||
case '\u00ee' : sResult += "i"; break;
|
||||
case '\u00ef' : sResult += "i"; break;
|
||||
case '\u00f0' : sResult += "d"; break;
|
||||
case '\u00f1' : sResult += "n"; break;
|
||||
case '\u00f2' : sResult += "o"; break;
|
||||
case '\u00f3' : sResult += "o"; break;
|
||||
case '\u00f4' : sResult += "o"; break;
|
||||
case '\u00f5' : sResult += "o"; break;
|
||||
case '\u00f6' : sResult += "oe"; break;
|
||||
case '\u00f8' : sResult += "oe"; break;
|
||||
case '\u00f9' : sResult += "u"; break;
|
||||
case '\u00fa' : sResult += "u"; break;
|
||||
case '\u00fb' : sResult += "u"; break;
|
||||
case '\u00fc' : sResult += "ue"; break;
|
||||
case '\u00fd' : sResult += "y"; break;
|
||||
case '\u00ff' : sResult += "y"; break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (sResult.length()==0) { return "writer4latex"; }
|
||||
else { return sResult; }
|
||||
|
|
|
|||
|
|
@ -15,6 +15,18 @@
|
|||
<prop oor:name="TemplateName"/>
|
||||
</node>
|
||||
|
||||
<node oor:name="org.openoffice.da.writer4latex.xelatex" oor:op="replace" oor:finalized="true" oor:mandatory="true">
|
||||
<prop oor:name="UIName"><value>XeLaTeX</value></prop>
|
||||
<prop oor:name="Type"><value>org.openoffice.da.writer4latex.XeLaTeX_File</value></prop>
|
||||
<prop oor:name="DocumentService"><value>com.sun.star.text.TextDocument</value></prop>
|
||||
<prop oor:name="FilterService"><value>org.openoffice.da.comp.writer4latex.TeXImportFilter</value></prop>
|
||||
<prop oor:name="UIComponent"/>
|
||||
<prop oor:name="Flags"><value>IMPORT TEMPLATE TEMPLATEPATH ALIEN 3RDPARTYFILTER</value></prop>
|
||||
<prop oor:name="UserData"/>
|
||||
<prop oor:name="FileFormatVersion"><value>0</value></prop>
|
||||
<prop oor:name="TemplateName"/>
|
||||
</node>
|
||||
|
||||
</node>
|
||||
|
||||
</oor:component-data>
|
||||
|
|
|
|||
|
|
@ -13,6 +13,18 @@
|
|||
<prop oor:name="DetectService"><value>org.openoffice.da.comp.writer4latex.TeXDetectService</value></prop>
|
||||
<prop oor:name="PreferredFilter"><value>org.openoffice.da.writer4latex.latex</value></prop>
|
||||
</node>
|
||||
|
||||
<node oor:name="org.openoffice.da.writer4latex.XeLaTeX_File" oor:op="replace" oor:finalized="true" oor:mandatory="true">
|
||||
<prop oor:name="UIName"><value>XeLaTeX File</value></prop>
|
||||
<prop oor:name="MediaType"/>
|
||||
<prop oor:name="ClipboardFormat"/>
|
||||
<prop oor:name="URLPattern"/>
|
||||
<prop oor:name="Extensions"><value>tex</value></prop>
|
||||
<prop oor:name="Preferred"><value>true</value></prop>
|
||||
<prop oor:name="DetectService"><value>org.openoffice.da.comp.writer4latex.TeXDetectService</value></prop>
|
||||
<prop oor:name="PreferredFilter"><value>org.openoffice.da.writer4latex.xelatex</value></prop>
|
||||
</node>
|
||||
|
||||
</node>
|
||||
|
||||
</oor:component-data>
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue