/** \brief Calls a parser function with its corresponding arguments.
\param a_stOpt The operator stack
\param a_stVal The value stack
\param a_iArgCount The number of function arguments
*/
void ParserXBase::ApplyFunc(Stack<ptr_tok_type> &a_stOpt,
int a_iArgCount) const
{
if (a_stOpt.empty())
return;
ptr_tok_type tok = a_stOpt.pop();
ICallback *pFun = tok->AsICallback();
int iArgCount = (pFun->GetArgc()>=0) ? pFun->GetArgc() : a_iArgCount;
pFun->SetNumArgsPresent(iArgCount);
m_nPos -= (iArgCount - 1);
m_rpn.Add(tok);
}
// UndoList.cpp : Implementation of CUndoList
#include "stdafx.h"
#include "UndoList.h"
#include "ShapeEditor.h"
#include "TableHelper.h"
int CUndoList::g_UniqueId = -1;
const int CUndoList::EMPTY_BATCH_ID = -1;
//***********************************************************************/
//* GetShapefile()
//***********************************************************************/
IShapefile* CUndoList::GetShapefile(long layerHandle)
{
if (!CheckState()) return NULL;
return _mapCallback->_GetShapefile(layerHandle);
}
//***********************************************************************/
//* ErrorMessage()
//***********************************************************************/
void CUndoList::ErrorMessage(long ErrorCode)
{
if (!CheckState()) return;
_lastErrorCode = ErrorCode;
USES_CONVERSION;
ICallback* cb;
if (_lastErrorCode != tkNO_ERROR) {
cb = _mapCallback->_GetGlobalCallback();
if (cb) {
CallbackHelper::ErrorMsg("UndoList", cb, _key, ErrorMsg(_lastErrorCode));
cb->Release();
}
}
}
//---------------------------------------------------------------------------
void RPN::Add(ptr_tok_type tok)
{
m_vRPN.push_back(tok);
if (tok->AsIValue()!=NULL)
{
m_nStackPos++;
}
else if (tok->AsICallback())
{
ICallback *pFun = tok->AsICallback();
MUP_ASSERT(pFun);
m_nStackPos -= pFun->GetArgsPresent() - 1;
}
MUP_ASSERT(m_nStackPos>=0);
m_nMaxStackPos = std::max(m_nStackPos, m_nMaxStackPos);
}
static void CreateFault(ICallback<const DataObject&>& rCallback, const std::string& sFaultCode,
const std::string& sFaultError)
{
// generate fault using Operation
Operation tFault;
tFault.SetFault(sFaultCode, sFaultError);
rCallback.OnFault(tFault.GetResponse());
}
void SingleThreadedParallelizer::loop(ICallback& callback, int start, int end, int stride) {
for(int i=start; i<end; i+=stride) {
int jEnd = std::min(end, i + stride);
for(int j=i; j<jEnd; ++j) {
callback.invoke(j);
}
}
}
//++ ------------------------------------------------------------------------------------
// Details: Iterate all interested clients and tell them a command is being deleted.
// Type: Method.
// Args: vCmd - (RW) The command to be deleted.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
void
CSetClients::Delete(SMICmdData &vCmd)
{
m_bClientUnregistered = false; // Reset
iterator it = begin();
while (it != end())
{
ICallback *pObj = *it;
pObj->Delete(vCmd);
if (m_bClientUnregistered)
{
m_bClientUnregistered = false; // Reset
it = begin();
}
else
// Next
++it;
}
}
RESULT
Animation::CallbackOnFinished( ICallback& callback )
{
RESULT rval = S_OK;
if (callback.IsNull())
{
RETAILMSG(ZONE_ERROR, "ERROR: Animation::CallbackOnFinished( \"%s\", 0x%x ): Callback is NULL",
m_name.c_str(), (UINT32)&callback);
SAFE_DELETE(m_pCallbackOnFinished);
rval = E_INVALID_ARG;
goto Exit;
}
SAFE_DELETE(m_pCallbackOnFinished);
m_pCallbackOnFinished = callback.Clone();
Exit:
return rval;
}
virtual void Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc)
{
ParserXBase &parser = *GetParent();
console() << _T("\nParser functions:\n");
console() << _T( "----------------\n");
fun_maptype fmap = parser.GetFunDef();
if (!fmap.size())
{
console() << _T("No functions defined\n");
}
else
{
val_maptype::iterator item = fmap.begin();
for (; item!=fmap.end(); ++item)
{
ICallback *pFun = (ICallback*)item->second.Get();
console() << pFun->GetDesc() << _T("\n");
}
}
*ret = (int)fmap.size();
}
void SkypeLowIoImpl::thread_func()
{
utils::set_this_thread_name( "skype_low_io" );
dummy_log_trace( MODULENAME, "SkypeLowIoImpl::thread_func: started" );
is_running_ = true;
while( true )
{
if( must_stop_ )
break;
{
MUTEX_SCOPE_LOCK( mutex_ );
unsigned int seq = sequence_;
dbus_.read_write_dispatch( 100 );
if( seq != sequence_ )
{
if( sequence_ - seq > 1 )
{
dummy_log_fatal( MODULENAME, "SkypeLowIoImpl::thread_func: missed messages" );
::exit( 42 );
}
if( callback_ )
callback_->handle( response_ );
seq = sequence_;
}
}
THIS_THREAD_SLEEP_MS( 1 );
}
is_running_ = false;
dummy_log_trace( MODULENAME, "SkypeLowIoImpl::thread_func: exit" );
}
//---------------------------------------------------------------------------
void ParserXBase::CreateRPN() const
{
if (!m_pTokenReader->GetExpr().length())
Error(ecUNEXPECTED_EOF, 0);
// The Stacks take the ownership over the tokens
Stack<ptr_tok_type> stOpt;
Stack<ptr_val_type> stVal;
Stack<ICallback*> stFunc;
Stack<int> stArgCount;
Stack<int> stIdxCount;
ptr_tok_type pTok, pTokPrev;
Value val;
ReInit();
// The outermost counter counts the number of seperated items
// such as in "a=10,b=20,c=c+a"
stArgCount.push(1);
for(bool bLoop=true; bLoop;)
{
pTokPrev = pTok;
pTok = m_pTokenReader->ReadNextToken();
#if defined(MUP_DUMP_TOKENS)
cout << pTok->AsciiDump() << endl;
#endif
ECmdCode eCmd = pTok->GetCode();
switch (eCmd)
{
case cmVAR:
case cmVAL:
{
IValue *pVal = pTok->AsIValue();
if (stFunc.empty() && pVal->GetType()=='n')
{
ErrorContext err;
err.Errc = ecUNEXPECTED_PARENS;
err.Ident = _T(")");
err.Pos = pTok->GetExprPos();
throw ParserError(err);
}
stVal.push( ptr_val_type(pVal) );
// Arrays can't be added directly to the reverse polish notation
// since there may be an index operator following next...
m_rpn.Add(pTok);
// Apply infix operator if existant
if (stOpt.size() && stOpt.top()->GetCode()==cmOPRT_INFIX)
ApplyFunc(stOpt, stVal, 1);
}
break;
case cmIC:
{
// The argument count for parameterless functions is zero
// by default an opening bracket sets parameter count to 1
// in preparation of arguments to come. If the last token
// was an opening bracket we know better...
if (pTokPrev.Get()!=NULL && pTokPrev->GetCode()==cmIO)
--stArgCount.top();
ApplyRemainingOprt(stOpt, stVal);
// if opt is "]" and opta is "[" the bracket content has been evaluated.
// Now its time to check if there is either a function or a sign pending.
// - Neither the opening nor the closing bracket will be pushed back to
// the operator stack
// - Check if a function is standing in front of the opening bracket,
// if so evaluate it afterwards to apply an infix operator.
if ( stOpt.size() && stOpt.top()->GetCode()==cmIO )
{
//
// Find out how many dimensions were used in the index operator.
//
std::size_t iArgc = stArgCount.pop();
stOpt.pop(); // Take opening bracket from stack
IOprtIndex *pOprtIndex = pTok->AsIOprtIndex();
MUP_ASSERT(pOprtIndex!=NULL);
pOprtIndex->SetNumArgsPresent(iArgc);
m_rpn.Add(pTok);
// Pop the index values from the stack
MUP_ASSERT(stVal.size()>=iArgc+1);
for (std::size_t i=0; i<iArgc; ++i)
stVal.pop();
// Now i would need to pop the topmost value from the stack, apply the index
// opertor and push the result back to the stack. But here we are just creating the
// RPN and are working with dummy values anyway so i just mark the topmost value as
// volatile and leave it were it is. The real index logic is in the RPN evaluator...
stVal.top()->AddFlags(IToken::flVOLATILE);
} // if opening index bracket is on top of operator stack
}
break;
case cmBC:
{
// The argument count for parameterless functions is zero
// by default an opening bracket sets parameter count to 1
// in preparation of arguments to come. If the last token
// was an opening bracket we know better...
if (pTokPrev.Get()!=NULL && pTokPrev->GetCode()==cmBO)
--stArgCount.top();
ApplyRemainingOprt(stOpt, stVal);
// if opt is ")" and opta is "(" the bracket content has been evaluated.
// Now its time to check if there is either a function or a sign pending.
// - Neither the opening nor the closing bracket will be pushed back to
// the operator stack
// - Check if a function is standing in front of the opening bracket,
// if so evaluate it afterwards to apply an infix operator.
if ( stOpt.size() && stOpt.top()->GetCode()==cmBO )
{
//
// Here is the stuff to evaluate a function token
//
int iArgc = stArgCount.pop();
stOpt.pop(); // Take opening bracket from stack
if ( stOpt.empty() )
break;
if ( (stOpt.top()->GetCode()!=cmFUNC) && (stOpt.top()->GetCode()!=cmOPRT_INFIX) )
break;
ICallback *pFun = stOpt.top()->AsICallback();
stFunc.pop();
if (pFun->GetArgc()!=-1 && iArgc > pFun->GetArgc())
Error(ecTOO_MANY_PARAMS, pTok->GetExprPos(), pFun);
if (iArgc < pFun->GetArgc())
Error(ecTOO_FEW_PARAMS, pTok->GetExprPos(), pFun);
// Evaluate the function
ApplyFunc(stOpt, stVal, iArgc);
// Apply an infix operator, if present
if (stOpt.size() && stOpt.top()->GetCode()==cmOPRT_INFIX)
ApplyFunc(stOpt, stVal, 1);
}
}
break;
case cmELSE:
ApplyRemainingOprt(stOpt, stVal);
m_rpn.Add(pTok);
stOpt.push(pTok);
break;
case cmSCRIPT_NEWLINE:
{
ApplyRemainingOprt(stOpt, stVal);
// Value stack plätten
// Stack der RPN um die Anzahl im stack enthaltener Werte zurück setzen
int n = stVal.size();
m_rpn.AddNewline(pTok, n);
stVal.clear();
stOpt.clear();
}
break;
case cmARG_SEP:
if (stArgCount.empty())
Error(ecUNEXPECTED_COMMA, m_pTokenReader->GetPos());
++stArgCount.top();
//if (stVal.size()) // increase argument counter
// stArgCount.top()++;
ApplyRemainingOprt(stOpt, stVal);
break;
case cmEOE:
ApplyRemainingOprt(stOpt, stVal);
m_rpn.Finalize();
break;
case cmIF:
case cmOPRT_BIN:
{
while ( stOpt.size() &&
stOpt.top()->GetCode() != cmBO &&
stOpt.top()->GetCode() != cmIO &&
stOpt.top()->GetCode() != cmELSE &&
stOpt.top()->GetCode() != cmIF)
{
IToken *pOprt1 = stOpt.top().Get();
IToken *pOprt2 = pTok.Get();
MUP_ASSERT(pOprt1 && pOprt2);
MUP_ASSERT(pOprt1->AsIPrecedence() && pOprt2->AsIPrecedence());
int nPrec1 = pOprt1->AsIPrecedence()->GetPri(),
nPrec2 = pOprt2->AsIPrecedence()->GetPri();
if (pOprt1->GetCode()==pOprt2->GetCode())
{
// Deal with operator associativity
EOprtAsct eOprtAsct = pOprt1->AsIPrecedence()->GetAssociativity();
if ( (eOprtAsct==oaRIGHT && (nPrec1 <= nPrec2)) ||
(eOprtAsct==oaLEFT && (nPrec1 < nPrec2)) )
{
break;
}
}
else if (nPrec1 < nPrec2)
{
break;
}
// apply the operator now
// (binary operators are identic to functions with two arguments)
ApplyFunc(stOpt, stVal, 2);
} // while ( ... )
if (pTok->GetCode()==cmIF)
m_rpn.Add(pTok);
stOpt.push(pTok);
}
break;
//
// Postfix Operators
//
case cmOPRT_POSTFIX:
{
MUP_ASSERT(stVal.size());
ptr_val_type &pVal(stVal.top());
try
{
// place a dummy return value into the value stack, do not
// evaluate pOprt (this is important for lazy evaluation!)
// The only place where evaluation takes place is the RPN
// engine!
pVal = ptr_val_type(new Value());
m_rpn.Add(pTok);
}
catch(ParserError &)
{
if (!m_bIsQueryingExprVar)
throw;
}
}
break;
case cmIO:
case cmBO:
stOpt.push(pTok);
stArgCount.push(1);
break;
//
// Functions
//
case cmOPRT_INFIX:
case cmFUNC:
{
ICallback *pFunc = pTok->AsICallback();
MUP_ASSERT(pFunc);
// Check if this function is a argument to another function
// if so check if the the return type fits.
if (!stFunc.empty() && stFunc.top()->GetCode()==cmFUNC)
{
MUP_ASSERT(stArgCount.size());
int iArgc = (int)stArgCount.top() /*+ 1*/;
ICallback *pOuterFunc = stFunc.top();
if (pOuterFunc->GetArgc()!=-1 && iArgc>pOuterFunc->GetArgc())
Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos());
MUP_ASSERT(pOuterFunc->GetArgc()==-1 || iArgc<=pOuterFunc->GetArgc());
}
stOpt.push(pTok);
stFunc.push(pFunc); // to collect runtime type information
}
break;
default:
Error(ecINTERNAL_ERROR);
} // switch Code
if (ParserXBase::s_bDumpStack)
{
StackDump( stVal, stOpt );
}
if ( pTok->GetCode() == cmEOE )
bLoop = false;
} // for (all tokens)
if (ParserXBase::s_bDumpRPN)
{
m_rpn.AsciiDump();
}
m_nFinalResultIdx = stArgCount.top()-1;
MUP_ASSERT(stVal.size());
}
/** \brief Calls a parser function with its corresponding arguments.
\param a_stOpt The operator stack
\param a_stVal The value stack
\param a_iArgCount The number of function arguments
*/
void ParserXBase::ApplyFunc(Stack<ptr_tok_type> &a_stOpt,
Stack<ptr_val_type> &a_stVal,
int a_iArgCount) const
{
if (a_stOpt.empty())
return;
ptr_tok_type tok = a_stOpt.pop();
ICallback *pFun = tok->AsICallback();
int iArgCount = (pFun->GetArgc()>=0) ? pFun->GetArgc() : a_iArgCount;
int iOffset = a_stVal.size() - iArgCount;
MUP_ASSERT(iOffset>=0);
// The paramater stack may be empty since functions may not
// have a parameter. They do always have a return value though.
// If the param stack is empty create an entry for the function
// return value.
if (iArgCount==0)
a_stVal.push(ptr_val_type(new Value()));
MUP_ASSERT((std::size_t)iOffset<a_stVal.size());
ptr_val_type *pArg = a_stVal.get_data() + iOffset;
//if (pFun->GetArgc()==0)
// a_stVal.push(ptr_val_type(new Value()));
//ptr_val_type *pArg = a_stVal.get_data() + iOffset;
try
{
// Make sure to pass on a volatile flag to the function result
bool bResultIsVolatile = false;
for (int i=0; i<iArgCount && bResultIsVolatile==false; ++i)
{
if (pArg[i]->IsFlagSet(IToken::flVOLATILE))
bResultIsVolatile = true;
}
// Instead of evaluating the function merely a dummy value of the same type as the function return value
// is created
*pArg = ptr_val_type(new Value());
pFun->SetNumArgsPresent(iArgCount);
if (bResultIsVolatile)
(*pArg)->AddFlags(IToken::flVOLATILE);
m_rpn.Add(tok);
}
catch(ParserError &e)
{
// This are type related errors caused by undefined
// variables. They must be ignored if the parser is
// just checking the presence of expression variables
if (!m_bIsQueryingExprVar)
{
ErrorContext &err = e.GetContext();
err.Pos = m_pTokenReader->GetPos();
err.Expr = m_pTokenReader->GetExpr();
if (err.Ident.empty())
err.Ident = pFun->GetIdent();
throw;
}
}
if (iArgCount>0)
a_stVal.pop(iArgCount-1); // remove the arguments
}
//---------------------------------------------------------------------------
const IValue& ParserXBase::ParseFromRPN() const
{
ptr_val_type *pStack = &m_vStackBuffer[0];
const ptr_tok_type *pRPN = &(m_rpn.GetData()[0]);
int sidx = -1;
std::size_t lenRPN = m_rpn.GetSize();
for (std::size_t i=0; i<lenRPN; ++i)
{
IToken *pTok = pRPN[i].Get();
ECmdCode eCode = pTok->GetCode();
switch (eCode)
{
case cmSCRIPT_NEWLINE:
sidx = -1; //-= static_cast<TokenNewline*>(pTok)->GetStackOffset();
m_nFinalResultIdx = 0;
continue;
case cmVAR:
{
sidx++;
assert(sidx<(int)m_vStackBuffer.size());
pStack[sidx].Reset(static_cast<IValue*>(pTok));
}
continue;
case cmVAL:
{
sidx++;
assert(sidx<(int)m_vStackBuffer.size());
ptr_val_type &val = pStack[sidx];
if (val->GetCode()==cmVAR)
val.Reset(m_cache.CreateFromCache());
*val = *(static_cast<IValue*>(pTok));
}
continue;
case cmIC:
{
IOprtIndex *pIdxOprt = static_cast<IOprtIndex*>(pTok);
int nArgs = pIdxOprt->GetArgsPresent();
sidx -= nArgs - 1;
assert(sidx>=0);
ptr_val_type &idx = pStack[sidx]; // Pointer to the first index
ptr_val_type &val = pStack[--sidx]; // Pointer to the variable or value beeing indexed
pIdxOprt->At(val, &idx, nArgs);
/*
// apply the index operator
ptr_val_type &idx = pStack[sidx--];
ptr_val_type &val = pStack[sidx];
MUP_ASSERT(val->GetCode()==cmVAR);
int i;
try
{
i = idx->GetInteger();
if (i<0)
Error(ecINDEX_OUT_OF_BOUNDS, pTok->GetExprPos(), val.Get());
}
catch(ParserError &exc)
{
if (exc.GetCode()==ecTYPE_CONFLICT)
Error(ecTYPE_CONFLICT_IDX, pTok->GetExprPos(), val.Get());
else
throw;
}
val.Reset(new Variable( &(val->At(i)) ) );
*/
}
continue;
case cmOPRT_POSTFIX:
case cmFUNC:
case cmOPRT_BIN:
case cmOPRT_INFIX:
{
ICallback *pFun = static_cast<ICallback*>(pTok);
int nArgs = pFun->GetArgsPresent();
sidx -= nArgs - 1;
assert(sidx>=0);
ptr_val_type &val = pStack[sidx];
try
{
if (val->GetCode()==cmVAR)
{
ptr_val_type buf(m_cache.CreateFromCache());
pFun->Eval(buf, &val, nArgs);
val = buf;
}
else
pFun->Eval(val, &val, nArgs);
}
catch(ParserError &exc)
{
ErrorContext err;
err.Expr = m_pTokenReader->GetExpr();
err.Ident = pFun->GetIdent();
err.Errc = ecEVAL;
err.Pos = pFun->GetExprPos();
err.Hint = exc.GetMsg();
throw ParserError(err);
}
catch(MatrixError & /*exc*/)
{
ErrorContext err;
err.Expr = m_pTokenReader->GetExpr();
err.Ident = pFun->GetIdent();
err.Errc = ecEVAL;
err.Pos = pFun->GetExprPos();
err.Hint = _T("Matrix dimension mismatch");
throw ParserError(err);
}
}
continue;
case cmIF:
MUP_ASSERT(sidx>=0);
if (pStack[sidx--]->GetBool()==false)
i+=static_cast<TokenIfThenElse*>(pTok)->GetOffset();
continue;
case cmELSE:
case cmJMP:
i += static_cast<TokenIfThenElse*>(pTok)->GetOffset();
continue;
case cmENDIF:
continue;
default:
Error(ecINTERNAL_ERROR);
} // switch token
} // for all RPN tokens
return *pStack[m_nFinalResultIdx];
}
//---------------------------------------------------------------------------
const IValue& ParserXBase::ParseFromRPN() const
{
ptr_val_type *pStack = &m_vStackBuffer[0];
if (m_rpn.GetSize()==0)
{
// Passiert bei leeren strings oder solchen, die nur Leerzeichen enthalten
ErrorContext err;
err.Expr = m_pTokenReader->GetExpr();
err.Errc = ecUNEXPECTED_EOF;
err.Pos = 0;
throw ParserError(err);
}
const ptr_tok_type *pRPN = &(m_rpn.GetData()[0]);
int sidx = -1;
std::size_t lenRPN = m_rpn.GetSize();
for (std::size_t i=0; i<lenRPN; ++i)
{
IToken *pTok = pRPN[i].Get();
ECmdCode eCode = pTok->GetCode();
switch (eCode)
{
case cmSCRIPT_NEWLINE:
sidx = -1;
continue;
case cmVAL:
{
IValue *pVal = static_cast<IValue*>(pTok);
sidx++;
assert(sidx<(int)m_vStackBuffer.size());
if (pVal->IsVariable())
{
pStack[sidx].Reset(pVal);
}
else
{
ptr_val_type &val = pStack[sidx];
if (val->IsVariable())
val.Reset(m_cache.CreateFromCache());
*val = *(static_cast<IValue*>(pTok));
}
}
continue;
case cmIC:
{
IOprtIndex *pIdxOprt = static_cast<IOprtIndex*>(pTok);
int nArgs = pIdxOprt->GetArgsPresent();
sidx -= nArgs - 1;
assert(sidx>=0);
ptr_val_type &idx = pStack[sidx]; // Pointer to the first index
ptr_val_type &val = pStack[--sidx]; // Pointer to the variable or value beeing indexed
pIdxOprt->At(val, &idx, nArgs);
}
continue;
case cmOPRT_POSTFIX:
case cmFUNC:
case cmOPRT_BIN:
case cmOPRT_INFIX:
{
ICallback *pFun = static_cast<ICallback*>(pTok);
int nArgs = pFun->GetArgsPresent();
sidx -= nArgs - 1;
assert(sidx>=0);
ptr_val_type &val = pStack[sidx];
try
{
if (val->IsVariable())
{
ptr_val_type buf(m_cache.CreateFromCache());
pFun->Eval(buf, &val, nArgs);
val = buf;
}
else
pFun->Eval(val, &val, nArgs);
}
catch(ParserError &exc)
{
// <ibg 20130131> Not too happy about that:
// Multiarg functions may throw specific error codes when evaluating.
// These codes would be converted to ecEVAL here. I omit the conversion
// for certain handpicked errors. (The reason this catch block exists is
// that not all exceptions contain proper metadata when thrown out of
// a function.)
if (exc.GetCode()==ecTOO_FEW_PARAMS || exc.GetCode()==ecDOMAIN_ERROR || exc.GetCode()==ecOVERFLOW)
throw;
// </ibg>
ErrorContext err;
err.Expr = m_pTokenReader->GetExpr();
err.Ident = pFun->GetIdent();
err.Errc = ecEVAL;
err.Pos = pFun->GetExprPos();
err.Hint = exc.GetMsg();
throw ParserError(err);
}
catch(MatrixError & /*exc*/)
{
ErrorContext err;
err.Expr = m_pTokenReader->GetExpr();
err.Ident = pFun->GetIdent();
err.Errc = ecMATRIX_DIMENSION_MISMATCH;
err.Pos = pFun->GetExprPos();
throw ParserError(err);
}
}
continue;
case cmIF:
MUP_ASSERT(sidx>=0);
if (pStack[sidx--]->GetBool()==false)
i+=static_cast<TokenIfThenElse*>(pTok)->GetOffset();
continue;
case cmELSE:
case cmJMP:
i += static_cast<TokenIfThenElse*>(pTok)->GetOffset();
continue;
case cmENDIF:
continue;
default:
Error(ecINTERNAL_ERROR);
} // switch token
} // for all RPN tokens
return *pStack[0];
}
//---------------------------------------------------------------------------
void ParserXBase::CreateRPN() const
{
if (!m_pTokenReader->GetExpr().length())
Error(ecUNEXPECTED_EOF, 0);
// The Stacks take the ownership over the tokens
Stack<ptr_tok_type> stOpt;
Stack<ICallback*> stFunc;
Stack<int> stArgCount;
Stack<int> stIdxCount;
ptr_tok_type pTok, pTokPrev;
Value val;
ReInit();
for(;;)
{
pTokPrev = pTok;
pTok = m_pTokenReader->ReadNextToken();
#if defined(MUP_DUMP_TOKENS)
console() << pTok->AsciiDump() << endl;
#endif
ECmdCode eCmd = pTok->GetCode();
switch (eCmd)
{
case cmVAL:
m_nPos++;
m_rpn.Add(pTok);
break;
case cmIC:
{
// The argument count for parameterless functions is zero
// by default an opening bracket sets parameter count to 1
// in preparation of arguments to come. If the last token
// was an opening bracket we know better...
if (pTokPrev.Get()!=nullptr && pTokPrev->GetCode()==cmIO)
--stArgCount.top();
ApplyRemainingOprt(stOpt);
// if opt is "]" and opta is "[" the bracket content has been evaluated.
// Now its time to check if there is either a function or a sign pending.
// - Neither the opening nor the closing bracket will be pushed back to
// the operator stack
// - Check if a function is standing in front of the opening bracket,
// if so evaluate it afterwards to apply an infix operator.
if ( stOpt.size() && stOpt.top()->GetCode()==cmIO )
{
//
// Find out how many dimensions were used in the index operator.
//
std::size_t iArgc = stArgCount.pop();
stOpt.pop(); // Take opening bracket from stack
IOprtIndex *pOprtIndex = pTok->AsIOprtIndex();
MUP_ASSERT(pOprtIndex!=nullptr);
pOprtIndex->SetNumArgsPresent(iArgc);
m_rpn.Add(pTok);
// Pop the index values from the stack
MUP_ASSERT(m_nPos>=(int)iArgc+1);
m_nPos -= iArgc;
} // if opening index bracket is on top of operator stack
}
break;
case cmBC:
{
// The argument count for parameterless functions is zero
// by default an opening bracket sets parameter count to 1
// in preparation of arguments to come. If the last token
// was an opening bracket we know better...
if (pTokPrev.Get()!=nullptr && pTokPrev->GetCode()==cmBO)
--stArgCount.top();
ApplyRemainingOprt(stOpt);
// if opt is ")" and opta is "(" the bracket content has been evaluated.
// Now its time to check if there is either a function or a sign pending.
// - Neither the opening nor the closing bracket will be pushed back to
// the operator stack
// - Check if a function is standing in front of the opening bracket,
// if so evaluate it afterwards to apply an infix operator.
if ( stOpt.size() && stOpt.top()->GetCode()==cmBO )
{
//
// Here is the stuff to evaluate a function token
//
int iArgc = stArgCount.pop();
stOpt.pop(); // Take opening bracket from stack
if (stOpt.empty())
break;
if ((stOpt.top()->GetCode()!=cmFUNC) && (stOpt.top()->GetCode()!=cmOPRT_INFIX))
break;
ICallback *pFun = stOpt.top()->AsICallback();
stFunc.pop();
if (pFun->GetArgc()!=-1 && iArgc > pFun->GetArgc())
Error(ecTOO_MANY_PARAMS, pTok->GetExprPos(), pFun);
if (iArgc < pFun->GetArgc())
Error(ecTOO_FEW_PARAMS, pTok->GetExprPos(), pFun);
// Apply function, if present
if (stOpt.size() &&
stOpt.top()->GetCode()!=cmOPRT_INFIX &&
stOpt.top()->GetCode()!=cmOPRT_BIN)
{
ApplyFunc(stOpt, iArgc);
}
}
}
break;
case cmELSE:
ApplyRemainingOprt(stOpt);
m_rpn.Add(pTok);
stOpt.push(pTok);
break;
case cmSCRIPT_NEWLINE:
ApplyRemainingOprt(stOpt);
m_rpn.AddNewline(pTok, m_nPos);
stOpt.clear();
m_nPos = 0;
break;
case cmARG_SEP:
if (stArgCount.empty())
Error(ecUNEXPECTED_COMMA, m_pTokenReader->GetPos()-1);
++stArgCount.top();
ApplyRemainingOprt(stOpt);
break;
case cmEOE:
ApplyRemainingOprt(stOpt);
m_rpn.Finalize();
break;
case cmIF:
case cmOPRT_BIN:
{
while ( stOpt.size() &&
stOpt.top()->GetCode() != cmBO &&
stOpt.top()->GetCode() != cmIO &&
stOpt.top()->GetCode() != cmELSE &&
stOpt.top()->GetCode() != cmIF)
{
IToken *pOprt1 = stOpt.top().Get();
IToken *pOprt2 = pTok.Get();
MUP_ASSERT(pOprt1 && pOprt2);
MUP_ASSERT(pOprt1->AsIPrecedence() && pOprt2->AsIPrecedence());
int nPrec1 = pOprt1->AsIPrecedence()->GetPri(),
nPrec2 = pOprt2->AsIPrecedence()->GetPri();
if (pOprt1->GetCode()==pOprt2->GetCode())
{
// Deal with operator associativity
EOprtAsct eOprtAsct = pOprt1->AsIPrecedence()->GetAssociativity();
if ( (eOprtAsct==oaRIGHT && (nPrec1 <= nPrec2)) ||
(eOprtAsct==oaLEFT && (nPrec1 < nPrec2)) )
{
break;
}
}
else if (nPrec1 < nPrec2)
{
break;
}
// apply the operator now
// (binary operators are identic to functions with two arguments)
ApplyFunc(stOpt, 2);
} // while ( ... )
if (pTok->GetCode()==cmIF)
m_rpn.Add(pTok);
stOpt.push(pTok);
}
break;
//
// Postfix Operators
//
case cmOPRT_POSTFIX:
MUP_ASSERT(m_nPos);
m_rpn.Add(pTok);
break;
case cmIO:
case cmBO:
stOpt.push(pTok);
stArgCount.push(1);
break;
//
// Functions
//
case cmOPRT_INFIX:
case cmFUNC:
{
ICallback *pFunc = pTok->AsICallback();
MUP_ASSERT(pFunc);
// Check if this function is a argument to another function
// if so check if the the return type fits.
if (!stFunc.empty() && stFunc.top()->GetCode()==cmFUNC)
{
MUP_ASSERT(stArgCount.size());
int iArgc = (int)stArgCount.top() /*+ 1*/;
ICallback *pOuterFunc = stFunc.top();
if (pOuterFunc->GetArgc()!=-1 && iArgc>pOuterFunc->GetArgc())
Error(ecTOO_MANY_PARAMS, m_pTokenReader->GetPos());
MUP_ASSERT(pOuterFunc->GetArgc()==-1 || iArgc<=pOuterFunc->GetArgc());
}
stOpt.push(pTok);
stFunc.push(pFunc); // to collect runtime type information
}
break;
default:
Error(ecINTERNAL_ERROR);
} // switch Code
if (ParserXBase::s_bDumpStack)
{
StackDump(stOpt);
}
if ( pTok->GetCode() == cmEOE )
break;
} // for (all tokens)
if (ParserXBase::s_bDumpRPN)
{
m_rpn.AsciiDump();
}
if (m_nPos>1)
{
Error(ecUNEXPECTED_COMMA, -1);
}
}
void SingleThreadedParallelizer::loop(ICallback& callback, int start, int end) {
for(int i=start; i<end; ++i) {
callback.invoke(i);
}
}
