void InfoWidget::SetDrawInfo(Draw *draw) {
DrawInfo *info = draw->GetDrawInfo();
if (info == NULL)
return;
SetUnit(info->GetUnit());
SetColor(info->GetDrawColor());
SetPrec(info->GetPrec());
SetPeriod(draw->GetPeriod());
}
std::string SzbaseWrapper::add_param( const std::string& param
, const std::string& base
, const std::string& formula
, const std::string& token
, const std::string& type
, int prec
, unsigned start_time)
throw( szbase_invalid_name , szbase_formula_invalid_syntax, szbase_init_error )
{
if( !SzbaseWrapper::is_initialized() )
throw szbase_init_error("Szbase not initialized");
std::wstring _param = convert_string( param );
std::wstring _token = convert_string( token );
std::wstring _formula = convert_string( formula );
std::wstring new_param_name;
if ( !create_param_name( _param , _token , new_param_name ) )
throw szbase_invalid_name(param + " in not valid user defined param name");
std::vector<std::wstring> strings;
if( !extract_strings_from_formula( _formula , strings ) )
throw szbase_formula_invalid_syntax("formula cannot be parsed");
for( auto& param : strings )
{
std::wstring new_name;
if ( !create_param_name_in_formula( param , _token , new_name ) )
continue;
auto i = _formula.find( param );
assert( i != std::wstring::npos );
_formula.replace( i , param.size() , new_name );
}
TParam::FormulaType formula_type;
if( type == "av" )
formula_type = TParam::LUA_AV;
else if( type == "va" )
formula_type = TParam::LUA_VA;
auto tparam = new TParam(NULL, NULL, L"", formula_type, TParam::P_LUA);
tparam->SetName(new_param_name);
tparam->SetPrec(prec);
tparam->SetTimeType(TParam::NANOSECOND); ///XXX:
tparam->SetLuaScript(SC::S2U(_formula).c_str());
tparam->SetLuaStartDateTime(start_time);
IPKContainer::GetObject()->AddExtraParam( convert_string ( base ) , tparam );
return reinterpret_cast<const char*>(SC::S2U(new_param_name).c_str());
}
// ****************************************************************************
// Constructor: ExprGrammar::ExprGrammar
//
// Programmer: Jeremy Meredith
// Creation: April 5, 2002
//
// ****************************************************************************
ExprGrammar::ExprGrammar() : Grammar(D)
{
// ----------------------------------------------------------------------
// Start rule
SetStartSymbol(Expr);
// ----------------------------------------------------------------------
// Expression
AddRule(Rule(0, Expr) >> (Expr + T_Plus + Expr) ); // addition
AddRule(Rule(1, Expr) >> (Expr + T_Minus + Expr) ); // subtraction
AddRule(Rule(2, Expr) >> (Expr + T_Mult + Expr) ); // multiplication
AddRule(Rule(3, Expr) >> (Expr + T_Slash + Expr) ); // division
AddRule(Rule(4, Expr) >> (Expr + T_Exp + Expr) ); // exponentiation
AddRule(Rule(5, Expr) >> (Expr + T_Mod + Expr) ); // modulo
AddRule(Rule(15, Expr) >> (Expr + T_And + Expr) ); // bitwise and
AddRule(Rule(6, Expr) >> (Expr + T_LBracket + T_Integer + T_RBracket) ); // index
AddRule(Rule(7, Expr) >> (T_Minus + Expr), 5); // u-negative, prec=5
AddRule(Rule(8, Expr) >> (T_LParen + Expr + T_RParen) );
AddRule(Rule(9, Expr) >> Constant );
AddRule(Rule(10, Expr) >> Vector );
AddRule(Rule(11, Expr) >> Function );
AddRule(Rule(12, Expr) >> Variable );
AddRule(Rule(13, Expr) >> Database );
//AddRule(Rule(14, Expr) >> List );
// Constant
AddRule(Rule(0, Constant) >> T_Integer );
AddRule(Rule(1, Constant) >> T_Float );
AddRule(Rule(2, Constant) >> T_String );
AddRule(Rule(3, Constant) >> T_Bool );
// Vector
AddRule(Rule(0, Vector) >> (T_LBrace + Expr + T_Comma + Expr + T_RBrace));
AddRule(Rule(1, Vector) >> (T_LBrace + Expr + T_Comma + Expr + T_Comma + Expr + T_RBrace));
// List
AddRule(Rule(0, List) >> (T_LBracket + ListElems + T_RBracket));
// ListElems
AddRule(Rule(0, ListElems) >> (ListElems + T_Comma + ListElem));
AddRule(Rule(1, ListElems) >> ListElem);
// ListElem
AddRule(Rule(0, ListElem) >> Expr);
AddRule(Rule(1, ListElem) >> (Expr + T_Colon + Expr));
AddRule(Rule(2, ListElem) >> (Expr + T_Colon + Expr + T_Colon + Expr));
// Function
AddRule(Rule(0, Function) >> (T_Ident + T_LParen + T_RParen));
AddRule(Rule(1, Function) >> (T_Ident + T_LParen + Args + T_RParen));
// Args
AddRule(Rule(0, Args) >> (Args + T_Comma + Arg));
AddRule(Rule(1, Args) >> Arg);
// Arg
AddRule(Rule(0, Arg) >> Expr);
AddRule(Rule(1, Arg) >> (T_Ident + T_Equal + Expr));
AddRule(Rule(2, Arg) >> List);
// PathSpec
AddRule(Rule(0, PathSpec) >> (PathSpec + MultiSlash + T_Ident));
AddRule(Rule(1, PathSpec) >> (MultiSlash + T_Ident));
AddRule(Rule(2, PathSpec) >> T_Ident);
// MultiSlash
AddRule(Rule(0, MultiSlash) >> (MultiSlash + T_Slash));
AddRule(Rule(1, MultiSlash) >> T_Slash);
AddRule(Rule(2, MultiSlash) >> (MultiSlash + T_BackSlash));
AddRule(Rule(3, MultiSlash) >> T_BackSlash);
// Variable
AddRule(Rule(0, Variable) >> T_Ident );
AddRule(Rule(1, Variable) >> (T_LCarat + PathSpec + T_RCarat) );
AddRule(Rule(2, Variable) >> (T_LCarat + DBSpec + T_Colon + PathSpec + T_RCarat) );
// Database
AddRule(Rule(0, Database) >> (T_LCarat + DBSpec + T_Colon + T_RCarat) );
// DBSpec
AddRule(Rule(0, DBSpec) >> PathSpec );
AddRule(Rule(1, DBSpec) >> (PathSpec + MachSpec));
AddRule(Rule(2, DBSpec) >> TimeSpec );
AddRule(Rule(3, DBSpec) >> (PathSpec + TimeSpec) );
AddRule(Rule(4, DBSpec) >> (PathSpec + MachSpec + TimeSpec) );
// MachSpec
AddRule(Rule(0, MachSpec) >> (T_At + T_Ident) );
// TimeSpec
AddRule(Rule(0, TimeSpec) >> (T_LBracket + ListElems + T_RBracket + T_Ident));
AddRule(Rule(1, TimeSpec) >> (T_LBracket + ListElems + T_RBracket));
AddRule(Rule(2, TimeSpec) >> (T_LBracket + T_Pound + ListElems + T_RBracket));
// ----------------------------------------------------------------------
// -- associativity --
SetAssoc(T_Mod, Grammar::NonAssoc);
SetAssoc(T_Plus, Grammar::Left);
SetAssoc(T_Minus, Grammar::Left);
SetAssoc(T_Mult, Grammar::Left);
SetAssoc(T_Slash, Grammar::Left);
SetAssoc(T_Exp, Grammar::Right);
SetAssoc(T_And, Grammar::NonAssoc);
// -- precedence --
SetPrec(T_Mod, 1);
SetPrec(T_Plus, 2);
SetPrec(T_Minus, 2);
SetPrec(T_Mult, 3);
SetPrec(T_Slash, 3);
SetPrec(T_Exp, 4);
SetPrec(T_And, 4);
// Unary minus is 5 -- see rule above
SetPrec(T_LBracket, 6);
}
