2016-03-18 21:00:51 +00:00
|
|
|
// Compile ES5+Syndicate to plain ES5.
|
|
|
|
|
|
|
|
'use strict';
|
|
|
|
|
|
|
|
var fs = require('fs');
|
|
|
|
var path = require('path');
|
|
|
|
|
|
|
|
var ohm = require('ohm-js');
|
2016-03-19 18:49:44 +00:00
|
|
|
var ES5 = require('./es5.js');
|
2016-03-18 21:00:51 +00:00
|
|
|
|
|
|
|
var grammarSource = fs.readFileSync(path.join(__dirname, 'syndicate.ohm')).toString();
|
|
|
|
var grammar = ohm.grammar(grammarSource, { ES5: ES5.grammar });
|
|
|
|
var semantics = grammar.extendSemantics(ES5.semantics);
|
|
|
|
|
|
|
|
var gensym_start = Math.floor(new Date() * 1);
|
|
|
|
var gensym_counter = 0;
|
|
|
|
function gensym(label) {
|
|
|
|
return '_' + (label || 'g') + gensym_start + '_' + (gensym_counter++);
|
|
|
|
}
|
|
|
|
|
|
|
|
var forEachChild = (function () {
|
|
|
|
function flattenIterNodes(nodes, acc) {
|
|
|
|
for (var i = 0; i < nodes.length; ++i) {
|
|
|
|
if (nodes[i].isIteration()) {
|
|
|
|
flattenIterNodes(nodes[i].children, acc);
|
|
|
|
} else {
|
|
|
|
acc.push(nodes[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function compareByInterval(node, otherNode) {
|
|
|
|
return node.interval.startIdx - otherNode.interval.startIdx;
|
|
|
|
}
|
|
|
|
|
|
|
|
function forEachChild(children, f) {
|
|
|
|
var nodes = [];
|
|
|
|
flattenIterNodes(children, nodes);
|
|
|
|
nodes.sort(compareByInterval).forEach(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
return forEachChild;
|
|
|
|
})();
|
|
|
|
|
2016-05-18 20:51:51 +00:00
|
|
|
function buildActor(constructorES5, nameExpOpt, block) {
|
|
|
|
var nameExpStr;
|
|
|
|
if (nameExpOpt.numChildren === 1) {
|
|
|
|
nameExpStr = ', ' + nameExpOpt.asES5;
|
|
|
|
} else {
|
|
|
|
nameExpStr = '';
|
|
|
|
}
|
2016-03-18 21:00:51 +00:00
|
|
|
return 'Syndicate.Actor.spawnActor(new '+constructorES5+', '+
|
2016-05-18 20:51:51 +00:00
|
|
|
'function() ' + block.asES5 + nameExpStr + ');';
|
2016-03-18 21:00:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function buildFacet(facetBlock, transitionBlock) {
|
2016-06-05 17:14:48 +00:00
|
|
|
return '(function () { ' + (facetBlock ? facetBlock.facetVarDecls : '') +
|
|
|
|
'\nSyndicate.Actor.createFacet()' +
|
2016-03-18 21:00:51 +00:00
|
|
|
(facetBlock ? facetBlock.asES5 : '') +
|
|
|
|
(transitionBlock ? transitionBlock.asES5 : '') +
|
2016-06-05 17:14:48 +00:00
|
|
|
'.completeBuild(); })();';
|
2016-03-18 21:00:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function buildOnEvent(isTerminal, eventType, subscription, projection, bindings, body) {
|
|
|
|
return '\n.onEvent(' + isTerminal + ', ' + JSON.stringify(eventType) + ', ' +
|
|
|
|
subscription + ', ' + projection +
|
|
|
|
', (function(' + bindings.join(', ') + ') ' + body + '))';
|
|
|
|
}
|
|
|
|
|
2016-03-19 17:48:49 +00:00
|
|
|
function buildCaseEvent(eventPattern, body) {
|
|
|
|
if (eventPattern.eventType === 'risingEdge') {
|
|
|
|
return buildOnEvent(true,
|
|
|
|
eventPattern.eventType,
|
|
|
|
'function() { return (' + eventPattern.asES5 + '); }',
|
|
|
|
'null',
|
|
|
|
[],
|
|
|
|
body);
|
|
|
|
} else {
|
|
|
|
return buildOnEvent(true,
|
|
|
|
eventPattern.eventType,
|
|
|
|
eventPattern.subscription,
|
|
|
|
eventPattern.projection,
|
|
|
|
eventPattern.bindings,
|
|
|
|
body);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-18 21:00:51 +00:00
|
|
|
var modifiedSourceActions = {
|
2016-05-18 20:51:51 +00:00
|
|
|
ActorStatement_noConstructor: function(_actor, _namedOpt, nameExpOpt, block) {
|
|
|
|
return buildActor('Object()', nameExpOpt, block);
|
2016-03-18 21:00:51 +00:00
|
|
|
},
|
2016-05-18 20:51:51 +00:00
|
|
|
ActorStatement_withConstructor: function(_actor, ctorExp, _namedOpt, nameExpOpt, block) {
|
|
|
|
return buildActor(ctorExp.asES5, nameExpOpt, block);
|
2016-03-18 21:00:51 +00:00
|
|
|
},
|
|
|
|
|
2016-04-07 07:42:54 +00:00
|
|
|
DataspaceStatement_ground: function(_ground, _dataspace, maybeId, block) {
|
2016-03-19 19:06:07 +00:00
|
|
|
var code = 'new Syndicate.Ground(function () ' + block.asES5 + ').startStepping();';
|
|
|
|
if (maybeId.numChildren === 1) {
|
|
|
|
return 'var ' + maybeId.children[0].interval.contents + ' = ' + code;
|
|
|
|
} else {
|
|
|
|
return code;
|
|
|
|
}
|
2016-03-18 21:00:51 +00:00
|
|
|
},
|
2016-04-07 07:42:54 +00:00
|
|
|
DataspaceStatement_normal: function(_dataspace, block) {
|
|
|
|
return 'Syndicate.Dataspace.spawn(new Dataspace(function () ' + block.asES5 + '));';
|
2016-03-18 21:00:51 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
ActorFacetStatement_state: function(_state, facetBlock, _until, transitionBlock) {
|
|
|
|
return buildFacet(facetBlock, transitionBlock);
|
|
|
|
},
|
2016-05-10 22:49:12 +00:00
|
|
|
ActorFacetStatement_until: function(_react, _until, transitionBlock) {
|
2016-03-18 21:00:51 +00:00
|
|
|
return buildFacet(null, transitionBlock);
|
|
|
|
},
|
|
|
|
ActorFacetStatement_forever: function(_forever, facetBlock) {
|
|
|
|
return buildFacet(facetBlock, null);
|
|
|
|
},
|
|
|
|
|
|
|
|
AssertionTypeDeclarationStatement: function(_assertion,
|
|
|
|
_type,
|
|
|
|
typeName,
|
|
|
|
_leftParen,
|
|
|
|
formalsRaw,
|
|
|
|
_rightParen,
|
|
|
|
_maybeEquals,
|
|
|
|
maybeLabel,
|
|
|
|
_maybeSc)
|
|
|
|
{
|
|
|
|
var formals = formalsRaw.asSyndicateStructureArguments;
|
|
|
|
var label = maybeLabel.numChildren === 1
|
|
|
|
? maybeLabel.children[0].interval.contents
|
|
|
|
: JSON.stringify(typeName.interval.contents);
|
2016-05-10 04:40:53 +00:00
|
|
|
return 'var ' + typeName.asES5 + ' = Syndicate.Struct.makeConstructor(' +
|
2016-05-08 15:11:16 +00:00
|
|
|
label + ', ' + JSON.stringify(formals) + ');';
|
2016-03-18 21:00:51 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
SendMessageStatement: function(_colons, expr, sc) {
|
2016-04-07 07:42:54 +00:00
|
|
|
return 'Syndicate.Dataspace.send(' + expr.asES5 + ')' + sc.interval.contents;
|
2016-03-18 21:00:51 +00:00
|
|
|
},
|
|
|
|
|
2016-06-05 17:14:48 +00:00
|
|
|
FacetBlock: function(_leftParen, _varStmts, init, situations, done, _rightParen) {
|
2016-03-18 21:00:51 +00:00
|
|
|
return (init ? init.asES5 : '') + situations.asES5.join('') + (done ? done.asES5 : '');
|
|
|
|
},
|
|
|
|
FacetStateTransitionBlock: function(_leftParen, transitions, _rightParen) {
|
|
|
|
return transitions.asES5;
|
|
|
|
},
|
|
|
|
|
|
|
|
FacetInitBlock: function(_init, block) {
|
|
|
|
return '\n.addInitBlock((function() ' + block.asES5 + '))';
|
|
|
|
},
|
|
|
|
FacetDoneBlock: function(_done, block) {
|
|
|
|
return '\n.addDoneBlock((function() ' + block.asES5 + '))';
|
|
|
|
},
|
|
|
|
|
2016-05-08 16:19:40 +00:00
|
|
|
FacetSituation_assert: function(_assert, expr, whenClause, _sc) {
|
|
|
|
return '\n.addAssertion(' + buildSubscription([expr], 'assert', 'pattern', whenClause) + ')';
|
2016-03-18 21:00:51 +00:00
|
|
|
},
|
|
|
|
FacetSituation_event: function(_on, eventPattern, block) {
|
|
|
|
return buildOnEvent(false,
|
|
|
|
eventPattern.eventType,
|
|
|
|
eventPattern.subscription,
|
|
|
|
eventPattern.projection,
|
|
|
|
eventPattern.bindings,
|
|
|
|
block.asES5);
|
|
|
|
},
|
2016-05-14 23:06:00 +00:00
|
|
|
FacetSituation_onEvent: function (_on, _event, id, block) {
|
|
|
|
return '\n.addOnEventHandler((function(' + id.asES5 + ') ' + block.asES5 + '))';
|
|
|
|
},
|
2016-03-18 21:00:51 +00:00
|
|
|
FacetSituation_during: function(_during, pattern, facetBlock) {
|
|
|
|
return buildOnEvent(false,
|
|
|
|
'asserted',
|
|
|
|
pattern.subscription,
|
|
|
|
pattern.projection,
|
|
|
|
pattern.bindings,
|
2016-06-05 17:14:48 +00:00
|
|
|
'{ ' + facetBlock.facetVarDecls +
|
|
|
|
'\nSyndicate.Actor.createFacet()' +
|
2016-03-18 21:00:51 +00:00
|
|
|
facetBlock.asES5 +
|
|
|
|
buildOnEvent(true,
|
|
|
|
'retracted',
|
|
|
|
pattern.instantiatedSubscription,
|
2016-03-21 01:01:17 +00:00
|
|
|
pattern.instantiatedProjection,
|
2016-03-18 21:00:51 +00:00
|
|
|
[],
|
|
|
|
'{}') +
|
|
|
|
'.completeBuild(); }');
|
|
|
|
},
|
|
|
|
|
2016-05-08 16:19:40 +00:00
|
|
|
AssertWhenClause: function(_when, _lparen, expr, _rparen) {
|
|
|
|
return expr.asES5;
|
|
|
|
},
|
|
|
|
|
2016-03-18 21:00:51 +00:00
|
|
|
FacetStateTransition_withContinuation: function(_case, eventPattern, block) {
|
2016-03-19 17:48:49 +00:00
|
|
|
return buildCaseEvent(eventPattern, block.asES5);
|
2016-03-18 21:00:51 +00:00
|
|
|
},
|
|
|
|
FacetStateTransition_noContinuation: function(_case, eventPattern, _sc) {
|
2016-03-19 18:49:54 +00:00
|
|
|
return buildCaseEvent(eventPattern, '{}');
|
2016-03-18 21:00:51 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
semantics.extendAttribute('modifiedSource', modifiedSourceActions);
|
|
|
|
|
2016-06-05 17:14:48 +00:00
|
|
|
semantics.addAttribute('facetVarDecls', {
|
|
|
|
FacetBlock: function (_leftParen, varDecls, _init, _situations, _done, _rightParen) {
|
2016-06-05 18:52:40 +00:00
|
|
|
return varDecls.asES5.join(' ');
|
2016-06-05 17:14:48 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2016-03-18 21:00:51 +00:00
|
|
|
semantics.addAttribute('asSyndicateStructureArguments', {
|
|
|
|
FormalParameterList: function(formals) {
|
|
|
|
return formals.asIteration().asSyndicateStructureArguments;
|
|
|
|
},
|
|
|
|
identifier: function(_name) {
|
|
|
|
return this.interval.contents;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
semantics.addAttribute('eventType', {
|
|
|
|
FacetEventPattern_messageEvent: function(_kw, _pattern) { return 'message'; },
|
|
|
|
FacetEventPattern_assertedEvent: function(_kw, _pattern) { return 'asserted'; },
|
2016-03-19 17:48:49 +00:00
|
|
|
FacetEventPattern_retractedEvent: function(_kw, _pattern) { return 'retracted'; },
|
|
|
|
|
|
|
|
FacetTransitionEventPattern_facetEvent: function (pattern) { return pattern.eventType; },
|
2016-03-19 18:50:08 +00:00
|
|
|
FacetTransitionEventPattern_risingEdge: function (_lp, expr, _rp) { return 'risingEdge'; }
|
2016-03-18 21:00:51 +00:00
|
|
|
});
|
|
|
|
|
2016-05-08 16:19:40 +00:00
|
|
|
function buildSubscription(children, patchMethod, mode, whenClause) {
|
2016-03-18 21:00:51 +00:00
|
|
|
var fragments = [];
|
2016-05-08 16:19:40 +00:00
|
|
|
var hasWhenClause = (whenClause && (whenClause.numChildren === 1));
|
2016-03-18 21:00:51 +00:00
|
|
|
fragments.push('(function() { var _ = Syndicate.__; return ');
|
2016-05-08 16:19:40 +00:00
|
|
|
if (hasWhenClause) {
|
|
|
|
fragments.push('(' + whenClause.asES5 + ') ? ');
|
|
|
|
}
|
2016-03-18 21:00:51 +00:00
|
|
|
if (patchMethod) {
|
|
|
|
fragments.push('Syndicate.Patch.' + patchMethod + '(');
|
|
|
|
} else {
|
|
|
|
fragments.push('{ assertion: ');
|
|
|
|
}
|
|
|
|
children.forEach(function (c) { c.buildSubscription(fragments, mode); });
|
|
|
|
if (patchMethod) {
|
|
|
|
fragments.push(', ');
|
|
|
|
} else {
|
|
|
|
fragments.push(', metalevel: ');
|
|
|
|
}
|
|
|
|
children.forEach(function (c) { fragments.push(c.metalevel) });
|
|
|
|
if (patchMethod) {
|
|
|
|
fragments.push(')');
|
|
|
|
} else {
|
|
|
|
fragments.push(' }');
|
|
|
|
}
|
2016-05-08 16:19:40 +00:00
|
|
|
if (hasWhenClause) {
|
|
|
|
fragments.push(' : Syndicate.Patch.emptyPatch');
|
|
|
|
}
|
2016-03-18 21:00:51 +00:00
|
|
|
fragments.push('; })');
|
|
|
|
return fragments.join('');
|
|
|
|
}
|
|
|
|
|
|
|
|
semantics.addAttribute('subscription', {
|
|
|
|
_default: function(children) {
|
2016-05-08 16:19:40 +00:00
|
|
|
return buildSubscription(children, 'sub', 'pattern', null);
|
2016-03-18 21:00:51 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
semantics.addAttribute('instantiatedSubscription', {
|
|
|
|
_default: function(children) {
|
2016-05-08 16:19:40 +00:00
|
|
|
return buildSubscription(children, 'sub', 'instantiated', null);
|
2016-03-18 21:00:51 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2016-03-21 01:01:17 +00:00
|
|
|
semantics.addAttribute('instantiatedProjection', {
|
|
|
|
_default: function(children) {
|
2016-05-08 16:19:40 +00:00
|
|
|
return buildSubscription(children, null, 'instantiated', null);
|
2016-03-21 01:01:17 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2016-03-18 21:00:51 +00:00
|
|
|
semantics.addAttribute('projection', {
|
|
|
|
_default: function(children) {
|
2016-05-08 16:19:40 +00:00
|
|
|
return buildSubscription(children, null, 'projection', null);
|
2016-03-18 21:00:51 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
semantics.addAttribute('metalevel', {
|
|
|
|
FacetEventPattern_messageEvent: function(_kw, p) { return p.metalevel; },
|
|
|
|
FacetEventPattern_assertedEvent: function(_kw, p) { return p.metalevel; },
|
|
|
|
FacetEventPattern_retractedEvent: function(_kw, p) { return p.metalevel; },
|
|
|
|
|
2016-03-19 17:48:49 +00:00
|
|
|
FacetTransitionEventPattern_facetEvent: function (pattern) { return pattern.metalevel; },
|
|
|
|
|
2016-03-18 21:00:51 +00:00
|
|
|
FacetPattern_withMetalevel: function(_expr, _kw, metalevel) {
|
|
|
|
return metalevel.interval.contents;
|
|
|
|
},
|
|
|
|
FacetPattern_noMetalevel: function(_expr) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
semantics.addOperation('buildSubscription(acc,mode)', {
|
|
|
|
FacetEventPattern_messageEvent: function(_kw, pattern) {
|
|
|
|
pattern.buildSubscription(this.args.acc, this.args.mode);
|
|
|
|
},
|
|
|
|
FacetEventPattern_assertedEvent: function(_kw, pattern) {
|
|
|
|
pattern.buildSubscription(this.args.acc, this.args.mode);
|
|
|
|
},
|
|
|
|
FacetEventPattern_retractedEvent: function(_kw, pattern) {
|
|
|
|
pattern.buildSubscription(this.args.acc, this.args.mode);
|
2016-03-19 17:48:49 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
FacetTransitionEventPattern_facetEvent: function (pattern) {
|
|
|
|
pattern.buildSubscription(this.args.acc, this.args.mode);
|
2016-03-18 21:00:51 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
FacetPattern: function (v) {
|
|
|
|
v.children[0].buildSubscription(this.args.acc, this.args.mode); // both branches!
|
|
|
|
},
|
|
|
|
|
2016-05-10 04:40:53 +00:00
|
|
|
AssignmentExpression_assignment: function (lhsExpr, _assignmentOperator, rhsExpr) {
|
|
|
|
var i = lhsExpr.interval.contents;
|
|
|
|
if (i[0] === '$' && i.length > 1) {
|
|
|
|
switch (this.args.mode) {
|
|
|
|
case 'pattern': rhsExpr.buildSubscription(this.args.acc, this.args.mode); break;
|
|
|
|
case 'instantiated': lhsExpr.buildSubscription(this.args.acc, this.args.mode); break;
|
|
|
|
case 'projection': {
|
|
|
|
this.args.acc.push('(Syndicate._$(' + JSON.stringify(i.slice(1)) + ',');
|
|
|
|
rhsExpr.buildSubscription(this.args.acc, this.args.mode);
|
|
|
|
this.args.acc.push('))');
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: throw new Error('Unexpected buildSubscription mode ' + this.args.mode);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
lhsExpr.buildSubscription(this.args.acc, this.args.mode);
|
|
|
|
_assignmentOperator.buildSubscription(this.args.acc, this.args.mode);
|
|
|
|
rhsExpr.buildSubscription(this.args.acc, this.args.mode);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2016-03-18 21:00:51 +00:00
|
|
|
identifier: function(_name) {
|
|
|
|
var i = this.interval.contents;
|
2016-05-10 04:40:53 +00:00
|
|
|
if (i[0] === '$' && i.length > 1) {
|
2016-03-18 21:00:51 +00:00
|
|
|
switch (this.args.mode) {
|
2016-05-10 04:40:53 +00:00
|
|
|
case 'pattern': this.args.acc.push('_'); break;
|
|
|
|
case 'instantiated': this.args.acc.push(i.slice(1)); break;
|
|
|
|
case 'projection': this.args.acc.push('(Syndicate._$(' + JSON.stringify(i.slice(1)) + '))'); break;
|
|
|
|
default: throw new Error('Unexpected buildSubscription mode ' + this.args.mode);
|
2016-03-18 21:00:51 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
this.args.acc.push(i);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
_terminal: function() {
|
|
|
|
this.args.acc.push(this.interval.contents);
|
|
|
|
},
|
|
|
|
_nonterminal: function(children) {
|
|
|
|
var self = this;
|
|
|
|
forEachChild(children, function (c) {
|
|
|
|
c.buildSubscription(self.args.acc, self.args.mode);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
semantics.addAttribute('bindings', {
|
|
|
|
_default: function(children) {
|
|
|
|
var result = [];
|
|
|
|
this.pushBindings(result);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
semantics.addOperation('pushBindings(accumulator)', {
|
|
|
|
identifier: function(_name) {
|
|
|
|
var i = this.interval.contents;
|
2016-05-10 04:40:53 +00:00
|
|
|
if (i[0] === '$' && i.length > 1) {
|
2016-03-18 21:00:51 +00:00
|
|
|
this.args.accumulator.push(i.slice(1));
|
|
|
|
}
|
|
|
|
},
|
|
|
|
_terminal: function () {},
|
|
|
|
_nonterminal: function(children) {
|
|
|
|
var self = this;
|
|
|
|
children.forEach(function (c) { c.pushBindings(self.args.accumulator); });
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2016-03-19 17:01:14 +00:00
|
|
|
function compileSyndicateSource(inputSource, onError) {
|
2016-03-18 21:00:51 +00:00
|
|
|
var parseResult = grammar.match(inputSource);
|
2016-03-19 17:01:14 +00:00
|
|
|
if (parseResult.failed()) {
|
|
|
|
if (onError) {
|
|
|
|
return onError(parseResult.message, parseResult);
|
|
|
|
} else {
|
|
|
|
console.error(parseResult.message);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return '"use strict";\n' + semantics(parseResult).asES5;
|
2016-03-18 21:00:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-19 17:01:14 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
module.exports.grammar = grammar;
|
|
|
|
module.exports.semantics = semantics;
|
|
|
|
module.exports.compileSyndicateSource = compileSyndicateSource;
|