diff --git a/grammar_parser.meta b/grammar_parser.meta index ed58636..b4e48e0 100644 --- a/grammar_parser.meta +++ b/grammar_parser.meta @@ -101,13 +101,17 @@ setInTopNamespace(__identifier, __value) { __namespaces__.last()[__identifier] = __value; } -println = (x) { +println(x) { if (!x) { - print("\n"); + if (len(__env__().__delegate__) == 0){ + print("\n"); + } else { + print(nil, "\n"); + } } else { print(x, "\n", full: 1); } -}; +} Object.subtype(name) { self.new(__name__: name) } @@ -137,7 +141,7 @@ Stream.peek() { !self.atEnd() && self.content[self.position] } Context = Object.subtype(#Context); Context.init() { self.variables = []; self; } Context.declareVariable(var) { - found = 0; + local found = 0; for (key in self.variables.keys()) { if (key == var) { found = 1; @@ -163,6 +167,18 @@ StringLiteral.match(stream, context, actions) { } } +StringLiteral.getMatchingExpression() { + //return `(@stream).match(@self.string) && ((@stream).position += len(@self.string)) && @true; + return `{ + if (stream.match(@self.string)) { + stream.position += len(@self.string); + @true; + } else { + @false; + } + }; +} + //StringLiteral.match(stream, context, actions) { // // n = len(self.string); @@ -190,10 +206,10 @@ CharacterClass = Object.subtype(#CharacterClass); CharacterClass.match(stream, context, actions) { - classLength = len(self.value); - i = 0; - prevChar = nil; - success = 0; + local classLength = len(self.value); + local i = 0; + local prevChar = nil; + local success = 0; while (i < classLength && success == 0 && !stream.atEnd()) { @@ -211,8 +227,8 @@ CharacterClass.match(stream, context, actions) { // [a-z] case if (i+1 < classLength) { // println("[a-z] case"); - rangeStart = prevChar; - rangeEnd = self.value[i+1]; + local rangeStart = prevChar; + local rangeEnd = self.value[i+1]; // print("Range Start: ", rangeStart, " | "); // print("Range End: ", rangeEnd, "\n"); if (stream.peek() >= rangeStart @@ -250,6 +266,73 @@ CharacterClass.match(stream, context, actions) { success == 1; } +CharacterClass.staticmatch(stream, context, actions, value) { + + local classLength = len(value); + local i = 0; + local prevChar = nil; + local success = 0; + + while (i < classLength && success == 0 && !stream.atEnd()) { + + // [a] case + if (prevChar == nil) { + //println("[a] case"); + prevChar = value[i]; + + if (stream.peek() == value[i]) { + success = 1; + } + + } else if (prevChar != nil && value[i] == '-') { + + // [a-z] case + if (i+1 < classLength) { + // println("[a-z] case"); + local rangeStart = prevChar; + local rangeEnd = value[i+1]; + // print("Range Start: ", rangeStart, " | "); + // print("Range End: ", rangeEnd, "\n"); + if (stream.peek() >= rangeStart + && stream.peek() <= rangeEnd + ) { + success = 1; + } + prevChar = nil; + i = i + 1; + + // [a-] case + } else { + // println("[a-] case"); + if (stream.peek() == '-') { + success = 1; + } + } + + // [ab] case + } else if (prevChar != nil && value[i] != '-') { + // println("[ab] case"); + prevChar = value[i]; + if (stream.peek() == value[i]) { + success = 1; + } + } + // print("prevChar: ", prevChar, "\n"); + i = i + 1; + } + + if (success == 1) { + stream.inc(); + } + + success == 1; +} + +CharacterClass.getMatchingExpression() { + //return `CharacterClass.staticmatch(@stream, @context, @actions, @self.value); + return `{ CharacterClass.staticmatch(stream, context, actions, @self.value) }; +} + // Dot Dot = Object.subtype(#Dot); @@ -263,6 +346,11 @@ Dot.match(stream, context, actions) { } } +Dot.getMatchingExpression() { + //return `!(@stream).atEnd() && (@stream).inc() && @true; + return `{ !stream.atEnd() && stream.inc() && @true }; +} + // Begin Begin = Object.subtype(#Begin); @@ -272,6 +360,11 @@ Begin.match(stream, context, actions) { true; } +Begin.getMatchingExpression() { + //return `(@stream).setLastBegin() && true; + return `{ stream.setLastBegin() && @true }; +} + // End End = Object.subtype(#End); @@ -281,6 +374,13 @@ End.match(stream, context, actions) { true; } +End.getMatchingExpression() { + //return `((@context.variables).yytext = (@stream.content)[(@stream).lastBegin..(@stream).position].unescaped()) + // && true; + return `{ (context.variables.yytext = stream.content[stream.lastBegin..stream.position].unescaped()) + && @true }; +} + // Optional (? postfix operator) Optional = Object.subtype(#Optional); @@ -290,6 +390,11 @@ Optional.match(stream, context, actions) { true; } +Optional.getMatchingExpression() { + //return `(@self.expression.getMatchingExpression(stream, context, actions)) || @true; + return `{ (@self.expression.getMatchingExpression()); @true }; +} + // Star Star = Object.subtype(#Star); @@ -299,6 +404,10 @@ Star.match(stream, context, actions) { true; } +Star.getMatchingExpression() { + return `{ while (@self.expression.getMatchingExpression()) {} @true }; +} + // Plus Plus = Object.subtype(#Plus); @@ -312,12 +421,23 @@ Plus.match(stream, context, actions) { } } +Plus.getMatchingExpression() { + return `{ + if (@self.expression.getMatchingExpression()) { + while (@self.expression.getMatchingExpression()) {} + @true; + } else { + @false; + } + }; +} + // And And = Object.subtype(#And); And.match(stream, context, actions) { - position = stream.position; + local position = stream.position; if (self.expression.match(stream, context, actions) == true) { stream.position = position; @@ -327,12 +447,24 @@ And.match(stream, context, actions) { } } +And.getMatchingExpression() { + return `{ + local position = stream.position; + if (@self.expression.getMatchingExpression()) { + stream.position = position; + @true; + } else { + @false; + } + }; +} + // Not Not = Object.subtype(#Not); Not.match(stream, context, actions) { - position = stream.position; + local position = stream.position; if (self.expression.match(stream, context, actions) == true) { stream.position = position; @@ -342,6 +474,18 @@ Not.match(stream, context, actions) { } } +Not.getMatchingExpression() { + return `{ + local position = stream.position; + if (@self.expression.getMatchingExpression()) { + stream.position = position; + @false; + } else { + @true; + } + }; +} + // Sequence Sequence = Object.subtype(#Sequence); @@ -354,10 +498,10 @@ Sequence._match(stream, context, actions, index) { } Sequence.match(stream, context, actions) { - initialActionCount = actions.length(); - startingPosition = stream.position; + local initialActionCount = actions.length(); + local startingPosition = stream.position; - success = self._match(stream, context, actions, 0); + local success = self._match(stream, context, actions, 0); if (success == false) { while (actions.length() > initialActionCount) { @@ -369,6 +513,31 @@ Sequence.match(stream, context, actions) { success; } + +Sequence._getMatchingExpression(index) { + if (index == self.length() - 1) { + return self[index].getMatchingExpression(); + } + return `(@self[index].getMatchingExpression()) + && @self._getMatchingExpression(index + 1); +} + +Sequence.getMatchingExpression() { + return `{ + local initialActionCount = actions.length(); + local startingPosition = stream.position; + ({ + (@self._getMatchingExpression(0)); + } || { + while (actions.length() > initialActionCount) { + actions.pop(); + } + stream.position = startingPosition; + @false; + }); + } +} + // Alternation Alternation = Object.subtype(#Alternation); @@ -384,6 +553,18 @@ Alternation.match(stream, context, actions) { return self._match(stream, context, actions, 0); } +Alternation._getMatchingExpression(index) { + if (index == self.length() - 1) { + return self[index].getMatchingExpression(); + } + return `(@self[index].getMatchingExpression()) + || @self._getMatchingExpression(index + 1); +} + +Alternation.getMatchingExpression() { + return `{ @self._getMatchingExpression(0) }; +} + // Action Action = Object.subtype(#Action); @@ -393,6 +574,10 @@ Action.match(stream, context, actions) { true; } +Action.getMatchingExpression() { + return `{ actions.push([action: @self, context: context]); @true; } +} + Action.execute(context) { // Declare all variables that a value is set to in the context @@ -403,7 +588,7 @@ Action.execute(context) { } // Evaluate the parse tree and return to outer context if needed - returnValue = eval(self.parseTree, env: context.variables); + local returnValue = eval(self.parseTree, env: context.variables); if (context.outerContext != nil) { context.outerContext.variables[context.returnValueName] = returnValue; } @@ -423,16 +608,28 @@ ParseTimeAction.match(stream, context, actions) { } } +ParseTimeAction.getMatchingExpression() { + return `{ (@self.action).execute(context) }; +} + // Assignment Assignment = Object.subtype(#Assignment); Assignment.match(stream, context, actions) { context.declareVariable(self.name); - innerContext = Context.new(outerContext: context, returnValueName: self.name).init(); + local innerContext = Context.new(outerContext: context, returnValueName: self.name).init(); self.rule.match(stream, innerContext, actions); } +Assignment.getMatchingExpression() { + return `{ + context.declareVariable(@self.name); + local context = Context.new(outerContext: context, returnValueName: @self.name).init(); + @self.rule.getMatchingExpression(); + } +} + // RuleCall RuleCall = Object.subtype(#RuleCall); @@ -440,29 +637,72 @@ RuleCall = Object.subtype(#RuleCall); RuleCall.match(stream, context, actions) { //if (rules[self.name] == nil) { print("Trying to call undefined rule: ", self.name, "\n"); exit(); } //print("calling rule ", self.name, " | ", stream.position, "\n"); - res = get(self.name).match(stream, context, actions); + local res = get(self.name).match(stream, context, actions); //print("matching rule ", self.name, ": ", res, "\n"); res; } +RuleCall.getMatchingExpression() { + //print("Calling rule ", self.name, "\n"); + //local res = `{get(@self.name).getMatchingExpression(@stream, @context, @actions).__eval__()}; + + //if (innerContext == nil) { + `{ Invoke.new(self: self, method: @self.name, arguments: [stream, context, actions]).__eval__() }; + //} else { + // `{ self.rules[@self.name](stream, @innerContext, actions) }; + //} + + //print("Pos ", stream.position, " | Called rule ", self.name, "\n"); +} + // NamespacedRuleCall NamespacedRuleCall = Object.subtype(#NamespacedRuleCall); -NamespacedRuleCall.match(stream, context, actions) { +NamespacedRuleCall.match() { with(self.namespace); - res = get(self.name).match(stream, context, actions); + local res = get(self.name).match(stream, context, actions); without(); res; } +NamespacedRuleCall.getMatchingExpression(innerContext) { + //return `{ + // with(@self.namespace); + // local res = get(@self.name).getMatchingExpression(@stream, @context, @actions).__eval__(); + // without(); + // res; + //} + //if (innerContext == nil) { + `{ Invoke.new(self: @get(self.namespace), method: @self.name, arguments: [stream, context, actions]).__eval__() }; + //} else { + // `{ (@get(self.namespace)).rules[@self.name](stream, @innerContext, actions) }; + //} + +} + Definition = Object.subtype(#Definition); +Grammar = Object.subtype(#Grammar); + +Grammar.addRulesFromNamespace(namespace) { + for (key in __namespaces__[namespace].keys()) { + if (key == #__nsname__) continue; + self[key] = Closure.new( + environment: nil, + function: Lambda.new( + parameters: [#stream, #context, #actions], + body: __namespaces__[namespace][key].getMatchingExpression().body + ) + ) + } +} + // ----- Grammar of Meta Language (Minimal) ----- -hcmeta = with(#HardCodedMeta); +with(#HardCodedMeta); -hcmeta.metaStatement = +metaStatement = Alternation.new() .push(Sequence.new() .push(Assignment.new(name: #b, rule: RuleCall.new(name: #block))) @@ -477,7 +717,7 @@ hcmeta.metaStatement = .push(Action.new(parseTree: `{ e; })) ); -hcmeta.metaExpression = +metaExpression = Alternation.new(id: 1234) .push(Sequence.new() .push(Assignment.new(name: #p, rule: RuleCall.new(name: #metaPrimary))) @@ -509,7 +749,7 @@ hcmeta.metaExpression = .push(Action.new(parseTree: `{ pf; })) ); -hcmeta.metaPostfix = +metaPostfix = Sequence.new() .push(Assignment.new(name: #p, rule: RuleCall.new(name: #metaPrimary))) .push(Star.new(expression: Alternation.new() @@ -537,7 +777,7 @@ hcmeta.metaPostfix = )) .push(Action.new(parseTree: `{ p; })); -hcmeta.args = +args = Sequence.new() .push(RuleCall.new(name: #lparen)) .push(Assignment.new(name: #a, rule: RuleCall.new(name: #mklist))) @@ -573,23 +813,23 @@ hcmeta.args = .push(RuleCall.new(name: #rparen)) .push(Action.new(parseTree: `{ a; })); -hcmeta.mklist = Action.new(parseTree: `{ Object.new(); }); +mklist = Action.new(parseTree: `{ Object.new(); }); -hcmeta.metaPrimary = +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 = +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; })); + .push(Action.new(parseTree: `{ e; })); -hcmeta.block = +block = Sequence.new() .push(RuleCall.new(name: #lbrace)) .push(Assignment.new(name: #b, rule: RuleCall.new(name: #mklist))) @@ -603,7 +843,7 @@ hcmeta.block = .push(RuleCall.new(name: #rbrace)) .push(Action.new(parseTree: `{ Block.new(body: b); })); -hcmeta.number = +number = Alternation.new() .push(Sequence.new() .push(StringLiteral.new(string: "-")) @@ -620,7 +860,7 @@ hcmeta.number = .push(Action.new(parseTree: `{ n })) ); -hcmeta.unsign = +unsign = Sequence.new() .push(Begin.new()) .push(Plus.new(expression: RuleCall.new(name: #digit))) @@ -628,12 +868,12 @@ hcmeta.unsign = .push(RuleCall.new(name: #ws)) .push(Action.new(parseTree: `{ yytext.asInteger(10); })); -hcmeta.metaVar = +metaVar = Sequence.new() .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId))) .push(Action.new(parseTree: `{ GetVar.new(name: i); })); -hcmeta.metaId = +metaId = Sequence.new() .push(Begin.new()) .push(RuleCall.new(name: #letter)) @@ -642,52 +882,52 @@ hcmeta.metaId = .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 = +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)); -hcmeta.nil = +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)); +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)); -hcmeta.assign = +assign = Sequence.new() .push(StringLiteral.new(string: "=")) .push(Not.new(expression: CharacterClass.new(value: "="))) .push(RuleCall.new(name: #ws)); -hcmeta.dot = +dot = Sequence.new() .push(StringLiteral.new(string: ".")) .push(Not.new(expression: CharacterClass.new(value: "."))) .push(RuleCall.new(name: #ws)); -hcmeta.colon = +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()); +end_of_file = Not.new(expression: Dot.new()); -hcmeta.end_of_line = +end_of_line = Alternation.new() .push(StringLiteral.new(string: "\r\n")) .push(StringLiteral.new(string: "\n")) .push(StringLiteral.new(string: "\r")); -hcmeta.comment = +comment = Sequence.new() .push(StringLiteral.new(string: "//")) .push(Star.new(expression: @@ -697,13 +937,13 @@ hcmeta.comment = )) .push(RuleCall.new(name: #end_of_line)); -hcmeta.space = +space = Alternation.new() .push(StringLiteral.new(string: " ")) .push(StringLiteral.new(string: "\t")) .push(RuleCall.new(name: #end_of_line)); -hcmeta.ws = +ws = Star.new(expression: Alternation.new() .push(RuleCall.new(name: #space)) .push(RuleCall.new(name: #comment)) @@ -711,9 +951,9 @@ hcmeta.ws = // ----- Grammar of Grammars ----- -hcpeg = with(#HardCodedPeg); +with(#HardCodedPeg); -hcpeg.grammar = +grammar = Sequence.new() .push(RuleCall.new(name: #ws)) .push(Plus.new(expression: Sequence.new() @@ -722,7 +962,7 @@ hcpeg.grammar = )) .push(RuleCall.new(name: #end_of_file)); -hcpeg.definition = +definition = Sequence.new() .push(Assignment.new(name: #i, rule: RuleCall.new(name: #identifier))) .push(RuleCall.new(name: #assign)) @@ -730,7 +970,7 @@ hcpeg.definition = .push(Optional.new(expression: RuleCall.new(name: #semi))) .push(Action.new(parseTree: `{ Definition.new(name: i, expression: e); })); -hcpeg.expression = +expression = Alternation.new() .push(Sequence.new() .push(Assignment.new(name: #s, rule: RuleCall.new(name: #sequence))) @@ -748,7 +988,7 @@ hcpeg.expression = .push(Action.new(parseTree: `{ s1; })) ); -hcpeg.sequence = +sequence = Sequence.new() .push(Assignment.new(name: #p, rule: RuleCall.new(name: #prefix))) .push(Action.new(parseTree: `{ p = Sequence.new().push(p); })) @@ -758,7 +998,7 @@ hcpeg.sequence = )) .push(Action.new(parseTree: `{ p; })); -hcpeg.prefix = +prefix = Alternation.new() .push(Sequence.new() .push(RuleCall.new(name: #and)) @@ -781,7 +1021,7 @@ hcpeg.prefix = ) ); -hcpeg.suffix = +suffix = Sequence.new() .push(Assignment.new(name: #p, rule: RuleCall.new(name: #primary))) .push(Optional.new(expression: Alternation.new() @@ -800,7 +1040,7 @@ hcpeg.suffix = )) .push(Action.new(parseTree: `{ p; })); -hcpeg.primary = +primary = Alternation.new() .push(Sequence.new() .push(Assignment.new(name: #i1, rule: RuleCall.new(name: #identifier))) @@ -845,7 +1085,7 @@ hcpeg.primary = .push(Action.new(parseTree: `{ End.new(); })) ); -hcpeg.identifier = +identifier = Sequence.new() .push(Begin.new()) .push(CharacterClass.new(value: "-a-zA-Z_")) @@ -854,7 +1094,7 @@ hcpeg.identifier = .push(RuleCall.new(name: #ws)) .push(Action.new(parseTree: `{ intern(yytext); })); -hcpeg.ruleCall = +ruleCall = Alternation.new() .push(Sequence.new() .push(Assignment.new(name: #n, rule: RuleCall.new(name: #identifier))) @@ -867,7 +1107,7 @@ hcpeg.ruleCall = .push(Action.new(parseTree: `{ RuleCall.new(name: i); })) ); -hcpeg.literal = +literal = Alternation.new() .push(Sequence.new() .push(CharacterClass.new(value: "\'")) @@ -894,7 +1134,7 @@ hcpeg.literal = .push(Action.new(parseTree: `{ StringLiteral.new(string: yytext); })) ); -hcpeg.class = +class = Sequence.new() .push(StringLiteral.new(string: "[")) .push(Begin.new()) @@ -907,7 +1147,7 @@ hcpeg.class = .push(RuleCall.new(name: #ws)) .push(Action.new(parseTree: `{ CharacterClass.new(value: yytext); })); -hcpeg.range = +range = Alternation.new() .push(Sequence.new() .push(RuleCall.new(name: #char)) @@ -918,7 +1158,7 @@ hcpeg.range = RuleCall.new(name: #char) ); -hcpeg.char = +char = Alternation.new() .push(Sequence.new() .push(StringLiteral.new(string: "\\")) @@ -940,47 +1180,47 @@ hcpeg.char = .push(Dot.new()) ); -hcpeg.action = +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)); +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)); -hcpeg.ccolon = Sequence.new().push(StringLiteral.new(string: "::")).push(RuleCall.new(name: #ws)); +ccolon = Sequence.new().push(StringLiteral.new(string: "::")).push(RuleCall.new(name: #ws)); -hcpeg.and = +and = Sequence.new() .push(StringLiteral.new(string: "&")) .push(Not.new(expression: CharacterClass.new(value: "&="))) .push(RuleCall.new(name: #ws)); -hcpeg.plus = +plus = Sequence.new() .push(StringLiteral.new(string: "+")) .push(Not.new(expression: CharacterClass.new(value: "+="))) .push(RuleCall.new(name: #ws)); -hcpeg.star = +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()); +end_of_file = Not.new(expression: Dot.new()); -hcpeg.end_of_line = +end_of_line = Alternation.new() .push(StringLiteral.new(string: "\r\n")) .push(StringLiteral.new(string: "\n")) .push(StringLiteral.new(string: "\r")); -hcpeg.comment = +comment = Sequence.new() .push(StringLiteral.new(string: "#")) .push(Star.new(expression: @@ -990,13 +1230,13 @@ hcpeg.comment = )) .push(RuleCall.new(name: #end_of_line)); -hcpeg.space = +space = Alternation.new() .push(StringLiteral.new(string: " ")) .push(StringLiteral.new(string: "\t")) .push(RuleCall.new(name: #end_of_line)); -hcpeg.ws = +ws = Star.new(expression: Alternation.new() .push(RuleCall.new(name: #space)) .push(RuleCall.new(name: #comment)) @@ -1004,11 +1244,21 @@ hcpeg.ws = // ----- Main ----- -stream = newStream(readfile("rawminproto.leg")); -context = Context.new(outerContext: nil).init(); -actions = []; +without(all: 1); + +HardCodedPeg = Grammar.new(); +HardCodedMeta = Grammar.new(); + +HardCodedPeg.addRulesFromNamespace(#HardCodedPeg); +HardCodedMeta.addRulesFromNamespace(#HardCodedMeta); -print("Matching rawminproto.leg : ", grammar.match(stream, context, actions), "\n"); +HardCodedPeg.__delegate__ = HardCodedMeta; + +global stream = newStream(readfile("rawminproto.leg")); +global context = Context.new(outerContext: nil).init(); +global actions = []; + +print("Matching rawminproto.leg : ", HardCodedPeg.grammar(stream, context, actions), "\n"); with(#metaLanguage); for (actionAndContext in actions) { @@ -1018,29 +1268,11 @@ without(#metaLanguage); println("\n--------- META ---------\n\n"); println(__namespaces__.metaLanguage); -//stream = newStream(readfile("rawMetaGrammar.leg")); -//context = Context.new(outerContext: nil).init(); -//actions = []; -// -//print("Matching : ", grammar.match(stream, context, actions), "\n"); -// -//// Execute all actions after all matching -//// Open the namespace where rules will be declared -//with(#metaLanguage); -// -//for (actionAndContext in actions) { -// actionAndContext.action.execute(actionAndContext.context); -//} -// -//println("\n--------- META ---------\n\n"); -//println(__namespaces__.metaLanguage); -//without(#metaLanguage); - -stream = newStream(readfile("rawgrammar.leg")); -context = Context.new(outerContext: nil).init(); -actions = []; +global stream = newStream(readfile("rawgrammar.leg")); +global context = Context.new(outerContext: nil).init(); +global actions = []; -print("Matching : ", grammar.match(stream, context, actions), "\n"); +print("Matching rawgrammar.leg : ", HardCodedPeg.grammar(stream, context, actions), "\n"); // Execute all actions after all matching @@ -1055,17 +1287,20 @@ println("\n--------- PEG ---------\n\n"); println(__namespaces__.peg); // Circularity test -without(all: 1); -with(#metaLanguage); -with(#peg); +peg = Grammar.new(); +metaLanguage = Grammar.new(); + +peg.addRulesFromNamespace(#peg); +metaLanguage.addRulesFromNamespace(#metaLanguage); -stream2 = newStream(readfile("rawminproto.leg")); -//stream2 = newStream("a = b:c::d { print(a[b].c); }"); -context2 = Context.new(outerContext: nil).init(); -actions2 = []; +peg.__delegate__ = metaLanguage; -print("\nMatching : ", grammar.match(stream2, context2, actions2), "\n"); +global stream2 = newStream(readfile("rawminproto.leg")); +global context2 = Context.new(outerContext: nil).init(); +global actions2 = []; + +print("\nMatching : ", peg.grammar(stream2, context2, actions2), "\n"); with(#metaLanguageCircular); @@ -1077,11 +1312,11 @@ without(#metaLanguageCircular); println("\n--------- CIRCULAR META ---------\n\n"); println(__namespaces__.metaLanguageCircular); -stream2 = newStream(readfile("rawgrammar.leg")); -context2 = Context.new(outerContext: nil).init(); -actions2 = []; +global stream2 = newStream(readfile("rawgrammar.leg")); +global context2 = Context.new(outerContext: nil).init(); +global actions2 = []; -print("\nMatching : ", grammar.match(stream2, context2, actions2), "\n"); +print("\nMatching : ", peg.grammar(stream2, context2, actions2), "\n"); with(#pegCircular); @@ -1093,10 +1328,8 @@ without(#pegCircular); println("\n--------- CIRCULAR PEG ---------\n\n"); println(__namespaces__.pegCircular); -without(all: 1); - compareGrammars(grammar1, grammar2) { - success = 1; + local success = 1; for (key in __namespaces__[grammar1].keys()) { if (key == #__nsname__) continue;