path: root/ooxml/source/framework/JavaOOXMLParser/src/org/apache/openoffice/ooxml/parser/StateMachine.java

/**************************************************************
*
* 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.
*
*************************************************************/

package org.apache.openoffice.ooxml.parser;

import java.io.File;
import java.util.Stack;
import java.util.Vector;

import javax.xml.stream.Location;

import org.apache.openoffice.ooxml.parser.action.ActionManager;
import org.apache.openoffice.ooxml.parser.action.ActionTrigger;
import org.apache.openoffice.ooxml.parser.action.IAction;
import org.apache.openoffice.ooxml.parser.attribute.AttributeManager;
import org.apache.openoffice.ooxml.parser.attribute.AttributeProvider;
import org.apache.openoffice.ooxml.parser.attribute.AttributeValues;
import org.apache.openoffice.ooxml.parser.type.SimpleTypeManager;

/** The state machine is initialized at creation from the data tables
 *  created previously by a stack automaton.
 */
public class StateMachine
{
    public StateMachine (
        final File aParseTableFile,
        final Vector<String> aErrorsAndWarnings)
    {
        if (Log.Dbg != null)
            Log.Dbg.printf("reading parse tables from %s\n", aParseTableFile.toString());

        final ParseTableReader aReader = new ParseTableReader(aParseTableFile);
        maNamespaceMap = new NamespaceMap(aReader.GetSection("namespace"));
        maNameMap = new NameMap(aReader.GetSection("name"));
        maStateNameMap = new NameMap(aReader.GetSection("state-name"));
        maTransitions = new TransitionTable(aReader.GetSection("transition"));
        maSkipStates = new SkipStateTable(aReader.GetSection("skip"));
        maAttributeValueMap = new NameMap(aReader.GetSection("attribute-value"));
        maAcceptingStates = new AcceptingStateTable(aReader.GetSection("accepting-state"));
        maSimpleTypeManager = new SimpleTypeManager(
            aReader.GetSection("simple-type"),
            maAttributeValueMap);
        maAttributeManager = new AttributeManager(
            aReader.GetSection("attribute"),
            maNamespaceMap,
            maNameMap,
            maStateNameMap,
            maSimpleTypeManager,
            aErrorsAndWarnings);
        mnStartStateId = Integer.parseInt(aReader.GetSection("start-state").firstElement()[1]);
        mnEndStateId = Integer.parseInt(aReader.GetSection("end-state").firstElement()[1]);

        mnCurrentStateId = mnStartStateId;
        maStateStack = new Stack<>();
        maElementContextStack = new Stack<>();
        maActionManager = new ActionManager(maStateNameMap);
        maErrorsAndWarnings  = aErrorsAndWarnings;

        if (Log.Dbg != null)
        {
            Log.Dbg.printf("read %d namespace, %d names, %d states (%d skip, %d accept), %d transitions and %d attributes\n",
                maNamespaceMap.GetNamespaceCount(),
                maNameMap.GetNameCount(),
                maStateNameMap.GetNameCount(),
                maSkipStates.GetSkipStateCount(),
                maAcceptingStates.GetAcceptingStateCount(),
                maTransitions.GetTransitionCount(),
                maAttributeManager.GetAttributeCount());
            Log.Dbg.printf("starting in state _start_ (%d)\n", mnCurrentStateId);
        }
    }




    public boolean ProcessStartElement (
        final String sNamespaceURI,
        final String sElementName,
        final Location aStartLocation,
        final Location aEndLocation,
        final AttributeProvider aAttributes)
    {
        boolean bResult = false;

        try
        {
            final NamespaceMap.NamespaceDescriptor aNamespaceDescriptor = maNamespaceMap.GetDescriptorForURI(sNamespaceURI);
            final int nElementNameId = maNameMap.GetIdForName(sElementName);
            if (Log.Dbg != null)
                Log.Dbg.printf("%s:%s(%d:%d) L%dC%d\n",
                    aNamespaceDescriptor.Prefix,
                    sElementName,
                    aNamespaceDescriptor.Id,
                    nElementNameId,
                    aStartLocation.getLineNumber(),
                    aStartLocation.getColumnNumber());

            final Transition aTransition = maTransitions.GetTransition(
                mnCurrentStateId,
                aNamespaceDescriptor.Id,
                nElementNameId);
            if (aTransition == null)
            {
                final String sText = String.format(
                    "can not find transition for state %s(%d) and element %s:%s(%d:%d) at L%dC%d\n",
                    maStateNameMap.GetNameForId(mnCurrentStateId),
                    mnCurrentStateId,
                    aNamespaceDescriptor.Prefix,
                    maNameMap.GetNameForId(nElementNameId),
                    aNamespaceDescriptor.Id,
                    nElementNameId,
                    aStartLocation.getLineNumber(),
                    aStartLocation.getColumnNumber());
                Log.Err.printf(sText);
                if (Log.Dbg != null)
                    Log.Dbg.printf(sText);
            }
            else
            {
                if (Log.Dbg != null)
                {
                    Log.Dbg.printf(" %s(%d) -> %s(%d) via %s(%d)",
                        maStateNameMap.GetNameForId(mnCurrentStateId),
                        mnCurrentStateId,
                        maStateNameMap.GetNameForId(aTransition.GetEndStateId()),
                        aTransition.GetEndStateId(),
                        maStateNameMap.GetNameForId(aTransition.GetActionId()),
                        aTransition.GetActionId());
                    Log.Dbg.printf("\n");
                }

                // Follow the transition to its end state but first process its
                // content.  We do that by

                if (Log.Dbg != null)
                    Log.Dbg.IncreaseIndentation();

                // a) pushing the end state to the state stack so that on the
                // end tag that corresponds to the current start tag it will become the current state.
                maStateStack.push(aTransition.GetEndStateId());

                // b) entering the state that corresponds to start tag that
                // we are currently processing.
                mnCurrentStateId = aTransition.GetActionId();

                // c) Prepare the attributes and store them in the new element context.
                final AttributeValues aAttributeValues = maAttributeManager.ParseAttributes(
                    mnCurrentStateId,
                    aAttributes);

                // d) creating a new ElementContext for the element that just starts.
                maElementContextStack.push(maCurrentElementContext);
                final ElementContext aPreviousElementContext = maCurrentElementContext;
                maCurrentElementContext = new ElementContext(
                    sElementName,
                    maStateNameMap.GetNameForId(aTransition.GetActionId()),
                    false,
                    aAttributeValues,
                    aPreviousElementContext);

                // e) and run all actions that are bound to the the current start tag.
                ExecuteActions(
                    mnCurrentStateId,
                    maCurrentElementContext,
                    ActionTrigger.ElementStart,
                    null,
                    aStartLocation,
                    aEndLocation);

                bResult = true;
            }
        }
        catch (RuntimeException aException)
        {
            Log.Err.printf("error at line %d and column %d\n",
                aStartLocation.getLineNumber(),
                aStartLocation.getColumnNumber());
            throw aException;
        }
        return bResult;
    }




    public void ProcessEndElement (
        final String sNamespaceURI,
        final String sElementName,
        final Location aStartLocation,
        final Location aEndLocation)
    {
        if ( ! maAcceptingStates.Contains(mnCurrentStateId)
            && mnCurrentStateId!=-1)
        {
            if (Log.Dbg != null)
                Log.Dbg.printf("current state %s(%d) is not an accepting state\n",
                    maStateNameMap.GetNameForId(mnCurrentStateId),
                    mnCurrentStateId);
            throw new RuntimeException("not expecting end element "+sElementName);
        }

        final NamespaceMap.NamespaceDescriptor aDescriptor = maNamespaceMap.GetDescriptorForURI(sNamespaceURI);

        // Leave the current element.

        final int nPreviousStateId = mnCurrentStateId;
        mnCurrentStateId = maStateStack.pop();
        if (mnCurrentStateId == mnEndStateId)
            mnCurrentStateId = mnStartStateId;

        final ElementContext aPreviousElementContext = maCurrentElementContext;
        maCurrentElementContext = maElementContextStack.pop();

        ExecuteActions(
            nPreviousStateId,
            aPreviousElementContext,
            ActionTrigger.ElementEnd,
            null,
            aStartLocation,
            aEndLocation);

        if (Log.Dbg != null)
        {
            Log.Dbg.DecreaseIndentation();
            Log.Dbg.printf("/%s:%s L%d%d\n",
                aDescriptor.Prefix,
                sElementName,
                aStartLocation.getLineNumber(),
                aStartLocation.getColumnNumber());
            Log.Dbg.printf(" %s(%d) <- %s(%d)\n",
                maStateNameMap.GetNameForId(nPreviousStateId),
                nPreviousStateId,
                maStateNameMap.GetNameForId(mnCurrentStateId),
                mnCurrentStateId);
        }
    }




    public void ProcessCharacters (
        final String sText,
        final Location aStartLocation,
        final Location aEndLocation)
    {
        if (Log.Dbg != null)
            Log.Dbg.printf("text [%s]\n", sText.replace("\n", "\\n"));

        ExecuteActions(
            mnCurrentStateId,
            maCurrentElementContext,
            ActionTrigger.Text,
            sText,
            aStartLocation,
            aEndLocation);

    }




    public boolean IsInSkipState ()
    {
        return maSkipStates.Contains(mnCurrentStateId);
    }




    public ActionManager GetActionManager ()
    {
        return maActionManager;
    }




    private void ExecuteActions (
        final int nStateId,
        final ElementContext aElementContext,
        final ActionTrigger eTrigger,
        final String sText,
        final Location aStartLocation,
        final Location aEndLocation)
    {
        final Iterable<IAction> aActions = maActionManager.GetActions(nStateId, eTrigger);
        if (aActions != null)
            for (final IAction aAction : aActions)
                aAction.Run(eTrigger, aElementContext, sText, aStartLocation, aEndLocation);
    }




    private final NamespaceMap maNamespaceMap;
    private final NameMap maNameMap;
    private final NameMap maStateNameMap;
    private final TransitionTable maTransitions;
    private final SimpleTypeManager maSimpleTypeManager;
    private final AttributeManager maAttributeManager;
    private final NameMap maAttributeValueMap;
    private int mnCurrentStateId;
    private Stack<Integer> maStateStack;
    private ElementContext maCurrentElementContext;
    private Stack<ElementContext> maElementContextStack;
    private final int mnStartStateId;
    private final int mnEndStateId;
    private SkipStateTable maSkipStates;
    private AcceptingStateTable maAcceptingStates;
    private final ActionManager maActionManager;
    private final Vector<String> maErrorsAndWarnings;
}