ScriptEngineLexyn.h

Go to the documentation of this file.

/*
* SPDX-FileCopyrightText: Copyright (c) 2020-2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
 
 
#ifndef NVNEURAL_SCRIPTENGINELEXYN_H
#define NVNEURAL_SCRIPTENGINELEXYN_H
 
#include <map>
#include <set>
#include <string>
#include <vector>
 
namespace nvneural {
namespace detail {
 
struct Lexem //rule lexeme
{
    enum TypeCode
    {
        ID,
        INTEGER,
        FLOAT,
        DIMENSION,
        STRING,
        OPERATOR,
        COMMENT,
        FATAL_ERROR,
 
        //special case for syntax analyzer
        GRAMMAR
    };
    TypeCode type = FATAL_ERROR;
    std::string value;
};
 
std::vector<Lexem> lexParser(const std::string& text, bool debugScript = false);
 
class SynParser
{
public:
    SynParser()
    {
    }
    ~SynParser()
    {
    }
 
    SynParser& addLiteral(const std::string& name, const std::string& value, bool skip = false);
    SynParser& addTypedLiteral(const std::string& name, Lexem::TypeCode type, bool skip = false);
    SynParser& addGrammar(const std::string& name, const std::string& value, bool root = false, bool unskippable = false);
 
    struct Node
    {
        Lexem lex;
        std::vector<Node> child;
        std::string print(const std::string& tab = "");
    };
 
    Node parse(std::vector<Lexem>& lexems, std::string root = "");
 
private:
 
    std::string m_rootName;
    std::set<std::string> m_skippableLiterals;
    std::set<std::string> m_unskippableGrammars;
    std::map<std::string, std::string> m_literals;
    std::map<std::string, Lexem::TypeCode> m_literalsTyped;
    std::map<std::string, std::string> m_grammars;
    std::map<std::string, std::vector<Lexem>> m_grammarsParsed;
 
    Node parseRecursive(const std::string& g, std::vector<Lexem>& lexems, size_t& off);
};
 
struct SyntaxTreeNode
{
    enum TypeCode
    {
        CALL,
        SHAPE,
        ADDSUB,
        MULDIV,
        POWER,
        CONSTANT,
        PARAMETER,
        OPTION,
        BLOCK_SIZE,
        FATAL_ERROR
    };
    TypeCode type = FATAL_ERROR;
    Lexem literal;
    Lexem flag;
    std::vector<SyntaxTreeNode> params;
};
 
SyntaxTreeNode syntaxParserPower(std::vector<Lexem>& lexems, size_t& off);
SyntaxTreeNode syntaxParserMulDiv(std::vector<Lexem>& lexems, size_t& off);
SyntaxTreeNode syntaxParserAddSub(std::vector<Lexem>& lexems, size_t& off);
SyntaxTreeNode syntaxParserOperand(std::vector<Lexem>& lexems, size_t& off);
SyntaxTreeNode syntaxParserBlock(std::vector<Lexem>& lexems, size_t& off);
SyntaxTreeNode syntaxParser(std::vector<Lexem>& lexems, bool call, SyntaxTreeNode* pBlockParams = nullptr, size_t* pCallOffset = nullptr);
 
SyntaxTreeNode syntaxMixFormula(std::vector<Lexem>& lexems);
 
} // namespace detail
} // namespace nvneural
 
#endif // !NVNEURAL_SCRIPTENGINELEXYN_H