diff --git a/grammar_parser.meta b/grammar_parser.meta index d662381..ed58636 100644 --- a/grammar_parser.meta +++ b/grammar_parser.meta @@ -21,7 +21,7 @@ with(namespace) { } if (!__namespaces__.keys().contains(namespace)) { - let newNamespace = [__nsname__: namespace]; + newNamespace = [__nsname__: namespace]; __namespaces__[namespace] = newNamespace; __namespaces__[0][namespace] = newNamespace; } else { @@ -29,6 +29,7 @@ with(namespace) { } __namespaces__.push(__namespaces__[namespace]); + return __namespaces__[namespace]; } //without(); // latest @@ -40,7 +41,7 @@ without(namespace, all: nil) { // Remove all if (all != nil) { for (i in (__namespaces__.length() - 1)) { - let removedNamespace = __namespaces__.pop().__nsname__; + removedNamespace = __namespaces__.pop().__nsname__; //print("--- Without ", removedNamespace, " ---\n\n"); __namespaces__[0][removedNamespace] = nil; } @@ -50,7 +51,7 @@ without(namespace, all: nil) { // Remove last if (namespace == nil) { - let removedNamespace = __namespaces__.pop().__nsname__; + removedNamespace = __namespaces__.pop().__nsname__; //print("--- Without ", removedNamespace, " ---\n\n"); __namespaces__[0][removedNamespace] = nil; if (__namespaces__.length() == 1) { @@ -61,7 +62,7 @@ without(namespace, all: nil) { // Remove a given namespace // Find its index - let namespaceIndex = nil; + namespaceIndex = nil; for (i from (__namespaces__.length() - 1) to 1) { if (__namespaces__[i].__nsname__ == namespace) { namespaceIndex = i; @@ -96,8 +97,8 @@ get(__identifier) { eval(GetVar.new(name: __identifier)); } -set(__identifier, __value) { - eval(SetVar.new(name: __identifier, value: __value)); +setInTopNamespace(__identifier, __value) { + __namespaces__.last()[__identifier] = __value; } println = (x) { @@ -110,12 +111,14 @@ println = (x) { Object.subtype(name) { self.new(__name__: name) } +Object.last() { self[self.length() - 1] } + // Input stream //Stream = Object.subtype(#Stream); //newStream(string) { -// let self = Stream.new( +// self = Stream.new( // content: string, // position: 0, // limit: len(string) @@ -134,7 +137,7 @@ Stream.peek() { !self.atEnd() && self.content[self.position] } Context = Object.subtype(#Context); Context.init() { self.variables = []; self; } Context.declareVariable(var) { - let found = 0; + found = 0; for (key in self.variables.keys()) { if (key == var) { found = 1; @@ -162,11 +165,11 @@ StringLiteral.match(stream, context, actions) { //StringLiteral.match(stream, context, actions) { // -// let n = len(self.string); -// let i = 0; -// let success = 1; +// n = len(self.string); +// i = 0; +// success = 1; // if (stream.atEnd()) { success = 0; } -// let startPosition = stream.position; +// startPosition = stream.position; // // while(i < n && success == 1) { // if (self.string[i] != stream.peek()) { @@ -187,10 +190,10 @@ CharacterClass = Object.subtype(#CharacterClass); CharacterClass.match(stream, context, actions) { - let classLength = len(self.value); - let i = 0; - let prevChar = nil; - let success = 0; + classLength = len(self.value); + i = 0; + prevChar = nil; + success = 0; while (i < classLength && success == 0 && !stream.atEnd()) { @@ -208,8 +211,8 @@ CharacterClass.match(stream, context, actions) { // [a-z] case if (i+1 < classLength) { // println("[a-z] case"); - let rangeStart = prevChar; - let rangeEnd = self.value[i+1]; + rangeStart = prevChar; + rangeEnd = self.value[i+1]; // print("Range Start: ", rangeStart, " | "); // print("Range End: ", rangeEnd, "\n"); if (stream.peek() >= rangeStart @@ -314,7 +317,7 @@ Plus.match(stream, context, actions) { And = Object.subtype(#And); And.match(stream, context, actions) { - let position = stream.position; + position = stream.position; if (self.expression.match(stream, context, actions) == true) { stream.position = position; @@ -329,7 +332,7 @@ And.match(stream, context, actions) { Not = Object.subtype(#Not); Not.match(stream, context, actions) { - let position = stream.position; + position = stream.position; if (self.expression.match(stream, context, actions) == true) { stream.position = position; @@ -351,8 +354,8 @@ Sequence._match(stream, context, actions, index) { } Sequence.match(stream, context, actions) { - let initialActionCount = actions.length(); - let startingPosition = stream.position; + initialActionCount = actions.length(); + startingPosition = stream.position; success = self._match(stream, context, actions, 0); @@ -400,7 +403,7 @@ Action.execute(context) { } // Evaluate the parse tree and return to outer context if needed - let returnValue = eval(self.parseTree, env: context.variables); + returnValue = eval(self.parseTree, env: context.variables); if (context.outerContext != nil) { context.outerContext.variables[context.returnValueName] = returnValue; } @@ -426,7 +429,7 @@ Assignment = Object.subtype(#Assignment); Assignment.match(stream, context, actions) { context.declareVariable(self.name); - let innerContext = Context.new(outerContext: context, returnValueName: self.name).init(); + innerContext = Context.new(outerContext: context, returnValueName: self.name).init(); self.rule.match(stream, innerContext, actions); } @@ -436,7 +439,8 @@ RuleCall = Object.subtype(#RuleCall); RuleCall.match(stream, context, actions) { //if (rules[self.name] == nil) { print("Trying to call undefined rule: ", self.name, "\n"); exit(); } - let res = get(self.name).match(stream, context, actions); + //print("calling rule ", self.name, " | ", stream.position, "\n"); + res = get(self.name).match(stream, context, actions); //print("matching rule ", self.name, ": ", res, "\n"); res; } @@ -447,7 +451,7 @@ NamespacedRuleCall = Object.subtype(#NamespacedRuleCall); NamespacedRuleCall.match(stream, context, actions) { with(self.namespace); - let res = get(self.name).match(stream, context, actions); + res = get(self.name).match(stream, context, actions); without(); res; } @@ -456,524 +460,563 @@ Definition = Object.subtype(#Definition); // ----- Grammar of Meta Language (Minimal) ----- -with(#HardCodedMeta); - -metaStatement = Alternation.new() - .push(Sequence.new() - .push(Assignment.new(name: #b, rule: RuleCall.new(name: #block))) - .push(Action.new(parseTree: `{ b; })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) - .push(Alternation.new() - .push(RuleCall.new(name: #semi)) - .push(And.new(expression: RuleCall.new(name: #rbrace))) - ) - .push(Action.new(parseTree: `{ e; })) - ); - -metaExpression = Alternation.new(id: 1234) - .push(Sequence.new() - .push(Assignment.new(name: #p, rule: RuleCall.new(name: #metaPrimary))) - .push(Alternation.new() - .push(Sequence.new() - .push(RuleCall.new(name: #dot)) - .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) - .push(RuleCall.new(name: #assign)) - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) - ) - .push(Sequence.new() - .push(RuleCall.new(name: #lbrak)) - .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaExpression))) - .push(RuleCall.new(name: #rbrak)) - .push(RuleCall.new(name: #assign)) - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) - .push(Action.new(parseTree: `{ SetArray.new(object: p, index: i, value: e); })) - ) - ) - ) - .push(Sequence.new() - .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) - .push(RuleCall.new(name: #assign)) - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) - .push(Action.new(parseTree: `{ SetVar.new(name: i, value: e); })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #pf, rule: RuleCall.new(name: #metaPostfix))) - .push(Action.new(parseTree: `{ pf; })) - ); - -metaPostfix = Sequence.new() - .push(Assignment.new(name: #p, rule: RuleCall.new(name: #metaPrimary))) - .push(Star.new(expression: Alternation.new() - .push(Sequence.new() - .push(RuleCall.new(name: #dot)) - .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) - .push(Assignment.new(name: #a, rule: RuleCall.new(name: #args))) - .push(Not.new(expression: RuleCall.new(name: #assign))) - .push(Not.new(expression: RuleCall.new(name: #lbrace))) - .push(Action.new(parseTree: `{ p = Invoke.new(self: p, method: i, arguments: a); })) - ) - .push(Sequence.new() - .push(RuleCall.new(name: #dot)) - .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) - .push(Not.new(expression: RuleCall.new(name: #assign))) - .push(Action.new(parseTree: `{ p = GetProp.new(object: p, key: i); })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #a, rule: RuleCall.new(name: #args))) - .push(Not.new(expression: RuleCall.new(name: #assign))) - .push(Not.new(expression: RuleCall.new(name: #lbrace))) - .push(Action.new(parseTree: `{ p = Call.new(function: p, arguments: a); })) - // TODO: Voir si c'est toujours bon avec le newApply() - ) - )) - .push(Action.new(parseTree: `{ p; })); - -args = Sequence.new() - .push(RuleCall.new(name: #lparen)) - .push(Assignment.new(name: #a, rule: RuleCall.new(name: #mklist))) - .push(Optional.new(expression: Sequence.new() - .push(Alternation.new() - .push(Sequence.new() - .push(Assignment.new(name: #k, rule: RuleCall.new(name: #metaId))) - .push(RuleCall.new(name: #colon)) - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) - .push(Action.new(parseTree: `{ a[k] = e; })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) - .push(Action.new(parseTree: `{ a.push(e); })) - ) - ) - .push(Star.new(expression: Sequence.new() - .push(RuleCall.new(name: #comma)) - .push(Alternation.new() - .push(Sequence.new() - .push(Assignment.new(name: #k, rule: RuleCall.new(name: #metaId))) - .push(RuleCall.new(name: #colon)) - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) - .push(Action.new(parseTree: `{ a[k] = e; })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) - .push(Action.new(parseTree: `{ a.push(e); })) - ) - ) - )) - )) - .push(RuleCall.new(name: #rparen)) - .push(Action.new(parseTree: `{ a; })); - -mklist = Action.new(parseTree: `{ Object.new(); }); - -metaPrimary = Alternation.new() - .push(RuleCall.new(name: #nil)) - .push(RuleCall.new(name: #number)) - .push(RuleCall.new(name: #metaVar)) - .push(RuleCall.new(name: #metaSubExpr)); - -metaSubExpr = Sequence.new() - .push(RuleCall.new(name: #lparen)) - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) - .push(RuleCall.new(name: #rparen)) - .push(Action.new(parseTree = `{ e; })); - -block = Sequence.new() - .push(RuleCall.new(name: #lbrace)) - .push(Assignment.new(name: #b, rule: RuleCall.new(name: #mklist))) - .push( - Star.new( - expression: Sequence.new() - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaStatement))) - .push(Action.new(parseTree: `{ b.push(e); })) - ) - ) - .push(RuleCall.new(name: #rbrace)) - .push(Action.new(parseTree: `{ Block.new(body: b); })); - -number = Alternation.new() +hcmeta = with(#HardCodedMeta); + +hcmeta.metaStatement = + Alternation.new() + .push(Sequence.new() + .push(Assignment.new(name: #b, rule: RuleCall.new(name: #block))) + .push(Action.new(parseTree: `{ b; })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) + .push(Alternation.new() + .push(RuleCall.new(name: #semi)) + .push(And.new(expression: RuleCall.new(name: #rbrace))) + ) + .push(Action.new(parseTree: `{ e; })) + ); + +hcmeta.metaExpression = + Alternation.new(id: 1234) + .push(Sequence.new() + .push(Assignment.new(name: #p, rule: RuleCall.new(name: #metaPrimary))) + .push(Alternation.new() + .push(Sequence.new() + .push(RuleCall.new(name: #dot)) + .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) + .push(RuleCall.new(name: #assign)) + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) + ) + .push(Sequence.new() + .push(RuleCall.new(name: #lbrak)) + .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaExpression))) + .push(RuleCall.new(name: #rbrak)) + .push(RuleCall.new(name: #assign)) + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) + .push(Action.new(parseTree: `{ SetArray.new(object: p, index: i, value: e); })) + ) + ) + ) + .push(Sequence.new() + .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) + .push(RuleCall.new(name: #assign)) + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) + .push(Action.new(parseTree: `{ SetVar.new(name: i, value: e); })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #pf, rule: RuleCall.new(name: #metaPostfix))) + .push(Action.new(parseTree: `{ pf; })) + ); + +hcmeta.metaPostfix = + Sequence.new() + .push(Assignment.new(name: #p, rule: RuleCall.new(name: #metaPrimary))) + .push(Star.new(expression: Alternation.new() .push(Sequence.new() - .push(StringLiteral.new(string: "-")) - .push(Assignment.new(name: #n, rule: RuleCall.new(name: #unsign))) - .push(Action.new(parseTree: `{ Unyop.new(operation: __opNeg).push(n) })) + .push(RuleCall.new(name: #dot)) + .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) + .push(Assignment.new(name: #a, rule: RuleCall.new(name: #args))) + .push(Not.new(expression: RuleCall.new(name: #assign))) + .push(Not.new(expression: RuleCall.new(name: #lbrace))) + .push(Action.new(parseTree: `{ p = Invoke.new(self: p, method: i, arguments: a); })) ) .push(Sequence.new() - .push(StringLiteral.new(string: "+")) - .push(Assignment.new(name: #n, rule: RuleCall.new(name: #number))) - .push(Action.new(parseTree: `{ n })) + .push(RuleCall.new(name: #dot)) + .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) + .push(Not.new(expression: RuleCall.new(name: #assign))) + .push(Action.new(parseTree: `{ p = GetProp.new(object: p, key: i); })) ) .push(Sequence.new() - .push(Assignment.new(name: #n, rule: RuleCall.new(name: #unsign))) - .push(Action.new(parseTree: `{ n })) - ); - -unsign = Sequence.new() - .push(Begin.new()) - .push(Plus.new(expression: RuleCall.new(name: #digit))) - .push(End.new()) - .push(RuleCall.new(name: #ws)) - .push(Action.new(parseTree: `{ yytext.asInteger(10); })); - -metaVar = Sequence.new() - .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) - .push(Action.new(parseTree: `{ GetVar.new(name: i); })); - -metaId = Sequence.new() - .push(Begin.new()) - .push(RuleCall.new(name: #letter)) - .push(Star.new(expression: RuleCall.new(name: #alnum))) - .push(End.new()) - .push(RuleCall.new(name: #ws)) - .push(Action.new(parseTree: `{ intern(yytext); })); - -digit = CharacterClass.new(value: "0-9"); -letter = CharacterClass.new(value: "A-Za-z_"); -alnum = Alternation.new() - .push(RuleCall.new(name: #letter)) - .push(RuleCall.new(name: #digit)); -nil = Sequence.new() - .push(StringLiteral.new(string: "nil")) - .push(Not.new(expression: RuleCall.new(name: #alnum))) - .push(RuleCall.new(name: #ws)); - -semi = Sequence.new().push(StringLiteral.new(string: ";" )).push(RuleCall.new(name: #ws)); -comma = Sequence.new().push(StringLiteral.new(string: "," )).push(RuleCall.new(name: #ws)); -lparen = Sequence.new().push(StringLiteral.new(string: "(" )).push(RuleCall.new(name: #ws)); -rparen = Sequence.new().push(StringLiteral.new(string: ")" )).push(RuleCall.new(name: #ws)); -lbrak = Sequence.new().push(StringLiteral.new(string: "[" )).push(RuleCall.new(name: #ws)); -rbrak = Sequence.new().push(StringLiteral.new(string: "]" )).push(RuleCall.new(name: #ws)); -lbrace = Sequence.new().push(StringLiteral.new(string: "{" )).push(RuleCall.new(name: #ws)); -rbrace = Sequence.new().push(StringLiteral.new(string: "}" )).push(RuleCall.new(name: #ws)); - -assign = Sequence.new() - .push(StringLiteral.new(string: "=")) - .push(Not.new(expression: CharacterClass.new(value: "="))) - .push(RuleCall.new(name: #ws)); -dot = Sequence.new() - .push(StringLiteral.new(string: ".")) - .push(Not.new(expression: CharacterClass.new(value: "."))) - .push(RuleCall.new(name: #ws)); -colon = Sequence.new() - .push(StringLiteral.new(string: ":")) - .push(Not.new(expression: CharacterClass.new(value: ":"))) - .push(RuleCall.new(name: #ws)); - -end_of_file = Not.new(expression: Dot.new()); - -end_of_line = Alternation.new() - .push(StringLiteral.new(string: "\r\n")) - .push(StringLiteral.new(string: "\n")) - .push(StringLiteral.new(string: "\r")); - -comment = Sequence.new() - .push(StringLiteral.new(string: "//")) - .push(Star.new(expression: - Sequence.new() - .push(Not.new(expression: RuleCall.new(name: #end_of_line))) - .push(Dot.new()) - )) - .push(RuleCall.new(name: #end_of_line)); - -space = Alternation.new() - .push(StringLiteral.new(string: " ")) - .push(StringLiteral.new(string: "\t")) - .push(RuleCall.new(name: #end_of_line)); - -ws = Star.new(expression: Alternation.new() - .push(RuleCall.new(name: #space)) - .push(RuleCall.new(name: #comment)) - ); + .push(Assignment.new(name: #a, rule: RuleCall.new(name: #args))) + .push(Not.new(expression: RuleCall.new(name: #assign))) + .push(Not.new(expression: RuleCall.new(name: #lbrace))) + .push(Action.new(parseTree: `{ p = Call.new(function: p, arguments: a); })) + // TODO: Voir si c'est toujours bon avec le newApply() + ) + )) + .push(Action.new(parseTree: `{ p; })); + +hcmeta.args = + Sequence.new() + .push(RuleCall.new(name: #lparen)) + .push(Assignment.new(name: #a, rule: RuleCall.new(name: #mklist))) + .push(Optional.new(expression: Sequence.new() + .push(Alternation.new() + .push(Sequence.new() + .push(Assignment.new(name: #k, rule: RuleCall.new(name: #metaId))) + .push(RuleCall.new(name: #colon)) + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) + .push(Action.new(parseTree: `{ a[k] = e; })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) + .push(Action.new(parseTree: `{ a.push(e); })) + ) + ) + .push(Star.new(expression: Sequence.new() + .push(RuleCall.new(name: #comma)) + .push(Alternation.new() + .push(Sequence.new() + .push(Assignment.new(name: #k, rule: RuleCall.new(name: #metaId))) + .push(RuleCall.new(name: #colon)) + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) + .push(Action.new(parseTree: `{ a[k] = e; })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) + .push(Action.new(parseTree: `{ a.push(e); })) + ) + ) + )) + )) + .push(RuleCall.new(name: #rparen)) + .push(Action.new(parseTree: `{ a; })); + +hcmeta.mklist = Action.new(parseTree: `{ Object.new(); }); + +hcmeta.metaPrimary = + Alternation.new() + .push(RuleCall.new(name: #nil)) + .push(RuleCall.new(name: #number)) + .push(RuleCall.new(name: #metaVar)) + .push(RuleCall.new(name: #metaSubExpr)); + +hcmeta.metaSubExpr = + Sequence.new() + .push(RuleCall.new(name: #lparen)) + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression))) + .push(RuleCall.new(name: #rparen)) + .push(Action.new(parseTree = `{ e; })); + +hcmeta.block = + Sequence.new() + .push(RuleCall.new(name: #lbrace)) + .push(Assignment.new(name: #b, rule: RuleCall.new(name: #mklist))) + .push( + Star.new( + expression: Sequence.new() + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaStatement))) + .push(Action.new(parseTree: `{ b.push(e); })) + ) + ) + .push(RuleCall.new(name: #rbrace)) + .push(Action.new(parseTree: `{ Block.new(body: b); })); + +hcmeta.number = + Alternation.new() + .push(Sequence.new() + .push(StringLiteral.new(string: "-")) + .push(Assignment.new(name: #n, rule: RuleCall.new(name: #unsign))) + .push(Action.new(parseTree: `{ Unyop.new(operation: __opNeg).push(n) })) + ) + .push(Sequence.new() + .push(StringLiteral.new(string: "+")) + .push(Assignment.new(name: #n, rule: RuleCall.new(name: #number))) + .push(Action.new(parseTree: `{ n })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #n, rule: RuleCall.new(name: #unsign))) + .push(Action.new(parseTree: `{ n })) + ); + +hcmeta.unsign = + Sequence.new() + .push(Begin.new()) + .push(Plus.new(expression: RuleCall.new(name: #digit))) + .push(End.new()) + .push(RuleCall.new(name: #ws)) + .push(Action.new(parseTree: `{ yytext.asInteger(10); })); + +hcmeta.metaVar = + Sequence.new() + .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) + .push(Action.new(parseTree: `{ GetVar.new(name: i); })); + +hcmeta.metaId = + Sequence.new() + .push(Begin.new()) + .push(RuleCall.new(name: #letter)) + .push(Star.new(expression: RuleCall.new(name: #alnum))) + .push(End.new()) + .push(RuleCall.new(name: #ws)) + .push(Action.new(parseTree: `{ intern(yytext); })); + +hcmeta.digit = CharacterClass.new(value: "0-9"); +hcmeta.letter = CharacterClass.new(value: "A-Za-z_"); +hcmeta.alnum = + Alternation.new() + .push(RuleCall.new(name: #letter)) + .push(RuleCall.new(name: #digit)); +hcmeta.nil = + Sequence.new() + .push(StringLiteral.new(string: "nil")) + .push(Not.new(expression: RuleCall.new(name: #alnum))) + .push(RuleCall.new(name: #ws)); + +hcmeta.semi = Sequence.new().push(StringLiteral.new(string: ";" )).push(RuleCall.new(name: #ws)); +hcmeta.comma = Sequence.new().push(StringLiteral.new(string: "," )).push(RuleCall.new(name: #ws)); +hcmeta.lparen = Sequence.new().push(StringLiteral.new(string: "(" )).push(RuleCall.new(name: #ws)); +hcmeta.rparen = Sequence.new().push(StringLiteral.new(string: ")" )).push(RuleCall.new(name: #ws)); +hcmeta.lbrak = Sequence.new().push(StringLiteral.new(string: "[" )).push(RuleCall.new(name: #ws)); +hcmeta.rbrak = Sequence.new().push(StringLiteral.new(string: "]" )).push(RuleCall.new(name: #ws)); +hcmeta.lbrace = Sequence.new().push(StringLiteral.new(string: "{" )).push(RuleCall.new(name: #ws)); +hcmeta.rbrace = Sequence.new().push(StringLiteral.new(string: "}" )).push(RuleCall.new(name: #ws)); + +hcmeta.assign = + Sequence.new() + .push(StringLiteral.new(string: "=")) + .push(Not.new(expression: CharacterClass.new(value: "="))) + .push(RuleCall.new(name: #ws)); +hcmeta.dot = + Sequence.new() + .push(StringLiteral.new(string: ".")) + .push(Not.new(expression: CharacterClass.new(value: "."))) + .push(RuleCall.new(name: #ws)); +hcmeta.colon = + Sequence.new() + .push(StringLiteral.new(string: ":")) + .push(Not.new(expression: CharacterClass.new(value: ":"))) + .push(RuleCall.new(name: #ws)); + +hcmeta.end_of_file = Not.new(expression: Dot.new()); + +hcmeta.end_of_line = + Alternation.new() + .push(StringLiteral.new(string: "\r\n")) + .push(StringLiteral.new(string: "\n")) + .push(StringLiteral.new(string: "\r")); + +hcmeta.comment = + Sequence.new() + .push(StringLiteral.new(string: "//")) + .push(Star.new(expression: + Sequence.new() + .push(Not.new(expression: RuleCall.new(name: #end_of_line))) + .push(Dot.new()) + )) + .push(RuleCall.new(name: #end_of_line)); + +hcmeta.space = + Alternation.new() + .push(StringLiteral.new(string: " ")) + .push(StringLiteral.new(string: "\t")) + .push(RuleCall.new(name: #end_of_line)); + +hcmeta.ws = + Star.new(expression: Alternation.new() + .push(RuleCall.new(name: #space)) + .push(RuleCall.new(name: #comment)) + ); // ----- Grammar of Grammars ----- -with(#HardCodedPeg); - -grammar = Sequence.new() - .push(RuleCall.new(name: #ws)) - .push(Plus.new(expression: Sequence.new() - .push(Assignment.new(name: #d, rule: RuleCall.new(name: #definition))) - .push(Action.new(parseTree: `{ set(d.name, d.expression); })) - )) - .push(RuleCall.new(name: #end_of_file)); - -definition = Sequence.new() - .push(Assignment.new(name: #i, rule: RuleCall.new(name: #identifier))) - .push(RuleCall.new(name: #assign)) - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #expression))) - .push(Optional.new(expression: RuleCall.new(name: #semi))) - .push(Action.new(parseTree: `{ Definition.new(name: i, expression: e); })); +hcpeg = with(#HardCodedPeg); + +hcpeg.grammar = + Sequence.new() + .push(RuleCall.new(name: #ws)) + .push(Plus.new(expression: Sequence.new() + .push(Assignment.new(name: #d, rule: RuleCall.new(name: #definition))) + .push(Action.new(parseTree: `{ __namespaces__.last()[d.name] = d.expression; })) + )) + .push(RuleCall.new(name: #end_of_file)); + +hcpeg.definition = + Sequence.new() + .push(Assignment.new(name: #i, rule: RuleCall.new(name: #identifier))) + .push(RuleCall.new(name: #assign)) + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #expression))) + .push(Optional.new(expression: RuleCall.new(name: #semi))) + .push(Action.new(parseTree: `{ Definition.new(name: i, expression: e); })); + +hcpeg.expression = + Alternation.new() + .push(Sequence.new() + .push(Assignment.new(name: #s, rule: RuleCall.new(name: #sequence))) + .push(Not.new(expression: RuleCall.new(name: #bar))) + .push(Action.new(parseTree: `{ s; })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #s1, rule: RuleCall.new(name: #sequence))) + .push(Action.new(parseTree: `{ s1 = Alternation.new().push(s1); })) + .push(Star.new(expression: Sequence.new() + .push(RuleCall.new(name: #bar)) + .push(Assignment.new(name: #s2, rule: RuleCall.new(name: #sequence))) + .push(Action.new(parseTree: `{ s1.push(s2); })) + )) + .push(Action.new(parseTree: `{ s1; })) + ); + +hcpeg.sequence = + Sequence.new() + .push(Assignment.new(name: #p, rule: RuleCall.new(name: #prefix))) + .push(Action.new(parseTree: `{ p = Sequence.new().push(p); })) + .push(Star.new(expression: Sequence.new() + .push(Assignment.new(name: #q, rule: RuleCall.new(name: #prefix))) + .push(Action.new(parseTree: `{ p.push(q); })) + )) + .push(Action.new(parseTree: `{ p; })); + +hcpeg.prefix = + Alternation.new() + .push(Sequence.new() + .push(RuleCall.new(name: #and)) + .push(RuleCall.new(name: #action)) + ) + .push(Alternation.new() + .push(Sequence.new() + .push(RuleCall.new(name: #and)) + .push(Assignment.new(name: #s, rule: RuleCall.new(name: #suffix))) + .push(Action.new(parseTree: `{ And.new(expression: s); })) + ) + .push(Sequence.new() + .push(RuleCall.new(name: #not)) + .push(Assignment.new(name: #s, rule: RuleCall.new(name: #suffix))) + .push(Action.new(parseTree: `{ Not.new(expression: s); })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #s, rule: RuleCall.new(name: #suffix))) + .push(Action.new(parseTree: `{ s; })) + ) + ); -expression = Alternation.new() - .push(Sequence.new() - .push(Assignment.new(name: #s, rule: RuleCall.new(name: #sequence))) - .push(Not.new(expression: RuleCall.new(name: #bar))) - .push(Action.new(parseTree: `{ s; })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #s1, rule: RuleCall.new(name: #sequence))) - .push(Action.new(parseTree: `{ s1 = Alternation.new().push(s1); })) - .push(Star.new(expression: Sequence.new() - .push(RuleCall.new(name: #bar)) - .push(Assignment.new(name: #s2, rule: RuleCall.new(name: #sequence))) - .push(Action.new(parseTree: `{ s1.push(s2); })) - )) - .push(Action.new(parseTree: `{ s1; })) - ); - -sequence = Sequence.new() - .push(Assignment.new(name: #p, rule: RuleCall.new(name: #prefix))) - .push(Action.new(parseTree: `{ p = Sequence.new().push(p); })) - .push(Star.new(expression: Sequence.new() - .push(Assignment.new(name: #q, rule: RuleCall.new(name: #prefix))) - .push(Action.new(parseTree: `{ p.push(q); })) - )) - .push(Action.new(parseTree: `{ p; })); - -prefix = Alternation.new() - .push(Sequence.new() - .push(RuleCall.new(name: #and)) - .push(RuleCall.new(name: #action)) - ) - .push(Alternation.new() - .push(Sequence.new() - .push(RuleCall.new(name: #and)) - .push(Assignment.new(name: #s, rule: RuleCall.new(name: #suffix))) - .push(Action.new(parseTree: `{ And.new(expression: s); })) - ) - .push(Sequence.new() - .push(RuleCall.new(name: #not)) - .push(Assignment.new(name: #s, rule: RuleCall.new(name: #suffix))) - .push(Action.new(parseTree: `{ Not.new(expression: s); })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #s, rule: RuleCall.new(name: #suffix))) - .push(Action.new(parseTree: `{ s; })) - ) - ); - -suffix = Sequence.new() - .push(Assignment.new(name: #p, rule: RuleCall.new(name: #primary))) - .push(Optional.new(expression: Alternation.new() - .push(Sequence.new() - .push(RuleCall.new(name: #query)) - .push(Action.new(parseTree: `{ p = Optional.new(expression: p); })) - ) - .push(Sequence.new() - .push(RuleCall.new(name: #star)) - .push(Action.new(parseTree: `{ p = Star.new(expression: p); })) - ) - .push(Sequence.new() - .push(RuleCall.new(name: #plus)) - .push(Action.new(parseTree: `{ p = Plus.new(expression: p); })) - ) - )) - .push(Action.new(parseTree: `{ p; })); - -primary = Alternation.new() - .push(Sequence.new() - .push(Assignment.new(name: #i1, rule: RuleCall.new(name: #identifier))) - .push(RuleCall.new(name: #colon)) - .push(Assignment.new(name: #i2, rule: RuleCall.new(name: #ruleCall))) - .push(Not.new(expression: RuleCall.new(name: #assign))) - .push(Action.new(parseTree: `{ Assignment.new(name: i1, rule: i2); })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #i, rule: RuleCall.new(name: #ruleCall))) - .push(Not.new(expression: RuleCall.new(name: #assign))) - .push(Action.new(parseTree: `{ i; })) - ) - .push(Sequence.new() - .push(RuleCall.new(name: #lparen)) - .push(Assignment.new(name: #e, rule: RuleCall.new(name: #expression))) - .push(RuleCall.new(name: #rparen)) - .push(Action.new(parseTree: `{ e; })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #l, rule: RuleCall.new(name: #literal))) - .push(Action.new(parseTree: `{ l; })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #c, rule: RuleCall.new(name: #class))) - .push(Action.new(parseTree: `{ c; })) - ) - .push(Sequence.new() - .push(RuleCall.new(name: #dot)) - .push(Action.new(parseTree: `{ Dot.new(); })) - ) - .push(Sequence.new() - .push(Assignment.new(name: #a, rule: RuleCall.new(name: #action))) - .push(Action.new(parseTree: `{ a; })) - ) - .push(Sequence.new() - .push(RuleCall.new(name: #begin)) - .push(Action.new(parseTree: `{ Begin.new(); })) - ) - .push(Sequence.new() - .push(RuleCall.new(name: #end)) - .push(Action.new(parseTree: `{ End.new(); })) - ); - -identifier = Sequence.new() - .push(Begin.new()) - .push(CharacterClass.new(value: "-a-zA-Z_")) - .push(Star.new(expression: CharacterClass.new(value: "-a-zA-Z_0-9"))) - .push(End.new()) - .push(RuleCall.new(name: #ws)) - .push(Action.new(parseTree: `{ intern(yytext); })); - -ruleCall = Alternation.new() +hcpeg.suffix = + Sequence.new() + .push(Assignment.new(name: #p, rule: RuleCall.new(name: #primary))) + .push(Optional.new(expression: Alternation.new() .push(Sequence.new() - .push(Assignment.new(name: #n, rule: RuleCall.new(name: #identifier))) - .push(RuleCall.new(name: #ccolon)) - .push(Assignment.new(name: #r, rule: RuleCall.new(name: #identifier))) - .push(Action.new(parseTree: `{ NamespacedRuleCall.new(namespace: n, name: r); })) + .push(RuleCall.new(name: #query)) + .push(Action.new(parseTree: `{ p = Optional.new(expression: p); })) ) .push(Sequence.new() - .push(Assignment.new(name: #i, rule: RuleCall.new(name: #identifier))) - .push(Action.new(parseTree: `{ RuleCall.new(name: i); })) - ); - -literal = Alternation.new() - .push(Sequence.new() - .push(CharacterClass.new(value: "\'")) - .push(Begin.new()) - .push(Star.new(expression: Sequence.new() - .push(Not.new(expression: CharacterClass.new(value: "\'"))) - .push(RuleCall.new(name: #char)) - )) - .push(End.new()) - .push(CharacterClass.new(value: "\'")) - .push(RuleCall.new(name: #ws)) - .push(Action.new(parseTree: `{ StringLiteral.new(string: yytext); })) - ) - .push(Sequence.new() - .push(CharacterClass.new(value: "\"")) - .push(Begin.new()) - .push(Star.new(expression: Sequence.new() - .push(Not.new(expression: CharacterClass.new(value: "\""))) - .push(RuleCall.new(name: #char)) - )) - .push(End.new()) - .push(CharacterClass.new(value: "\"")) - .push(RuleCall.new(name: #ws)) - .push(Action.new(parseTree: `{ StringLiteral.new(string: yytext); })) - ); - -class = Sequence.new() - .push(StringLiteral.new(string: "[")) - .push(Begin.new()) - .push(Star.new(expression: Sequence.new() - .push(Not.new(expression: StringLiteral.new(string: "]"))) - .push(RuleCall.new(name: #range)) - )) - .push(End.new()) - .push(StringLiteral.new(string: "]")) - .push(RuleCall.new(name: #ws)) - .push(Action.new(parseTree: `{ CharacterClass.new(value: yytext); })); - -range = Alternation.new() - .push(Sequence.new() - .push(RuleCall.new(name: #char)) - .push(StringLiteral.new(string: "-")) - .push(RuleCall.new(name: #char)) - ) - .push( - RuleCall.new(name: #char) - ); - -char = Alternation.new() - .push(Sequence.new() - .push(StringLiteral.new(string: "\\")) - .push(CharacterClass.new(value: "abefnrtv\'\"[]\\")) - ) - .push(Sequence.new() - .push(StringLiteral.new(string: "\\")) - .push(CharacterClass.new(value: "0-3")) - .push(CharacterClass.new(value: "0-7")) - .push(CharacterClass.new(value: "0-7")) - ) - .push(Sequence.new() - .push(StringLiteral.new(string: "\\")) - .push(CharacterClass.new(value: "0-7")) - .push(Optional.new(expression: CharacterClass.new(value: "0-7"))) - ) - .push(Sequence.new() - .push(Not.new(expression: StringLiteral.new(string: "\\"))) - .push(Dot.new()) - ); - -action = Sequence.new() - .push(Assignment.new(name: #m, rule: NamespacedRuleCall.new(namespace: #HardCodedMeta, name: #block))) - .push(RuleCall.new(name: #ws)) - .push(Action.new(parseTree: `{ Action.new(parseTree: m); })); - -bar = Sequence.new().push(StringLiteral.new(string: "|")).push(RuleCall.new(name: #ws)); -not = Sequence.new().push(StringLiteral.new(string: "!")).push(RuleCall.new(name: #ws)); -query = Sequence.new().push(StringLiteral.new(string: "?")).push(RuleCall.new(name: #ws)); -begin = Sequence.new().push(StringLiteral.new(string: "<")).push(RuleCall.new(name: #ws)); -end = Sequence.new().push(StringLiteral.new(string: ">")).push(RuleCall.new(name: #ws)); -tilde = Sequence.new().push(StringLiteral.new(string: "~")).push(RuleCall.new(name: #ws)); -rpercent = Sequence.new().push(StringLiteral.new(string: "%}")).push(RuleCall.new(name: #ws)); - -ccolon = Sequence.new().push(StringLiteral.new(string: "::")).push(RuleCall.new(name: #ws)); - -and = Sequence.new() - .push(StringLiteral.new(string: "&")) - .push(Not.new(expression: CharacterClass.new(value: "&="))) - .push(RuleCall.new(name: #ws)); -plus = Sequence.new() - .push(StringLiteral.new(string: "+")) - .push(Not.new(expression: CharacterClass.new(value: "+="))) - .push(RuleCall.new(name: #ws)); -star = Sequence.new() - .push(StringLiteral.new(string: "*")) - .push(Not.new(expression: CharacterClass.new(value: "="))) - .push(RuleCall.new(name: #ws)); - -end_of_file = Not.new(expression: Dot.new()); - -end_of_line = Alternation.new() - .push(StringLiteral.new(string: "\r\n")) - .push(StringLiteral.new(string: "\n")) - .push(StringLiteral.new(string: "\r")); - -comment = Sequence.new() - .push(StringLiteral.new(string: "#")) - .push(Star.new(expression: - Sequence.new() - .push(Not.new(expression: RuleCall.new(name: #end_of_line))) - .push(Dot.new()) - )) - .push(RuleCall.new(name: #end_of_line)); - -space = Alternation.new() - .push(StringLiteral.new(string: " ")) - .push(StringLiteral.new(string: "\t")) - .push(RuleCall.new(name: #end_of_line)); - -ws = Star.new(expression: Alternation.new() - .push(RuleCall.new(name: #space)) - .push(RuleCall.new(name: #comment)) - ); + .push(RuleCall.new(name: #star)) + .push(Action.new(parseTree: `{ p = Star.new(expression: p); })) + ) + .push(Sequence.new() + .push(RuleCall.new(name: #plus)) + .push(Action.new(parseTree: `{ p = Plus.new(expression: p); })) + ) + )) + .push(Action.new(parseTree: `{ p; })); + +hcpeg.primary = + Alternation.new() + .push(Sequence.new() + .push(Assignment.new(name: #i1, rule: RuleCall.new(name: #identifier))) + .push(RuleCall.new(name: #colon)) + .push(Assignment.new(name: #i2, rule: RuleCall.new(name: #ruleCall))) + .push(Not.new(expression: RuleCall.new(name: #assign))) + .push(Action.new(parseTree: `{ Assignment.new(name: i1, rule: i2); })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #i, rule: RuleCall.new(name: #ruleCall))) + .push(Not.new(expression: RuleCall.new(name: #assign))) + .push(Action.new(parseTree: `{ i; })) + ) + .push(Sequence.new() + .push(RuleCall.new(name: #lparen)) + .push(Assignment.new(name: #e, rule: RuleCall.new(name: #expression))) + .push(RuleCall.new(name: #rparen)) + .push(Action.new(parseTree: `{ e; })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #l, rule: RuleCall.new(name: #literal))) + .push(Action.new(parseTree: `{ l; })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #c, rule: RuleCall.new(name: #class))) + .push(Action.new(parseTree: `{ c; })) + ) + .push(Sequence.new() + .push(RuleCall.new(name: #dot)) + .push(Action.new(parseTree: `{ Dot.new(); })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #a, rule: RuleCall.new(name: #action))) + .push(Action.new(parseTree: `{ a; })) + ) + .push(Sequence.new() + .push(RuleCall.new(name: #begin)) + .push(Action.new(parseTree: `{ Begin.new(); })) + ) + .push(Sequence.new() + .push(RuleCall.new(name: #end)) + .push(Action.new(parseTree: `{ End.new(); })) + ); + +hcpeg.identifier = + Sequence.new() + .push(Begin.new()) + .push(CharacterClass.new(value: "-a-zA-Z_")) + .push(Star.new(expression: CharacterClass.new(value: "-a-zA-Z_0-9"))) + .push(End.new()) + .push(RuleCall.new(name: #ws)) + .push(Action.new(parseTree: `{ intern(yytext); })); + +hcpeg.ruleCall = + Alternation.new() + .push(Sequence.new() + .push(Assignment.new(name: #n, rule: RuleCall.new(name: #identifier))) + .push(RuleCall.new(name: #ccolon)) + .push(Assignment.new(name: #r, rule: RuleCall.new(name: #identifier))) + .push(Action.new(parseTree: `{ NamespacedRuleCall.new(namespace: n, name: r); })) + ) + .push(Sequence.new() + .push(Assignment.new(name: #i, rule: RuleCall.new(name: #identifier))) + .push(Action.new(parseTree: `{ RuleCall.new(name: i); })) + ); + +hcpeg.literal = + Alternation.new() + .push(Sequence.new() + .push(CharacterClass.new(value: "\'")) + .push(Begin.new()) + .push(Star.new(expression: Sequence.new() + .push(Not.new(expression: CharacterClass.new(value: "\'"))) + .push(RuleCall.new(name: #char)) + )) + .push(End.new()) + .push(CharacterClass.new(value: "\'")) + .push(RuleCall.new(name: #ws)) + .push(Action.new(parseTree: `{ StringLiteral.new(string: yytext); })) + ) + .push(Sequence.new() + .push(CharacterClass.new(value: "\"")) + .push(Begin.new()) + .push(Star.new(expression: Sequence.new() + .push(Not.new(expression: CharacterClass.new(value: "\""))) + .push(RuleCall.new(name: #char)) + )) + .push(End.new()) + .push(CharacterClass.new(value: "\"")) + .push(RuleCall.new(name: #ws)) + .push(Action.new(parseTree: `{ StringLiteral.new(string: yytext); })) + ); + +hcpeg.class = + Sequence.new() + .push(StringLiteral.new(string: "[")) + .push(Begin.new()) + .push(Star.new(expression: Sequence.new() + .push(Not.new(expression: StringLiteral.new(string: "]"))) + .push(RuleCall.new(name: #range)) + )) + .push(End.new()) + .push(StringLiteral.new(string: "]")) + .push(RuleCall.new(name: #ws)) + .push(Action.new(parseTree: `{ CharacterClass.new(value: yytext); })); + +hcpeg.range = + Alternation.new() + .push(Sequence.new() + .push(RuleCall.new(name: #char)) + .push(StringLiteral.new(string: "-")) + .push(RuleCall.new(name: #char)) + ) + .push( + RuleCall.new(name: #char) + ); + +hcpeg.char = + Alternation.new() + .push(Sequence.new() + .push(StringLiteral.new(string: "\\")) + .push(CharacterClass.new(value: "abefnrtv\'\"[]\\")) + ) + .push(Sequence.new() + .push(StringLiteral.new(string: "\\")) + .push(CharacterClass.new(value: "0-3")) + .push(CharacterClass.new(value: "0-7")) + .push(CharacterClass.new(value: "0-7")) + ) + .push(Sequence.new() + .push(StringLiteral.new(string: "\\")) + .push(CharacterClass.new(value: "0-7")) + .push(Optional.new(expression: CharacterClass.new(value: "0-7"))) + ) + .push(Sequence.new() + .push(Not.new(expression: StringLiteral.new(string: "\\"))) + .push(Dot.new()) + ); + +hcpeg.action = + Sequence.new() + .push(Assignment.new(name: #m, rule: NamespacedRuleCall.new(namespace: #HardCodedMeta, name: #block))) + .push(RuleCall.new(name: #ws)) + .push(Action.new(parseTree: `{ Action.new(parseTree: m); })); + +hcpeg.bar = Sequence.new().push(StringLiteral.new(string: "|")).push(RuleCall.new(name: #ws)); +hcpeg.not = Sequence.new().push(StringLiteral.new(string: "!")).push(RuleCall.new(name: #ws)); +hcpeg.query = Sequence.new().push(StringLiteral.new(string: "?")).push(RuleCall.new(name: #ws)); +hcpeg.begin = Sequence.new().push(StringLiteral.new(string: "<")).push(RuleCall.new(name: #ws)); +hcpeg.end = Sequence.new().push(StringLiteral.new(string: ">")).push(RuleCall.new(name: #ws)); +hcpeg.tilde = Sequence.new().push(StringLiteral.new(string: "~")).push(RuleCall.new(name: #ws)); +hcpeg.rpercent = Sequence.new().push(StringLiteral.new(string: "%}")).push(RuleCall.new(name: #ws)); + +hcpeg.ccolon = Sequence.new().push(StringLiteral.new(string: "::")).push(RuleCall.new(name: #ws)); + +hcpeg.and = + Sequence.new() + .push(StringLiteral.new(string: "&")) + .push(Not.new(expression: CharacterClass.new(value: "&="))) + .push(RuleCall.new(name: #ws)); +hcpeg.plus = + Sequence.new() + .push(StringLiteral.new(string: "+")) + .push(Not.new(expression: CharacterClass.new(value: "+="))) + .push(RuleCall.new(name: #ws)); +hcpeg.star = + Sequence.new() + .push(StringLiteral.new(string: "*")) + .push(Not.new(expression: CharacterClass.new(value: "="))) + .push(RuleCall.new(name: #ws)); + +hcpeg.end_of_file = Not.new(expression: Dot.new()); + +hcpeg.end_of_line = + Alternation.new() + .push(StringLiteral.new(string: "\r\n")) + .push(StringLiteral.new(string: "\n")) + .push(StringLiteral.new(string: "\r")); + +hcpeg.comment = + Sequence.new() + .push(StringLiteral.new(string: "#")) + .push(Star.new(expression: + Sequence.new() + .push(Not.new(expression: RuleCall.new(name: #end_of_line))) + .push(Dot.new()) + )) + .push(RuleCall.new(name: #end_of_line)); + +hcpeg.space = + Alternation.new() + .push(StringLiteral.new(string: " ")) + .push(StringLiteral.new(string: "\t")) + .push(RuleCall.new(name: #end_of_line)); + +hcpeg.ws = + Star.new(expression: Alternation.new() + .push(RuleCall.new(name: #space)) + .push(RuleCall.new(name: #comment)) + ); // ----- Main ----- -with(#reading); - stream = newStream(readfile("rawminproto.leg")); context = Context.new(outerContext: nil).init(); actions = []; -grammar.match(stream, context, actions); +print("Matching rawminproto.leg : ", grammar.match(stream, context, actions), "\n"); with(#metaLanguage); for (actionAndContext in actions) { actionAndContext.action.execute(actionAndContext.context); } +without(#metaLanguage); println("\n--------- META ---------\n\n"); println(__namespaces__.metaLanguage); -without(#metaLanguage); //stream = newStream(readfile("rawMetaGrammar.leg")); //context = Context.new(outerContext: nil).init(); @@ -993,9 +1036,6 @@ without(#metaLanguage); //println(__namespaces__.metaLanguage); //without(#metaLanguage); -without(#reading); -with(#reading); - stream = newStream(readfile("rawgrammar.leg")); context = Context.new(outerContext: nil).init(); actions = []; @@ -1010,18 +1050,15 @@ for (actionAndContext in actions) { actionAndContext.action.execute(actionAndContext.context); } +without(#peg); println("\n--------- PEG ---------\n\n"); println(__namespaces__.peg); -without(#peg); - -without(#reading); // Circularity test without(all: 1); with(#metaLanguage); with(#peg); -with(#reading); stream2 = newStream(readfile("rawminproto.leg")); //stream2 = newStream("a = b:c::d { print(a[b].c); }"); @@ -1036,9 +1073,9 @@ for (actionAndContext in actions2) { actionAndContext.action.execute(actionAndContext.context); } +without(#metaLanguageCircular); println("\n--------- CIRCULAR META ---------\n\n"); println(__namespaces__.metaLanguageCircular); -without(#metaLanguageCircular); stream2 = newStream(readfile("rawgrammar.leg")); context2 = Context.new(outerContext: nil).init(); @@ -1052,14 +1089,14 @@ for (actionAndContext in actions2) { actionAndContext.action.execute(actionAndContext.context); } +without(#pegCircular); println("\n--------- CIRCULAR PEG ---------\n\n"); println(__namespaces__.pegCircular); -without(#pegCircular); without(all: 1); compareGrammars(grammar1, grammar2) { - let success = 1; + success = 1; for (key in __namespaces__[grammar1].keys()) { if (key == #__nsname__) continue; diff --git a/rawgrammar.leg b/rawgrammar.leg index 0aebb67..dd1a87e 100644 --- a/rawgrammar.leg +++ b/rawgrammar.leg @@ -1,5 +1,5 @@ grammar = - - ( d:definition { set(d.name, d.expression); } + ( d:definition { setInTopNamespace(d.name, d.expression); } ) + end-of-file definition = i:identifier ASSIGN e:expression SEMI? { Definition.new(name: i, expression: e); }