MaximeBarniaudy
/
minproto
derivado de piumarta/minproto
1
0
Derivar 0
Código Questões 0 Pedidos de integração 0 Lançamentos 0 Wiki Trabalho
Minimal (?) protype-based language.
Não pode escolher mais do que 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
74 Cometimentos
1 Ramo
4.0 MiB
 
Árvore: c3125a863f
Ramos Etiquetas
${ item.name }
Criar ramo ${ searchTerm }
de 'c3125a863f'
${ noResults }
minproto/grammar_parser.meta

1085 linhas
35 KiB
Em bruto Responsabilidade Histórico

// ----- Utils -----
true = (1 == 1);
false = (1 == 0);
Object.contains(item) {
for (i in self.length()) {
if (self[i] == item) {
return 1;
}
}
return nil;
}
with(namespace) {
//print("--- With ", namespace, " ---\n\n");
if (__namespaces__.length() == 0) {
__namespaces__.push([]);
}
if (!__namespaces__.keys().contains(namespace)) {
newNamespace = [__nsname__: namespace];
__namespaces__[namespace] = newNamespace;
__namespaces__[0][namespace] = newNamespace;
} else {
__namespaces__[0][namespace] = __namespaces__[namespace];
}
__namespaces__.push(__namespaces__[namespace]);
return __namespaces__[namespace];
}
//without(); // latest
//without(#peg); // remove a plate from the middle the pile without smashing everything
//without(all: 1); // ALL
without(namespace, all: nil) {
// Remove all
if (all != nil) {
for (i in (__namespaces__.length() - 1)) {
removedNamespace = __namespaces__.pop().__nsname__;
//print("--- Without ", removedNamespace, " ---\n\n");
__namespaces__[0][removedNamespace] = nil;
}
__namespaces__.pop();
return;
}
// Remove last
if (namespace == nil) {
removedNamespace = __namespaces__.pop().__nsname__;
//print("--- Without ", removedNamespace, " ---\n\n");
__namespaces__[0][removedNamespace] = nil;
if (__namespaces__.length() == 1) {
__namespaces__.pop();
}
return;
}
// Remove a given namespace
// Find its index
namespaceIndex = nil;
for (i from (__namespaces__.length() - 1) to 1) {
if (__namespaces__[i].__nsname__ == namespace) {
namespaceIndex = i;
break;
}
}
// If it's on top of the stack, just pop
if (namespaceIndex == __namespaces__.length() - 1) {
__namespaces__.pop();
//print("--- Without ", namespace, " ---\n\n");
__namespaces__[0][namespace] = nil;
if (__namespaces__.length() == 1) {
__namespaces__.pop();
}
return;
}
// If it's not on top, offset all the namespaces on top of it by one, and then pop
for (i from namespaceIndex to (__namespaces__.length() - 2)) {
__namespaces__[i] = __namespaces__[i + 1];
}
__namespaces__.pop();
//print("--- Without ", namespace, " ---\n\n");
__namespaces__[0][namespace] = nil;
if (__namespaces__.length() == 1) {
__namespaces__.pop();
}
}
get(__identifier) {
eval(GetVar.new(name: __identifier));
}
setInTopNamespace(__identifier, __value) {
__namespaces__.last()[__identifier] = __value;
}
println(x) {
if (!x) {
if (len(__env__().__delegate__) == 0){
print("\n");
} else {
print(nil, "\n");
}
} else {
print(x, "\n", full: 1);
}
}
Object.subtype(name) { self.new(__name__: name) }
Object.last() { self[self.length() - 1] }
// Input stream
Stream.peek() { self.content[self.position] }
// Context
Context = Object.subtype(#Context);
Context.init() { self.variables = []; self; }
Context.declareVariable(var) {
local found = 0;
for (key in self.variables.keys()) {
if (key == var) {
found = 1;
}
}
if (found == 0) {
self.variables[var] = nil;
}
}
// ----- Grammar Constructs -----
// String Literal
StringLiteral = Object.subtype(#StringLiteral);
StringLiteral.getMatchingExpression() {
return `{
((stream.content.compareFrom(stream.position, @self.string) == 0) &&
(stream.position += len(@self.string)) &&
@true)
||
@false
};
}
// Character Class
CharacterClass = Object.subtype(#CharacterClass);
CharacterClass.getMatchingExpression() {
return `{ !stream.atEnd() && (@self.value.charClass()).bitTest(stream.peek()) && stream.inc() && @true };
}
// Dot
Dot = Object.subtype(#Dot);
Dot.getMatchingExpression() {
return `{ !stream.atEnd() && stream.inc() && @true };
}
// Begin
Begin = Object.subtype(#Begin);
Begin.getMatchingExpression() {
return `{ stream.setLastBegin() && @true };
}
// End
End = Object.subtype(#End);
End.getMatchingExpression() {
return `{ (context.variables.yytext = stream.content[stream.lastBegin..stream.position].unescaped())
&& @true };
}
// Optional (? postfix operator)
Optional = Object.subtype(#Optional);
Optional.getMatchingExpression() {
return `{ (@self.expression.getMatchingExpression()); @true };
}
// Star
Star = Object.subtype(#Star);
Star.getMatchingExpression() {
return `{ while (@self.expression.getMatchingExpression()) @true; @true };
}
// Plus
Plus = Object.subtype(#Plus);
Plus.getMatchingExpression() {
return `{
if (@self.expression.getMatchingExpression()) {
while (@self.expression.getMatchingExpression()) {}
@true;
} else {
@false;
}
};
}
// And
And = Object.subtype(#And);
And.getMatchingExpression() {
return `{
local position = stream.position;
if (@self.expression.getMatchingExpression()) {
stream.position = position;
@true;
} else {
@false;
}
};
}
// Not
Not = Object.subtype(#Not);
Not.getMatchingExpression() {
return `{
local position = stream.position;
if (@self.expression.getMatchingExpression()) {
stream.position = position;
@false;
} else {
@true;
}
};
}
// Sequence
Sequence = Object.subtype(#Sequence);
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);
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);
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
for (statement in self.parseTree.body) {
if (statement.__name__ == "SetVar") {
context.declareVariable(statement.name);
}
}
// Evaluate the parse tree and return to outer context if needed
local returnValue = eval(self.parseTree, env: context.variables);
if (context.outerContext != nil) {
context.outerContext.variables[context.returnValueName] = returnValue;
}
returnValue;
}
// Parse-time Action
ParseTimeAction = Object.subtype(#ParseTimeAction);
ParseTimeAction.getMatchingExpression() {
return `{ (@self.action).execute(context) };
}
// Assignment
Assignment = Object.subtype(#Assignment);
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);
RuleCall.getMatchingExpression() {
`{ /*increaseCount(@self.name);*/ Invoke.new(self: self, method: @self.name, arguments: [stream, context, actions]).__eval__() };
}
// NamespacedRuleCall
NamespacedRuleCall = Object.subtype(#NamespacedRuleCall);
NamespacedRuleCall.getMatchingExpression(innerContext) {
`{ Invoke.new(self: @get(self.namespace), method: @self.name, arguments: [stream, context, actions]).__eval__() };
}
Definition = Object.subtype(#Definition);
Grammar = Object.subtype(#Grammar);
Grammar.addRulesFromNamespace(namespace) {
for (key in __namespaces__[namespace].keys()) {
if (key == #__nsname__) continue;
self.addRule(key, __namespaces__[namespace][key]);
}
}
Grammar.addRule(ruleName, rule) {
self[ruleName] = Closure.new(
environment: nil,
function: Lambda.new(
parameters: [#stream, #context, #actions],
body: rule.getMatchingExpression().body,
name: ruleName,
parent: self
)
)
}
//global functionCounts = [];
//
//increaseCount(function) {
// if (!functionCounts.keys().contains(function)){
// functionCounts[function] = 1;
// } else {
// functionCounts[function]++;
// }
//}
// ----- 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()
.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 }))
);
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))
);
// ----- Grammar of Grammars -----
with(#HardCodedPeg);
grammar =
Sequence.new()
.push(RuleCall.new(name: #ws))
.push(Alternation.new()
.push(Sequence.new()
.push(Assignment.new(name: #d, rule: RuleCall.new(name: #definition)))
.push(Action.new(parseTree: `{ d; }))
)
.push(Sequence.new()
.push(RuleCall.new(name: #end_of_file))
.push(Action.new(parseTree: `{ nil; }))
)
);
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); }));
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()
.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); }))
);
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))
);
// ----- Main -----
without(all: 1);
HardCodedPeg = Grammar.new();
HardCodedMeta = Grammar.new();
HardCodedPeg.addRulesFromNamespace(#HardCodedPeg);
HardCodedMeta.addRulesFromNamespace(#HardCodedMeta);
HardCodedPeg.__delegate__ = HardCodedMeta;
global stream = newStream(readfile("rawminproto.leg"));
global context = Context.new(outerContext: nil).init();
global actions = [];
while(!stream.atEnd()) {
HardCodedPeg.grammar(stream, context, actions);
with(#metaLanguage);
local definition = { for (actionAndContext in actions) {
actionAndContext.action.execute(actionAndContext.context);
} };
if (definition == nil) continue; // end of file case
setInTopNamespace(definition.name, definition.expression);
without(#metaLanguage);
global actions = [];
}
println("\n--------- META ---------\n\n");
println(__namespaces__.metaLanguage);
global stream = newStream(readfile("rawgrammar.leg"));
global context = Context.new(outerContext: nil).init();
global actions = [];
while(!stream.atEnd()) {
HardCodedPeg.grammar(stream, context, actions);
with(#peg);
local definition = { for (actionAndContext in actions) {
actionAndContext.action.execute(actionAndContext.context);
} };
if (definition == nil) continue; // end of file case
setInTopNamespace(definition.name, definition.expression);
without(#peg);
global actions = [];
}
println("\n--------- PEG ---------\n\n");
println(__namespaces__.peg);
// Circularity test
peg = Grammar.new();
metaLanguage = Grammar.new();
peg.addRulesFromNamespace(#peg);
metaLanguage.addRulesFromNamespace(#metaLanguage);
peg.__delegate__ = metaLanguage;
global stream2 = newStream(readfile("rawminproto.leg"));
global context2 = Context.new(outerContext: nil).init();
global actions2 = [];
while(!stream2.atEnd()) {
peg.grammar(stream2, context2, actions2);
with(#metaLanguageCircular);
local definition = { for (actionAndContext in actions2) {
actionAndContext.action.execute(actionAndContext.context);
} };
if (definition == nil) continue; // end of file case
setInTopNamespace(definition.name, definition.expression);
without(#metaLanguageCircular);
global actions2 = [];
}
println("\n--------- CIRCULAR META ---------\n\n");
println(__namespaces__.metaLanguageCircular);
global stream2 = newStream(readfile("rawgrammar.leg"));
global context2 = Context.new(outerContext: nil).init();
global actions2 = [];
while(!stream2.atEnd()) {
peg.grammar(stream2, context2, actions2);
with(#pegCircular);
local definition = { for (actionAndContext in actions2) {
actionAndContext.action.execute(actionAndContext.context);
} };
if (definition == nil) continue; // end of file case
setInTopNamespace(definition.name, definition.expression);
without(#pegCircular);
global actions2 = [];
}
println("\n--------- CIRCULAR PEG ---------\n\n");
println(__namespaces__.pegCircular);
compareGrammars(grammar1, grammar2) {
local success = 1;
for (key in __namespaces__[grammar1].keys()) {
if (key == #__nsname__) continue;
if (codeString(__namespaces__[grammar1][key]) != codeString(__namespaces__[grammar2][key])) {
print("Found different objects for rule ", key, ":\n");
println(__namespaces__[grammar1][key]);
println(__namespaces__[grammar2][key]);
success = 0;
}
}
if (success == 1) {
print("Grammars ", grammar1, " and ", grammar2, " are equal\n");
}
}
compareGrammars(#peg, #pegCircular);
compareGrammars(#metaLanguage, #metaLanguageCircular);
//global functionCounts = [];
global then = cputime();
global stream3 = newStream(readfile("grammar_parser.meta"));
global context3 = Context.new(outerContext: nil).init();
global actions3 = [];
while(!stream3.atEnd()) {
metaLanguage.start(stream3, context3, actions3);
res = { for (actionAndContext in actions3) {
actionAndContext.action.execute(actionAndContext.context);
} };
//print(res, "\n");
//println(len(actions3));
//println(context3.variables.s);
//eval(context3.variables.s, nil);
global actions3 = [];
}
global now = cputime();
print("Parse time : ", now - then, "s\n");
//println(functionCounts);