Dmitry Soshnikov DmitrySoshnikov

Boolean.parse(string)

Specification

Parses the string argument as a boolean. The boolean returned represents the value true if the string argument is not null and is equal, ignoring case, to the string "true".

When the Boolean.parse function is called with a string argument the following steps are taken:

If Type(string) is not "string"

Return false

Start conditions of lex rules, and tokenizer states

Start conditions are declared in the definitions (first) section of the input using unindented lines beginning with either %s or %x followed by a list of names. The former declares inclusive start conditions, the latter exclusive start conditions. A start condition is activated using the BEGIN action. Until the next BEGIN action is executed, rules with the given start condition will be active and rules with other start conditions will be inactive. If the start condition is inclusive, then rules with no start conditions at all will also be active. If it is exclusive, then only rules qualified with the start condition will be active. A set of rules contingent on the same exclusive start condition describe a scanner which is independent of any of the other rules in the flex input. Because of this, exclusive start conditions make it easy to specify "mini-scanners" which scan portions of the input that are syntactically different from the res

	const regexpTree = require('regexp-tree');

	// Get AST.
	const ast = regexpTree.parse('/[a-z]{1,}/');

	// Handle nodes.
	regexpTree.traverse(ast, {

	// Handle "Quantifier" node type,
	// transforming `{1,}` quantifier to `+`.

	// by Dmitry Soshnikov

	ES7:

	== Lexical environment ==

	- Environment Record
	- parent (can be null)

	== Environment Record ==

	{
	"type": "RegExp",
	"body": {
	"type": "Repetition",
	"expression": {
	"type": "CharacterClass",
	"expressions": [
	{
	"type": "ClassRange",
	"from": {

	// RegExp:

	/x*?/

	// 1. Char is main, repetition is secondary (modifier)

	{
	type: 'Char',
	value: 'x',
	modifier: {

	%%

	boolean
	: term bool'
	;

	bool'
	: 'OR' term bool'
	\| /* epsilon */
	;

	const regexpTree = require('regexp-tree');

	console.log(regexpTree.parse(/a\|b/i)); // RegExp AST

	.dmitrys:syntax$ syntax-cli --grammar ~/calculator.grammar.js --mode LALR1 --table

	Parsing mode: LALR(1).

	Grammar:

	0. $accept -> E
	----------------
	1. E -> E + E
	2. \| E * E

	/**
	* Explicit handling of the operator associativity. See also implicit handling
	* https://gist.github.com/DmitrySoshnikov/ab6ed4d41505c579cee9af759e77ead9
	*
	* Calculator grammar for a parser in Python.
	*
	* syntax-cli -g calc-no-assoc.g.js -m LALR1 -o calcparser.py
	*
	* >>> import calcparser
	* >>> calcparser.parse('2 + 2 * 2')