infix2postfix Namespace Reference

Namespaces
namespace	preprocessor_detail
namespace	preprocessor
namespace	detail
namespace	stdlib

Classes
struct	Diagnostic
class	AnalysisEngine
struct	NumberExpr
struct	VariableExpr
struct	UnaryExpr
struct	BinaryExpr
struct	TernaryExpr
struct	CallExpr
struct	PropAccessExpr
struct	StaticRelPixelAccessExpr
struct	FrameDimensionExpr
struct	ArrayAccessExpr
struct	ExprStmt
struct	AssignStmt
struct	ArrayAssignStmt
struct	BlockStmt
struct	IfStmt
struct	WhileStmt
struct	ReturnStmt
struct	LabelStmt
struct	GotoStmt
struct	GlobalDecl
struct	Parameter
struct	FunctionDef
struct	Expr
struct	Stmt
struct	Program
struct	is_variant_member
struct	is_variant_member< T, std::variant< Types... > >
struct	NodeWrapper
class	ASTPrinter
struct	BuiltinFunction
class	CodeGenError
class	CodeGenerator
struct	OverloadCandidate
struct	ErrorInfo
struct	ParseResult
class	Parser
class	PostfixBuilder
class	PreprocessorError
struct	MacroExpansion
struct	LineMapping
struct	MacroDefinition
struct	PreprocessResult
class	Preprocessor
class	SemanticAnalyzer
class	StandardLibraryManager
struct	Symbol
class	SymbolTable
class	Tokenizer
struct	SourceLocation
struct	Range
struct	TokenMapping
struct	Token
struct	ParameterInfo
struct	FunctionSignature
struct	ExportedFunction

Typedefs
template<typename T>
using	node_wrapper_t = typename NodeWrapper<T>::type
using	Token = preprocessor_detail::Token
using	TokenType = preprocessor_detail::TokenType
using	PreprocessorTokenizer = preprocessor_detail::PreprocessorTokenizer
using	AllStandardLibraries
template<IsLibrary Lib>
using	ResolveLibraryDependencies

Enumerations
enum class	DiagnosticSeverity : std::uint8_t { Error , Warning }
enum class	PostfixMode : std::uint8_t { Expr , SingleExpr }
enum class	SymbolKind : std::uint8_t { Variable , Function , Parameter , Label }
enum class	Type : std::uint8_t {   Value , Clip , Literal , LiteralString ,   Array , Void }
enum class	TokenType : std::uint8_t {   If , Else , While , Goto ,   Function , Return , Plus , Minus ,   Star , Slash , Percent , StarStar ,   LogicalAnd , LogicalOr , BitAnd , BitOr ,   BitXor , BitNot , Eq , Ne ,   Lt , Le , Gt , Ge ,   Assign , Question , Colon , Not ,   LParen , RParen , LBrace , RBrace ,   LBracket , RBracket , Comma , Dot ,   Semicolon , Identifier , Number , Global ,   Newline , EndOfFile , Invalid }
enum class	Mode : std::uint8_t { Expr , Single , VkExpr }
enum class	GlobalMode : std::uint8_t { None , All , Specific }

Functions
template<typename T, typename... Args>
auto	make_node (Args &&... args)
template<typename T, typename Wrapper>
auto	get_if (Wrapper *wrapper) -> decltype(std::get_if< T >(&wrapper->value))
const std::map< std::string, std::vector< BuiltinFunction > > &	get_builtin_functions ()
bool	is_convertible (Type from, Type to, Mode mode)
template<typename T>
const OverloadCandidate< T > *	select_best_candidate (std::vector< OverloadCandidate< T > > &candidates)
template<typename T>
bool	is_ambiguous (const std::vector< OverloadCandidate< T > > &candidates, const OverloadCandidate< T > *best)
template<typename T, typename ArgTypeGetter, typename ParamTypeGetter>
std::vector< OverloadCandidate< T > >	compute_candidates (const std::vector< T > &overloads, size_t arg_count, ArgTypeGetter get_arg_type, ParamTypeGetter get_param_type, Mode mode)
int	compute_postfix_stack_effect (const std::string &postfix_expr, PostfixMode mode, int line, int num_inputs, int num_intermediate_inputs)
std::string	token_type_to_string (TokenType type)
template<FixedString Prefix>
std::optional< int >	get_index_with_prefix (const std::string &s)
template<FixedString Prefix>
bool	is_name (const std::string &s)
std::optional< int >	get_clip_index (const std::string &s)
bool	is_clip_name (const std::string &s)
std::optional< int >	get_buffer_index (const std::string &s)
bool	is_buffer_name (const std::string &s)

Variables
template<class T, class V>
constexpr bool	IS_VARIANT_MEMBER_V = is_variant_member<T, V>::value
constexpr std::array	TOKEN_MAPPINGS

Detailed Description

Copyright (C) 2025 yuygfgg

This file is part of Vapoursynth-llvmexpr.

Vapoursynth-llvmexpr is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Vapoursynth-llvmexpr is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with Vapoursynth-llvmexpr. If not, see https://www.gnu.org/licenses/.

Typedef Documentation

AllStandardLibraries

using infix2postfix::AllStandardLibraries

Initial value:

 
std::tuple<stdlib::Algorithms, stdlib::Meta, stdlib::Std>

Definition at line 39 of file StandardLibrary.hpp.

node_wrapper_t

template<typename T>

using infix2postfix::node_wrapper_t = typename NodeWrapper<T>::type

Definition at line 435 of file AST.hpp.

PreprocessorTokenizer

using infix2postfix::PreprocessorTokenizer = preprocessor_detail::PreprocessorTokenizer

Definition at line 486 of file Preprocessor.cpp.

ResolveLibraryDependencies

template<IsLibrary Lib>

using infix2postfix::ResolveLibraryDependencies

Initial value:

 
typename detail::ResolveOne<Lib, std::tuple<>, std::tuple<>>::type

Definition at line 97 of file StandardLibrary.hpp.

Token

using infix2postfix::Token = preprocessor_detail::Token

Definition at line 484 of file Preprocessor.cpp.

TokenType

using infix2postfix::TokenType = preprocessor_detail::TokenType

Definition at line 485 of file Preprocessor.cpp.

Enumeration Type Documentation

DiagnosticSeverity

enum class infix2postfix::DiagnosticSeverity : std::uint8_t

strong

Enumerator
Error
Warning

Definition at line 33 of file AnalysisEngine.hpp.

                              : std::uint8_t {
    Error,
    Warning,
};

GlobalMode

enum class infix2postfix::GlobalMode : std::uint8_t

strong

Enumerator
None
All
Specific

Definition at line 207 of file types.hpp.

: std::uint8_t { None, All, Specific };

Mode

enum class infix2postfix::Mode : std::uint8_t

strong

Enumerator
Expr
Single
VkExpr

Definition at line 205 of file types.hpp.

: std::uint8_t { Expr, Single, VkExpr };

PostfixMode

enum class infix2postfix::PostfixMode : std::uint8_t

strong

Enumerator
Expr
SingleExpr

Definition at line 28 of file PostfixHelper.hpp.

                       : std::uint8_t {
    Expr,
    SingleExpr,
};

SymbolKind

enum class infix2postfix::SymbolKind : std::uint8_t

strong

Enumerator
Variable
Function
Parameter
Label

Definition at line 33 of file Symbol.hpp.

: std::uint8_t { Variable, Function, Parameter, Label };

TokenType

enum class infix2postfix::TokenType : std::uint8_t

strong

Enumerator
If
Else
While
Goto
Function
Return
Plus
Minus
Star
Slash
Percent
StarStar
LogicalAnd
LogicalOr
BitAnd
BitOr
BitXor
BitNot
Eq
Ne
Lt
Le
Gt
Ge
Assign
Question
Colon
Not
LParen
RParen
LBrace
RBrace
LBracket
RBracket
Comma
Dot
Semicolon
Identifier
Number
Global
Newline
EndOfFile
Invalid

Definition at line 66 of file types.hpp.

                     : std::uint8_t {
    // Keywords
    If,       // if
    Else,     // else
    While,    // while
    Goto,     // goto
    Function, // function
    Return,   // return
 
    // Operators
    Plus,       // +
    Minus,      // -
    Star,       // *
    Slash,      // /
    Percent,    // %
    StarStar,   // **
    LogicalAnd, // &&
    LogicalOr,  // ||
    BitAnd,     // &
    BitOr,      // |
    BitXor,     // ^
    BitNot,     // ~
    Eq,         // ==
    Ne,         // !=
    Lt,         // <
    Le,         // <=
    Gt,         // >
    Ge,         // >=
    Assign,     // =
    Question,   // ?
    Colon,      // :
    Not,        // !
 
    // Punctuation
    LParen,    // (
    RParen,    // )
    LBrace,    // {
    RBrace,    // }
    LBracket,  // [
    RBracket,  // ]
    Comma,     // ,
    Dot,       // .
    Semicolon, // ;
 
    // Literals
    Identifier,
    Number,
 
    // Special
    Global, // <global...>
    Newline,
    EndOfFile,
    Invalid,
};

Type

enum class infix2postfix::Type : std::uint8_t

strong

Enumerator
Value
Clip
Literal
LiteralString
Array
Void

Definition at line 57 of file types.hpp.

                : std::uint8_t {
    Value,
    Clip,
    Literal,
    LiteralString,
    Array,
    Void,
};

Function Documentation

compute_candidates()

template<typename T, typename ArgTypeGetter, typename ParamTypeGetter>

std::vector< OverloadCandidate< T > > infix2postfix::compute_candidates	(	const std::vector< T > &	overloads,
		size_t	arg_count,
		ArgTypeGetter	get_arg_type,
		ParamTypeGetter	get_param_type,
		Mode	mode )

Definition at line 84 of file OverloadResolution.hpp.

                              {
    std::vector<OverloadCandidate<T>> candidates;
 
    for (const auto& item : overloads) {
        int conversion_count = 0;
        int first_conversion_index = -1;
        bool possible = true;
 
        for (size_t j = 0; j < arg_count; ++j) {
            std::optional<Type> arg_type_opt = get_arg_type(item, j);
            std::optional<Type> param_type_opt = get_param_type(item, j);
 
            if (!arg_type_opt.has_value() || !param_type_opt.has_value()) {
                possible = false;
                break;
            }
 
            Type arg_type = arg_type_opt.value();
            Type param_type = param_type_opt.value();
 
            if (arg_type != param_type) {
                if (is_convertible(arg_type, param_type, mode)) {
                    conversion_count++;
                    if (first_conversion_index == -1) {
                        first_conversion_index = static_cast<int>(j);
                    }
                } else {
                    possible = false;
                    break;
                }
            }
        }
 
        if (possible) {
            candidates.push_back(
                {&item, conversion_count, first_conversion_index});
        }
    }
 
    return candidates;
}

References is_convertible().

compute_postfix_stack_effect()

int infix2postfix::compute_postfix_stack_effect	(	const std::string &	postfix_expr,
		PostfixMode	mode,
		int	line,
		int	num_inputs,
		int	num_intermediate_inputs )

Definition at line 28 of file PostfixHelper.cpp.

                                                              {
    ::ExprMode expr_mode = ::ExprMode::SingleExpr;
    if (mode == PostfixMode::Expr) {
        expr_mode = (num_intermediate_inputs > 0) ? ::ExprMode::VkExpr
                                                  : ::ExprMode::Expr;
    }
 
    std::vector<::Token> tokens;
    try {
        tokens = ::tokenize(postfix_expr, num_inputs, expr_mode,
                            num_intermediate_inputs);
    } catch (const std::exception& e) {
        throw std::runtime_error(
            std::format("Line {}: Failed to tokenize postfix expression: {}",
                        line, e.what()));
    }
 
    int stack = 0;
    for (const auto& token : tokens) {
        ::TokenBehavior behavior = ::get_token_behavior(token);
        stack += behavior.stack_effect;
        if (stack < 0) {
            throw std::runtime_error(
                std::format("Line {}: Stack underflow while processing '{}'",
                            line, token.text));
        }
    }
    return stack;
}

References Expr, Expr, get_token_behavior(), SingleExpr, TokenBehavior::stack_effect, tokenize(), and VkExpr.

get_buffer_index()

std::optional< int > infix2postfix::get_buffer_index ( const std::string & s )

inline

Definition at line 267 of file types.hpp.

                                                             {
    return get_index_with_prefix<FixedString{"buf"}>(s);
}

References get_index_with_prefix().

get_builtin_functions()

const std::map< std::string, std::vector< BuiltinFunction > > & infix2postfix::get_builtin_functions

(

)

Definition at line 400 of file Builtins.cpp.

                        {
    return builtin_functions;
}

get_clip_index()

std::optional< int > infix2postfix::get_clip_index ( const std::string & s )

inline

Definition at line 256 of file types.hpp.

                                                           {
    if (s.length() == 1 && s[0] >= 'a' && s[0] <= 'z') {
        return parse_std_clip_idx(s[0]);
    }
    return get_index_with_prefix<FixedString{"src"}>(s);
}

References get_index_with_prefix(), and parse_std_clip_idx().

Referenced by is_clip_name().

get_if()

template<typename T, typename Wrapper>

auto infix2postfix::get_if

(

Wrapper *

wrapper

)

-> decltype(std::get_if< T >(&wrapper->value))

Definition at line 442 of file AST.hpp.

                                                                         {
    if (!wrapper) {
        return nullptr;
    }
    return std::get_if<T>(&wrapper->value);
}

Referenced by infix2postfix::SemanticAnalyzer::analyze().

get_index_with_prefix()

template<FixedString Prefix>

std::optional< int > infix2postfix::get_index_with_prefix ( const std::string & s )

inline

Definition at line 228 of file types.hpp.

                                                                  {
    if (!s.starts_with(Prefix.view())) {
        return std::nullopt;
    }
    auto idx_str = s.substr(Prefix.view().size());
    if (idx_str.empty()) {
        return std::nullopt;
    }
 
    if (!std::ranges::all_of(idx_str,
                             [](char c) { return std::isdigit(c) != 0; })) {
        return std::nullopt;
    }
 
    int idx = 0;
    const char* begin = idx_str.data();
    const char* end = begin + static_cast<std::ptrdiff_t>(idx_str.size());
    auto res = std::from_chars(begin, end, idx);
    if (res.ec != std::errc{} || res.ptr != end) {
        return std::nullopt;
    }
    return idx;
}

Referenced by get_buffer_index(), get_clip_index(), and is_name().

is_ambiguous()

template<typename T>

bool infix2postfix::is_ambiguous	(	const std::vector< OverloadCandidate< T > > &	candidates,
		const OverloadCandidate< T > *	best )

Definition at line 68 of file OverloadResolution.hpp.

                                                    {
    if (!best || candidates.size() <= 1) {
        return false;
    }
 
    int count = 0;
    count = std::ranges::count_if(candidates, [best](const auto& cand) {
        return cand.conversion_count == best->conversion_count &&
               cand.first_conversion_index == best->first_conversion_index;
    });
    return count > 1;
}

References infix2postfix::OverloadCandidate< T >::conversion_count, and infix2postfix::OverloadCandidate< T >::first_conversion_index.

is_buffer_name()

bool infix2postfix::is_buffer_name ( const std::string & s )

inline

Definition at line 271 of file types.hpp.

                                               {
    return is_name<FixedString{"buf"}>(s);
}

References is_name().

is_clip_name()

bool infix2postfix::is_clip_name ( const std::string & s )

inline

Definition at line 263 of file types.hpp.

                                             {
    return get_clip_index(s).has_value();
}

References get_clip_index().

is_convertible()

bool infix2postfix::is_convertible ( Type from, Type to, Mode mode )

inline

Definition at line 31 of file OverloadResolution.hpp.

                                                          {
    if (from == Type::Void) {
        return false;
    }
    return from == to || (to == Type::Value && from != Type::LiteralString &&
                          from != Type::Array &&
                          (mode != Mode::Single || from != Type::Clip));
}

References Array, Clip, LiteralString, Single, Value, and Void.

Referenced by compute_candidates().

is_name()

template<FixedString Prefix>

bool infix2postfix::is_name ( const std::string & s )

inline

Definition at line 252 of file types.hpp.

                                                                      {
    return get_index_with_prefix<Prefix>(s).has_value();
}

References get_index_with_prefix().

Referenced by is_buffer_name().

make_node()

template<typename T, typename... Args>

auto infix2postfix::make_node

(

Args &&...

args

)

Definition at line 437 of file AST.hpp.

                                                                       {
    return std::make_unique<node_wrapper_t<T>>(T(std::forward<Args>(args)...));
}

select_best_candidate()

template<typename T>

const OverloadCandidate< T > * infix2postfix::select_best_candidate

(

std::vector< OverloadCandidate< T > > &

candidates

)

Definition at line 48 of file OverloadResolution.hpp.

                                                                   {
    if (candidates.empty()) {
        return nullptr;
    }
 
    OverloadCandidate<T>* best = candidates.data();
    for (size_t i = 1; i < candidates.size(); ++i) {
        if (candidates[i].conversion_count < best->conversion_count) {
            best = &candidates[i];
        } else if (candidates[i].conversion_count == best->conversion_count) {
            if (candidates[i].first_conversion_index >
                best->first_conversion_index) {
                best = &candidates[i];
            }
        }
    }
    return best;
}

References infix2postfix::OverloadCandidate< T >::conversion_count, and infix2postfix::OverloadCandidate< T >::first_conversion_index.

token_type_to_string()

std::string infix2postfix::token_type_to_string ( TokenType type )

inline

Definition at line 171 of file types.hpp.

                                                      {
    if (const auto* it = std::ranges::find_if(
            TOKEN_MAPPINGS,
            [type](const auto& mapping) { return mapping.type == type; });
        it != TOKEN_MAPPINGS.end()) {
        return std::string(it->str);
    }
    // Handle special cases not in the table
    switch (type) {
    case TokenType::Identifier:
        return "identifier";
    case TokenType::Number:
        return "number";
    case TokenType::Global:
        return "global declaration";
    case TokenType::Newline:
        return "newline";
    case TokenType::Semicolon:
        return "semicolon";
    case TokenType::EndOfFile:
        return "end of file";
    case TokenType::Invalid:
        return "invalid token";
    default:
        std::unreachable();
    }
}

References Number, and TOKEN_MAPPINGS.

Variable Documentation

IS_VARIANT_MEMBER_V

template<class T, class V>

bool infix2postfix::IS_VARIANT_MEMBER_V = is_variant_member<T, V>::value

inlineconstexpr

Definition at line 425 of file AST.hpp.

TOKEN_MAPPINGS

std::array infix2postfix::TOKEN_MAPPINGS

constexpr

Definition at line 126 of file types.hpp.

                                  {
    // Keywords
    TokenMapping{.type = TokenType::If, .str = "if"},
    TokenMapping{.type = TokenType::Else, .str = "else"},
    TokenMapping{.type = TokenType::While, .str = "while"},
    TokenMapping{.type = TokenType::Goto, .str = "goto"},
    TokenMapping{.type = TokenType::Function, .str = "function"},
    TokenMapping{.type = TokenType::Return, .str = "return"},
 
    // Operators
    TokenMapping{.type = TokenType::Plus, .str = "+"},
    TokenMapping{.type = TokenType::Minus, .str = "-"},
    TokenMapping{.type = TokenType::Star, .str = "*"},
    TokenMapping{.type = TokenType::Slash, .str = "/"},
    TokenMapping{.type = TokenType::Percent, .str = "%"},
    TokenMapping{.type = TokenType::StarStar, .str = "**"},
    TokenMapping{.type = TokenType::LogicalAnd, .str = "&&"},
    TokenMapping{.type = TokenType::LogicalOr, .str = "||"},
    TokenMapping{.type = TokenType::BitAnd, .str = "&"},
    TokenMapping{.type = TokenType::BitOr, .str = "|"},
    TokenMapping{.type = TokenType::BitXor, .str = "^"},
    TokenMapping{.type = TokenType::BitNot, .str = "~"},
    TokenMapping{.type = TokenType::Eq, .str = "=="},
    TokenMapping{.type = TokenType::Ne, .str = "!="},
    TokenMapping{.type = TokenType::Lt, .str = "<"},
    TokenMapping{.type = TokenType::Le, .str = "<="},
    TokenMapping{.type = TokenType::Gt, .str = ">"},
    TokenMapping{.type = TokenType::Ge, .str = ">="},
    TokenMapping{.type = TokenType::Assign, .str = "="},
    TokenMapping{.type = TokenType::Question, .str = "?"},
    TokenMapping{.type = TokenType::Colon, .str = ":"},
    TokenMapping{.type = TokenType::Not, .str = "!"},
 
    // Punctuation
    TokenMapping{.type = TokenType::LParen, .str = "("},
    TokenMapping{.type = TokenType::RParen, .str = ")"},
    TokenMapping{.type = TokenType::LBrace, .str = "{"},
    TokenMapping{.type = TokenType::RBrace, .str = "}"},
    TokenMapping{.type = TokenType::LBracket, .str = "["},
    TokenMapping{.type = TokenType::RBracket, .str = "]"},
    TokenMapping{.type = TokenType::Comma, .str = ","},
    TokenMapping{.type = TokenType::Dot, .str = "."},
    TokenMapping{.type = TokenType::Semicolon, .str = ";"},
};

Referenced by token_type_to_string().