Quelle  tokenmap.cxx

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */

#include <sal/config.h>

#include <array>

#include <oox/token/tokenmap.hxx>

#include <string.h>
#include <rtl/string.hxx>
#include <oox/token/tokens.hxx>

namespace oox {

namespace {
// include auto-generated Perfect_Hash
#if defined __clang__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
#if __has_warning("-Wdeprecated-register")
#pragma GCC diagnostic ignored "-Wdeprecated-register"
#endif
#endif
#include <tokenhash.inc>
#if defined __clang__
#pragma GCC diagnostic pop
#endif
} // namespace

static sal_Int32 getTokenPerfectHash(const char* pStr, sal_Int32 nLength)
{
    const struct xmltoken* pToken = Perfect_Hash::in_word_set( pStr, nLength );
    return pToken ? pToken->nToken : XML_TOKEN_INVALID;
}

css::uno::Sequence<sal_Int8> const& TokenMap::getUtf8TokenName(sal_Int32 nToken)
{
    static const auto saTokenNames = []()
    {
        static constexpr std::string_view sppcTokenNames[] = {
// include auto-generated C array with token names as C strings
#include <tokennames.inc>
        };
        static_assert(std::size(sppcTokenNames) == XML_TOKEN_COUNT);

        std::vector<css::uno::Sequence<sal_Int8>> aTokenNames;
        aTokenNames.reserve(std::size(sppcTokenNames));
        std::transform(
            std::begin(sppcTokenNames), std::end(sppcTokenNames), std::back_inserter(aTokenNames),
            [](auto aUtf8Token)
            {
                return css::uno::Sequence<sal_Int8>(
                    reinterpret_cast<const sal_Int8*>(aUtf8Token.data()), aUtf8Token.size());
            });
        return aTokenNames;
    }();

    SAL_WARN_IF(nToken < 0 || nToken >= XML_TOKEN_COUNT, "oox", "Wrong nToken parameter");
    if (0 <= nToken && nToken < XML_TOKEN_COUNT)
        return saTokenNames[nToken];
    static const css::uno::Sequence<sal_Int8> EMPTY_BYTE_SEQ;
    return EMPTY_BYTE_SEQ;
}


/** Returns the token identifier for a UTF8 string passed in pToken */
sal_Int32 TokenMap::getTokenFromUtf8(std::string_view token)
{
    static const auto snAlphaTokens = []()
    {
        std::array<sal_Int32, 26> nAlphaTokens{};
        for (char c = 'a'; c <= 'z'; c++)
            nAlphaTokens[c - 'a'] = getTokenPerfectHash(&c, 1);
        return nAlphaTokens;
    }();

    // 50% of OOXML tokens are primarily 1 lower-case character, a-z
    if (token.size() == 1)
    {
        char c = token[0];
        if (c >= 'a' && c <= 'z')
            return snAlphaTokens[c - 'a'];
    }
    return getTokenPerfectHash(token.data(), token.size());
}

} // namespace oox

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */