////////////////////////////////////////////////////////////////////
// Function: PPInstance::set_failed
// Access: Private
// Description: Called when something has gone wrong that prevents
// the plugin instance from running. Specifically, this
// means it failed to load the core API.
////////////////////////////////////////////////////////////////////
void PPInstance::
set_failed() {
if (!_failed) {
_failed = true;
nout << "Plugin failed.\n";
// Look for the "onpluginfail" token.
string expression = lookup_token("onpluginfail");
if (!expression.empty()) {
// Now attempt to evaluate the expression.
COleVariant varResult;
CComPtr<IDispatch> pDispatch;
CString evalExpression( expression.c_str() );
HRESULT hr = m_parentCtrl.EvalExpression( pDispatch, evalExpression , varResult );
if (FAILED(hr)) {
nout << "Unable to eval " << expression << "\n";
} else {
nout << "Eval " << expression << "\n";
}
}
}
}
void CDirectiveData::Encode()
{
int num;
int totalsize = 0;
for (int i = 0; i < TotalAmount; i++)
{
if (Entries[i].String == true)
{
unsigned char* Data = StrData.GetEntry(Entries[i].num);
int len = StrData.GetLen(Entries[i].num);
for (int i = 0; i < len; i++)
{
num = Data[i];
g_fileManager->write(&num,UnitSize);
}
totalsize += len*UnitSize;
} else {
if (evalExpression(ExpData[Entries[i].num],num) == false)
return;
totalsize += UnitSize;
g_fileManager->write(&num,UnitSize);
}
}
SpaceNeeded = totalsize;
}
bool CDirectiveArea::Validate()
{
int NewSize;
RamPos = g_fileManager->getVirtualAddress();
if (Start == true)
{
if (evalExpression(SizeExpression,NewSize,true) == false)
return false;
if (FillExpression.isInitialized())
{
if (evalExpression(FillExpression,fillValue,true) == false)
return false;
}
Global.areaData.startArea(RamPos,NewSize,FileNum,FileLine,fillValue);
if (Size != NewSize)
{
Size = NewSize;
return true;
} else {
return false;
}
} else {
if (Global.areaData.getEntryCount() != 0)
{
fillValue = Global.areaData.getCurrentFillValue();
Size = Global.areaData.getCurrentMaxAddress()-g_fileManager->getVirtualAddress();
if (fillValue != -1)
g_fileManager->seekVirtual(Global.areaData.getCurrentMaxAddress());
}
Global.areaData.endArea();
return false;
}
}
/*=macfunc INCLUDE
*
* what: Read in and emit a template block
* handler_proc:
* load_proc:
*
* desc:
*
* The entire contents of the named file is inserted at this point.
* The contents of the file are processed for macro expansion. The
* arguments are eval-ed, so you may compute the name of the file to
* be included. The included file must not contain any incomplete
* function blocks. Function blocks are template text beginning with
* any of the macro functions @samp{CASE}, @samp{DEFINE}, @samp{FOR},
* @samp{IF} and @samp{WHILE}; extending through their respective
* terminating macro functions.
=*/
tMacro*
mFunc_Include(tTemplate* pT, tMacro* pMac)
{
tTemplate * pNewTpl;
ag_bool needFree;
char const * pzFile = evalExpression(&needFree);
tMacro* pM;
if (*pzFile != NUL) {
pNewTpl = loadTemplate(pzFile, pT->pzTplFile);
/*
* Strip off trailing white space from included templates
*/
pM = pNewTpl->aMacros + (pNewTpl->macroCt - 1);
if (pM->funcCode == FTYP_TEXT) {
char* pz = pNewTpl->pzTemplText + pM->ozText;
char* pzE = pz + strlen(pz);
while ((pzE > pz) && IS_WHITESPACE_CHAR(pzE[-1])) --pzE;
/*
* IF there is no text left, remove the macro entirely
*/
if (pz == pzE)
pNewTpl->macroCt--;
else *pzE = NUL;
}
if (OPT_VALUE_TRACE > TRACE_DEBUG_MESSAGE) {
fprintf(pfTrace, TRACE_FN_INC_TPL, pNewTpl->pzTplFile);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(pfTrace, TRACE_FN_INC_LINE, pCurTemplate->pzTplFile,
pMac->lineNo);
}
generateBlock(pNewTpl, pNewTpl->aMacros,
pNewTpl->aMacros + pNewTpl->macroCt);
unloadTemplate(pNewTpl);
pCurTemplate = pT;
}
if (needFree)
AGFREE((void*)pzFile);
return pMac + 1;
}
double ff_eval(char *s, double *const_value, const char **const_name,
double (**func1)(void *, double), const char **func1_name,
double (**func2)(void *, double, double), char **func2_name,
void *opaque){
Parser p;
p.stack_index=100;
p.s= s;
p.const_value= const_value;
p.const_name = const_name;
p.func1 = func1;
p.func1_name = func1_name;
p.func2 = func2;
p.func2_name = func2_name;
p.opaque = opaque;
return evalExpression(&p);
}
bool CDirectiveData::Validate()
{
RamPos = g_fileManager->getVirtualAddress();
int num;
for (int i = 0; i < TotalAmount; i++)
{
if (Entries[i].String == false)
{
if (evalExpression(ExpData[Entries[i].num],num,true) == false)
return false;
g_fileManager->advanceMemory(UnitSize);
} else {
g_fileManager->advanceMemory(StrData.GetLen(Entries[i].num)*UnitSize);
}
}
return false;
}
static void evalPow(Parser *p){
int neg= 0;
if(p->s[0]=='+') p->s++;
if(p->s[0]=='-'){
neg= 1;
p->s++;
}
if(p->s[0]=='('){
p->s++;;
evalExpression(p);
if(p->s[0]!=')')
fprintf(stderr, "Parser: missing )\n");
p->s++;
}else{
evalPrimary(p);
}
if(neg) push(p, -pop(p));
}
void CDirectiveData::writeTempData(TempData& tempData)
{
int num;
std::wstring result;
switch (UnitSize)
{
case 1:
result = L".byte ";
break;
case 2:
result = L".halfword ";
break;
case 4:
result = L".word ";
break;
}
for (int i = 0; i < TotalAmount; i++)
{
if (Entries[i].String == true)
{
unsigned char* Data = StrData.GetEntry(Entries[i].num);
int len = StrData.GetLen(Entries[i].num);
for (int i = 0; i < len; i++)
{
result += formatString(L"0x%0*X,",UnitSize*2,Data[i]);
}
} else {
if (evalExpression(ExpData[Entries[i].num],num) == false)
return;
result += formatString(L"0x%0*X,",UnitSize*2,num);
}
}
result.pop_back();
tempData.writeLine(RamPos,result);
}
/*
* eval_true - should a string be interpreted as TRUE?
*
* It is always true unless:
*
* 1. it is the empty string
* 2. it starts with a digit and the number evaluates to zero
* 3. it starts with either "#f" or "#F"
* 4. For its length or its first five characters (whichever is less)
* it matches the string "false"
*/
static ag_bool
eval_true(void)
{
ag_bool needFree;
ag_bool res = AG_TRUE;
char const * pz = evalExpression(&needFree);
if (IS_DEC_DIGIT_CHAR(*pz))
res = (atoi(pz) == 0) ? AG_FALSE : AG_TRUE;
else switch (*pz) {
case NUL:
res = AG_FALSE;
break;
case '#':
if ((pz[1] == 'f') || (pz[1] == 'F'))
res = AG_FALSE;
break;
case 'f':
case 'F':
{
int len = strlen(pz);
if (len > 5)
len = 5;
if (strneqvcmp(EVAL_TRUE_FALSE_STR, pz, len) == 0)
res = AG_FALSE;
break;
}
}
if (needFree)
AGFREE(pz);
return res;
}
/*=macfunc ESAC
*
* what: Terminate the @code{CASE} Template Block
* in-context:
*
* desc:
* This macro ends the @code{CASE} function template block.
* For a complete description, @xref{CASE}.
=*/
tMacro*
mFunc_Case(tTemplate* pT, tMacro* pMac)
{
typedef tSuccess (t_match_proc)(char const *, char const *);
/*
* There are only 15 procedures because the case insenstive matching
* get mapped into the previous four. The last three are "match always",
* "match if a value was found" "match if no value found".
*/
static t_match_proc * const match_procs[] = {
&Select_Compare_Full,
&Select_Compare_End,
&Select_Compare_Start,
&Select_Compare,
&Select_Equivalent_Full,
&Select_Equivalent_End,
&Select_Equivalent_Start,
&Select_Equivalent,
&Select_Match_Full,
&Select_Match_End,
&Select_Match_Start,
&Select_Match,
&Select_Match_Always,
&Select_Match_Existence,
&Select_Match_NonExistence
};
static char const * const match_names[] = {
"COMPARE_FULL",
"COMPARE_END",
"COMPARE_START",
"CONTAINS",
"EQUIVALENT_FULL",
"EQUIVALENT_END",
"EQUIVALENT_START",
"EQUIV_CONTAINS",
"MATCH_FULL",
"MATCH_END",
"MATCH_START",
"MATCH_WITHIN",
"MATCH_ALWAYS",
"MATCH_EXISTENCE",
"MATCH_NONEXISTENCE"
};
tMacro* pEnd = pT->aMacros + pMac->endIndex;
ag_bool needFree;
char const * pzSampleText = evalExpression(&needFree);
/*
* Search through the selection clauses until we either
* reach the end of the list for this CASE macro, or we match.
*/
for (;;) {
tSuccess mRes;
pMac = pT->aMacros + pMac->sibIndex;
if (pMac >= pEnd) {
if (OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS) {
fprintf(pfTrace, "CASE string `%s' did not match\n",
pzSampleText);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(pfTrace, zFileLine, pCurTemplate->pzTplFile,
pMac->lineNo);
}
break;
}
/*
* The current macro becomes the selected selection macro
*/
pCurMacro = pMac;
mRes = (*(match_procs[pMac->funcCode & 0x0F])
)(pzSampleText, pT->pzTemplText + pMac->ozText);
/*
* IF match, THEN generate and stop looking for a match.
*/
if (SUCCEEDED(mRes)) {
if (OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS) {
fprintf(pfTrace, "CASE string `%s' %s matched `%s'\n",
pzSampleText,
match_names[pMac->funcCode & 0x0F],
pT->pzTemplText + pMac->ozText);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(pfTrace, zFileLine, pCurTemplate->pzTplFile,
pMac->lineNo);
}
generateBlock(pT, pMac + 1, pT->aMacros + pMac->sibIndex);
break;
}
else if (OPT_VALUE_TRACE == TRACE_EVERYTHING) {
fprintf(pfTrace, "CASE no match: `%s' %s vs. `%s'\n",
pzSampleText,
match_names[pMac->funcCode & 0x0F],
pT->pzTemplText + pMac->ozText);
}
}
if (needFree)
AGFREE((void*)pzSampleText);
return pEnd;
}
static double evalPrimary(Parser *p){
double d, d2=NAN;
char *next= p->s;
int i;
/* number */
d= strtod(p->s, &next);
if(next != p->s){
p->s= next;
return d;
}
/* named constants */
for(i=0; p->const_name && p->const_name[i]; i++){
if(strmatch(p->s, p->const_name[i])){
p->s+= strlen(p->const_name[i]);
return p->const_value[i];
}
}
p->s= strchr(p->s, '(');
if(p->s==NULL){
av_log(NULL, AV_LOG_ERROR, "Parser: missing ( in \"%s\"\n", next);
return NAN;
}
p->s++; // "("
d= evalExpression(p);
if(p->s[0]== ','){
p->s++; // ","
d2= evalExpression(p);
}
if(p->s[0] != ')'){
av_log(NULL, AV_LOG_ERROR, "Parser: missing ) in \"%s\"\n", next);
return NAN;
}
p->s++; // ")"
if( strmatch(next, "sinh" ) ) d= sinh(d);
else if( strmatch(next, "cosh" ) ) d= cosh(d);
else if( strmatch(next, "tanh" ) ) d= tanh(d);
else if( strmatch(next, "sin" ) ) d= sin(d);
else if( strmatch(next, "cos" ) ) d= cos(d);
else if( strmatch(next, "tan" ) ) d= tan(d);
else if( strmatch(next, "exp" ) ) d= exp(d);
else if( strmatch(next, "log" ) ) d= log(d);
else if( strmatch(next, "squish") ) d= 1/(1+exp(4*d));
else if( strmatch(next, "gauss" ) ) d= exp(-d*d/2)/sqrt(2*M_PI);
else if( strmatch(next, "abs" ) ) d= fabs(d);
else if( strmatch(next, "max" ) ) d= d > d2 ? d : d2;
else if( strmatch(next, "min" ) ) d= d < d2 ? d : d2;
else if( strmatch(next, "gt" ) ) d= d > d2 ? 1.0 : 0.0;
else if( strmatch(next, "gte" ) ) d= d >= d2 ? 1.0 : 0.0;
else if( strmatch(next, "lt" ) ) d= d > d2 ? 0.0 : 1.0;
else if( strmatch(next, "lte" ) ) d= d >= d2 ? 0.0 : 1.0;
else if( strmatch(next, "eq" ) ) d= d == d2 ? 1.0 : 0.0;
else if( strmatch(next, "(" ) ) d= d;
// else if( strmatch(next, "l1" ) ) d= 1 + d2*(d - 1);
// else if( strmatch(next, "sq01" ) ) d= (d >= 0.0 && d <=1.0) ? 1.0 : 0.0;
else{
for(i=0; p->func1_name && p->func1_name[i]; i++){
if(strmatch(next, p->func1_name[i])){
return p->func1[i](p->opaque, d);
}
}
for(i=0; p->func2_name && p->func2_name[i]; i++){
if(strmatch(next, p->func2_name[i])){
return p->func2[i](p->opaque, d, d2);
}
}
av_log(NULL, AV_LOG_ERROR, "Parser: unknown function in \"%s\"\n", next);
return NAN;
}
return d;
}
static void evalPrimary(Parser *p){
double d, d2=NAN;
char *next= p->s;
int i;
/* number */
d= strtod(p->s, &next);
if(next != p->s){
push(p, d);
p->s= next;
return;
}
/* named constants */
for(i=0; p->const_name[i]; i++){
if(strmatch(p->s, p->const_name[i])){
push(p, p->const_value[i]);
p->s+= strlen(p->const_name[i]);
return;
}
}
p->s= strchr(p->s, '(');
if(p->s==NULL){
fprintf(stderr, "Parser: missing ( in \"%s\"\n", next);
return;
}
p->s++; // "("
evalExpression(p);
d= pop(p);
if(p->s[0]== ','){
p->s++; // ","
evalExpression(p);
d2= pop(p);
}
if(p->s[0] != ')'){
fprintf(stderr, "Parser: missing ) in \"%s\"\n", next);
return;
}
p->s++; // ")"
if( strmatch(next, "sinh" ) ) d= sinh(d);
else if( strmatch(next, "cosh" ) ) d= cosh(d);
else if( strmatch(next, "tanh" ) ) d= tanh(d);
else if( strmatch(next, "sin" ) ) d= sin(d);
else if( strmatch(next, "cos" ) ) d= cos(d);
else if( strmatch(next, "tan" ) ) d= tan(d);
else if( strmatch(next, "exp" ) ) d= exp(d);
else if( strmatch(next, "log10" ) ) d= log10(d);
else if( strmatch(next, "log2" ) ) d= log10(d)/log10(2);
else if( strmatch(next, "log" ) ) d= log(d);
else if( strmatch(next, "sqrt" ) ) d= sqrt(d);
else if( strmatch(next, "squish") ) d= 1/(1+exp(4*d));
else if( strmatch(next, "gauss" ) ) d= exp(-d*d/2)/sqrt(2*M_PI);
else if( strmatch(next, "abs" ) ) d= fabs(d);
else if( strmatch(next, "max" ) ) d= d > d2 ? d : d2;
else if( strmatch(next, "min" ) ) d= d < d2 ? d : d2;
else if( strmatch(next, "gte" ) ) d= d >= d2 ? 1.0 : 0.0;
else if( strmatch(next, "gt" ) ) d= d > d2 ? 1.0 : 0.0;
else if( strmatch(next, "lte" ) ) d= d >= d2 ? 0.0 : 1.0;
else if( strmatch(next, "lt" ) ) d= d > d2 ? 0.0 : 1.0;
else if( strmatch(next, "eq" ) ) d= d == d2 ? 1.0 : 0.0;
// else if( strmatch(next, "l1" ) ) d= 1 + d2*(d - 1);
// else if( strmatch(next, "sq01" ) ) d= (d >= 0.0 && d <=1.0) ? 1.0 : 0.0;
else{
int error=1;
for(i=0; p->func1_name && p->func1_name[i]; i++){
if(strmatch(next, p->func1_name[i])){
d= p->func1[i](p->opaque, d);
error=0;
break;
}
}
for(i=0; p->func2_name && p->func2_name[i]; i++){
if(strmatch(next, p->func2_name[i])){
d= p->func2[i](p->opaque, d, d2);
error=0;
break;
}
}
if(error){
fprintf(stderr, "Parser: unknown function in \"%s\"\n", next);
return;
}
}
push(p, d);
}
qreal PdfElementText::paint(QPainter *painter) {
qreal width = toQReal(_attributes.value("stroke", "2"));
QString strokeColor = _attributes.value("strokecolor", "black");
QString fillColor = _attributes.value("fillcolor", "");
QString valign = _attributes.value("valign", "justify");
QString halign = _attributes.value("halign", "top");
QString fontfamily = _attributes.value("font", "Aller light");
QString weight = _attributes.value("weight", "normal");
qreal size = _attributes.value("size", "12").toFloat();
bool italic = _attributes.value("italic", "false").toLower() == "true";
bool underline = _attributes.value("underline", "false").toLower() == "true";
bool wordwrap = _attributes.value("wordwrap", "true").toLower() == "true";
qreal x = toQReal(_attributes.value("x", "0"));
qreal y = toQReal(_attributes.value("y", "0")) + _offsetY;
qreal w = toQReal(_attributes.value("width", "0"));
qreal h = toQReal(_attributes.value("height", "0"));
qreal s = toQReal(_attributes.value("spacing", "0"));
if (w > 0 && h > 0) {
QFont font = QApplication::font();
font.setFamily(fontfamily);
if (weight == "light") {
font.setWeight(QFont::Light);
} else if (weight == "normal") {
font.setWeight(QFont::Normal);
} else if (weight == "demibold") {
font.setWeight(QFont::DemiBold);
} else if (weight == "bold") {
font.setWeight(QFont::Bold);
} else if (weight == "black") {
font.setWeight(QFont::Black);
} else {
font.setWeight(QFont::Normal);
}
font.setItalic(italic);
font.setUnderline(underline);
font.setPointSizeF(size);
QPen pen(Qt::black, width, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin);
painter->setPen(pen);
painter->setBrush(Qt::black);
painter->setFont(font);
int flags = Qt::TextDontClip;
if (halign == "left") flags |= Qt::AlignLeft;
else if (halign == "right") flags |= Qt::AlignRight;
else if (halign == "justify") flags |= Qt::AlignJustify;
else if (halign == "center") flags |= Qt::AlignHCenter;
if (valign == "top") flags |= Qt::AlignTop;
else if (valign == "bottom") flags |= Qt::AlignBottom;
else if (valign == "center") flags |= Qt::AlignVCenter;
if (wordwrap) flags |= Qt::TextWordWrap;
// Replace repeating variables and static ones after
QString cdata = _attributes.value("cdata", "");
QHash<QString, QString>::const_iterator it;
if (_repeating != 0) {
for (it = _repeating->constBegin(); it != _repeating->constEnd(); it++) {
cdata.replace(QString("{%1}").arg(it.key()), it.value(), Qt::CaseInsensitive);
}
}
if (_variables != 0) {
for (it = _variables->constBegin(); it != _variables->constEnd(); it++) {
// #14 Variables can occure in expressions and show different content in different situations
evalExpression(&cdata, it.key(), it.value());
// Replace variables with it's value
cdata.replace(QString("{%1}").arg(it.key()), it.value(), Qt::CaseInsensitive);
}
}
// split into different paragraphs
QStringList paragraphs = cdata.split(QRegExp("(\r|\n)"), QString::SkipEmptyParts);
// paint the text
QRectF *bounding = new QRectF;
QRectF rect = QRectF(QPointF(x, y), QSizeF(w, h));
for (int i = 0; i < paragraphs.size(); i++) {
painter->drawText(rect, flags, paragraphs.at(i).trimmed(), bounding);
rect.adjust(0, bounding->height() + s, 0, 0);
}
}
return bottom();
}
ParseStatus Parser::parseDecl() {
Token& name = lex[0];
Token& op1 = lex[1];
lex += 2;
assert(name.isIdentifier());
assert(resolve(name.text).isNil());
int slot = allocateVariable(name.text);
Atom& local = stack[slot];
local.name_ = name.text;
// Resolve the type expression if present.
// TODO(aappleby): Allow complex type expressions.
if (op1.isOperator(OP_COLON))
{
Atom type = resolve(lex[0].text);
assert(!type.isNil());
local.type_ = type.name_;
lex++;
assert(lex[0].isOperator(OP_EQUALS));
lex++;
}
// Evaluate the right hand side.
evalExpression();
skipExpected(TT_DELIMITER, DL_SEMICOLON);
Atom& value = stack.back();
// Local type is inferred from the expression.
if (op1.isOperator(OP_DECLARE)) {
local.type_ = value.type_;
} else if (local.type_ != value.type_) {
// Attempt to convert the item to the given type if necessary.
if (local.type_ == "int32" && value.type_ == "int64") {
value.type_ = "int32";
} else if (local.type_ == "float32" && value.type_ == "float64") {
value.type_ = "float32";
} else {
assert(false);
}
}
if (value.isSymbol()) {
// Move the expression value to the slot.
local.setValue(value);
emit(OC_MOVV, slot, stack.size() - 1);
emit(OC_POP, 1);
} else {
// The result of the right-hand expression is a constant.
// Store it in the constant table and emit a load instruction to place it
// in the destination register.
local.ptype_ = value.ptype_;
local.value_.blob = value.value_.blob;
value.setName(name.text);
assert(local == value);
int cslot = addConstant(value);
emit(OC_LOADC, slot, cslot);
}
stack.pop();
return PARSE_OK;
}
ParseStatus Parser::parseAtom() {
Token t = lex[0];
if (t.isLiteral()) {
evalExpression();
return PARSE_OK;
}
Atom temp;
bool hasName = false;
bool hasType = false;
bool hasValue = false;
if (t.isIdentifier()) {
// (a | (b
// Could be name, type, function call, expression.
// Don't bother handling function call for now.
// See if the identifier matches a known type.
Atom resolved = resolve(t.text);
if (resolved.isType()) {
// must be type
temp.type_ = resolved.name_;
hasType = true;
} else {
// must be name
temp.name_ = t.text;
hasName = true;
}
}
// First piece done.
lex++;
t = lex[0];
// If the next token is a delimiter, that's the end of the atom.
if (t.isDelimiter()) {
stack.push(temp);
return PARSE_OK;
}
if (t.isOperator(OP_DECLARE)) {
// (a := c)
parseExpression();
temp.setValue(stack.back());
stack.pop();
return PARSE_OK;
}
if (t.isOperator(OP_EQUALS)) {
assert(!hasName);
assert(hasType);
// (b = c)
parseExpression();
temp.setValue(stack.pop());
return PARSE_OK;
}
if (t.isOperator(OP_COLON)) {
// a : b
assert(hasName);
assert(!hasType);
lex++;
Token b = lex[0];
temp.type_ = b.text;
hasType = true;
lex++;
t = lex[0];
if (!t.isOperator(OP_EQUALS)) {
assert(false);
}
lex++;
parseExpression();
temp.setValue(stack.pop());
return PARSE_OK;
}
assert(false);
return PARSE_ERROR;
}
