myparser Namespace Reference

Classes
class	RuleDef< MP_STR("root", 4)>
class	RuleDef< MP_STR("main structure", 14)>
class	RuleDef< MP_STR("program", 7)>
class	RuleDef< MP_STR("function", 8)>
class	RuleDef< MP_STR("class", 5)>
class	RuleDef< MP_STR("main body", 9)>
class	RuleDef< MP_STR("interface block", 15)>
class	RuleDef< MP_STR("is block", 8)>
class	RuleDef< MP_STR("code block", 10)>
class	RuleDef< MP_STR("main end", 8)>
class	RuleDef< MP_STR("function proto", 14)>
class	RuleDef< MP_STR("argument list", 13)>
class	RuleDef< MP_STR("argument option", 15)>
class	RuleDef< MP_STR("specific list", 13)>
class	RuleDef< MP_STR("specific", 8)>
class	RuleDef< MP_STR("definition", 10)>
class	RuleDef< MP_STR("type definition", 15)>
class	RuleDef< MP_STR("var definition", 14)>
class	RuleDef< MP_STR("const definition", 16)>
class	RuleDef< MP_STR("static definition", 17)>
class	RuleDef< MP_STR("return definition", 17)>
class	RuleDef< MP_STR("statement list", 14)>
class	RuleDef< MP_STR("statement", 9)>
class	RuleDef< MP_STR("assignment", 10)>
class	RuleDef< MP_STR("assign sign", 11)>
class	RuleDef< MP_STR("return", 6)>
class	RuleDef< MP_STR("structure", 9)>
class	RuleDef< MP_STR("condition chain", 15)>
class	RuleDef< MP_STR("for range", 9)>
class	RuleDef< MP_STR("structure end", 13)>
class	RuleDef< MP_STR("repeat", 6)>
class	RuleDef< MP_STR("expression list", 15)>
class	RuleDef< MP_STR("expression", 10)>
class	RuleDef< MP_STR("relative expression", 19)>
class	RuleDef< MP_STR("relative operation", 18)>
class	RuleDef< MP_STR("additive expression", 19)>
class	RuleDef< MP_STR("additive operation", 18)>
class	RuleDef< MP_STR("multiplicative expression", 25)>
class	RuleDef< MP_STR("multiplicative operation", 24)>
class	RuleDef< MP_STR("unary expression", 16)>
class	RuleDef< MP_STR("access operation", 16)>
class	RuleDef< MP_STR("argument apply", 14)>
class	RuleDef< MP_STR("type", 4)>
class	RuleDef< MP_STR("native type", 11)>
class	RuleDef< MP_STR("wrap type", 9)>
class	RuleDef< MP_STR("array", 5)>
class	RuleDef< MP_STR("pointer", 7)>
class	RuleDef< MP_STR("reference", 9)>
class	RuleDef< MP_STR("program type", 12)>
class	RuleDef< MP_STR("function type", 13)>
class	RuleDef< MP_STR("type inference", 14)>
class	RuleDef< MP_STR("relation", 8)>
class	RuleDef< MP_STR("addition", 8)>
class	RuleDef< MP_STR("multiplication", 14)>
class	RuleDef< MP_STR("unary operator", 14)>
class	RuleDef< MP_STR("comparison", 10)>
class	RuleDef< MP_STR("addsub", 6)>
class	RuleDef< MP_STR("muldiv", 6)>
class	RuleDef< MP_STR("literal", 7)>
class	RuleDef< MP_STR("boolean", 7)>
class	RuleDef< MP_STR("byte", 4)>
class	RuleDef< MP_STR("integer", 7)>
class	RuleDef< MP_STR("real", 4)>
class	RuleDef< MP_STR("string", 6)>
class	RuleDef< MP_STR("instant array", 13)>
class	RuleDef< MP_STR("space", 5)>
class	RuleDef< MP_STR("keyword", 7)>
class	RuleDef< MP_STR("id", 2)>
class	RuleDef< MP_STR("reserved id", 11)>
class	RuleDef< MP_STR("sign", 4)>
class	RuleDef< MP_STR("ignored", 7)>
class	NodeId
class	NodeTyped< BuiltinSpace, NodeListIndexed< I > >
class	NodeTyped< RuleId, NodeText<> >
class	Node
class	NodeList
class	NodeListIndexed
class	NodeText
class	NodeTextOrError
class	NodeError
class	NodeTypedProto
class	NodeTyped
class	NodeSpace
class	NodeData
class	Pass
class	PassBase
class	PassProto
class	Pass< PASS_FIN >
class	Pass< PASS_FILTER >
class	Pass< PASS_REPR >
class	PassReprText
class	PassReprSimple
class	PassReprFull
class	PassReprJSON
class	Tag
class	Rule
class	RuleNamed
class	RuleDef
class	RuleDef< BuiltinError >
class	RuleList
class	RuleRegex
class	RuleItemSpace
class	RuleItemKeyword
class	RuleItemRef
class	RuleItemError
class	RuleLine
class	Parser
class	StaticStr

Typedefs
using	RuleId = MP_STR("id", 2)
using	ErrorId = MP_STR("Illegal identifier", 18)
using	Input = std::string::const_iterator
template<class NT , size_t I>
using	NodeListTyped = NodeTyped< NT, NodeListIndexed< I >>
template<class NT >
using	NodeTextTyped = NodeTyped< NT, NodeText<>>
template<class NT , class E >
using	NodeErrorTyped = NodeTyped< NT, NodeError< E >>
using	BuiltinRoot = MP_STR("root", 4)
using	BuiltinSpace = MP_STR("space", 5)
using	BuiltinKeyword = MP_STR("keyword", 7)
using	BuiltinError = MP_STR("error", 5)
using	ErrorList = MP_STR("Nothing matched", 15)
using	ErrorRegex = MP_STR("Regex not matched", 17)
using	ErrorChecking = MP_STR("Match not accepted", 18)
using	ErrorKeyword = MP_STR("Bad keyword", 11)
using	TagNormal = Tag< 1, 1 >
using	TagMaybe = Tag< 0, 1 >
using	TagAny0 = Tag< 0, std::numeric_limits< size_t >::max()>
using	TagAny1 = Tag< 1, std::numeric_limits< size_t >::max()>

Enumerations
enum	{   PASS_FILTER, PASS_REPR, PASS_HIGHLIGHT, PASS_MESSAGE,   PASS_FIN = 64 }

Functions
template<class T >
void	mpDebug (T value)

Variables
const auto	style_index = ccc::cf_magenta + ccc::s_bold
const auto	style_keyword = ccc::cf_yellow + ccc::s_bold + ccc::s_underline_single
const auto	style_error = ccc::cf_red + ccc::s_bold
const auto	style_faint = ""
const auto	style_normal = ccc::d_all

Typedef Documentation

using myparser::BuiltinError = typedef MP_STR("error", 5)

using myparser::BuiltinKeyword = typedef MP_STR("keyword", 7)

using myparser::BuiltinRoot = typedef MP_STR("root", 4)

using myparser::BuiltinSpace = typedef MP_STR("space", 5)

using myparser::ErrorChecking = typedef MP_STR("Match not accepted", 18)

using myparser::ErrorId = typedef MP_STR("Illegal identifier", 18)

using myparser::ErrorKeyword = typedef MP_STR("Bad keyword", 11)

using myparser::ErrorList = typedef MP_STR("Nothing matched", 15)

using myparser::ErrorRegex = typedef MP_STR("Regex not matched", 17)

using myparser::Input = typedef std::string::const_iterator

template<class NT , class E >

using myparser::NodeErrorTyped = typedef NodeTyped<NT, NodeError<E>>

template<class NT , size_t I>

using myparser::NodeListTyped = typedef NodeTyped<NT, NodeListIndexed<I>>

template<class NT >

using myparser::NodeTextTyped = typedef NodeTyped<NT, NodeText<>>

using myparser::RuleId = typedef MP_STR("id", 2)

using myparser::TagAny0 = typedef Tag<0, std::numeric_limits<size_t>::max()>

using myparser::TagAny1 = typedef Tag<1, std::numeric_limits<size_t>::max()>

using myparser::TagMaybe = typedef Tag<0, 1>

using myparser::TagNormal = typedef Tag<1, 1>

Enumeration Type Documentation

anonymous enum

Enumerator
PASS_FILTER
PASS_REPR
PASS_HIGHLIGHT
PASS_MESSAGE
PASS_FIN

Function Documentation

template<class T >

void myparser::mpDebug ( T  value )

inline

Variable Documentation

const auto myparser::style_error = ccc::cf_red + ccc::s_bold

const auto myparser::style_faint = ""

const auto myparser::style_index = ccc::cf_magenta + ccc::s_bold

const auto myparser::style_keyword = ccc::cf_yellow + ccc::s_bold + ccc::s_underline_single

const auto myparser::style_normal = ccc::d_all