AnimExpression::OpCode AnimExpression::coerseToValue(const AnimVariantMap& map, const OpCode& opCode) const {
switch (opCode.type) {
case OpCode::Identifier:
{
const AnimVariant& var = map.get(opCode.strVal);
switch (var.getType()) {
case AnimVariant::Type::Bool:
return OpCode((bool)var.getBool());
break;
case AnimVariant::Type::Int:
return OpCode(var.getInt());
break;
case AnimVariant::Type::Float:
return OpCode(var.getFloat());
break;
default:
// TODO: Vec3, Quat are unsupported
assert(false);
return OpCode(0);
break;
}
}
break;
case OpCode::Bool:
case OpCode::Int:
case OpCode::Float:
return opCode;
default:
qCCritical(animation) << "AnimExpression: ERROR expected a number, type = " << opCode.type;
assert(false);
return OpCode(0);
break;
}
}
//
// Borrar Líneas de Nombre de Fantasía, Encabezado y Cola
//
// Nota: en este modelo solo se tienen en cuenta los flags de borrado
// de Encabezado y Cola (ya que no reconoce Líneas de Fantasía).
//
void
ImpresorFiscalP950_100::BorrarFantasiaEncabezadoCola (bool BorrarFantasia, bool BorrarEncabezado, bool BorrarCola) throw (Excepcion)
{
// printf ("Comando BorrarFantasiaEncabezadoCola ejecutado en P950_100\n");
if ( BorrarEncabezado )
for ( unsigned Linea = First_Header_Line; Linea <= Last_Header_Line; Linea++ )
EnviarComandoFiscal(OpCode(CMD_SET_HEADER_TRAILER) + FS +
Numero (Linea) + FS + ERASE_LINE);
if ( BorrarCola )
for ( unsigned Linea = First_Trailer_Line; Linea <= Last_Trailer_Line; Linea++ )
EnviarComandoFiscal(OpCode(CMD_SET_HEADER_TRAILER) + FS +
Numero (Linea) + FS + ERASE_LINE);
}
bool CDumpMemory::DumpMemory(LPCSTR FileName, DumpFormat Format, DWORD StartPC, DWORD EndPC, DWORD /*DumpPC*/)
{
switch (Format)
{
case DisassemblyWithPC:
{
CLog LogFile;
if (!LogFile.Open(FileName))
{
g_Notify->DisplayError(stdstr_f("Failed to open\n%s", FileName).c_str());
return false;
}
LogFile.SetFlush(false);
LogFile.SetTruncateFile(false);
g_Notify->BreakPoint(__FILE__, __LINE__);
#ifdef legacycode
char Command[200];
for (COpcode OpCode(StartPC); OpCode.PC() < EndPC; OpCode.Next())
{
const char * szOpName = OpCode.OpcodeName();
OpCode.OpcodeParam(Command);
LogFile.LogF("%X: %-15s%s\r\n",OpCode.PC(),szOpName,Command);
}
#endif
m_StartAddress.SetValue(StartPC, true, true);
m_EndAddress.SetValue(EndPC, true, true);
return true;
}
break;
}
return false;
}
//
// Cortar Papel
//
void
ImpresorFiscalP950_100::CortarPapel () throw (Excepcion)
{
// printf ("Comando CortarPapel ejecutado en P950_100\n");
// Enviamos el comando fiscal y evaluamos los status
EnviarComandoFiscal(OpCode(CMD_CUT_NON_FISCAL_RECEIPT));
}
//
// Descuento General
//
// Nota: en este modelo (por no contar con el comando asociado)
// este método se implementa como una venta.
//
void
ImpresorFiscalP950_100::DescuentoGeneral (const std::string &Texto, double Monto, bool EnNegativo) throw (Excepcion)
{
// printf ("Comando DescuentoGeneral ejecutado en P950_100\n");
unsigned PrintItemTextSize = PrintItemTextTicketSize;
assert(PrintItemTextSize != 0);
// Enviamos el comando fiscal y evaluamos los status
EnviarComandoFiscal(OpCode(CMD_PRINT_LINE_ITEM) + FS +
Cadena (Texto, PrintItemTextSize) + FS +
Numero (1, 10) + FS +
Numero (Monto, PriceDecimals) + FS +
Cadena ("**.**", 5) + FS +
(EnNegativo ? "m" : "M") + FS +
Numero (0, 2) + FS +
Caracter (ModoDisplay) + FS +
Caracter (ModalidadPrecio));
// Reinicializamos 'LastIVA' y 'LastII'
LastIVA = -1;
LastII = -1;
}
void random_setup(
size_t num_var ,
const pod_vector<opcode_t>& op_vec ,
const pod_vector<addr_t>& arg_vec ,
pod_vector<Addr>* op2arg_vec ,
pod_vector<Addr>* op2var_vec ,
pod_vector<Addr>* var2op_vec )
{
if( op2arg_vec->size() != 0 )
{ CPPAD_ASSERT_UNKNOWN( op2arg_vec->size() == op_vec.size() );
CPPAD_ASSERT_UNKNOWN( op2var_vec->size() == op_vec.size() );
CPPAD_ASSERT_UNKNOWN( var2op_vec->size() == num_var );
return;
}
CPPAD_ASSERT_UNKNOWN( op2var_vec->size() == 0 );
CPPAD_ASSERT_UNKNOWN( op2var_vec->size() == 0 );
CPPAD_ASSERT_UNKNOWN( var2op_vec->size() == 0 );
CPPAD_ASSERT_UNKNOWN( OpCode( op_vec[0] ) == BeginOp );
CPPAD_ASSERT_NARG_NRES(BeginOp, 1, 1);
//
size_t num_op = op_vec.size();
size_t var_index = 0;
size_t arg_index = 0;
//
op2arg_vec->resize( num_op );
op2var_vec->resize( num_op );
var2op_vec->resize( num_var );
# ifndef NDEBUG
// value of var2op for auxillary variables is num_op (invalid)
for(size_t i_var = 0; i_var < num_var; ++i_var)
(*var2op_vec)[i_var] = Addr( num_op );
// value of op2var is num_var (invalid) when NumRes(op) = 0
for(size_t i_op = 0; i_op < num_op; ++i_op)
(*op2var_vec)[i_op] = Addr( num_var );
# endif
for(size_t i_op = 0; i_op < num_op; ++i_op)
{ OpCode op = OpCode( op_vec[i_op] );
//
// index of first argument for this operator
(*op2arg_vec)[i_op] = Addr( arg_index );
arg_index += NumArg(op);
//
// index of first result for next operator
var_index += NumRes(op);
if( NumRes(op) > 0 )
{ // index of last (primary) result for this operator
(*op2var_vec)[i_op] = Addr( var_index - 1 );
//
// mapping from primary variable to its operator
(*var2op_vec)[var_index - 1] = Addr( i_op );
}
// CSumOp
if( op == CSumOp )
{ CPPAD_ASSERT_UNKNOWN( NumArg(CSumOp) == 0 );
//
// pointer to first argument for this operator
const addr_t* op_arg = arg_vec.data() + arg_index;
//
// The actual number of arugments for this operator is
// op_arg[4] + 1
// Correct index of first argument for next operator
arg_index += size_t(op_arg[4] + 1);
}
//
// CSkip
if( op == CSkipOp )
{ CPPAD_ASSERT_UNKNOWN( NumArg(CSumOp) == 0 );
//
// pointer to first argument for this operator
const addr_t* op_arg = arg_vec.data() + arg_index;
//
// The actual number of arugments for this operator is
// 7 + op_arg[4] + op_arg[5].
// Correct index of first argument for next operator.
arg_index += size_t(7 + op_arg[4] + op_arg[5]);
}
}
}
GimpleNode* AstFilterState::gimplify(FlowGraph* thisGraph){
GimpleStatement* gimpleStmt = new GimpleStatement(OpCode('*'),outFrame, inFrame, filterKernel );
thisGraph->appandGimpleNode(gimpleStmt);
return gimpleStmt;
}
