writerfilter/source/ooxml/factoryimpl.py

   1 #!/usr/bin/env python
   2 #
   3 # This file is part of the LibreOffice project.
   4 #
   5 # This Source Code Form is subject to the terms of the Mozilla Public
   6 # License, v. 2.0. If a copy of the MPL was not distributed with this
   7 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8 #
   9
  10 from xml.dom import minidom
  11 import sys
  12
  13
  14 def getElementsByTagNamesNS(parent, ns, names, ret=minidom.NodeList()):
  15     for node in parent.childNodes:
  16         if node.nodeType == minidom.Node.ELEMENT_NODE and node.namespaceURI == ns and node.tagName in names:
  17             ret.append(node)
  18         getElementsByTagNamesNS(node, ns, names, ret)
  19     return ret
  20
  21
  22 def createFastChildContextFromFactory(model):
  23     print("""uno::Reference<xml::sax::XFastContextHandler> OOXMLFactory::createFastChildContextFromFactory
  24 (OOXMLFastContextHandler* pHandler, OOXMLFactory_ns::Pointer_t pFactory, Token_t Element)
  25 {
  26     uno::Reference <xml::sax::XFastContextHandler> aResult;
  27     const Id nDefine = pHandler->getDefine();
  28
  29     if (pFactory.get() != NULL)
  30     {
  31         ResourceType nResource;
  32         Id nElementId;
  33         if (pFactory->getElementId(nDefine, Element, nResource, nElementId))
  34         {
  35             const Id nId = pFactory->getResourceId(nDefine, Element);
  36
  37             switch (nResource)
  38             {""")
  39     resources = [
  40         "List", "Integer", "Hex", "HexColor", "String",
  41         "TwipsMeasure_asSigned", "TwipsMeasure_asZero",
  42         "HpsMeasure", "Boolean", "MeasurementOrPercent",
  43     ]
  44     for resource in [r.getAttribute("resource") for r in model.getElementsByTagName("resource")]:
  45         if resource not in resources:
  46             resources.append(resource)
  47             print("""            case ResourceType::%s:
  48                 aResult.set(OOXMLFastHelper<OOXMLFastContextHandler%s>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId));
  49                 break;""" % (resource, resource))
  50     print("""            case ResourceType::Any:
  51                 aResult.set(createFastChildContextFromStart(pHandler, Element));
  52                 break;
  53             default:
  54                 break;
  55             }
  56
  57         }
  58     }
  59
  60     return aResult;
  61 }
  62 """)
  63
  64
  65 def getFactoryForNamespace(model):
  66     print("""OOXMLFactory_ns::Pointer_t OOXMLFactory::getFactoryForNamespace(Id nId)
  67 {
  68     OOXMLFactory_ns::Pointer_t pResult;
  69
  70     switch (oox::getNamespace(nId))
  71     {""")
  72
  73     for namespace in [ns.getAttribute("name") for ns in model.getElementsByTagName("namespace")]:
  74         id = namespace.replace('-', '_')
  75         print("""    case NN_%s:
  76         pResult = OOXMLFactory_%s::getInstance();
  77         break;""" % (id, id))
  78     print("""    default:
  79         break;
  80     }
  81
  82     return pResult;
  83 }
  84 """)
  85
  86
  87 def createFastChildContextFromStart(model):
  88     print("""uno::Reference<xml::sax::XFastContextHandler> OOXMLFactory::createFastChildContextFromStart
  89 (OOXMLFastContextHandler* pHandler, Token_t Element)
  90 {
  91     uno::Reference<xml::sax::XFastContextHandler> aResult;
  92     OOXMLFactory_ns::Pointer_t pFactory;
  93
  94 """)
  95
  96     for namespace in [ns.getAttribute("name") for ns in model.getElementsByTagName("namespace")]:
  97         id = namespace.replace('-', '_')
  98         print("""    if (!aResult.is())
  99     {
 100         pFactory = getFactoryForNamespace(NN_%s);
 101         aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element));
 102     }""" % id)
 103
 104     print("""
 105     return aResult;
 106 }
 107 """)
 108
 109
 110 def fastTokenToId(model):
 111     print("""
 112 std::string fastTokenToId(sal_uInt32 nToken)
 113 {
 114     std::string sResult;
 115 #ifdef DBG_UTIL
 116
 117     switch (oox::getNamespace(nToken))
 118     {""")
 119
 120     aliases = []
 121     for alias in sorted(ooxUrlAliases.values()):
 122         if alias not in aliases:
 123             aliases.append(alias)
 124             print("""    case oox::NMSP_%s:
 125         sResult += "%s:";
 126         break;""" % (alias, alias))
 127     print("""    }
 128
 129     switch (nToken & 0xffff)
 130     {""")
 131
 132     tokens = [""]
 133     for token in [t.getAttribute("localname") for t in getElementsByTagNamesNS(model, "http://relaxng.org/ns/structure/1.0", ["element", "attribute"])]:
 134         if token not in tokens:
 135             tokens.append(token)
 136             print("""    case oox::XML_%s:
 137         sResult += "%s";
 138         break;""" % (token, token))
 139
 140     print("""    }
 141 #else
 142     (void)nToken;
 143 #endif
 144     return sResult;
 145 }
 146 """)
 147
 148
 149 def getFastParser():
 150     print("""uno::Reference <xml::sax::XFastParser> OOXMLStreamImpl::getFastParser()
 151 {
 152     if (!mxFastParser.is())
 153     {
 154         mxFastParser = css::xml::sax::FastParser::create(mxContext);
 155         // the threaded parser is about 20% slower loading writer documents
 156         css::uno::Reference< css::lang::XInitialization > xInit( mxFastParser, css::uno::UNO_QUERY_THROW );
 157         css::uno::Sequence< css::uno::Any > args{ css::uno::Any(OUString("DisableThreadedParser")) };
 158         xInit->initialize(args);
 159 """)
 160     for url in sorted(ooxUrlAliases.keys()):
 161         print("""        mxFastParser->registerNamespace("%s", oox::NMSP_%s);""" % (url, ooxUrlAliases[url]))
 162     print("""    }
 163
 164     return mxFastParser;
 165 }
 166
 167 /// @endcond
 168 }}""")
 169
 170
 171 def createImpl(model):
 172     print("""
 173 #include <com/sun/star/xml/sax/FastParser.hpp>
 174 #include <com/sun/star/lang/XInitialization.hpp>
 175 #include "ooxml/OOXMLFactory.hxx"
 176 #include "ooxml/OOXMLFastHelper.hxx"
 177 #include "ooxml/OOXMLStreamImpl.hxx"
 178 """)
 179
 180     for namespace in [ns.getAttribute("name") for ns in model.getElementsByTagName("namespace")]:
 181         print('#include "OOXMLFactory_%s.hxx"' % namespace)
 182
 183     print("""namespace writerfilter {
 184 namespace ooxml {
 185
 186 using namespace com::sun::star;
 187
 188 /// @cond GENERATED
 189 """)
 190
 191     createFastChildContextFromFactory(model)
 192     getFactoryForNamespace(model)
 193     createFastChildContextFromStart(model)
 194     fastTokenToId(model)
 195     getFastParser()
 196
 197
 198 def parseNamespaces(fro):
 199     sock = open(fro)
 200     for i in sock.readlines():
 201         line = i.strip()
 202         alias, url = line.split(' ')[1:]  # first column is ID, not interesting for us
 203         ooxUrlAliases[url] = alias
 204     sock.close()
 205
 206
 207 namespacesPath = sys.argv[1]
 208 ooxUrlAliases = {}
 209 parseNamespaces(namespacesPath)
 210 modelPath = sys.argv[2]
 211 model = minidom.parse(modelPath)
 212 createImpl(model)
 213
 214 # vim:set shiftwidth=4 softtabstop=4 expandtab: