grammar-composer 0.3.1 → 0.5.0

package/src/tests/test-grammars/RegExpGrammar.ts

@@ -5,103 +5,157 @@ export class RegExpGrammar {
 	//////////////////////////////////////////////////////////////////////////////////////////////
 	// High-level productions
 	//////////////////////////////////////////////////////////////////////////////////////////////
+	root = () => this.disjunctionOrSequence
+
+	disjunctionOrSequence = () => [
+		G.anyOf(
+			this.disjunction,
+			this.sequence,
+		)
+	]
+
 	disjunction = () => [
 		this.sequence,
 
-		G.possibly([
-			this.disjunctionSeparator,
-			this.disjunction,
+		G.oneOrMore([
+			'|',
+			this.sequence,
 		])
 	]
 
-	sequence = () => G.zeroOrMore(this.element)
+	sequence = () => G.cached(
+		G.zeroOrMore(this.sequenceElement)
+	)
 
-	element = () => G.anyOf(
+	sequenceElement = () => G.anyOf(
 		this.anchor,
 		this.lookaround,
-		this.possiblyQuantifiedExpression,
+		this.quantifiedExpression,
+		this.quantifiableExpression,
 	)
 
 	//////////////////////////////////////////////////////////////////////////////////////////////
-	// Quantifed expressions
+	// Quantifiable expression
 	//////////////////////////////////////////////////////////////////////////////////////////////
-	possiblyQuantifiedExpression = () => [
+	quantifiableExpression = () => G.cached(
 		G.anyOf(
 			this.group,
 			this.backReference,
 			this.singleCharExpression
-		),
+		)
+	)
 
-		G.possibly(G.anyOf(
-			this.starQuantifier,
-			this.plusQuantifier,
-			this.exactCountQuantifier,
-			this.countRangeQuantifier,
-		)),
+	quantifiedExpression = () => [
+		this.quantifiableExpression,
+		this.quantifier,
+	]
 
-		G.possibly(this.nongreedyQuantifier), // Nongreedy quantifier
+	//////////////////////////////////////////////////////////////////////////////////////////////
+	// Quantifier expressions
+	//////////////////////////////////////////////////////////////////////////////////////////////
+	starQuantifier = () => [
+		'*',
+		G.possibly(this.nongreedyQuantifier)
 	]
 
-	exactCountQuantifier = () => G.pattern([
-		'{',
-		R.captureAs('count', R.oneOrMore(digit)),
-		'}',
-	])
+	plusQuantifier = () => [
+		'+',
+		G.possibly(this.nongreedyQuantifier)
+	]
 
-	countRangeQuantifier = () => G.pattern([
-		'{',
-		R.captureAs('start', R.oneOrMore(digit)),
-		',',
-		R.possibly(R.captureAs('end', R.oneOrMore(digit))),
-		'}',
-	])
+	optionalQuantifier = () => [
+		'?',
+		G.possibly(this.nongreedyQuantifier)
+	]
+
+	exactCountQuantifier = () => [
+		G.pattern([
+			'{',
+			R.captureAs('count',
+				R.oneOrMore(digit)
+			),
+			'}',
+		]),
+		G.possibly(this.nongreedyQuantifier)
+	]
+
+	countRangeQuantifier = () => [
+		G.pattern([
+			'{',
+			R.captureAs('start',
+				R.oneOrMore(digit)
+			),
+			',',
+			R.possibly(R.captureAs('end',
+				R.oneOrMore(digit))
+			),
+			'}',
+		]),
+		G.possibly(this.nongreedyQuantifier)
+	]
+
+	nongreedyQuantifier = () => '?'
+
+	quantifier = () => G.anyOf(
+		this.starQuantifier,
+		this.plusQuantifier,
+		this.optionalQuantifier,
+		this.exactCountQuantifier,
+		this.countRangeQuantifier,
+	)
 
 	//////////////////////////////////////////////////////////////////////////////////////////////
 	// Group expressions
 	//////////////////////////////////////////////////////////////////////////////////////////////
-	group = () => G.anyOf(
-		this.uncapturedGroup,
-		this.namedCaptureGroup,
-		this.unnamedCaptureGroup,
-	)
-
 	uncapturedGroup = () => [
 		'(?:',
-		this.disjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
 	namedCaptureGroup = () => [
 		'(?<',
-		G.pattern(R.captureAs('name', R.oneOrMore(identifierChar))),
+		G.pattern(R.captureAs('name',
+			R.oneOrMore(identifierChar))
+		),
 		'>',
-		this.disjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
 	unnamedCaptureGroup = () => [
 		'(',
-		this.disjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
+	group = () => G.anyOf(
+		this.uncapturedGroup,
+		this.namedCaptureGroup,
+		this.unnamedCaptureGroup,
+	)
+
 	//////////////////////////////////////////////////////////////////////////////////////////////
 	// Backreferences
 	//////////////////////////////////////////////////////////////////////////////////////////////
 	unnamedBackreference = () =>
 		G.pattern([
 			'\\',
-			R.captureAs('index', digit),
+			R.captureAs('index',
+				digit
+			),
 		])
 
 	namedBackreference = () =>
 		G.pattern([
 			'\\k<',
-			R.captureAs('name', R.oneOrMore(identifierChar)),
+			R.captureAs('name',
+				R.oneOrMore(identifierChar)
+			),
 			'>',
 		])
 
-	backReference = G.anyOf(
+	backReference = () => G.anyOf(
 		this.unnamedBackreference,
 		this.namedBackreference,
 	)
@@ -111,29 +165,29 @@ export class RegExpGrammar {
 	//////////////////////////////////////////////////////////////////////////////////////////////
 	positiveLookahead = () => [
 		'(?=',
-		this.disjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
 	negativeLookahead = () => [
 		'(?!',
-		this.disjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
 	positiveLookbehind = () => [
 		'(?<=',
-		this.disjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
 	negativeLookbehind = () => [
 		'(?<!',
-		this.disjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
-	lookaround = G.anyOf(
+	lookaround = () => G.anyOf(
 		this.positiveLookahead,
 		this.negativeLookahead,
 		this.positiveLookbehind,
@@ -154,24 +208,31 @@ export class RegExpGrammar {
 	)
 
 	unreservedCharLiteral = () => G.pattern(
-		R.notAnyOfChars('[', '.', '*', '+', '?', '^', '$', '{', '}', '(', ')', '|', ']', '\\')
+		R.captureAs('char',
+			R.notAnyOfChars('[', '.', '*', '+', '?', '^', '$', '{', '}', '(', ')', '|', ']', '\\')
+		)
 	)
 
 	escapedCharLiteral = () => G.pattern([
 		'\\',
-		R.anyChar
+		R.captureAs('char',
+			R.anyChar
+		)
 	])
 
 	hexCharcode = () =>
 		G.pattern([
 			'\\x',
-			hexDigit,
-			hexDigit
+			R.captureAs('value',
+				R.repeated(2, hexDigit)
+			)
 		])
 
 	controlCharcode = () => G.pattern([
 		'\\c',
-		R.anyOf(R.charRange('A', 'Z'), R.charRange('a', 'z')),
+		R.captureAs('value',
+			R.anyOf(R.charRange('A', 'Z'), R.charRange('a', 'z'))
+		)
 	])
 
 	nullCharcode = () => G.pattern('\\0')
@@ -180,48 +241,55 @@ export class RegExpGrammar {
 		G.pattern([
 			'\\u',
 			'{',
-			R.captureAs('value', R.repeated([1, 6], hexDigit)),
+			R.captureAs('value',
+				R.repeated([1, 6], hexDigit)
+			),
 			'}',
 		]),
 		G.pattern([
 			'\\u',
-			hexDigit,
-			hexDigit,
-			hexDigit,
-			hexDigit
+			R.captureAs('value',
+				R.repeated(4, hexDigit)
+			)
 		])
 	)
 
 	codepointRange = () => G.pattern([
 		'\\u',
 		'{',
-		R.captureAs('start', R.oneOrMore(hexDigit)),
+		R.captureAs('start',
+			R.oneOrMore(hexDigit)
+		),
 		'-',
-		R.captureAs('end', R.oneOrMore(hexDigit)),
+		R.captureAs('end',
+			R.oneOrMore(hexDigit)
+		),
 		'}',
 	])
 
-	unicodeProperty = () => G.pattern([
+	unicodeProperty = () => [
 		'\\p',
 		this.unicodePropertyBodyPattern,
-	])
+	]
 
-	notUnicodeProperty = () => G.pattern([
+	notUnicodeProperty = () => [
 		'\\P',
 		this.unicodePropertyBodyPattern,
-	])
+	]
 
-	unicodePropertyBodyPattern: R.Pattern = [
+	unicodePropertyBodyPattern = () => G.pattern([
 		'{',
-		R.captureAs('property', R.oneOrMore(R.anyOf(letter, digit, '_', '-'))),
+		R.captureAs('property',
+			R.oneOrMore(R.anyOf(letter, digit, '_', '-'))
+		),
 		R.possibly([
 			'=',
-			R.captureAs('value', R.oneOrMore(R.anyOf(letter, digit, '_', '-'))),
+			R.captureAs('value',
+				R.oneOrMore(R.anyOf(letter, digit, '_', '-'))
+			),
 		]),
 		'}',
-	]
-
-	charClassChar = () => G.pattern(R.notAnyOfChars(']'))
+	])
 
 	charClass = () => [
 		'[',
@@ -233,36 +301,42 @@ export class RegExpGrammar {
 			this.notUnicodeProperty,
 			this.escapedCharacterClass,
 			this.charcodeOrEscapedChar,
-			this.charClassChar
+			this.charClassLiteral
 		)),
 		']',
 	]
 
-	charcodeOrEscapedChar = G.anyOf(
+	charcodeOrEscapedChar = () => G.anyOf(
 		this.codepoint,
 		this.hexCharcode,
 		this.controlCharcode,
+		this.nullCharcode,
 		this.escapedCharLiteral,
 	)
 
-	charRangeElement = G.anyOf(
+	charClassLiteral = () => G.pattern(
+		R.captureAs('char',
+			R.notAnyOfChars(']')
+		)
+	)
+
+	charRangeElement = () => G.anyOf(
 		this.charcodeOrEscapedChar,
-		G.pattern(R.notAnyOfChars(']')),
+		this.charClassLiteral,
 	)
 
+	charRangeStart = () => this.charRangeElement
+	charRangeEnd = () => this.charRangeElement
+
 	charRange = () => [
-		this.charRangeElement,
+		this.charRangeStart,
 		'-',
-		this.charRangeElement,
+		this.charRangeEnd,
 	]
 
 	//////////////////////////////////////////////////////////////////////////////////////////////
 	// Special symbols
 	//////////////////////////////////////////////////////////////////////////////////////////////
-	starQuantifier = () => '*'
-	plusQuantifier = () => '+'
-	nongreedyQuantifier = () => '?'
-
 	charClassNegator = () => '^'
 
 	inputStartAnchor = () => '^'
@@ -270,34 +344,39 @@ export class RegExpGrammar {
 
 	anyCharWildcard = () => '.'
 
-	disjunctionSeparator = () => '|'
-
-	anchor = G.anyOf(this.inputStartAnchor, this.inputEndAnchor)
+	anchor = () =>
+		G.anyOf(this.inputStartAnchor, this.inputEndAnchor)
 
 	escapedCharacterClass = () => G.pattern(R.anyOf(
-		R.captureAs('whitespace', escapedCharString.whitespace),
-		R.captureAs('nonWhitespace', escapedCharString.nonWhitespace),
-		R.captureAs('digit', escapedCharString.digit),
-		R.captureAs('nonDigit', escapedCharString.nonDigit),
-		R.captureAs('word', escapedCharString.word),
-		R.captureAs('nonWord', escapedCharString.nonWord),
-		R.captureAs('wordBoundary', escapedCharString.wordBoundary),
-		R.captureAs('nonWordBoundary', escapedCharString.nonWordBoundary),
-		R.captureAs('formFeed', escapedCharString.formFeed),
-		R.captureAs('carriageReturn', escapedCharString.carriageReturn),
-		R.captureAs('lineFeed', escapedCharString.lineFeed),
-		R.captureAs('tab', escapedCharString.tab),
-		R.captureAs('verticalTab', escapedCharString.verticalTab),
-		R.captureAs('backwardSlash', escapedCharString.backwardSlash),
+		R.captureAs('whitespace', escapedChars.whitespace),
+		R.captureAs('nonWhitespace', escapedChars.nonWhitespace),
+		R.captureAs('digit', escapedChars.digit),
+		R.captureAs('nonDigit', escapedChars.nonDigit),
+		R.captureAs('word', escapedChars.word),
+		R.captureAs('nonWord', escapedChars.nonWord),
+		R.captureAs('wordBoundary', escapedChars.wordBoundary),
+		R.captureAs('nonWordBoundary', escapedChars.nonWordBoundary),
+		R.captureAs('formFeed', escapedChars.formFeed),
+		R.captureAs('carriageReturn', escapedChars.carriageReturn),
+		R.captureAs('lineFeed', escapedChars.lineFeed),
+		R.captureAs('tab', escapedChars.tab),
+		R.captureAs('verticalTab', escapedChars.verticalTab),
+		R.captureAs('backwardSlash', escapedChars.backwardSlash),
 	))
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Shared regular expressions
+//////////////////////////////////////////////////////////////////////////////////////////////
 const digit = R.charRange('0', '9')
 const letter = R.anyOf(R.charRange('a', 'z'), R.charRange('A', 'Z'))
 const hexDigit = R.anyOf(digit, R.charRange('a', 'f'), R.charRange('A', 'F'))
 const identifierChar = R.anyOf(letter, digit, '_', '$')
 
-const escapedCharString = {
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Escaped characters lookup
+//////////////////////////////////////////////////////////////////////////////////////////////
+const escapedChars = {
 	whitespace: '\\s',
 	nonWhitespace: '\\S',
 	digit: '\\d',
@@ -313,3 +392,21 @@ const escapedCharString = {
 	verticalTab: '\\v',
 	backwardSlash: '\\\\'
 }
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Wrapped nonterminal names
+//////////////////////////////////////////////////////////////////////////////////////////////
+export const regExpGrammarUnwrappedNonterminalNames: G.GrammarNonterminalNames<RegExpGrammar> = [
+	'disjunctionOrSequence',
+	'group',
+	'backReference',
+	'lookaround',
+	'unicodeProperty',
+	'notUnicodeProperty',
+	'unicodePropertyBodyPattern',
+	'charcodeOrEscapedChar',
+	'charRangeElement',
+	'anchor',
+	'quantifiableExpression',
+	'sequenceElement',
+]

package/src/tests/test-grammars/SimpleTestGrammar1.ts

@@ -0,0 +1,10 @@
+import * as G from '../../exports/Exports.js'
+
+export class SimpleTestGrammar1 {
+	root = () => [
+		G.anyOf(
+			'abc',
+			'abcdefg',
+		)
+	]
+}

package/src/tests/test-grammars/XmlGrammar.ts

@@ -14,7 +14,7 @@ export class XmlGrammar {
 		)
 	]
 
-	textFragment = G.pattern([
+	textFragment = () => G.pattern([
 		R.oneOrMore(R.notAnyOfChars('<'))
 	])
 
@@ -26,7 +26,7 @@ export class XmlGrammar {
 		this.tagEnd
 	]
 
-	openingTagStart = G.pattern([
+	openingTagStart = () => G.pattern([
 		'<',
 
 		R.possibly('?'),
@@ -38,7 +38,7 @@ export class XmlGrammar {
 		R.zeroOrMore(R.whitespace),
 	])
 
-	tagEnd = G.pattern([
+	tagEnd = () => G.pattern([
 		R.zeroOrMore(R.whitespace),
 
 		R.possibly(R.anyOf('/', '?')),
@@ -46,7 +46,7 @@ export class XmlGrammar {
 		'>'
 	])
 
-	attribute = G.pattern([
+	attribute = () => G.pattern([
 		R.zeroOrMore(R.whitespace),
 
 		R.captureAs('attributeName',
@@ -66,7 +66,7 @@ export class XmlGrammar {
 		])
 	])
 
-	closingTag = G.pattern([
+	closingTag = () => G.pattern([
 		'</',
 
 		R.zeroOrMore(R.whitespace),
@@ -88,7 +88,7 @@ export class XmlGrammar {
 		this.tagEnd
 	]
 
-	declarationTagOpening = G.pattern([
+	declarationTagOpening = () => G.pattern([
 		'<!',
 
 		R.captureAs('tagName',
@@ -98,7 +98,7 @@ export class XmlGrammar {
 		R.zeroOrMore(R.whitespace)
 	])
 
-	declarationTagAttribute = G.pattern([
+	declarationTagAttribute = () => G.pattern([
 		R.zeroOrMore(R.whitespace),
 
 		R.anyOf(
@@ -112,7 +112,7 @@ export class XmlGrammar {
 		R.zeroOrMore(R.whitespace),
 	])
 
-	comment = G.pattern([
+	comment = () => G.pattern([
 		'<!--',
 
 		R.captureAs('commentBody',
@@ -123,6 +123,9 @@ export class XmlGrammar {
 	])
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Helper regular expressions
+//////////////////////////////////////////////////////////////////////////////////////////////
 const quotedString = R.anyOf(
 	[
 		'"',
@@ -139,3 +142,12 @@ const quotedString = R.anyOf(
 		"'"
 	],
 )
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Wrapped nonterminal names
+//////////////////////////////////////////////////////////////////////////////////////////////
+export const xmlGrammarUnwrappedNonterminalNames: G.GrammarNonterminalNames<XmlGrammar> = [
+	'openingTagStart',
+	'tagEnd',
+	'declarationTagOpening',
+]

package/src/utilities/LineAndColumn.ts

@@ -0,0 +1,61 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Position helpers
+/////////////////////////////////////////////////////////////////////////////////////////////////
+export function getLineAndColumn(input: string, offset: number): { line: number, column: number } {
+	let line = 1
+	let lineStartOffset = 0
+
+	for (let i = 0; i < offset && i < input.length; i++) {
+		if (input[i] === '\n') {
+			line += 1
+			lineStartOffset = i + 1
+		}
+	}
+
+	return {
+		line,
+		column: offset - lineStartOffset + 1
+	}
+}
+
+const tabSize = 4
+
+export function expandTabs(text: string): string {
+	let result = ''
+	let column = 0
+
+	for (const char of text) {
+		if (char === '\t') {
+			const spacesToNextTabStop = tabSize - (column % tabSize)
+
+			result += ' '.repeat(spacesToNextTabStop)
+			column += spacesToNextTabStop
+		} else {
+			result += char
+			column += 1
+		}
+	}
+
+	return result
+}
+
+export function buildCaretSpacing(text: string, caretColumn: number): string {
+	let spacing = ''
+	let column = 0
+
+	for (let i = 0; i < caretColumn - 1 && i < text.length; i++) {
+		const char = text[i]
+
+		if (char === '\t') {
+			const spacesToNextTabStop = tabSize - (column % tabSize)
+
+			spacing += ' '.repeat(spacesToNextTabStop)
+			column += spacesToNextTabStop
+		} else {
+			spacing += ' '
+			column += 1
+		}
+	}
+
+	return spacing
+}