|
|
|
@ -188,431 +188,431 @@ let visitor = require("../visitor");
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// silentFails--;
|
|
|
|
// silentFails--;
|
|
|
|
function generateBytecode(ast) {
|
|
|
|
function generateBytecode(ast) {
|
|
|
|
let consts = [];
|
|
|
|
let consts = [];
|
|
|
|
|
|
|
|
|
|
|
|
function addConst(value) {
|
|
|
|
function addConst(value) {
|
|
|
|
let index = consts.indexOf(value);
|
|
|
|
let index = consts.indexOf(value);
|
|
|
|
|
|
|
|
|
|
|
|
return index === -1 ? consts.push(value) - 1 : index;
|
|
|
|
return index === -1 ? consts.push(value) - 1 : index;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function addFunctionConst(params, code) {
|
|
|
|
function addFunctionConst(params, code) {
|
|
|
|
return addConst(
|
|
|
|
return addConst(
|
|
|
|
"function(" + params.join(", ") + ") {" + code + "}"
|
|
|
|
"function(" + params.join(", ") + ") {" + code + "}"
|
|
|
|
);
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function cloneEnv(env) {
|
|
|
|
function cloneEnv(env) {
|
|
|
|
let clone = {};
|
|
|
|
let clone = {};
|
|
|
|
|
|
|
|
|
|
|
|
Object.keys(env).forEach(name => {
|
|
|
|
Object.keys(env).forEach(name => {
|
|
|
|
clone[name] = env[name];
|
|
|
|
clone[name] = env[name];
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
return clone;
|
|
|
|
return clone;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function buildSequence() {
|
|
|
|
function buildSequence() {
|
|
|
|
return Array.prototype.concat.apply([], arguments);
|
|
|
|
return Array.prototype.concat.apply([], arguments);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function buildCondition(condCode, thenCode, elseCode) {
|
|
|
|
function buildCondition(condCode, thenCode, elseCode) {
|
|
|
|
return condCode.concat(
|
|
|
|
return condCode.concat(
|
|
|
|
[thenCode.length, elseCode.length],
|
|
|
|
[thenCode.length, elseCode.length],
|
|
|
|
thenCode,
|
|
|
|
thenCode,
|
|
|
|
elseCode
|
|
|
|
elseCode
|
|
|
|
);
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function buildLoop(condCode, bodyCode) {
|
|
|
|
function buildLoop(condCode, bodyCode) {
|
|
|
|
return condCode.concat([bodyCode.length], bodyCode);
|
|
|
|
return condCode.concat([bodyCode.length], bodyCode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function buildCall(functionIndex, delta, env, sp) {
|
|
|
|
function buildCall(functionIndex, delta, env, sp) {
|
|
|
|
let params = Object.keys(env).map(name => sp - env[name]);
|
|
|
|
let params = Object.keys(env).map(name => sp - env[name]);
|
|
|
|
|
|
|
|
|
|
|
|
return [op.CALL, functionIndex, delta, params.length].concat(params);
|
|
|
|
return [op.CALL, functionIndex, delta, params.length].concat(params);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function buildSimplePredicate(expression, negative, context) {
|
|
|
|
function buildSimplePredicate(expression, negative, context) {
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
[op.PUSH_CURR_POS],
|
|
|
|
[op.PUSH_CURR_POS],
|
|
|
|
[op.SILENT_FAILS_ON],
|
|
|
|
[op.SILENT_FAILS_ON],
|
|
|
|
generate(expression, {
|
|
|
|
generate(expression, {
|
|
|
|
sp: context.sp + 1,
|
|
|
|
sp: context.sp + 1,
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
action: null
|
|
|
|
action: null
|
|
|
|
}),
|
|
|
|
}),
|
|
|
|
[op.SILENT_FAILS_OFF],
|
|
|
|
[op.SILENT_FAILS_OFF],
|
|
|
|
buildCondition(
|
|
|
|
buildCondition(
|
|
|
|
[negative ? op.IF_ERROR : op.IF_NOT_ERROR],
|
|
|
|
[negative ? op.IF_ERROR : op.IF_NOT_ERROR],
|
|
|
|
buildSequence(
|
|
|
|
buildSequence(
|
|
|
|
[op.POP],
|
|
|
|
[op.POP],
|
|
|
|
[negative ? op.POP : op.POP_CURR_POS],
|
|
|
|
[negative ? op.POP : op.POP_CURR_POS],
|
|
|
|
[op.PUSH_UNDEFINED]
|
|
|
|
[op.PUSH_UNDEFINED]
|
|
|
|
),
|
|
|
|
),
|
|
|
|
buildSequence(
|
|
|
|
buildSequence(
|
|
|
|
[op.POP],
|
|
|
|
[op.POP],
|
|
|
|
[negative ? op.POP_CURR_POS : op.POP],
|
|
|
|
[negative ? op.POP_CURR_POS : op.POP],
|
|
|
|
[op.PUSH_FAILED]
|
|
|
|
[op.PUSH_FAILED]
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function buildSemanticPredicate(code, negative, context) {
|
|
|
|
function buildSemanticPredicate(code, negative, context) {
|
|
|
|
let functionIndex = addFunctionConst(Object.keys(context.env), code);
|
|
|
|
let functionIndex = addFunctionConst(Object.keys(context.env), code);
|
|
|
|
|
|
|
|
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
[op.UPDATE_SAVED_POS],
|
|
|
|
[op.UPDATE_SAVED_POS],
|
|
|
|
buildCall(functionIndex, 0, context.env, context.sp),
|
|
|
|
buildCall(functionIndex, 0, context.env, context.sp),
|
|
|
|
buildCondition(
|
|
|
|
buildCondition(
|
|
|
|
[op.IF],
|
|
|
|
[op.IF],
|
|
|
|
buildSequence(
|
|
|
|
buildSequence(
|
|
|
|
[op.POP],
|
|
|
|
[op.POP],
|
|
|
|
negative ? [op.PUSH_FAILED] : [op.PUSH_UNDEFINED]
|
|
|
|
negative ? [op.PUSH_FAILED] : [op.PUSH_UNDEFINED]
|
|
|
|
),
|
|
|
|
),
|
|
|
|
buildSequence(
|
|
|
|
buildSequence(
|
|
|
|
[op.POP],
|
|
|
|
[op.POP],
|
|
|
|
negative ? [op.PUSH_UNDEFINED] : [op.PUSH_FAILED]
|
|
|
|
negative ? [op.PUSH_UNDEFINED] : [op.PUSH_FAILED]
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function buildAppendLoop(expressionCode) {
|
|
|
|
function buildAppendLoop(expressionCode) {
|
|
|
|
return buildLoop(
|
|
|
|
return buildLoop(
|
|
|
|
[op.WHILE_NOT_ERROR],
|
|
|
|
[op.WHILE_NOT_ERROR],
|
|
|
|
buildSequence([op.APPEND], expressionCode)
|
|
|
|
buildSequence([op.APPEND], expressionCode)
|
|
|
|
);
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
let generate = visitor.build({
|
|
|
|
let generate = visitor.build({
|
|
|
|
grammar(node) {
|
|
|
|
grammar(node) {
|
|
|
|
node.rules.forEach(generate);
|
|
|
|
node.rules.forEach(generate);
|
|
|
|
|
|
|
|
|
|
|
|
node.consts = consts;
|
|
|
|
node.consts = consts;
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
rule(node) {
|
|
|
|
rule(node) {
|
|
|
|
node.bytecode = generate(node.expression, {
|
|
|
|
node.bytecode = generate(node.expression, {
|
|
|
|
sp: -1, // stack pointer
|
|
|
|
sp: -1, // stack pointer
|
|
|
|
env: { }, // mapping of label names to stack positions
|
|
|
|
env: { }, // mapping of label names to stack positions
|
|
|
|
action: null // action nodes pass themselves to children here
|
|
|
|
action: null // action nodes pass themselves to children here
|
|
|
|
});
|
|
|
|
});
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
named(node, context) {
|
|
|
|
named(node, context) {
|
|
|
|
let nameIndex = addConst(
|
|
|
|
let nameIndex = addConst(
|
|
|
|
"peg$otherExpectation(\"" + js.stringEscape(node.name) + "\")"
|
|
|
|
"peg$otherExpectation(\"" + js.stringEscape(node.name) + "\")"
|
|
|
|
);
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
|
|
// The code generated below is slightly suboptimal because |FAIL| pushes
|
|
|
|
// The code generated below is slightly suboptimal because |FAIL| pushes
|
|
|
|
// to the stack, so we need to stick a |POP| in front of it. We lack a
|
|
|
|
// to the stack, so we need to stick a |POP| in front of it. We lack a
|
|
|
|
// dedicated instruction that would just report the failure and not touch
|
|
|
|
// dedicated instruction that would just report the failure and not touch
|
|
|
|
// the stack.
|
|
|
|
// the stack.
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
[op.SILENT_FAILS_ON],
|
|
|
|
[op.SILENT_FAILS_ON],
|
|
|
|
generate(node.expression, context),
|
|
|
|
generate(node.expression, context),
|
|
|
|
[op.SILENT_FAILS_OFF],
|
|
|
|
[op.SILENT_FAILS_OFF],
|
|
|
|
buildCondition([op.IF_ERROR], [op.FAIL, nameIndex], [])
|
|
|
|
buildCondition([op.IF_ERROR], [op.FAIL, nameIndex], [])
|
|
|
|
);
|
|
|
|
);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
choice(node, context) {
|
|
|
|
choice(node, context) {
|
|
|
|
function buildAlternativesCode(alternatives, context) {
|
|
|
|
function buildAlternativesCode(alternatives, context) {
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
generate(alternatives[0], {
|
|
|
|
generate(alternatives[0], {
|
|
|
|
sp: context.sp,
|
|
|
|
sp: context.sp,
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
action: null
|
|
|
|
action: null
|
|
|
|
}),
|
|
|
|
}),
|
|
|
|
alternatives.length > 1
|
|
|
|
alternatives.length > 1
|
|
|
|
? buildCondition(
|
|
|
|
? buildCondition(
|
|
|
|
[op.IF_ERROR],
|
|
|
|
[op.IF_ERROR],
|
|
|
|
buildSequence(
|
|
|
|
buildSequence(
|
|
|
|
[op.POP],
|
|
|
|
[op.POP],
|
|
|
|
buildAlternativesCode(alternatives.slice(1), context)
|
|
|
|
buildAlternativesCode(alternatives.slice(1), context)
|
|
|
|
),
|
|
|
|
),
|
|
|
|
[]
|
|
|
|
[]
|
|
|
|
)
|
|
|
|
)
|
|
|
|
: []
|
|
|
|
: []
|
|
|
|
);
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return buildAlternativesCode(node.alternatives, context);
|
|
|
|
return buildAlternativesCode(node.alternatives, context);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
action(node, context) {
|
|
|
|
action(node, context) {
|
|
|
|
let env = cloneEnv(context.env);
|
|
|
|
let env = cloneEnv(context.env);
|
|
|
|
let emitCall = node.expression.type !== "sequence"
|
|
|
|
let emitCall = node.expression.type !== "sequence"
|
|
|
|
|| node.expression.elements.length === 0;
|
|
|
|
|| node.expression.elements.length === 0;
|
|
|
|
let expressionCode = generate(node.expression, {
|
|
|
|
let expressionCode = generate(node.expression, {
|
|
|
|
sp: context.sp + (emitCall ? 1 : 0),
|
|
|
|
sp: context.sp + (emitCall ? 1 : 0),
|
|
|
|
env: env,
|
|
|
|
env: env,
|
|
|
|
action: node
|
|
|
|
action: node
|
|
|
|
});
|
|
|
|
});
|
|
|
|
let functionIndex = addFunctionConst(Object.keys(env), node.code);
|
|
|
|
let functionIndex = addFunctionConst(Object.keys(env), node.code);
|
|
|
|
|
|
|
|
|
|
|
|
return emitCall
|
|
|
|
return emitCall
|
|
|
|
? buildSequence(
|
|
|
|
? buildSequence(
|
|
|
|
[op.PUSH_CURR_POS],
|
|
|
|
[op.PUSH_CURR_POS],
|
|
|
|
expressionCode,
|
|
|
|
expressionCode,
|
|
|
|
buildCondition(
|
|
|
|
buildCondition(
|
|
|
|
[op.IF_NOT_ERROR],
|
|
|
|
[op.IF_NOT_ERROR],
|
|
|
|
buildSequence(
|
|
|
|
buildSequence(
|
|
|
|
[op.LOAD_SAVED_POS, 1],
|
|
|
|
[op.LOAD_SAVED_POS, 1],
|
|
|
|
buildCall(functionIndex, 1, env, context.sp + 2)
|
|
|
|
buildCall(functionIndex, 1, env, context.sp + 2)
|
|
|
|
),
|
|
|
|
),
|
|
|
|
[]
|
|
|
|
[]
|
|
|
|
),
|
|
|
|
),
|
|
|
|
[op.NIP]
|
|
|
|
[op.NIP]
|
|
|
|
)
|
|
|
|
)
|
|
|
|
: expressionCode;
|
|
|
|
: expressionCode;
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
sequence(node, context) {
|
|
|
|
sequence(node, context) {
|
|
|
|
function buildElementsCode(elements, context) {
|
|
|
|
function buildElementsCode(elements, context) {
|
|
|
|
if (elements.length > 0) {
|
|
|
|
if (elements.length > 0) {
|
|
|
|
let processedCount = node.elements.length - elements.slice(1).length;
|
|
|
|
let processedCount = node.elements.length - elements.slice(1).length;
|
|
|
|
|
|
|
|
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
generate(elements[0], {
|
|
|
|
generate(elements[0], {
|
|
|
|
sp: context.sp,
|
|
|
|
sp: context.sp,
|
|
|
|
env: context.env,
|
|
|
|
env: context.env,
|
|
|
|
action: null
|
|
|
|
action: null
|
|
|
|
}),
|
|
|
|
}),
|
|
|
|
buildCondition(
|
|
|
|
buildCondition(
|
|
|
|
[op.IF_NOT_ERROR],
|
|
|
|
[op.IF_NOT_ERROR],
|
|
|
|
buildElementsCode(elements.slice(1), {
|
|
|
|
buildElementsCode(elements.slice(1), {
|
|
|
|
sp: context.sp + 1,
|
|
|
|
sp: context.sp + 1,
|
|
|
|
env: context.env,
|
|
|
|
env: context.env,
|
|
|
|
action: context.action
|
|
|
|
action: context.action
|
|
|
|
}),
|
|
|
|
}),
|
|
|
|
buildSequence(
|
|
|
|
buildSequence(
|
|
|
|
processedCount > 1 ? [op.POP_N, processedCount] : [op.POP],
|
|
|
|
processedCount > 1 ? [op.POP_N, processedCount] : [op.POP],
|
|
|
|
[op.POP_CURR_POS],
|
|
|
|
[op.POP_CURR_POS],
|
|
|
|
[op.PUSH_FAILED]
|
|
|
|
[op.PUSH_FAILED]
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
if (context.action) {
|
|
|
|
if (context.action) {
|
|
|
|
let functionIndex = addFunctionConst(
|
|
|
|
let functionIndex = addFunctionConst(
|
|
|
|
Object.keys(context.env),
|
|
|
|
Object.keys(context.env),
|
|
|
|
context.action.code
|
|
|
|
context.action.code
|
|
|
|
);
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
[op.LOAD_SAVED_POS, node.elements.length],
|
|
|
|
[op.LOAD_SAVED_POS, node.elements.length],
|
|
|
|
buildCall(
|
|
|
|
buildCall(
|
|
|
|
functionIndex,
|
|
|
|
functionIndex,
|
|
|
|
node.elements.length,
|
|
|
|
node.elements.length,
|
|
|
|
context.env,
|
|
|
|
context.env,
|
|
|
|
context.sp
|
|
|
|
context.sp
|
|
|
|
),
|
|
|
|
),
|
|
|
|
[op.NIP]
|
|
|
|
[op.NIP]
|
|
|
|
);
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
return buildSequence([op.WRAP, node.elements.length], [op.NIP]);
|
|
|
|
return buildSequence([op.WRAP, node.elements.length], [op.NIP]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
[op.PUSH_CURR_POS],
|
|
|
|
[op.PUSH_CURR_POS],
|
|
|
|
buildElementsCode(node.elements, {
|
|
|
|
buildElementsCode(node.elements, {
|
|
|
|
sp: context.sp + 1,
|
|
|
|
sp: context.sp + 1,
|
|
|
|
env: context.env,
|
|
|
|
env: context.env,
|
|
|
|
action: context.action
|
|
|
|
action: context.action
|
|
|
|
})
|
|
|
|
})
|
|
|
|
);
|
|
|
|
);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
labeled(node, context) {
|
|
|
|
labeled(node, context) {
|
|
|
|
let env = cloneEnv(context.env);
|
|
|
|
let env = cloneEnv(context.env);
|
|
|
|
|
|
|
|
|
|
|
|
context.env[node.label] = context.sp + 1;
|
|
|
|
context.env[node.label] = context.sp + 1;
|
|
|
|
|
|
|
|
|
|
|
|
return generate(node.expression, {
|
|
|
|
return generate(node.expression, {
|
|
|
|
sp: context.sp,
|
|
|
|
sp: context.sp,
|
|
|
|
env: env,
|
|
|
|
env: env,
|
|
|
|
action: null
|
|
|
|
action: null
|
|
|
|
});
|
|
|
|
});
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
text(node, context) {
|
|
|
|
text(node, context) {
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
[op.PUSH_CURR_POS],
|
|
|
|
[op.PUSH_CURR_POS],
|
|
|
|
generate(node.expression, {
|
|
|
|
generate(node.expression, {
|
|
|
|
sp: context.sp + 1,
|
|
|
|
sp: context.sp + 1,
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
action: null
|
|
|
|
action: null
|
|
|
|
}),
|
|
|
|
}),
|
|
|
|
buildCondition(
|
|
|
|
buildCondition(
|
|
|
|
[op.IF_NOT_ERROR],
|
|
|
|
[op.IF_NOT_ERROR],
|
|
|
|
buildSequence([op.POP], [op.TEXT]),
|
|
|
|
buildSequence([op.POP], [op.TEXT]),
|
|
|
|
[op.NIP]
|
|
|
|
[op.NIP]
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
simple_and(node, context) {
|
|
|
|
simple_and(node, context) {
|
|
|
|
return buildSimplePredicate(node.expression, false, context);
|
|
|
|
return buildSimplePredicate(node.expression, false, context);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
simple_not(node, context) {
|
|
|
|
simple_not(node, context) {
|
|
|
|
return buildSimplePredicate(node.expression, true, context);
|
|
|
|
return buildSimplePredicate(node.expression, true, context);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
optional(node, context) {
|
|
|
|
optional(node, context) {
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
generate(node.expression, {
|
|
|
|
generate(node.expression, {
|
|
|
|
sp: context.sp,
|
|
|
|
sp: context.sp,
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
action: null
|
|
|
|
action: null
|
|
|
|
}),
|
|
|
|
}),
|
|
|
|
buildCondition(
|
|
|
|
buildCondition(
|
|
|
|
[op.IF_ERROR],
|
|
|
|
[op.IF_ERROR],
|
|
|
|
buildSequence([op.POP], [op.PUSH_NULL]),
|
|
|
|
buildSequence([op.POP], [op.PUSH_NULL]),
|
|
|
|
[]
|
|
|
|
[]
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
zero_or_more(node, context) {
|
|
|
|
zero_or_more(node, context) {
|
|
|
|
let expressionCode = generate(node.expression, {
|
|
|
|
let expressionCode = generate(node.expression, {
|
|
|
|
sp: context.sp + 1,
|
|
|
|
sp: context.sp + 1,
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
action: null
|
|
|
|
action: null
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
[op.PUSH_EMPTY_ARRAY],
|
|
|
|
[op.PUSH_EMPTY_ARRAY],
|
|
|
|
expressionCode,
|
|
|
|
expressionCode,
|
|
|
|
buildAppendLoop(expressionCode),
|
|
|
|
buildAppendLoop(expressionCode),
|
|
|
|
[op.POP]
|
|
|
|
[op.POP]
|
|
|
|
);
|
|
|
|
);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
one_or_more(node, context) {
|
|
|
|
one_or_more(node, context) {
|
|
|
|
let expressionCode = generate(node.expression, {
|
|
|
|
let expressionCode = generate(node.expression, {
|
|
|
|
sp: context.sp + 1,
|
|
|
|
sp: context.sp + 1,
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
action: null
|
|
|
|
action: null
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
return buildSequence(
|
|
|
|
return buildSequence(
|
|
|
|
[op.PUSH_EMPTY_ARRAY],
|
|
|
|
[op.PUSH_EMPTY_ARRAY],
|
|
|
|
expressionCode,
|
|
|
|
expressionCode,
|
|
|
|
buildCondition(
|
|
|
|
buildCondition(
|
|
|
|
[op.IF_NOT_ERROR],
|
|
|
|
[op.IF_NOT_ERROR],
|
|
|
|
buildSequence(buildAppendLoop(expressionCode), [op.POP]),
|
|
|
|
buildSequence(buildAppendLoop(expressionCode), [op.POP]),
|
|
|
|
buildSequence([op.POP], [op.POP], [op.PUSH_FAILED])
|
|
|
|
buildSequence([op.POP], [op.POP], [op.PUSH_FAILED])
|
|
|
|
)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
group(node, context) {
|
|
|
|
group(node, context) {
|
|
|
|
return generate(node.expression, {
|
|
|
|
return generate(node.expression, {
|
|
|
|
sp: context.sp,
|
|
|
|
sp: context.sp,
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
env: cloneEnv(context.env),
|
|
|
|
action: null
|
|
|
|
action: null
|
|
|
|
});
|
|
|
|
});
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
semantic_and(node, context) {
|
|
|
|
semantic_and(node, context) {
|
|
|
|
return buildSemanticPredicate(node.code, false, context);
|
|
|
|
return buildSemanticPredicate(node.code, false, context);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
semantic_not(node, context) {
|
|
|
|
semantic_not(node, context) {
|
|
|
|
return buildSemanticPredicate(node.code, true, context);
|
|
|
|
return buildSemanticPredicate(node.code, true, context);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
rule_ref(node) {
|
|
|
|
rule_ref(node) {
|
|
|
|
return [op.RULE, asts.indexOfRule(ast, node.name)];
|
|
|
|
return [op.RULE, asts.indexOfRule(ast, node.name)];
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
literal(node) {
|
|
|
|
literal(node) {
|
|
|
|
if (node.value.length > 0) {
|
|
|
|
if (node.value.length > 0) {
|
|
|
|
let stringIndex = addConst("\""
|
|
|
|
let stringIndex = addConst("\""
|
|
|
|
+ js.stringEscape(
|
|
|
|
+ js.stringEscape(
|
|
|
|
node.ignoreCase ? node.value.toLowerCase() : node.value
|
|
|
|
node.ignoreCase ? node.value.toLowerCase() : node.value
|
|
|
|
)
|
|
|
|
)
|
|
|
|
+ "\""
|
|
|
|
+ "\""
|
|
|
|
);
|
|
|
|
);
|
|
|
|
let expectedIndex = addConst(
|
|
|
|
let expectedIndex = addConst(
|
|
|
|
"peg$literalExpectation("
|
|
|
|
"peg$literalExpectation("
|
|
|
|
+ "\"" + js.stringEscape(node.value) + "\", "
|
|
|
|
+ "\"" + js.stringEscape(node.value) + "\", "
|
|
|
|
+ node.ignoreCase
|
|
|
|
+ node.ignoreCase
|
|
|
|
+ ")"
|
|
|
|
+ ")"
|
|
|
|
);
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
|
|
// For case-sensitive strings the value must match the beginning of the
|
|
|
|
// For case-sensitive strings the value must match the beginning of the
|
|
|
|
// remaining input exactly. As a result, we can use |ACCEPT_STRING| and
|
|
|
|
// remaining input exactly. As a result, we can use |ACCEPT_STRING| and
|
|
|
|
// save one |substr| call that would be needed if we used |ACCEPT_N|.
|
|
|
|
// save one |substr| call that would be needed if we used |ACCEPT_N|.
|
|
|
|
return buildCondition(
|
|
|
|
return buildCondition(
|
|
|
|
node.ignoreCase
|
|
|
|
node.ignoreCase
|
|
|
|
? [op.MATCH_STRING_IC, stringIndex]
|
|
|
|
? [op.MATCH_STRING_IC, stringIndex]
|
|
|
|
: [op.MATCH_STRING, stringIndex],
|
|
|
|
: [op.MATCH_STRING, stringIndex],
|
|
|
|
node.ignoreCase
|
|
|
|
node.ignoreCase
|
|
|
|
? [op.ACCEPT_N, node.value.length]
|
|
|
|
? [op.ACCEPT_N, node.value.length]
|
|
|
|
: [op.ACCEPT_STRING, stringIndex],
|
|
|
|
: [op.ACCEPT_STRING, stringIndex],
|
|
|
|
[op.FAIL, expectedIndex]
|
|
|
|
[op.FAIL, expectedIndex]
|
|
|
|
);
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
let stringIndex = addConst("\"\"");
|
|
|
|
let stringIndex = addConst("\"\"");
|
|
|
|
|
|
|
|
|
|
|
|
return [op.PUSH, stringIndex];
|
|
|
|
return [op.PUSH, stringIndex];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
class(node) {
|
|
|
|
class(node) {
|
|
|
|
let regexp = "/^["
|
|
|
|
let regexp = "/^["
|
|
|
|
+ (node.inverted ? "^" : "")
|
|
|
|
+ (node.inverted ? "^" : "")
|
|
|
|
+ node.parts.map(part =>
|
|
|
|
+ node.parts.map(part =>
|
|
|
|
Array.isArray(part)
|
|
|
|
Array.isArray(part)
|
|
|
|
? js.regexpClassEscape(part[0])
|
|
|
|
? js.regexpClassEscape(part[0])
|
|
|
|
+ "-"
|
|
|
|
+ "-"
|
|
|
|
+ js.regexpClassEscape(part[1])
|
|
|
|
+ js.regexpClassEscape(part[1])
|
|
|
|
: js.regexpClassEscape(part)
|
|
|
|
: js.regexpClassEscape(part)
|
|
|
|
).join("")
|
|
|
|
).join("")
|
|
|
|
+ "]/" + (node.ignoreCase ? "i" : "");
|
|
|
|
+ "]/" + (node.ignoreCase ? "i" : "");
|
|
|
|
let parts = "["
|
|
|
|
let parts = "["
|
|
|
|
+ node.parts.map(part =>
|
|
|
|
+ node.parts.map(part =>
|
|
|
|
Array.isArray(part)
|
|
|
|
Array.isArray(part)
|
|
|
|
? "[\"" + js.stringEscape(part[0]) + "\", \"" + js.stringEscape(part[1]) + "\"]"
|
|
|
|
? "[\"" + js.stringEscape(part[0]) + "\", \"" + js.stringEscape(part[1]) + "\"]"
|
|
|
|
: "\"" + js.stringEscape(part) + "\""
|
|
|
|
: "\"" + js.stringEscape(part) + "\""
|
|
|
|
).join(", ")
|
|
|
|
).join(", ")
|
|
|
|
+ "]";
|
|
|
|
+ "]";
|
|
|
|
let regexpIndex = addConst(regexp);
|
|
|
|
let regexpIndex = addConst(regexp);
|
|
|
|
let expectedIndex = addConst(
|
|
|
|
let expectedIndex = addConst(
|
|
|
|
"peg$classExpectation("
|
|
|
|
"peg$classExpectation("
|
|
|
|
+ parts + ", "
|
|
|
|
+ parts + ", "
|
|
|
|
+ node.inverted + ", "
|
|
|
|
+ node.inverted + ", "
|
|
|
|
+ node.ignoreCase
|
|
|
|
+ node.ignoreCase
|
|
|
|
+ ")"
|
|
|
|
+ ")"
|
|
|
|
);
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
|
|
return buildCondition(
|
|
|
|
return buildCondition(
|
|
|
|
[op.MATCH_REGEXP, regexpIndex],
|
|
|
|
[op.MATCH_REGEXP, regexpIndex],
|
|
|
|
[op.ACCEPT_N, 1],
|
|
|
|
[op.ACCEPT_N, 1],
|
|
|
|
[op.FAIL, expectedIndex]
|
|
|
|
[op.FAIL, expectedIndex]
|
|
|
|
);
|
|
|
|
);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
|
|
any() {
|
|
|
|
any() {
|
|
|
|
let expectedIndex = addConst("peg$anyExpectation()");
|
|
|
|
let expectedIndex = addConst("peg$anyExpectation()");
|
|
|
|
|
|
|
|
|
|
|
|
return buildCondition(
|
|
|
|
return buildCondition(
|
|
|
|
[op.MATCH_ANY],
|
|
|
|
[op.MATCH_ANY],
|
|
|
|
[op.ACCEPT_N, 1],
|
|
|
|
[op.ACCEPT_N, 1],
|
|
|
|
[op.FAIL, expectedIndex]
|
|
|
|
[op.FAIL, expectedIndex]
|
|
|
|
);
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
generate(ast);
|
|
|
|
generate(ast);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
module.exports = generateBytecode;
|
|
|
|
module.exports = generateBytecode;
|
|
|
|
|
