MaximeBarniaudy
/
minproto
geforked van piumarta/minproto
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
Minimal (?) protype-based language.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
77 Commits
1 Branch
4.0 MiB
 
Branch: master
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van 'master'
${ noResults }
minproto/grammar_parser.meta

1437 regels
45 KiB
Ruw Permalink Blame Geschiedenis

global then = cputime();
// ----- 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 -----
// Parser VM op-codes
// opcodes opcode argument arglength next-pc notes
OpCodes = [
PUSH: 0, // PUSH nil 0 ok ok both pcs should be set the same
DROP: 1, // DROP nil 0 ok ok
POP: 2, // POP nil 0 ok ok
DOT: 3, // DOT nil 0 ok ko ok/ko next pc are absolute and are
CLASS: 4, // CLASS bitarray len(bitarray) ok ko instruction indexes (0, 1, 2, ...)
STRING: 5, // STRING string len(string) ok ko and not array indexes (0, 5, 10, ...)
TEST: 6,
RULE2: 7,
RULE: 8, // RULE symbol 0 ok ko
CALL: 9, // CALL nil 0 ok ko do not use this; VM internal use only
CALL2: 10, // CALL nil 0 ok ko do not use this; VM internal use only
SUCCEED: 11, // SUCCEED nil 0 0 0 next pcs are ignored
FAIL: 12, // FAIL nil 0 0 0
ACTION: 13, // ACTION function 0 ok ok both pcs should be the same
BEGIN: 14, // BEGIN nil 0 ok ok
END: 15, // END nil 0 ok ok
UNEND: 16, // UNEND nil 0 ok ok
SET: 17 // SET symbol 0 ok ok
];
OpCodeNames = [
"PUSH",
"DROP",
"POP",
"DOT",
"CLASS",
"STRING",
"TEST",
"RULE2",
"RULE",
"CALL",
"CALL2",
"SUCCEED",
"FAIL",
"ACTION",
"BEGIN",
"END",
"UNEND",
"SET"
];
Instruction = Object.subtype(#Instruction);
Instruction.new(op, arg, arglen, ok, ko) {
self = super.new();
self.op = op;
self.arg = arg;
self.arglen = arglen;
self.ok = ok;
self.ko = ko;
self;
}
Instruction.printline() {
print(OpCodeNames[self.op], " ", codeString(self.arg), " ", self.arglen, " ", self.ok, " ", self.ko, "\n");
}
// String Literal
StringLiteral = Object.subtype(#StringLiteral);
StringLiteral.emitByteCode(instructions, ok, ko) {
//emit(STRING, (byte *)node->String.string, strlen(node->String.string), ok, ko);
instructions.push(Instruction.new(OpCodes.STRING, self.string, len(self.string), ok, ko));
instructions.length() - 1;
}
// Character Class
CharacterClass = Object.subtype(#CharacterClass);
CharacterClass.emitByteCode(instructions, ok, ko) {
//emit(CLASS, node->Class.bits, 32, ok, ko);
instructions.push(Instruction.new(OpCodes.CLASS, self.value.charClass(), 32, ok, ko));
instructions.length() - 1;
}
// Dot
Dot = Object.subtype(#Dot);
Dot.emitByteCode(instructions, ok, ko) {
//emit(DOT, 0, 0, ok, ko);
instructions.push(Instruction.new(OpCodes.DOT, 0, 0, ok, ko));
instructions.length() - 1;
}
// Capture
Capture = Object.subtype(#Capture);
Capture.emitByteCode(instructions, ok, ko) {
//ok = emit(END, 0, 0, ok, ok);
//ko = emit(UNEND, 0, 0, ko, ko);
//ok = generateNode(node->Capture.exp, ok, ko);
//emit(BEGIN, 0, 0, ok, ok);
// FAIS CE QUE LE CODE DIT BORDEL
instructions.push(Instruction.new(OpCodes.END, 0, 0, ok, ok));
ok = instructions.length() - 1;
instructions.push(Instruction.new(OpCodes.UNEND, 0, 0, ko, ko));
ko = instructions.length() - 1;
ok = self.expression.emitByteCode(instructions, ok, ko);
instructions.push(Instruction.new(OpCodes.BEGIN, 0, 0, ok, ok));
instructions.length() - 1;
}
// Optional (? postfix operator)
Optional = Object.subtype(#Optional);
Optional.emitByteCode(instructions, ok, ko) {
self.expression.emitByteCode(instructions, ok, ok);
instructions.length() - 1;
}
// Star
Star = Object.subtype(#Star);
Star.emitByteCode(instructions, ok, ko) {
local last = instructions.length();
self.expression.emitByteCode(instructions, ok, ok);
instructions[last].ok = instructions.length() - 1;
instructions.length() - 1;
}
// Plus
Plus = Object.subtype(#Plus);
Plus.emitByteCode(instructions, ok, ko) {
local last = instructions.length();
local next = self.expression.emitByteCode(instructions, ok, ok);
instructions[last].ok = instructions.length() - 1;
self.expression.emitByteCode(instructions, next, ko);
instructions.length() - 1;
}
// And
And = Object.subtype(#And);
And.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(OpCodes.POP, 0, 0, ok, ok));
ok = instructions.length() - 1;
instructions.push(Instruction.new(OpCodes.DROP, 0, 0, ko, ko));
ko = instructions.length() - 1;
local here = self.expression.emitByteCode(instructions, ok, ko);
instructions.push(Instruction.new(OpCodes.PUSH, 0, 0, here, here));
instructions.length() - 1;
}
// Not
Not = Object.subtype(#Not);
Not.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(OpCodes.POP, 0, 0, ko, ko));
local nok = instructions.length() - 1;
instructions.push(Instruction.new(OpCodes.DROP, 0, 0, ok, ok));
local nko = instructions.length() - 1;
local here = self.expression.emitByteCode(instructions, nok, nko);
instructions.push(Instruction.new(OpCodes.PUSH, 0, 0, here, here));
instructions.length() - 1;
}
// Sequence
Sequence = Object.subtype(#Sequence);
Sequence.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(OpCodes.DROP, 0, 0, ok, ok));
ok = instructions.length() - 1;
instructions.push(Instruction.new(OpCodes.POP, 0, 0, ko, ko));
ko = instructions.length() - 1;
for (i from self.length() - 1 to 0) {
ok = self[i].emitByteCode(instructions, ok, ko);
}
instructions.push(Instruction.new(OpCodes.PUSH, 0, 0, ok, ok));
instructions.length() - 1;
}
// Alternation
Alternation = Object.subtype(#Alternation);
Alternation.prepend(sequenceString) {
alt = self;
parse(sequenceString, pegGrammar, #startSequence,
(result) {
alt.push(alt[len(alt) - 1]);
for (i from len(alt) - 2 to 0) {
alt[i + 1] = alt[i];
}
alt[0] = result;
}
);
self.parser.__update(self.name, self);
}
parseDefinition(pegString) {
local definition = nil;
parse(pegString, pegGrammar, #grammar, (result){ definition = result });
definition;
}
Alternation.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(OpCodes.DROP, 0, 0, ok, ok));
ok = instructions.length() - 1;
instructions.push(Instruction.new(OpCodes.POP, 0, 0, ko, ko));
ko = instructions.length() - 1;
for (i from self.length() - 1 to 0) {
ko = self[i].emitByteCode(instructions, ok, ko);
}
instructions.push(Instruction.new(OpCodes.PUSH, 0, 0, ko, ko));
instructions.length() - 1;
}
// Action
Action = Object.subtype(#Action);
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;
}
Action.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(
OpCodes.ACTION,
Closure.new(
environment: nil,
function: Lambda.new(
parameters: [],
body: self.parseTree.body
)
),
0,
ok,
ok
));
instructions.length() - 1;
}
// Parse-time Action (&)
ParseTimeAction = Object.subtype(#ParseTimeAction);
ParseTimeAction.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(
OpCodes.TEST,
Closure.new(
environment: nil,
function: Lambda.new(
parameters: [],
body: self.action.parseTree.body
)
),
0,
ok,
ko
));
instructions.length() - 1;
}
// Execute Action (@)
ExecuteAction = Object.subtype(#ExecuteAction);
ExecuteAction.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(
OpCodes.TEST,
Closure.new(
environment: nil,
function: Lambda.new(
parameters: [],
body: self.action.parseTree.body
)
),
0,
ok,
ok
));
instructions.length() - 1;
}
// Assignment
Assignment = Object.subtype(#Assignment);
Assignment.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(OpCodes.SET, self.name, 0, ok, ok));
ok = instructions.length() - 1;
self.rule.emitByteCode(instructions, ok, ko);
instructions.length() - 1;
}
// RuleCall
RuleCall = Object.subtype(#RuleCall);
RuleCall.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(OpCodes.RULE, self.name, 0, ok, ko));
instructions.length() - 1;
}
// NamespacedRuleCall
NamespacedRuleCall = Object.subtype(#NamespacedRuleCall);
NamespacedRuleCall.emitByteCode(instructions, ok, ko) {
instructions.push(Instruction.new(OpCodes.RULE2, self.name, self.namespace, ok, ko));
instructions.length() - 1;
}
Definition = Object.subtype(#Definition);
// Initialize grammar objects
Grammar = Object.subtype(#Grammar);
Parser = Object.subtype(#Parser);
Grammar.new() {
self = super.new();
self.parser = Parser.new();
self;
}
minPegGrammar = Grammar.new();
minMetaGrammar = Grammar.new();
// ----- 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()
.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(Action.new(parseTree: `{ $$ = SetProp.new(object: p, key: i, value: e); }))
)
.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(StringLiteral.new(string: "global"))
.push(RuleCall.new(name: #ws))
.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: `{ $$ = SetGlobal.new(name: 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: #metaPrefix)))
.push(Action.new(parseTree: `{ $$ = pf; }))
);
metaPrefix =
Alternation.new()
.push(Sequence.new()
.push(RuleCall.new(name: #pplus))
.push(Assignment.new(name: #p, rule: RuleCall.new(name: #metaPrefix)))
.push(Action.new(parseTree: `{ $$ = newBinop(opPreAdd, lvalue(p), newInteger(1)) }))
)
.push(RuleCall.new(name: #metaPostfix));
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: #lbrak))
.push(Assignment.new(name: #s, rule: RuleCall.new(name: #metaExpression)))
.push(RuleCall.new(name: #rbrak))
.push(Not.new(expression: RuleCall.new(name: #assign)))
.push(Action.new(parseTree: `{ p = newGetArray(p, s) }))
)
.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: #string))
.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: `{ $$ = b; }));
string =
Sequence.new()
.push(StringLiteral.new(string: "\""))
.push(Capture.new(expression: Star.new(expression: Sequence.new()
.push(Not.new(expression: StringLiteral.new(string: "\"")))
.push(RuleCall.new(name: #char))
)))
.push(StringLiteral.new(string: "\""))
.push(RuleCall.new(name: #ws))
.push(Action.new(parseTree: `{ $$ = newStringUnescaped(yytext) }));
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(StringLiteral.new(string: "\\"))
.push(CharacterClass.new(value: "xX"))
.push(Star.new(expression: RuleCall.new(name: #higit)))
)
.push(Sequence.new()
.push(Not.new(expression: StringLiteral.new(string: "\\")))
.push(Dot.new())
);
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(Capture.new(expression:
Plus.new(expression: RuleCall.new(name: #digit)))
)
.push(RuleCall.new(name: #ws))
.push(Action.new(parseTree: `{ $$ = yytext.asInteger(10); }));
metaVar =
Alternation.new()
.push(
Sequence.new()
.push(StringLiteral.new(string: "global"))
.push(RuleCall.new(name: #ws))
.push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId)))
.push(Action.new(parseTree: `{ $$ = GetGlobal.new(name: i); }))
)
.push(
Sequence.new()
.push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId)))
.push(Action.new(parseTree: `{ $$ = GetVar.new(name: i); }))
);
metaId =
Sequence.new()
.push(Capture.new(expression: Sequence.new()
.push(RuleCall.new(name: #letter))
.push(Star.new(expression: RuleCall.new(name: #alnum)))
))
.push(RuleCall.new(name: #ws))
.push(Action.new(parseTree: `{ $$ = intern(yytext); }));
digit = CharacterClass.new(value: "0-9");
higit = CharacterClass.new(value: "0-9A-Fa-f");
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))
.push(Action.new(parseTree: `{ $$ = nil }));
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));
pplus = 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: `{ global yysval = d; }))
)
.push(Sequence.new()
.push(RuleCall.new(name: #end_of_file))
.push(Action.new(parseTree: `{ global yysval = 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(Optional.new(expression: Sequence.new()
.push(Assignment.new(name: #q, rule: RuleCall.new(name: #prefix)))
.push(Action.new(parseTree: `{ $$ = p = Sequence.new().push(p).push(q); }))
.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(Sequence.new()
.push(RuleCall.new(name: #at))
.push(Assignment.new(name: #a, rule: RuleCall.new(name: #action)))
.push(Action.new(parseTree: `{ $$ = ExecuteAction.new(action: a); }))
)
.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(Assignment.new(name: #e, rule: RuleCall.new(name: #expression)))
.push(RuleCall.new(name: #end))
.push(Action.new(parseTree: `{ $$ = Capture.new(expression: e); }))
);
identifier =
Sequence.new()
.push(Capture.new(expression: Sequence.new()
.push(CharacterClass.new(value: "-a-zA-Z_"))
.push(Star.new(expression: CharacterClass.new(value: "-a-zA-Z_0-9")))
))
.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: GetProp.new(object: GetVar.new(name: n), key: #parser).__eval__(),
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(Capture.new(expression:
Star.new(expression: Sequence.new()
.push(Not.new(expression: CharacterClass.new(value: "\'")))
.push(RuleCall.new(name: #char)))
))
.push(CharacterClass.new(value: "\'"))
.push(RuleCall.new(name: #ws))
.push(Action.new(parseTree: `{ $$ = StringLiteral.new(string: yytext.unescaped()); }))
)
.push(Sequence.new()
.push(CharacterClass.new(value: "\""))
.push(Capture.new(expression:
Star.new(expression: Sequence.new()
.push(Not.new(expression: CharacterClass.new(value: "\"")))
.push(RuleCall.new(name: #char)))
))
.push(CharacterClass.new(value: "\""))
.push(RuleCall.new(name: #ws))
.push(Action.new(parseTree: `{ $$ = StringLiteral.new(string: yytext.unescaped()); }))
);
class =
Sequence.new()
.push(StringLiteral.new(string: "["))
.push(Capture.new(expression:
Star.new(expression: Sequence.new()
.push(Not.new(expression: StringLiteral.new(string: "]")))
.push(RuleCall.new(name: #range)))
))
.push(StringLiteral.new(string: "]"))
.push(RuleCall.new(name: #ws))
.push(Action.new(parseTree: `{ $$ = CharacterClass.new(value: yytext.unescaped()); }));
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: minMetaGrammar.parser, name: #block)))
.push(RuleCall.new(name: #ws))
.push(Action.new(parseTree: `{ $$ = Action.new(parseTree: Block.new(body: 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));
at = 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))
);
without(all: 1);
// Functions for minproto parser
Object_push(o, v) {
o.push(v);
o;
}
Object_put(o, k, v) {
o[k] = v;
o;
}
global pObject = Object;
new(_) {
[];
}
_get(obj, _, __) {
obj;
}
expected(what, where)
{
error("syntax error: " + what + " expected near: " + where);
}
syntaxError(str) {
error("syntax error: " + str);
}
newWhile(cond, stmt) {
While.new(condition: cond, body: stmt);
}
newIf(c, s, t) {
If.new(condition: c, consequent: s, alternate: t);
}
newContinue() {
Continue.new();
}
newBreak(e) {
Break.new(value: e);
}
newReturn(e) {
Return.new(value: e);
}
newForIn(i, e, s) {
ForIn.new(identifier: i, expression: e, body: s);
}
newForFromTo(i, a, b, s) {
ForFromTo.new(identifier: i, first: a, last: b, body: s);
}
newFor(i, c, u, s) {
For.new(initialise: i, condition: c, update: u, body: s);
}
newTryCatch(t, i, c) {
TryCatch.new(statement: t, identifier: i, handler: c);
}
newTryEnsure(t, e) {
TryEnsure.new(statement: t, handler: e);
}
newRaise(e) {
Raise.new(value: e);
}
newLambda(p, b, par, n) {
Lambda.new(parameters: p, body: b, parent: par, name: n);
}
newGetLocal(i) {
GetLocal.new(name: i);
}
newSetLocal(i, v) {
SetLocal.new(name: i, value: v);
}
newGetGlobal(i) {
GetGlobal.new(name: i);
}
newSetGlobal(i, v) {
SetGlobal.new(name: i, value: v);
}
newGetVar(i) {
GetVar.new(name: i);
}
newSetVar(i, v) {
SetVar.new(name: i, value: v);
}
newGetProp(v, j) {
GetProp.new(object: v, key: j);
}
newSetProp(o, k, v) {
SetProp.new(object: o, key: k, value: v);
}
newBlock(b) {
Block.new(body: b);
}
newUnyop(o, p) {
Unyop.new(operation: o).push(p);
}
neg(n) {
Unyop.new(operation: opNeg).push(n);
}
newSuper(i, a) {
Super.new(method: i, arguments: a);
}
newGetArray(p, e) {
GetArray.new(object: p, index: e);
}
newGetSlice(o, s, e) {
GetSlice.new(object: o, start: s, stop: e);
}
newInvoke(p, i, a) {
Invoke.new(self: p, method: i, arguments: a);
}
newLiteral(o) {
Literal.new(object: o);
}
newFloat(f) {
f;
}
strtod(text, _) {
text.asFloat();
}
newInteger(i) {
i;
}
strtol(text, _, base) {
text.asInteger(base)
}
newStringUnescaped(text) {
text.unescaped();
}
//--------------------------------------------------------------------------------------------------
Parser.__update(ruleName, ruleExpression, v: false) {
local instructions = [];
instructions.push(Instruction.new(OpCodes.FAIL, nil, 0, 0, 0));
local ko = instructions.length() - 1;
instructions.push(Instruction.new(OpCodes.SUCCEED, nil, 0, 0, 0));
local ok = instructions.length() - 1;
ruleExpression.emitByteCode(instructions, ok, ko);
for (n from 0 to (instructions.length() - 1 - ((instructions.length() - 1) % 2)) / 2) {
local i = instructions[n];
instructions[n] = instructions[instructions.length() - 1 - n];
instructions[instructions.length() - 1 - n] = i;
}
if (v) {
println(ruleName);
}
for (n in instructions.length()) {
i = instructions[n];
i.ok = instructions.length() - 1 - i.ok;
i.ko = instructions.length() - 1 - i.ko;
if (v) {
print(" ", { if (n < 100) { "0" } else { "" } }, { if (n < 10) { "0" } else { "" } }, n, " ");
i.printline();
}
}
self[ruleName] = [];
for (instruction in instructions) {
self[ruleName].push(instruction.op);
self[ruleName].push(instruction.arg);
self[ruleName].push(instruction.arglen);
self[ruleName].push(instruction.ok);
self[ruleName].push(instruction.ko);
}
}
Grammar.addRule(ruleName, ruleExpression, v: false) {
self[ruleName] = ruleExpression;
self[ruleName].parser = self.parser;
self[ruleName].name = ruleName;
self.parser.__update(ruleName, ruleExpression, v: v);
}
// Grammar object construction
for (ruleName in __namespaces__.HardCodedPeg.keys()) {
if (ruleName == #__nsname__) continue;
minPegGrammar.addRule(ruleName, __namespaces__.HardCodedPeg[ruleName]);
}
for (ruleName in __namespaces__.HardCodedMeta.keys()) {
if (ruleName == #__nsname__) continue;
minMetaGrammar.addRule(ruleName, __namespaces__.HardCodedMeta[ruleName]);
}
minPegGrammar.parser.__delegate__ = minMetaGrammar.parser;
// Parsing function
parse(input, grammar, startRule, resultCallback){
local cursor = 0;
matchedCharacters = __match__(grammar.parser, startRule, input, cursor);
cursor += matchedCharacters;
while (yysval != 0 && yysval != nil && matchedCharacters >= 0) {
resultCallback(yysval);
matchedCharacters = __match__(grammar.parser, startRule, input, cursor);
cursor += matchedCharacters;
}
}
input = readfile("minproto.grammar");
metaGrammar = Grammar.new();
global lineno = 0; // This is for the grammar above
// How to read the following function call :
// parse input with minPegGrammar starting with rule grammar applying this function to each result
parse(input, minPegGrammar, #grammar, (result){ metaGrammar.addRule(result.name, result.expression) });
input = readfile("rawgrammar.leg");
pegGrammar = Grammar.new();
parse(input, minPegGrammar, #grammar, (result){ pegGrammar.addRule(result.name, result.expression) });
circularityTest = false;
//circularityTest = true;
if (circularityTest) {
compareGrammars(grammar1, grammar2) {
for (rule in grammar1.parser.keys()) {
if (grammar1.parser[rule].length() != grammar2.parser[rule].length()) {
print("Unmatching lengths for rule ", rule, "\n");
return false;
}
for (i in grammar1[rule].length()) {
if (codeString(grammar1.parser[rule][i]) != codeString(grammar2.parser[rule][i])) {
print("Unmatching contents for rule ", rule, " at index ", i, ":\n",
grammar1.parser[rule][i], "\n", grammar2.parser[rule][i], "\n");
return false;
}
}
}
return true;
}
input = readfile("rawgrammar.leg");
pegGrammarCircular = Grammar.new();
parse(input, pegGrammar, #grammar, (result){ pegGrammarCircular.addRule(result.name, result.expression) });
input = readfile("minproto.grammar");
metaGrammarCircular = Grammar.new();
parse(input, pegGrammar, #grammar, (result){ metaGrammarCircular.addRule(result.name, result.expression) });
if (compareGrammars(pegGrammar, pegGrammarCircular))
print("Grammars pegGrammar and pegGrammarCircular are equal\n");
if (compareGrammars(metaGrammar, metaGrammarCircular))
print("Grammars metaGrammar and metaGrammarCircular are equal\n");
}
input = readfile("dowhile.meta");
parse(input, metaGrammar, #start, (result){ eval(result, env: nil) });
input = readfile("fstring.meta");
parse(input, metaGrammar, #start, (result){ eval(result, env: nil) });