aParser

MMO\core\classes · 1 symbol · generated 5 Oct 2026

class

aParser

Base class for a single-instance, non-reentrant text parser built on Tokenizer: a subclass builds its tokenizer once (createTokenizer) and implements process to turn the tokenized text into a result (e.g. a parsed value, a DOM). parse is the public entry point -- see e.g.

abstract class MMO\core\classes\aParser extends MMO\core\classes\aModule

Namespace: MMO\core\classes
Extends: aModule

\MMO\core\JsonParser / \MMO\core\XmlParser for concrete subclasses.

class MyParser extends aParser { public function createTokenizer(): Tokenizer {return new Tokenizer(...);} protected function process(array $opts = []): mixed { // read tokens from $this->getTokenizer(), call $this->addError(...) on failures return $result; } } MyParser::Shared()->parse($text);

Index

	errors
	lock
	tokenizer
	addError($token, $message, $context)	Record a parse error/warning: logs it (`tLogEmitter::warning`) and appends it to
	createTokenizer() abstract	Build (once) the `Tokenizer` this parser uses to split its input into tokens.
	getErrors()
	getTokenizer()
	hasErrors()
	isLocked()
	parse($text, $opts)	Parse $text: resets `getErrors`, (re)builds/reuses the tokenizer, runs `process`, then always clears the tokenizer's tokens from memory (even if process() throws).
	process($opts) abstract	Do the actual parsing, reading tokens from `getTokenizer` and returning the parsed result.

Properties3

errors

#[MMO\core\attributes\Serialize(false)] protected array $errors = []

Type: array

lock

#[MMO\core\attributes\Serialize(false)] protected bool $lock = false

Type: bool

tokenizer

protected ?MMO\core\helpers\Tokenizer $tokenizer = null

Type: null | Tokenizer

Methods8

addError($token, $message, $context)

aParser.php:57

Record a parse error/warning: logs it (tLogEmitter::warning) and appends it to

protected function addError(?MMO\core\helpers\Token $token, string $message, array $context = []): string

See: getErrors, without stopping parsing -- a subclass wanting a hard failure should throw after calling this.

$token	null \| Token	the offending token, for position info in the message; null if the error is about input simply running out (e.g. "unexpected end of input") -- in that case the message is suffixed with "(EOF)" instead of a line:col position
$message	string
$context = []	array
returns	string	the final, formatted error message

$this->addError($token, 'unexpected [{char}].', ['char' => $token->text]); // "unexpected [x]. (3:5): x"

$this->addError(null, 'unexpected end of input.'); // "unexpected end of input. (EOF)"

createTokenizer()

abstractaParser.php:36

Build (once) the Tokenizer this parser uses to split its input into tokens.

abstract function createTokenizer(): MMO\core\helpers\Tokenizer

returns

Tokenizer

getErrors()

aParser.php:85

function getErrors(): array

returns array [[formatted message, Token|null], ...] every error recorded by addError during the most recent parse call

getTokenizer()

aParser.php:70

function getTokenizer(): ?MMO\core\helpers\Tokenizer

returns null | Tokenizer the tokenizer built by createTokenizer, or null before the first parse call

hasErrors()

aParser.php:77

function hasErrors(): bool

returns bool true if the most recent parse call recorded at least one addError

isLocked()

aParser.php:92

function isLocked(): bool

returns bool true while a parse call is in progress (this parser instance is not reentrant: see parse)

parse($text, $opts)

aParser.php:106

Parse $text: resets getErrors, (re)builds/reuses the tokenizer, runs process, then always clears the tokenizer's tokens from memory (even if process() throws).

function parse($text, array $opts = []): mixed

$text
$opts = []	array	forwarded to `process`
returns	mixed	whatever `process` returns
throws		if this parser instance is already parsing (this class is not reentrant -- e.g. don't call parse() again from within your own process() implementation on the same shared instance)

MyParser::Shared()->parse('{"a": 1}');

process($opts)

abstractaParser.php:43

Do the actual parsing, reading tokens from getTokenizer and returning the parsed result.

abstract protected function process(array $opts = []): mixed

$opts = []	array
returns	mixed

Inherited members (48)

Constants	Declared by	Description
`ALERT`	iLogLevel	Alert: Action must be taken immediately.
`ALL`	iLogLevel	Mask for all
`ALL_PLUS`	iLogLevel	debug everything
`BACKTRACE`	iLogLevel
`CRITICAL`	iLogLevel	Critical: Critical conditions.
`DEBUG`	iLogLevel	Debug: Detailed debug information.
`DEEP`	iLogLevel	debug everything with arguments
`EMERGENCY`	iLogLevel	Emergency: System is unusable.
`ERROR`	iLogLevel	Error: Runtime errors that do not require immediate action but should typically be logged and monitored.
`ERROR_PLUS`	iLogLevel	Mask for all error
`FATAL`	iLogLevel	Mask for all fatal error
`INFO`	iLogLevel	Info: Interesting events.
`INFO_PLUS`	iLogLevel	Mask for all errors/warning/notices/info
`MEMORY`	iLogLevel	include backtrace object
`NOTICE`	iLogLevel	Notice: Normal but significant events.
`NOTICE_PLUS`	iLogLevel	Mask for all errors/warning/notices/info
`TRACE`	iLogLevel	include backtrace as origins
`WARNING`	iLogLevel	Warning: Exceptional occurrences that are not errors.
`WARNING_PLUS`	iLogLevel	Mask for all errors and warnings

	Properties	Declared by	Description
	`verbosity`	aModule

Methods	Declared by	Description
`alert($message, $context)`	aModule	Action must be taken immediately.
`backtraces($message, $context)`	aModule	Force-log a message at INFO level together with a full stack trace/memory snapshot (`iLogLevel::BACKTRACE`), bypassing the verbosity mask entirely (any non-zero verbosity is enough to trigger it).
`Configure($config)`	aModule	Merge $config into this module's configuration in the shared `Configuration`.
`critical($message, $context)`	aModule	Critical conditions. No-op if CRITICAL is currently filtered out by the verbosity mask.
`debug($message, $context)`	aModule	Detailed debug information.
`debugName()`	aModule	Human-readable identifier used as the default `{origin}` in this instance's log messages.
`DefaultConfig()`	aModule	The config a module starts from before anything loaded via `Configuration` is merged in.
`emergency($message, $context)`	aModule	System is unusable. No-op if EMERGENCY is currently filtered out by the verbosity mask.
`error($message, $context)`	aModule	Runtime errors that do not require immediate action but should typically be logged and monitored.
`getVerbosity()`	aModule
`info($message, $context)`	aModule	Interesting events. No-op if INFO is currently filtered out by the verbosity mask.
`Instantiate($config)`	aModule	(Re)create the shared instance immediately, configured with $config merged into the class's existing config.
`IsShared()`	aModule
`log($level, $message, $context)`	aModule	Logs with an arbitrary level.
`notice($message, $context)`	aModule	Normal but significant events.
`offsetExists($key)`	aModule	\ArrayAccess::offsetExists -- tells whether $key is a declared property at all, regardless of whether it is currently readable/writable through array access.
`offsetGet($key)`	aModule	\ArrayAccess::offsetGet -- reads a property directly, unless it has a `#[Serialize(serialize: 'methodName')]` attribute, in which case that zero-argument method is called instead (e.g.
`offsetSet($key, $value)`	aModule	\ArrayAccess::offsetSet -- sets a property directly, unless it has a `#[Serialize(unserialize: 'methodName')]` attribute, in which case that method is called with $value instead (e.g.
`offsetUnset($key)`	aModule	\ArrayAccess::offsetUnset -- equivalent to `$module[$key] = null`.
`serialize($path, $serializer)`	aModule	\MMO\core\interfaces\iSerializable::serialize -- exports every property (via
`setVerbosity($verb)`	aModule	Set the current verbosity mask, replacing whatever it was before.
`Shared()`	aModule	Get the shared instance, creating (and configuring) it on first call.
`testVerbosity($level)`	aModule	Test whether a given level (or set of levels) is currently enabled by this instance's verbosity mask.
`traitUnshare($serialize)`	aModule	Remove the shared instance, so the next `Shared()` call creates a fresh one.
`unserialize($data, $path, $instances)`	aModule	\MMO\core\interfaces\iSerializable::unserialize -- merges $data onto `DefaultConfig`, runs it through the (possibly overridden) constructor, then applies each resulting value to its property (via
`Unshare($serialize)`	aModule	Like `tSingleton::Unshare`, but also disconnects this module's instance from every event it was listening to (via `Event::DisconnectListeners`) before dropping it.
`warning($message, $context)`	aModule	Exceptional occurrences that are not errors.
`__construct($config)`	aModule	protected constructor, so it is not possible to do `new Module(...)` called by the serialization process just before being injected with data.