Laboratoire ICAR » Plateforme TXM

root.macosx.cocoa.x86_64=mac/

      <import plugin="javax.annotation" version="1.2.0" match="greaterOrEqual"/>

package org.txm.xml;

import java.io.Reader;

import java.io.StringReader;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLStreamConstants;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamReader;

import org.txm.utils.xml.DomUtils;

import org.w3c.dom.CDATASection;

import org.w3c.dom.Comment;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.EntityReference;

import org.w3c.dom.ProcessingInstruction;

import org.w3c.dom.Text;

public class StaxDomConstructor {

	XMLStreamReader parser = null;

	public StaxDomConstructor(XMLStreamReader parser) {

		this.parser = parser;

	}

	/**

	 * consumes the parser events to create a DOM. start consuming after the current Stax event

	 * 

	 * stop consuming when the current parser element is closed

	 * 

	 * @return

	 * @throws ParserConfigurationException

	 * @throws XMLStreamException

	 * @throws IllegalAccessException

	 */

	public Element getDom() throws ParserConfigurationException, XMLStreamException, IllegalAccessException {

		if (parser.getEventType() != XMLStreamConstants.START_ELEMENT) {

			throw new IllegalAccessException("The Dom constructor must be called from the XMLStreamConstants.START_ELEMENT event");

		}

		Document doc = DomUtils.emptyDocument();

		Element currentElement = null;

		int elements = 0;

		String localname = null;

		for (int event = parser.getEventType(); event != XMLStreamConstants.END_DOCUMENT; event = parser.next()) {

			switch (event) {

				case XMLStreamConstants.START_ELEMENT:

					localname = parser.getLocalName();

					String ns = parser.getNamespaceURI();

					Element e = null;

					if (ns != null) {

						e = doc.createElementNS(ns, localname);

					}

					else {

						e = doc.createElement(localname);

					}

					for (int i = 0; i < parser.getAttributeCount(); i++) {

						ns = parser.getAttributeNamespace(i);

						if (ns != null) {

							e.setAttributeNS(ns, parser.getAttributeLocalName(i), parser.getAttributeValue(i));

						}

						else {

							e.setAttribute(parser.getAttributeLocalName(i), parser.getAttributeValue(i));

						}

					}

					if (currentElement == null) {

						doc.appendChild(e);

					}

					else {

						currentElement.appendChild(e);

					}

					currentElement = e;

					elements++;

					break;

				case XMLStreamConstants.CHARACTERS:

					Text textNode = doc.createTextNode(parser.getText());

					currentElement.appendChild(textNode);

					break;

				case XMLStreamConstants.END_ELEMENT:

					elements--;

					if (elements == 0) return doc.getDocumentElement();

					currentElement = (Element) currentElement.getParentNode();

					break;

				case XMLStreamConstants.PROCESSING_INSTRUCTION:

					ProcessingInstruction piNode = doc.createProcessingInstruction(parser.getPITarget(), parser.getPIData());

					currentElement.appendChild(piNode);

					break;

				case XMLStreamConstants.CDATA:

					CDATASection cDataNode = doc.createCDATASection(parser.getText());

					currentElement.appendChild(cDataNode);

					break;

				case XMLStreamConstants.COMMENT:

					Comment commentNode = doc.createComment(parser.getText());

					currentElement.appendChild(commentNode);

					break;

				case XMLStreamConstants.END_DOCUMENT:

					return doc.getDocumentElement();

				case XMLStreamConstants.ENTITY_REFERENCE:

					EntityReference entityNode = doc.createEntityReference(parser.getText());

					currentElement.appendChild(entityNode);

					break;

			}

		}

		return null;

	}

	public static void main(String[] args) throws Exception {

		Reader inputData = new StringReader("<test><ceci><est><un></un></est></ceci></test>");

		XMLStreamReader parser = XMLInputFactory.newInstance().createXMLStreamReader(inputData);

		parser.next();

		System.out.println("E=" + parser.getLocalName());

		parser.next();

		System.out.println("E=" + parser.getLocalName());

		System.out.println(new StaxDomConstructor(parser).getDom());

		parser.close();

		inputData.close();

	}

}

package org.txm.xml;

/**

 * Simple Activator activated when the localname matches the localname constructor parameter

 * 

 * @author mdecorde

 *

 */

public class LocalNameHookActivator extends HookActivator {

	String localname;

	/**

	 * @param localname the element localname to match

	 */

	public LocalNameHookActivator(Hook hook, String localname) {

		this.localname = localname;

	}

	@Override

	public boolean mustActivate() {

		if (localname == null) return false;

		return localname.equals(hook.getLocalName());

	}

	@Override

	public void hookWasActivated() {

		// nothing to do

	}

}

package org.txm.xml;

import java.io.IOException;

import javax.xml.stream.XMLStreamException;

public abstract class IdentityHook extends Hook {

	public IdentityHook(String name, HookActivator activator, XMLProcessor parentParser) throws IOException, XMLStreamException {

		super(name, activator, parentParser);

	}

	@Override

	protected void processNamespace() throws XMLStreamException {

		parentParser.processNamespace();

	}

	@Override

	protected void processStartElement() throws XMLStreamException, IOException {

		parentParser.processStartElement();

	}

	@Override

	protected void processCharacters() throws XMLStreamException {

		parentParser.processCharacters();

	}

	@Override

	protected void processProcessingInstruction() throws XMLStreamException {

		parentParser.processProcessingInstruction();

	}

	@Override

	protected void processDTD() throws XMLStreamException {

		parentParser.processDTD();

	}

	@Override

	protected void processCDATA() throws XMLStreamException {

		parentParser.processCDATA();

	}

	@Override

	protected void processComment() throws XMLStreamException {

		parentParser.processComment();

	}

	@Override

	protected void processEndElement() throws XMLStreamException {

		parentParser.processEndElement();

	}

	@Override

	protected void processEndDocument() throws XMLStreamException {

		parentParser.processEndDocument();

	}

	@Override

	protected void processEntityReference() throws XMLStreamException {

		parentParser.processEntityReference();

	}

}

package org.txm.xml;

/**

 * This class is used by Hook to do the activation test. If no activator is provided no activation are done.

 * 

 * @author mdecorde

 *

 */

public abstract class HookActivator {

	/**

	 * to access to current parsing informations

	 */

	Hook hook;

	/**

	 * 

	 * The Hook will be associated in the Hook constructor

	 */

	public HookActivator() {}

	/**

	 * 

	 * @return true if the hook must be activated

	 */

	public abstract boolean mustActivate();

	/**

	 * Use this method if you need the activator to be updated when the hook was activated once

	 */

	public abstract void hookWasActivated();

	/**

	 * Set afterward the hook

	 * 

	 * @param hook this activators hook

	 */

	public void setHook(Hook hook) {

		this.hook = hook;

	}

}

package org.txm.xml;

import java.io.IOException;

import java.util.List;

import javax.xml.stream.XMLStreamException;

/**

 * To use if you have N elements to process with a specific localname for each one

 * 

 * @author mdecorde

 *

 */

public class ToDoListHookActivator extends HookActivator {

	List<String> tasks;

	int current = 0;

	public ToDoListHookActivator(List<String> tasks) throws IOException, XMLStreamException {

		this.tasks = tasks;

	}

	@Override

	public boolean mustActivate() {

		if (tasks.size() <= current) return false;

		return tasks.get(current).equals(hook.getLocalName());

	}

	@Override

	public void hookWasActivated() {

		current++;

	}

}

import org.txm.utils.logger.Log;

public abstract class Hook {

	protected XMLProcessor parentParser = null;

	protected HookActivator activator = null;

	protected String name;

	private int elements = 0;

	 * register the hok to the XMLProcessor

	 * 

	public Hook(String name, HookActivator activator, XMLProcessor parentParser) throws IOException, XMLStreamException {

		setActivator(activator); // set the activator

		parentParser.addHook(name, this); // register the hook to the XMLProcessor

	public void setActivator(HookActivator activator) {

		this.activator = activator;

		if (activator != null) {

			activator.setHook(this);

		}

	}

	public final boolean activate() {

		elements = 0;

		return _activate();

	public abstract boolean _activate();

	public abstract boolean deactivate();

	public final boolean mustActivate() {

		if (activator == null) return false;

		return activator.mustActivate();

	public final boolean mustDeactivate() {

		return elements == 0;

	}

	 * if something needs to be done BEFORE XMLProcessor starts parsing

	protected void before() {}

	/**

	 * if something needs to be done AFTER XMLProcessor starts parsing

	 */

	protected void after() {}

	/**

	 * if something needs to be done when an error occurs

	 */

	protected void closeForError() {}

				elements++;

				elements--;

				if (elements < 0) {

					Log.severe("ERROR: Hook was not interupted on time AT " + getLocation());

				}

		return parentParser.getLocation();

	protected abstract void processNamespace() throws XMLStreamException;

	protected abstract void processStartElement() throws XMLStreamException, IOException;

	protected abstract void processCharacters() throws XMLStreamException;

	protected abstract void processProcessingInstruction() throws XMLStreamException;

	protected abstract void processDTD() throws XMLStreamException;

	protected abstract void processCDATA() throws XMLStreamException;

	protected abstract void processComment() throws XMLStreamException;

	protected abstract void processEndElement() throws XMLStreamException;

	protected abstract void processEndDocument() throws XMLStreamException;

	protected abstract void processEntityReference() throws XMLStreamException;

	public String getCurrentPath() {

		return parentParser.getCurrentPath();

	public String getLocalName() {

		return parentParser.localname;

import java.util.Stack;

	private Hook activeHook = null;

				// preparing process

				if (event == XMLStreamConstants.START_ELEMENT) {

					localname = parser.getLocalName();

					currentXPath.append(SLASH);

					currentXPath.append(localname);

					buildCurrentAttributes(); // for easier access later

				else if (event == XMLStreamConstants.END_ELEMENT) {

					localname = parser.getLocalName();

				}

				if (activeHook != null) {

					if (activeHook.mustDeactivate()) {

						activeHook.deactivate();

						activeHook = null;

					else {

						activeHook.processParserEvent(event);

					}

				}

				if (activeHook == null && event == XMLStreamConstants.START_ELEMENT) { // only activate when starting an element (for now, thus we cannot process only text nodes)

					for (Hook hook : hooks.values()) {

						if (hook.mustActivate()) {

							if (hook.activate()) {

								activeHook = hook;

								hook.processParserEvent(event);

								break;

				if (activeHook == null) {

					this.processParserEvent(event);

				}

				// post-preparing process

				if (event == XMLStreamConstants.END_ELEMENT) {

					currentXPath.setLength(currentXPath.length() - localname.length() - 1);

					popCurrentAttributes();

				}

	private Stack<LinkedHashMap<String, String>> attributesStack = new Stack<>();

	private HashMap<String, String> popCurrentAttributes() {

		return attributesStack.pop();

	private void buildCurrentAttributes() throws XMLStreamException {

		LinkedHashMap<String, String> currentAttributes = new LinkedHashMap<>(); // keep order

		attributesStack.push(currentAttributes);

	public LinkedHashMap<String, String> getCurrentAttributes() {

		return attributesStack.lastElement();

	}

			File input = new File(System.getProperty("user.home"), "xml/tdm80j/tdm80j.xml");

			File output = new File(System.getProperty("user.home"), "xml/tdm80j/out.xml");

			// IdentityHook hook1 = new IdentityHook("hook1", new LocalNameHookActivator(null, "p"), builder) {

			//

			// @Override

			// public boolean _activate() {

			// System.out.println("ACTIVATING " + name + " AT " + getLocation());

			// return true;

			// }

			//

			// @Override

			// public boolean deactivate() {

			// System.out.println("DEACTIVATING " + name + " AT " + getLocation());

			// return true;

			// }

			//

			// @Override

			// public void processStartElement() throws XMLStreamException, IOException {

			// super.processStartElement();

			// parentParser.writer.writeAttribute("hook", name);

			// }

			// };

			IdentityHook hook2 = new IdentityHook("hook2", new XPathHookActivator(null, "//language[@ident='fr']"), builder) {

				@Override

				public boolean _activate() {

					System.out.println("ACTIVATING " + name + " AT " + getLocation());

					return true;

				}

				@Override

				public boolean deactivate() {

					System.out.println("DEACTIVATING " + name + " AT " + getLocation());

					return true;

				}

				@Override

				public void processStartElement() throws XMLStreamException, IOException {

					super.processStartElement();

					parentParser.writer.writeAttribute("hook", name);

				}

			};

	/**

	 * 

	 * @return the actual hooks hash

	 */

	public LinkedHashMap<String, Hook> getHooks() {

		return hooks;

	}

	public void addHook(String name, Hook hook) {

		hooks.put(name, hook);

	}

package org.txm.xml;

import java.util.Arrays;

import java.util.LinkedHashMap;

import java.util.regex.Pattern;

/**

 * Simple "XPath without attribute selector" Activator activated when the current path matches the xpath

 * 

 * supported operators : / , // , * , node()

 * only the last element attributes can be tested with simple equals test

 * 

 * exemple: //p[name='value']

 * exemple: /text/node()/p[name='value']

 * 

 * @author mdecorde

 *

 */

public class XPathHookActivator extends HookActivator {

	String xpath;

	Pattern p;

	LinkedHashMap<String, String> attributesTest = null;

	private boolean debug = false;

	/**

	 * @param localname the element localname to match

	 */

	public XPathHookActivator(Hook hook, String xpath) {

		this.xpath = xpath;

		String regex = xpath;

		int attrTest = xpath.indexOf("["); // [some tests]

		int lastNodeTest = xpath.lastIndexOf("/");

		if (attrTest > 0 && attrTest > lastNodeTest) {

			attributesTest = new LinkedHashMap<>();

			regex = xpath.substring(0, attrTest);

			String tail = xpath.substring(attrTest);

			tail = tail.substring(1, tail.length() - 1);

			if (debug) System.out.println("TAIL=" + tail);

			String tests[] = tail.split("@");

			if (debug) System.out.println("TESTS=" + Arrays.toString(tests));

			for (String test : tests) {

				if (test.length() == 0) continue;

				String split2[] = test.split("=", 2); // 0 name 1 "value"

				if (debug) System.out.println("TEST=" + Arrays.toString(split2));

				attributesTest.put(split2[0], split2[1].substring(1, split2[1].length() - 1));

			}

		}

		regex = regex.replaceAll("([^.])[*]", "$1[^/]+");

		if (regex.startsWith("//")) regex = "(/[^/]+)*/" + regex.substring(2);

		regex = regex.replace("//", "(/[^/]+)*/");

		regex = regex.replace("node()", "[^/]+");

		this.p = Pattern.compile(regex);

		// System.out.println(p);

		// System.out.println(attributesTest);

	}

	@Override

	public boolean mustActivate() {

		if (xpath == null) return false;

		// System.out.println(hook.getCurrentPath() + hook.parentParser.getCurrentAttributes());

		if (attributesTest != null) {

			return p.matcher(hook.getCurrentPath()).find() && hook.parentParser.getCurrentAttributes().equals(attributesTest);

		}

		else {

			return p.matcher(hook.getCurrentPath()).find();

		}

	}

	@Override

	public void hookWasActivated() {

		// nothing to do

	}

	public static void main(String[] args) {

		new XPathHookActivator(null, "//*");

		new XPathHookActivator(null, "//p[@name='value']");

		new XPathHookActivator(null, "//text/node()/p[@name='value']");

		new XPathHookActivator(null, "/TEI/text/node()/p[@name='value']");

		new XPathHookActivator(null, "//text//p[@name='value']");

	}

}

package org.txm.importer;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamReader;

/**

 * Re align a XML TEI file with a TAL tool result. The TAL result might change: words boundaries, words properties, an element.

 * 

 * 

 * 

 * @author mdecorde

 *

 */

public class ReAlignXMLTEI extends StaxIdentityParser {

	String elementToPatch;

	protected URL patchUrl;

	protected InputStream patchInputData;

	protected XMLStreamReader patchParser;

	public ReAlignXMLTEI(File origFile, File patchFile, String elementToPatch) throws XMLStreamException, IOException {

		super(origFile);

		this.elementToPatch = elementToPatch;

		this.patchUrl = patchFile.toURI().toURL();

		this.factory = XMLInputFactory.newInstance();

		this.patchInputData = patchUrl.openStream();

		this.patchParser = factory.createXMLStreamReader(patchInputData);

	}

	@Override

	public boolean process(File outfile) throws XMLStreamException, IOException {

		boolean ret = super.process(outfile);

		if (patchParser != null) {

			try {

				patchParser.close();

			}

			catch (Exception e) {

				System.out.println("patchParser excep: " + e);

			}

		}

		if (patchInputData != null) {

			try {

				patchInputData.close();

			}

			catch (Exception e) {

				System.out.println("patchInputData excep: " + e);

			}

		}

		return ret;

	}

}

		CQPCorpus corpus = result.getFirstParent(Subcorpus.class);

			corpus = result.getFirstParent(CQPCorpus.class);

	@Override

		// reset the internal variables that store cached information

		return getFirstParent(MainCorpus.class);

		return getFirstParent(MainCorpus.class);

		List<Partition> partitions = getChildren(Partition.class);

		return getChildren(Partition.class);

		return getChildren(Subcorpus.class);

			// Log.severe(NLS.bind("** The \"{0}\" MainCorpus object in the \"{1}\" project can not be computed: another one with the same CQP identifier has already been computed.", this.pID, this

			// .getProjectDirectory()));

			return true;

	// public static OpenDocumentEventProcessor openDocProcessor = new OpenDocumentEventProcessor();

		// if (Platform.inDevelopmentMode() || Platform.inDebugMode()) {

		// // this can not work in development environment

		// // as it need to have a default workspace set to none

		// // see product configuration :

		// // osgi.instance.area=@noDefault

		// // ignored in development

		// // -------------------------------------

		// } else {

		System.out.println("instance location=" + Platform.getInstanceLocation().getURL());

			}

			else if (ret == IApplication.EXIT_OK) {

			}

			else {

					if (fontFiles[i].endsWith(".ttf")) { //$NON-NLS-1$

		List<String> argsList = Arrays.asList((String[]) (args.get("application.args"))); //$NON-NLS-1$

			// } else if (argsList.contains("-standalone")) { //$NON-NLS-1$

			// File userhomeDirectory = new File("workspace").getAbsoluteFile(); // eclipse default workspace directory

			// File defaultWorkspaceFile = new File("workspace/corpora/default.xml");

			// if (!defaultWorkspaceFile.exists()) {

			// System.out.println("Stand alone launch, creating minimal TXM user home directory in "+userhomeDirectory.getAbsolutePath());

			// System.out.println("Sample corpora, scripts, import scripts and macros files are not yet installed.");

			// TBXPreferences.getInstance().put(TBXPreferences.USER_TXM_HOME, userhomeDirectory.getAbsolutePath());

			// TBXPreferences.getInstance().put(TBXPreferences.INSTALL_DIR, userhomeDirectory.getParentFile().getAbsolutePath());

			// File corpusworkspaceDirectory = new File(userhomeDirectory, "workspaces");

			// corpusworkspaceDirectory.mkdirs();

			// String createfolders[] = {

			// "corpora", "clipboard", //$NON-NLS-1$ //$NON-NLS-2$

			// "workspaces", "css", "scripts", "scripts/lib", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

			// "scripts/macro", "scripts/user", "xsl", "samples", "schema", "R"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

			//

			// for (String folder : createfolders) {

			// new File(userhomeDirectory, folder).mkdir();

			// }

			//

			// Workspace.createEmptyWorkspaceDefinition(new File(corpusworkspaceDirectory, "default.xml")); //$NON-NLS-1$

			// BundleUtils.copyFiles("org.txm.core", "res", "org/txm", "css", new File(userhomeDirectory, "css"));

			// BundleUtils.copyFiles("org.txm.core", "res", "org/txm/xml", "xsl", new File(userhomeDirectory, "xsl"));

			// BundleUtils.copyFiles("org.txm.core", "res", "org/txm/xml", "schema", new File(userhomeDirectory, "schema"));

			// File scriptsDirectory = new File(userhomeDirectory, "scripts");

			// new File(scriptsDirectory, "user").mkdir();

			// new File(scriptsDirectory, "import").mkdir();

			// new File(scriptsDirectory, "lib").mkdir();

			// new File(scriptsDirectory, "macro").mkdir();

			// new File(scriptsDirectory, "samples").mkdir();

			// }

		}

		else {

		// display.addListener(SWT.OpenDocument, openDocProcessor);

		// //Lock the RCP workspace, thus there is only one TXM instance running

		// Log.warning(TXMUIMessages.lockRCPWorkspace);

		// if (!Platform.getInstanceLocation().lock()){

		// //Shell shell = display.getActiveShell();

		// System.out.println("TXM is already running. Exiting...");

		// return IApplication.EXIT_OK;

		// }

		}

		catch (Exception e) {

			// add listener to catch --launcher.openFile

			// display.addListener(SWT.OpenDocument, new Listener() {

			//

			// @Override

			// public void handleEvent(Event event) {

			// if (event.text != null && event.text.endsWith(".txm")) {