bool Program::dispatchExecution(const Bind<void (const Callback&)>& dispatcher, uint timeout)
{
auto envptr = pEnv;
if (!envptr)
{
envptr = std::make_shared<ProcessSharedInfo>();
pEnv = envptr;
}
Thread::Signal signal;
if (not signal.valid())
{
std::cerr << "impossible to initialize signal\n";
return false;
}
// Dispatch the message
// The code is within a block to let the variable
// `runner` destroyed, thus to notify the end of the execution
// (via signal->notify())
ExecutionHelper runner(*this, signal);
// scope to destroy our callback as soon as possible
{
Bind<bool ()> callback;
callback.bind(&runner, &ExecutionHelper::perform, timeout);
dispatcher(callback);
}
// waiting for the process startup from the main loop
signal.wait();
// ok ready
return runner.result;
}
int main(int argc,char* argv[])
{
if (argc == 3)
{
Bind bd;
return bd.BindProc(argv[1], argv[2]);
}
else
{
printf("usage:%s lm_dict bind_dict.\n", argv[0]);
return -1;
}
}
void ScopeBuilder::initializeScopeChain()
{
ScopeChain &scopeChain = _context->scopeChain();
if (scopeChain.qmlComponentScope
&& scopeChain.qmlComponentScope->document == _doc) {
return;
}
scopeChain = ScopeChain(); // reset
Interpreter::Engine *engine = _context->engine();
// ### TODO: This object ought to contain the global namespace additions by QML.
scopeChain.globalScope = engine->globalObject();
if (! _doc) {
scopeChain.update();
return;
}
Bind *bind = _doc->bind();
QHash<Document *, ScopeChain::QmlComponentChain *> componentScopes;
ScopeChain::QmlComponentChain *chain = new ScopeChain::QmlComponentChain;
scopeChain.qmlComponentScope = QSharedPointer<const ScopeChain::QmlComponentChain>(chain);
if (_doc->qmlProgram()) {
componentScopes.insert(_doc.data(), chain);
makeComponentChain(_doc, chain, &componentScopes);
if (const TypeEnvironment *typeEnvironment = _context->typeEnvironment(_doc.data())) {
scopeChain.qmlTypes = typeEnvironment;
}
} else {
// add scope chains for all components that import this file
foreach (Document::Ptr otherDoc, _snapshot) {
foreach (const ImportInfo &import, otherDoc->bind()->imports()) {
if (import.type() == ImportInfo::FileImport && _doc->fileName() == import.name()) {
ScopeChain::QmlComponentChain *component = new ScopeChain::QmlComponentChain;
componentScopes.insert(otherDoc.data(), component);
chain->instantiatingComponents += component;
makeComponentChain(otherDoc, component, &componentScopes);
}
}
}
// ### TODO: Which type environment do scripts see?
if (bind->rootObjectValue())
scopeChain.jsScopes += bind->rootObjectValue();
}
bool hasStatePrototype(Node *ast)
{
Bind *bind = m_scopeChain.document()->bind();
const ObjectValue *v = bind->findQmlObject(ast);
if (!v)
return false;
PrototypeIterator it(v, m_scopeChain.context());
while (it.hasNext()) {
const ObjectValue *proto = it.next();
const CppComponentValue *qmlProto = value_cast<CppComponentValue>(proto);
if (!qmlProto)
continue;
if (qmlProto->metaObject() == m_statePrototype->metaObject())
return true;
}
return false;
}
void Link::initializeScopeChain()
{
ScopeChain &scopeChain = _context->scopeChain();
// ### TODO: This object ought to contain the global namespace additions by QML.
scopeChain.globalScope = engine()->globalObject();
if (! _doc) {
scopeChain.update();
return;
}
Bind *bind = _doc->bind();
QHash<Document *, ScopeChain::QmlComponentChain *> componentScopes;
if (_doc->qmlProgram()) {
scopeChain.qmlComponentScope.clear();
componentScopes.insert(_doc.data(), &scopeChain.qmlComponentScope);
makeComponentChain(_doc, &scopeChain.qmlComponentScope, &componentScopes);
if (const ObjectValue *typeEnvironment = _context->typeEnvironment(_doc.data()))
scopeChain.qmlTypes = typeEnvironment;
} else {
// add scope chains for all components that import this file
foreach (Document::Ptr otherDoc, _snapshot) {
foreach (const QString &fileImport, otherDoc->bind()->fileImports()) {
if (_doc->fileName() == fileImport) {
ScopeChain::QmlComponentChain *component = new ScopeChain::QmlComponentChain;
componentScopes.insert(otherDoc.data(), component);
scopeChain.qmlComponentScope.instantiatingComponents += component;
makeComponentChain(otherDoc, component, &componentScopes);
}
}
}
// ### TODO: Which type environment do scripts see?
if (bind->rootObjectValue())
scopeChain.jsScopes += bind->rootObjectValue();
}
void audioSample(int16_t lsample, int16_t rsample) { return bind->audioSample(lsample, rsample); }
string server() { return bind->server(); }
template<typename... Args> void notify(Args&&... args) { return bind->notify({std::forward<Args>(args)...}); }
unsigned dipSettings(const Markup::Node& node) { return bind->dipSettings(node); }
string path(unsigned group) { return bind->path(group); }
int16_t inputPoll(unsigned port, unsigned device, unsigned input) { return bind->inputPoll(port, device, input); }
void inputRumble(unsigned port, unsigned device, unsigned input, bool enable) { return bind->inputRumble(port, device, input, enable); }
//callback bindings (provided by user interface)
void loadRequest(unsigned id, string name, string type) { return bind->loadRequest(id, name, type); }
void videoRefresh(const uint32_t* palette, const uint32_t* data, unsigned pitch, unsigned width, unsigned height) { return bind->videoRefresh(palette, data, pitch, width, height); }
uint32_t videoColor(unsigned source, uint16_t alpha, uint16_t red, uint16_t green, uint16_t blue) { return bind->videoColor(source, alpha, red, green, blue); }
void saveRequest(unsigned id, string path) { return bind->saveRequest(id, path); }
void loadRequest(unsigned id, string path) { return bind->loadRequest(id, path); }