void GfxImageLoaderEngine::abort(GfxImageLoader *out)
{
lock.lock();
ops.remove(out);
completedops.remove(out);
lock.unlock();
}
int
main (int argc, char *argv[])
{
Ops inst = opsMake();
int z = inst->add(1, 2);
printf("%d + %d = %d\n", 1, 2, z);
return 0;
}
void GfxImageLoaderEngine::runOp(const Op &op)
{
QImage img;
bool found = false;
for(int ii = 0; ii < cache.count(); ++ii) {
if(cache.at(ii).first == op.filename) {
QPair<QString, QImage> p = cache.at(ii);
cache.removeAt(ii);
cache.append(p);
img = p.second;
found = true;
break;
}
}
if(!found) {
img = QImage(op.filename);
int contrib = img.height() * img.bytesPerLine();
if(contrib <= maxCacheSize) {
cacheSize += contrib;
cache.append(qMakePair(op.filename, img));
}
while(cacheSize > maxCacheSize) {
int c = cache.first().second.bytesPerLine() * cache.first().second.height();
cacheSize -= c;
cache.removeFirst();
}
}
QList<QImage> imgs;
if(img.isNull()) {
for(int ii = 0; ii < op.sizes.count(); ++ii)
imgs << img;
} else {
for(int ii = 0; ii < op.sizes.count(); ++ii)
imgs << img.scaled(op.sizes.at(ii), Qt::IgnoreAspectRatio,
Qt::SmoothTransformation);
}
lock.lock();
Ops::Iterator iter = ops.find(op.out);
bool exists = iter != ops.end() && iter->id == op.id;
if(exists) {
op.out->filter(imgs);
completedops.insert(op.out, op);
ops.erase(iter);
GfxImageLoaderEvent *e = new GfxImageLoaderEvent();
e->out = op.out;
e->id = op.id;
e->imgs = imgs;
QCoreApplication::instance()->postEvent(proxy, e);
}
lock.unlock();
}
void GfxImageLoaderEngine::complete(GfxImageLoaderEvent *e)
{
lock.lock();
Ops::Iterator iter = completedops.find(e->out);
bool exists = iter != completedops.end() && iter->id == e->id;
if(iter != completedops.end())
completedops.erase(iter);
lock.unlock();
if(exists) {
e->out->_active = false;
e->out->images(e->imgs);
}
}
void QDeclarativeTimeLinePrivate::add(QDeclarativeTimeLineObject &g, const Op &o)
{
if (g._t && g._t != q) {
qWarning() << "QDeclarativeTimeLine: Cannot modify a QDeclarativeTimeLineValue owned by"
<< "another timeline.";
return;
}
g._t = q;
Ops::Iterator iter = ops.find(&g);
if (iter == ops.end()) {
iter = ops.insert(&g, TimeLine());
if (syncPoint > 0)
q->pause(g, syncPoint);
}
if (!iter->ops.isEmpty() &&
o.type == Op::Pause &&
iter->ops.last().type == Op::Pause) {
iter->ops.last().length += o.length;
iter->length += o.length;
} else {
iter->ops.append(o);
iter->length += o.length;
}
if (iter->length > length)
length = iter->length;
if (!clockRunning) {
q->stop();
prevTime = 0;
clockRunning = true;
if (syncMode == QDeclarativeTimeLine::LocalSync) {
syncAdj = -1;
} else {
syncAdj = 0;
}
q->start();
/* q->tick(0);
if (syncMode == QDeclarativeTimeLine::LocalSync) {
syncAdj = -1;
} else {
syncAdj = 0;
}
*/
}
}
void GfxImageLoaderEngine::run()
{
lock.lock();
while(true) {
if(ops.isEmpty()) {
wait.wait(&lock);
} else {
Op op = *ops.begin();
lock.unlock();
runOp(op);
lock.lock();
}
}
}
void GfxImageLoaderEngine::load(GfxImageLoader *out, const QString &filename,
const QList<QSize> &sizes)
{
lock.lock();
bool wasEmpty = ops.isEmpty();
Op op;
op.filename = filename;
op.sizes = sizes;
op.id = id++;
op.out = out;
ops.insert(out, op);
if(wasEmpty)
wait.wakeAll();
lock.unlock();
}
void init() {
SourceFile * code = new_source_file(SOURCE_PREFIX "ops.in");
//const char * s = code.begin();
parse_parse::Res r = parse_parse::parse(SourceStr(code));
//printf(">.>%.*s<.<\n", r.end-s, s);
//r.parse->print();
//printf("\n");
ops.parse_self(r.parse);
}
void GrAuditTrail::addOp(const GrOp* op, GrRenderTargetProxy::UniqueID proxyID) {
SkASSERT(fEnabled);
Op* auditOp = new Op;
fOpPool.emplace_back(auditOp);
auditOp->fName = op->name();
auditOp->fBounds = op->bounds();
auditOp->fClientID = kGrAuditTrailInvalidID;
auditOp->fOpListID = kGrAuditTrailInvalidID;
auditOp->fChildID = kGrAuditTrailInvalidID;
// consume the current stack trace if any
auditOp->fStackTrace = fCurrentStackTrace;
fCurrentStackTrace.reset();
if (fClientID != kGrAuditTrailInvalidID) {
auditOp->fClientID = fClientID;
Ops** opsLookup = fClientIDLookup.find(fClientID);
Ops* ops = nullptr;
if (!opsLookup) {
ops = new Ops;
fClientIDLookup.set(fClientID, ops);
} else {
ops = *opsLookup;
}
ops->push_back(auditOp);
}
// Our algorithm doesn't bother to reorder inside of an OpNode so the ChildID will start at 0
auditOp->fOpListID = fOpList.count();
auditOp->fChildID = 0;
// We use the op pointer as a key to find the OpNode we are 'glomming' ops onto
fIDLookup.set(op->uniqueID(), auditOp->fOpListID);
OpNode* opNode = new OpNode(proxyID);
opNode->fBounds = op->bounds();
opNode->fChildren.push_back(auditOp);
fOpList.emplace_back(opNode);
}
int QDeclarativeTimeLinePrivate::advance(int t)
{
int pauseTime = -1;
// XXX - surely there is a more efficient way?
do {
pauseTime = -1;
// Minimal advance time
int advanceTime = t;
for (Ops::Iterator iter = ops.begin(); iter != ops.end(); ++iter) {
TimeLine &tl = *iter;
Op &op = tl.ops.first();
int length = op.length - tl.consumedOpLength;
if (length < advanceTime) {
advanceTime = length;
if (advanceTime == 0)
break;
}
}
t -= advanceTime;
// Process until then. A zero length advance time will only process
// sets.
QList<QPair<int, Update> > updates;
for (Ops::Iterator iter = ops.begin(); iter != ops.end(); ) {
QDeclarativeTimeLineValue *v = static_cast<QDeclarativeTimeLineValue *>(iter.key());
TimeLine &tl = *iter;
Q_ASSERT(!tl.ops.isEmpty());
do {
Op &op = tl.ops.first();
if (advanceTime == 0 && op.length != 0)
continue;
if (tl.consumedOpLength == 0 &&
op.type != Op::Pause &&
op.type != Op::Execute)
tl.base = v->value();
if ((tl.consumedOpLength + advanceTime) == op.length) {
if (op.type == Op::Execute) {
updates << qMakePair(op.order, Update(op.event));
} else {
bool changed = false;
qreal val = value(op, op.length, tl.base, &changed);
if (changed)
updates << qMakePair(op.order, Update(v, val));
}
tl.length -= qMin(advanceTime, tl.length);
tl.consumedOpLength = 0;
tl.ops.removeFirst();
} else {
tl.consumedOpLength += advanceTime;
bool changed = false;
qreal val = value(op, tl.consumedOpLength, tl.base, &changed);
if (changed)
updates << qMakePair(op.order, Update(v, val));
tl.length -= qMin(advanceTime, tl.length);
break;
}
} while(!tl.ops.isEmpty() && advanceTime == 0 && tl.ops.first().length == 0);
if (tl.ops.isEmpty()) {
iter = ops.erase(iter);
v->_t = 0;
} else {
if (tl.ops.first().type == Op::Pause && pauseTime != 0) {
int opPauseTime = tl.ops.first().length - tl.consumedOpLength;
if (pauseTime == -1 || opPauseTime < pauseTime)
pauseTime = opPauseTime;
} else {
pauseTime = 0;
}
++iter;
}
}
length -= qMin(length, advanceTime);
syncPoint -= advanceTime;
qSort(updates.begin(), updates.end());
updateQueue = &updates;
for (int ii = 0; ii < updates.count(); ++ii) {
const Update &v = updates.at(ii).second;
if (v.g) {
v.g->setValue(v.v);
} else {
v.e.d0(v.e.d1);
}
}
updateQueue = 0;
} while(t);
return pauseTime;
}
QVector<UInt8ArrayType::Pointer> makePoleFigures(PoleFigureConfiguration_t& config)
{
Ops ops;
return ops.generatePoleFigure(config);
}
const Syntax * parse(const Syntax * p, const char * l_i) {
//printf("ParseExpImpl::parse: %s %s\n", ~p->sample_w_loc(), ~p->to_string());
opr_s.clear();
val_s.clear();
list_is = l_i;
Op::Types prev = 0;
try {
for (parts_iterator i = p->args_begin(), e = p->args_end(); i != e; ++i) {
const Syntax * pop = *i; // parsed op
Op::Types cur = ops.lookup_types(pop);
if (cur & Op::Special) {
const Syntax * res = ops.try_special(pop, i, e);
if (res) {
pop = res;
cur = ops.lookup_types(pop);
} else {
cur &= ~Op::Special;
}
}
assert(!(cur & Op::Special));
if (prev == 0 || prev & (Op::Prefix | Op::Bin)) {
cur &= (Op::Prefix | Op::Other);
if (cur == 0)
throw error(pop, "Expected an operand or a prefix operator.");
} else {
cur &= (Op::Bin | Op::Postfix);
if (cur == 0)
throw error(pop, "Expected a binary or postfix operator.");
}
//if (cur == (Op::Prefix | Op::Other)) {
// if (i + 1 == sz || (ops.lookup_types(p->arg(i+1)) & (Op::Postfix | Op::Bin))) {
// cur &= (Op::Postfix | Op::Other);
// if (cur == 0)
// throw error(pop, "Expected an operand or a postfix operator.");
// } else {
// cur &= (Op::Bin | Op::Prefix);
// if (cur == 0)
// throw error(pop, "Expected an binary or prefix operator.");
// }
//}
const Op * op = ops.lookup(pop, cur);
if (op->type == Op::Other) {
val_s.push_back(pop);
} else {
while (!opr_s.empty() &&
(opr_s.back().op->level < op->level ||
(opr_s.back().op->level == op->level && op->assoc == Left)))
reduce();
if (!opr_s.empty() && opr_s.back().op->level == op->level && op->assoc == None)
throw error(pop, "\"%s\" is non-associative.",
op->what.c_str());
opr_s.push_back(OpInfo(op, pop));
}
prev = cur;
}
while (!opr_s.empty())
reduce();
if (val_s.size() == 0)
throw error(p, "Empty expression.");
if (val_s.size() > 1)
throw error(val_s[val_s.size()-2], "Extra operand(s).");
assert(val_s.size() == 1);
Syntax * res = val_s.front();
if (!res->is_a("syntax") && !res->is_a("raw_syntax"))
res->str_ = p->str();
return res;
} catch (Error * err) {
//printf("?? %s %s\n", ~p->sample_w_loc(), ~p->to_string());
//abort();
err->msg.span.source = p->str().source;
err->add_note(extra_parse_info(p->str(), "<op exp>"));
throw err;
}
}
