int BinaryData::Compare(const BinaryData & inData) const
{
int diff((int)DataSize() - (int)inData.DataSize());
if (!diff && DataSize() > 0)
diff = memcmp((const void *)*this, (const void *)inData, DataSize());
return diff;
}
bool vmTypeLibrary::DataSizeBiggerThan (vmValType& type, int size) {
// Return true if data size > size.
// This is logically equivalent to: DataSize (type) > size,
// except it correctly handles integer overflow for really big types.
assert (TypeValid (type));
if (type.PhysicalPointerLevel () == 0 && type.m_arrayLevel > 0) {
vmValType element = type;
element.m_arrayLevel = 0;
return type.ArraySizeBiggerThan (size, DataSize (element));
}
else
return DataSize (type) > size;
}
nsCSSCompressedDataBlock*
nsCSSCompressedDataBlock::Clone() const
{
const char *cursor = Block(), *cursor_end = BlockEnd();
char *result_cursor;
nsAutoPtr<nsCSSCompressedDataBlock> result
(new(cursor_end - cursor) nsCSSCompressedDataBlock());
if (!result)
return nsnull;
result_cursor = result->Block();
while (cursor < cursor_end) {
nsCSSProperty iProp = PropertyAtCursor(cursor);
NS_ABORT_IF_FALSE(!nsCSSProps::IsShorthand(iProp), "out of range");
PropertyAtCursor(result_cursor) = iProp;
const nsCSSValue* val = ValueAtCursor(cursor);
nsCSSValue *result_val = ValueAtCursor(result_cursor);
new (result_val) nsCSSValue(*val);
cursor += CDBValueStorage_advance;
result_cursor += CDBValueStorage_advance;
}
NS_ABORT_IF_FALSE(cursor == cursor_end, "inconsistent data");
result->SetBlockEnd(result_cursor);
result->mStyleBits = mStyleBits;
NS_ABORT_IF_FALSE(result->DataSize() == DataSize(), "wrong size");
return result.forget();
}
unsigned char BinaryData::operator[](size_t index) const
{
unsigned char ch = 0;
if (index < DataSize())
ch = ((const unsigned char *)((const void *)*this))[index];
return ch;
}
size_t BinaryData::Append(const BinaryData &inData)
{
if (inData.DataSize() == 0)
return 0;
if (m_pBuffer != NULL)
SetData(m_pBuffer, DataSize());
if (Size() - DataSize() < inData.DataSize()) {
mBuffer.resize(Size() + inData.DataSize(), 0);
mBufferSize = mBuffer.size();
}
memcpy_s((void *)(*this + DataSize()), Size() - DataSize(), inData, inData.DataSize());
mDataSize += inData.DataSize();
return DataSize();
}
size_t BinaryData::BuildFromString(const TCHAR * pStr, bool asString)
{
SetData();
mBufferSize = BinaryDataUtil::StrToBuffer(pStr, mBuffer, asString);
mDataSize = mBufferSize;
return DataSize();
}
void PtexReader::getPixel(int faceid, int u, int v,
float* result, int firstchan, int nchannels,
Ptex::Res res)
{
memset(result, 0, nchannels);
// clip nchannels against actual number available
nchannels = PtexUtils::min(nchannels,
_header.nchannels-firstchan);
if (nchannels <= 0) return;
// get raw pixel data
PtexPtr<PtexFaceData> data ( getData(faceid, res) );
if (!data) return;
void* pixel = alloca(_pixelsize);
data->getPixel(u, v, pixel);
// adjust for firstchan offset
int datasize = DataSize(_header.datatype);
if (firstchan)
pixel = (char*) pixel + datasize * firstchan;
// convert/copy to result as needed
if (_header.datatype == dt_float)
memcpy(result, pixel, datasize * nchannels);
else
ConvertToFloat(result, pixel, _header.datatype, nchannels);
}
void PtexWriterBase::writeFaceBlock(FILE* fp, const void* data, int stride,
Res res, FaceDataHeader& fdh)
{
// write a single face data block
// copy to temp buffer, and deinterleave
int ures = res.u(), vres = res.v();
int blockSize = ures*vres*_pixelSize;
bool useMalloc = blockSize > AllocaMax;
char* buff = useMalloc ? (char*) malloc(blockSize) : (char*)alloca(blockSize);
PtexUtils::deinterleave(data, stride, ures, vres, buff,
ures*DataSize(_header.datatype),
_header.datatype, _header.nchannels);
// difference if needed
bool diff = (_header.datatype == dt_uint8 ||
_header.datatype == dt_uint16);
if (diff) PtexUtils::encodeDifference(buff, blockSize, _header.datatype);
// compress and stream data to file, and record size in header
int zippedsize = writeZipBlock(fp, buff, blockSize);
// record compressed size and encoding in data header
fdh.set(zippedsize, diff ? enc_diffzipped : enc_zipped);
if (useMalloc) free(buff);
}
void PtexReader::readFaceData(FilePos pos, FaceDataHeader fdh, Res res, int levelid,
FaceData*& face)
{
// keep new face local until fully initialized
FaceData* volatile newface = 0;
seek(pos);
switch (fdh.encoding()) {
case enc_constant:
{
ConstantFace* pf = new ConstantFace((void**)&face, _cache, _pixelsize);
readBlock(pf->data(), _pixelsize);
if (levelid==0 && _premultiply && _header.hasAlpha())
PtexUtils::multalpha(pf->data(), 1, _header.datatype,
_header.nchannels, _header.alphachan);
newface = pf;
}
break;
case enc_tiled:
{
Res tileres;
readBlock(&tileres, sizeof(tileres));
uint32_t tileheadersize;
readBlock(&tileheadersize, sizeof(tileheadersize));
TiledFace* tf = new TiledFace((void**)&face, _cache, res, tileres, levelid, this);
readZipBlock(&tf->_fdh[0], tileheadersize, FaceDataHeaderSize * tf->_ntiles);
computeOffsets(tell(), tf->_ntiles, &tf->_fdh[0], &tf->_offsets[0]);
newface = tf;
}
break;
case enc_zipped:
case enc_diffzipped:
{
int uw = res.u(), vw = res.v();
int npixels = uw * vw;
int unpackedSize = _pixelsize * npixels;
PackedFace* pf = new PackedFace((void**)&face, _cache,
res, _pixelsize, unpackedSize);
bool useMalloc = unpackedSize > AllocaMax;
void* tmp = useMalloc ? malloc(unpackedSize) : alloca(unpackedSize);
readZipBlock(tmp, fdh.blocksize(), unpackedSize);
if (fdh.encoding() == enc_diffzipped)
PtexUtils::decodeDifference(tmp, unpackedSize, _header.datatype);
PtexUtils::interleave(tmp, uw * DataSize(_header.datatype), uw, vw,
pf->data(), uw * _pixelsize,
_header.datatype, _header.nchannels);
if (levelid==0 && _premultiply && _header.hasAlpha())
PtexUtils::multalpha(pf->data(), npixels, _header.datatype,
_header.nchannels, _header.alphachan);
newface = pf;
if (useMalloc) free(tmp);
}
break;
}
face = newface;
}
// Data
void *
ResourceItem::Data() const
{
// Since MallocIO may have a NULL buffer, if the data size is 0,
// we return a pointer to ourselves in this case. This ensures, that
// the resource item still can be uniquely identified by its data pointer.
if (DataSize() == 0)
return const_cast<ResourceItem*>(this);
return const_cast<void*>(Buffer());
}
PTEX_NAMESPACE_BEGIN
void PtexTriangleFilter::eval(float* result, int firstChan, int nChannels,
int faceid, float u, float v,
float uw1, float vw1, float uw2, float vw2,
float width, float blur)
{
// init
if (!_tx || nChannels <= 0) return;
if (faceid < 0 || faceid >= _tx->numFaces()) return;
_ntxchan = _tx->numChannels();
_dt = _tx->dataType();
_firstChanOffset = firstChan*DataSize(_dt);
_nchan = PtexUtils::min(nChannels, _ntxchan-firstChan);
// get face info
const FaceInfo& f = _tx->getFaceInfo(faceid);
// if neighborhood is constant, just return constant value of face
if (f.isNeighborhoodConstant()) {
PtexPtr<PtexFaceData> data ( _tx->getData(faceid, 0) );
if (data) {
char* d = (char*) data->getData() + _firstChanOffset;
Ptex::ConvertToFloat(result, d, _dt, _nchan);
}
return;
}
// clamp u and v
u = PtexUtils::clamp(u, 0.0f, 1.0f);
v = PtexUtils::clamp(v, 0.0f, 1.0f);
// build kernel
PtexTriangleKernel k;
buildKernel(k, u, v, uw1, vw1, uw2, vw2, width, blur, f.res);
// accumulate the weight as we apply
_weight = 0;
// allocate temporary result
_result = (float*) alloca(sizeof(float)*_nchan);
memset(_result, 0, sizeof(float)*_nchan);
// apply to faces
splitAndApply(k, faceid, f);
// normalize (both for data type and cumulative kernel weight applied)
// and output result
float scale = 1.0f / (_weight * OneValue(_dt));
for (int i = 0; i < _nchan; i++) result[i] = float(_result[i] * scale);
// clear temp result
_result = 0;
}
char * PlotWndPropText::GetText(size_t index)
{
if (this->seriesInPlotWndProp.size() == 0)
return false;
auto seriesText = dynamic_cast<TextSeriesProp *>(this->seriesInPlotWndProp[0]);
seriesText->LockData();
size_t size = seriesText->DataSize();
char * data = seriesText->GetData(size - 1 - index);
seriesText->UnlockData();
return data;
}
ByteStream& ShortInt::BinaryWrite(ByteStream& Os_, Boolean* Ok_) const
{
Boolean WrChk_;
if (!Ok_)
Ok_ = &WrChk_;
*Ok_ = WriteObjectData(*this, Os_);
if (*Ok_)
Os_.owrite((char*)(&_Value), DataSize());
ReturnWriteValid(Os_, Ok_);
return Os_;
}
ByteStream& ShortInt::BinaryIgnore(ByteStream& Is_, Boolean* Ok_)
{
Boolean RdChk_;
if (!Ok_)
Ok_ = &RdChk_;
*Ok_ = ReadObjectData(*this, Is_, TRUE);
if (*Ok_ && Is_.iseekg(DataSize(), ios::cur).good())
SetIOstate(TRUE, IO_CLEAR, TRUE);
SetIOstate(FALSE, IO_STREAMERROR);
ReturnReadValid(Is_, Ok_);
return Is_;
}
ByteStream& ShortInt::BinaryRead(ByteStream& Is_, Boolean* Ok_)
{
Boolean RdChk_;
if (!Ok_)
Ok_ = &RdChk_;
*Ok_ = ReadObjectData(*this, Is_, FALSE);
if (*Ok_ && Is_.iread((char*)(&_Value), DataSize()).good())
SetIOstate(TRUE, IO_CLEAR, TRUE);
SetIOstate(FALSE, IO_STREAMERROR);
ReturnReadValid(Is_, Ok_);
return Is_;
}
int vmTypeLibrary::DataSize (vmValType& type) {
// How big would a variable of type "type" be?
if (type.PhysicalPointerLevel () > 0) // Pointers are always one element long
return 1;
if (type.m_arrayLevel > 0) { // Calculate array size
vmValType vt(type.m_basicType);
return type.ArraySize (DataSize (vt));
}
if (type.m_basicType >= 0) {
// Structured type. Lookup and return size of structure.
assert (type.m_basicType < m_structures.size ());
return m_structures [type.m_basicType].m_dataSize;
}
// Otherwise is basic type
return 1;
}
int64 CIndexTreeAccess::GetStringLong(char* pszKey)
{
int iKeySize;
BOOL bResult;
int i;
unsigned short uiDataSize;
if (StrEmpty(pszKey))
{
return FALSE;
}
iKeySize = strlen(pszKey);
uiDataSize = DataSize(pszKey, iKeySize);
if (uiDataSize != sizeof(int64))
{
return 0;
}
bResult = Get(pszKey, iKeySize, &i, NULL);
return i;
}
unsigned long Database::DiskSize() {
return DataSize();
}
void PtexSeparableFilter::eval(float* result, int firstChan, int nChannels,
int faceid, float u, float v,
float uw1, float vw1, float uw2, float vw2,
float width, float blur)
{
// init
if (!_tx || nChannels <= 0) return;
if (faceid < 0 || faceid >= _tx->numFaces()) return;
_ntxchan = _tx->numChannels();
_dt = _tx->dataType();
_firstChanOffset = firstChan*DataSize(_dt);
_nchan = PtexUtils::min(nChannels, _ntxchan-firstChan);
// get face info
const FaceInfo& f = _tx->getFaceInfo(faceid);
// if neighborhood is constant, just return constant value of face
if (f.isNeighborhoodConstant()) {
PtexPtr<PtexFaceData> data ( _tx->getData(faceid, 0) );
if (data) {
char* d = (char*) data->getData() + _firstChanOffset;
Ptex::ConvertToFloat(result, d, _dt, _nchan);
}
return;
}
// find filter width as bounding box of vectors w1 and w2
float uw = fabs(uw1) + fabs(uw2), vw = fabs(vw1) + fabs(vw2);
// handle border modes
switch (_uMode) {
case m_clamp: u = PtexUtils::clamp(u, 0.0f, 1.0f); break;
case m_periodic: u = u-floor(u); break;
case m_black: break; // do nothing
}
switch (_vMode) {
case m_clamp: v = PtexUtils::clamp(v, 0.0f, 1.0f); break;
case m_periodic: v = v-floor(v);
case m_black: break; // do nothing
}
// build kernel
PtexSeparableKernel k;
if (f.isSubface()) {
// for a subface, build the kernel as if it were on a main face and then downres
uw = uw * width + blur * 2;
vw = vw * width + blur * 2;
buildKernel(k, u*.5, v*.5, uw*.5, vw*.5, f.res);
if (k.res.ulog2 == 0) k.upresU();
if (k.res.vlog2 == 0) k.upresV();
k.res.ulog2--; k.res.vlog2--;
}
else {
uw = uw * width + blur;
vw = vw * width + blur;
buildKernel(k, u, v, uw, vw, f.res);
}
k.stripZeros();
// check kernel (debug only)
assert(k.uw > 0 && k.vw > 0);
assert(k.uw <= PtexSeparableKernel::kmax && k.vw <= PtexSeparableKernel::kmax);
_weight = k.weight();
// allocate temporary double-precision result
_result = (double*) alloca(sizeof(double)*_nchan);
memset(_result, 0, sizeof(double)*_nchan);
// apply to faces
splitAndApply(k, faceid, f);
// normalize (both for data type and cumulative kernel weight applied)
// and output result
double scale = 1.0 / (_weight * OneValue(_dt));
for (int i = 0; i < _nchan; i++) result[i] = float(_result[i] * scale);
// clear temp result
_result = 0;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//
void CPosLmNameIndex::SaveL( TChar aDrive )
{
RDbTable table;
TInt err = table.Open( iDatabase, KPosLmIndexTable, RDbRowSet::EUpdatable );
if ( err == KErrNotFound )
{
PosLmDatabaseManager::CreateIndexTableL( iDatabase );
err = table.Open( iDatabase, KPosLmIndexTable, RDbRowSet::EUpdatable );
}
User::LeaveIfError( err );
CleanupClosePushL( table );
TInt currentSize = 0;
table.FirstL();
if ( table.AtEnd() )
{
table.InsertL();
}
else
{
table.GetL();
currentSize = table.ColSize( EPosLmIncIndexDataCol );
table.UpdateL();
}
if ( currentSize < DataSize() )
{
// check disk size
CPosLmDiskUtilities* diskUtilities = CPosLmDiskUtilities::NewL();
CleanupStack::PushL( diskUtilities );
TInt bytesToWrite = DataSize() - currentSize;
diskUtilities->DiskSpaceBelowCriticalLevelL( bytesToWrite, aDrive );
CleanupStack::PopAndDestroy( diskUtilities );
}
// current language
table.SetColL( EPosLmIncLanguageCol, User::Language() );
// index data
RDbColWriteStream writeStream;
writeStream.OpenL( table, EPosLmIncIndexDataCol );
CleanupClosePushL( writeStream );
ExternalizeL( writeStream );
CleanupStack::PopAndDestroy( &writeStream );
// index timestamp
TTime now;
now.UniversalTime();
table.SetColL( EPosLmIncTimestampCol, now );
#ifdef _DEBUG
TBuf<64> mtime;
now.FormatL( mtime, KPosLmTimeFormat );
LOG1( "NameIndex: Saving index timestamp %S", &mtime);
#endif
table.PutL();
CleanupStack::PopAndDestroy ( &table );
iTimeStamp = now;
}
extern eRunStatus node3_Run( )
{
Boolean bRunToFinish = true;
int32 nReady = 1;
node3_InitVIConstantList();
{
heap->e_State_in =node3_in_0_State_in_31;
heap->l_While_____i = 0;
do {
{
heap->b_Constant = true;
heap->c_While_____SR_1 = node3_heap_lsr->c_While_____SR;
heap->b_While_____SR_1 = node3_heap_lsr->b_While_____SR;
{ /* Select */
heap->e_State_in_CS = heap->e_State_in;
switch ( heap->e_State_in_CS ) {
/* begin case */
case 0 : {
/*********************************************************************************/
/* mod0 \325\375\263\243\262\311\321\371 */
/* mod1 \275\332\265\347\262\311\321\371 */
/* mod2 \275\364\274\261\262\311\321\371 */
/*********************************************************************************/
{
heap->n_sampleRate = 5.0000000000000000000E+0;
heap->e_sampleRateMode = 1;
heap->n_Range_1 = 3;
heap->n_Range = 3;
heap->n_DIO_Drive_Mode_3 = 3;
heap->n_DIO_Drive_Mode_2 = 3;
heap->n_DIO_Drive_Mode_1 = 3;
heap->n_DIO_Drive_Mode = 3;
heap->l_pow_1 = 100;
heap->l_mod = 0;
heap->l_bat = 3;
heap->l_pow = 100;
heap->l_sh1 = 35;
heap->l_sh2 = 40;
heap->b_Case_Structure_CT = false;
if ((set_ai_power_Run( int32DataType, heap->l_pow_1 )) == eFail) CGenErr();
{
heap->by_IO_Channel_Number = 1;
/* Inline C node */
{
uInt8 channel = 0;
uInt16 mode = 0;
channel = heap->by_IO_Channel_Number;
mode = heap->n_DIO_Drive_Mode;
{
#include "node3_inlineC__71.h"
}
#undef log
#undef log2
#undef ln
}
}
{
heap->by_IO_Channel_Number_1 = 0;
/* Inline C node */
{
uInt8 channel = 0;
uInt16 mode = 0;
channel = heap->by_IO_Channel_Number_1;
mode = heap->n_DIO_Drive_Mode_1;
{
#include "node3_inlineC__66.h"
}
#undef log
#undef log2
#undef ln
}
}
{
heap->by_IO_Channel_Number_2 = 2;
/* Inline C node */
{
uInt8 channel = 0;
uInt16 mode = 0;
channel = heap->by_IO_Channel_Number_2;
mode = heap->n_DIO_Drive_Mode_2;
{
#include "node3_inlineC__5B.h"
}
#undef log
#undef log2
#undef ln
}
}
{
heap->by_IO_Channel_Number_3 = 3;
/* Inline C node */
{
uInt8 channel = 0;
uInt16 mode = 0;
channel = heap->by_IO_Channel_Number_3;
mode = heap->n_DIO_Drive_Mode_3;
{
#include "node3_inlineC__50.h"
}
#undef log
#undef log2
#undef ln
}
}
{
heap->i_IO_Channel_Number = 1;
/* Inline C node */
{
uInt16 range = 0;
int16 channel = 0;
range = heap->n_Range;
channel = heap->i_IO_Channel_Number;
{
#include "node3_inlineC__45.h"
}
#undef log
#undef log2
#undef ln
}
}
{
heap->i_IO_Channel_Number_1 = 0;
/* Inline C node */
{
uInt16 range = 0;
int16 channel = 0;
range = heap->n_Range_1;
channel = heap->i_IO_Channel_Number_1;
{
#include "node3_inlineC__3A.h"
}
#undef log
#undef log2
#undef ln
}
}
{
heap->XNodeTun82 = 0;
/* Inline C node */
{
int16 error = 0;
uInt32 sampleIntervalMode = 0;
float32 sampleInterval = 0.0;
error = heap->XNodeTun82;
sampleIntervalMode = heap->e_sampleRateMode;
sampleInterval = heap->n_sampleRate;
{
#include "node3_inlineC__2F.h"
heap->XNodeTunB2 = error;
}
#undef log
#undef log2
#undef ln
}
}
/* Bundle by name */
{
cl_A0000* cl_001 = NULL;
/* Cluster CopyOnModify */
MemMove( &heap->c_Case_Structure_CT, &heap->c_While_____SR_1, sizeof( cl_A0000 ) );
cl_001 = (cl_A0000*)&heap->c_Case_Structure_CT;
cl_001->el_0 = heap->l_mod;
cl_001->el_1 = heap->l_bat;
cl_001->el_2 = heap->l_pow;
cl_001->el_3 = heap->l_sh1;
cl_001->el_4 = heap->l_sh2;
}
}
} /* end case */
break;
/* begin case */
case 1 : {
{
MemMove( &heap->c_While_____CT_2, &heap->c_While_____SR_1, sizeof( cl_A0000 ) );
MemMove( &heap->c_While_____ST, &heap->c_While_____CT_2, sizeof( cl_A0000 ) );
MemMove( &heap->c_While_____ST_1, &heap->c_While_____CT_2, sizeof( cl_A0000 ) );
{
MemMove( &heap->c_While_____ST_3, &heap->c_While_____ST_1, sizeof( cl_A0000 ) );
/* Unbundle by name */
{
cl_A0000* cl_002 = (cl_A0000*)&heap->c_While_____ST_3;
heap->l________________mod = cl_002->el_0;
}
{ /* Select */
heap->l________________mod_CS = heap->l________________mod;
MemMove( &heap->c_While_____CT_3, &heap->c_While_____ST_3, sizeof( cl_A0000 ) );
switch ( heap->l________________mod_CS ) {
/* begin case */
case 1 : {
{
heap->l_times_3 = 10;
heap->l_times_2 = 10;
heap->l_delta_1 = 5;
/* Unbundle by name */
{
cl_A0000* cl_003 = (cl_A0000*)&heap->c_While_____CT_3;
heap->l________________sh1_1 = cl_003->el_3;
heap->l________________sh2_1 = cl_003->el_4;
}
{
extern Boolean sample_a0_out_0_A______1DC_init_;
Boolean sample_a0_out_0_A______1DC = sample_a0_out_0_A______1DC_init_;
extern float32 sample_a0_out_1_ai_426_init_;
float32 sample_a0_out_1_ai_426 = sample_a0_out_1_ai_426_init_;
heap->b_Case_Structure_CT = sample_a0_out_0_A______1DC_init_;
heap->n_sample_a0_vi_ai_1 = sample_a0_out_1_ai_426_init_;
if ((sample_a0_Run( int32DataType, heap->l________________sh1_1,
int32DataType, heap->l_times_3,
BooleanDataType, &heap->b_Case_Structure_CT,
floatDataType, &heap->n_sample_a0_vi_ai_1 )) == eFail) CGenErr();
}
{
static uInt32 id = 0;
static NetworkVariableAttrs attrs = {
/* url */ _LVT("\\\\169.254.62.215\\Node1\\AI0"),
/* alias */ _LVT("VISN-WSN"),
/* buffering */ true,
/* buffer size limit */ 800 /* 0x320 */,
/* buffer value limit */ 50 /* 0x32 */
};
if (!NetworkVariableWrite(&id, attrs, NULL, &(heap->n_sample_a0_vi_ai_1), floatDataType, floatDataType, NULL)) {
CGenErr();
}
}
{
extern float32 sample_a1_out_0_ai_426_init_;
float32 sample_a1_out_0_ai_426 = sample_a1_out_0_ai_426_init_;
heap->n_sample_a1_vi_ai_1 = sample_a1_out_0_ai_426_init_;
if ((sample_a1_Run( int32DataType, heap->l_delta_1,
int32DataType, heap->l________________sh2_1,
int32DataType, heap->l_times_2,
floatDataType, &heap->n_sample_a1_vi_ai_1 )) == eFail) CGenErr();
}
{
static uInt32 id = 0;
static NetworkVariableAttrs attrs = {
/* url */ _LVT("\\\\169.254.62.215\\Node1\\AI1"),
/* alias */ _LVT("VISN-WSN"),
/* buffering */ true,
/* buffer size limit */ 800 /* 0x320 */,
/* buffer value limit */ 50 /* 0x32 */
};
if (!NetworkVariableWrite(&id, attrs, NULL, &(heap->n_sample_a1_vi_ai_1), floatDataType, floatDataType, NULL)) {
CGenErr();
}
}
}
} /* end case */
break;
/* begin case */
case 2 : {
{
heap->l_times_4 = 1;
heap->l_times_5 = 1;
heap->l_delta_2 = 5;
/* Unbundle by name */
{
cl_A0000* cl_004 = (cl_A0000*)&heap->c_While_____CT_3;
heap->l________________sh1_2 = cl_004->el_3;
heap->l________________sh2_2 = cl_004->el_4;
}
{
extern Boolean sample_a0_out_0_A______1DC_init_;
Boolean sample_a0_out_0_A______1DC = sample_a0_out_0_A______1DC_init_;
extern float32 sample_a0_out_1_ai_426_init_;
float32 sample_a0_out_1_ai_426 = sample_a0_out_1_ai_426_init_;
heap->b_Case_Structure_CT = sample_a0_out_0_A______1DC_init_;
heap->n_sample_a0_vi_ai_2 = sample_a0_out_1_ai_426_init_;
if ((sample_a0_Run( int32DataType, heap->l________________sh1_2,
int32DataType, heap->l_times_4,
BooleanDataType, &heap->b_Case_Structure_CT,
floatDataType, &heap->n_sample_a0_vi_ai_2 )) == eFail) CGenErr();
}
{
static uInt32 id = 0;
static NetworkVariableAttrs attrs = {
/* url */ _LVT("\\\\169.254.62.215\\Node1\\AI0"),
/* alias */ _LVT("VISN-WSN"),
/* buffering */ true,
/* buffer size limit */ 800 /* 0x320 */,
/* buffer value limit */ 50 /* 0x32 */
};
if (!NetworkVariableWrite(&id, attrs, NULL, &(heap->n_sample_a0_vi_ai_2), floatDataType, floatDataType, NULL)) {
CGenErr();
}
}
{
extern float32 sample_a1_out_0_ai_426_init_;
float32 sample_a1_out_0_ai_426 = sample_a1_out_0_ai_426_init_;
heap->n_sample_a1_vi_ai_2 = sample_a1_out_0_ai_426_init_;
if ((sample_a1_Run( int32DataType, heap->l_delta_2,
int32DataType, heap->l________________sh2_2,
int32DataType, heap->l_times_5,
floatDataType, &heap->n_sample_a1_vi_ai_2 )) == eFail) CGenErr();
}
{
static uInt32 id = 0;
static NetworkVariableAttrs attrs = {
/* url */ _LVT("\\\\169.254.62.215\\Node1\\AI1"),
/* alias */ _LVT("VISN-WSN"),
/* buffering */ true,
/* buffer size limit */ 800 /* 0x320 */,
/* buffer value limit */ 50 /* 0x32 */
};
if (!NetworkVariableWrite(&id, attrs, NULL, &(heap->n_sample_a1_vi_ai_2), floatDataType, floatDataType, NULL)) {
CGenErr();
}
}
}
} /* end case */
break;
/* begin case */
default : {
{
heap->l_times_1 = 3;
heap->l_times = 3;
heap->l_delta = 5;
/* Unbundle by name */
{
cl_A0000* cl_005 = (cl_A0000*)&heap->c_While_____CT_3;
heap->l________________sh1 = cl_005->el_3;
heap->l________________sh2 = cl_005->el_4;
}
{
extern Boolean sample_a0_out_0_A______1DC_init_;
Boolean sample_a0_out_0_A______1DC = sample_a0_out_0_A______1DC_init_;
extern float32 sample_a0_out_1_ai_426_init_;
float32 sample_a0_out_1_ai_426 = sample_a0_out_1_ai_426_init_;
heap->b_Case_Structure_CT = sample_a0_out_0_A______1DC_init_;
heap->n_sample_a0_vi_ai = sample_a0_out_1_ai_426_init_;
if ((sample_a0_Run( int32DataType, heap->l________________sh1,
int32DataType, heap->l_times_1,
BooleanDataType, &heap->b_Case_Structure_CT,
floatDataType, &heap->n_sample_a0_vi_ai )) == eFail) CGenErr();
}
{
static uInt32 id = 0;
static NetworkVariableAttrs attrs = {
/* url */ _LVT("\\\\169.254.62.215\\Node1\\AI0"),
/* alias */ _LVT("VISN-WSN"),
/* buffering */ true,
/* buffer size limit */ 800 /* 0x320 */,
/* buffer value limit */ 50 /* 0x32 */
};
if (!NetworkVariableWrite(&id, attrs, NULL, &(heap->n_sample_a0_vi_ai), floatDataType, floatDataType, NULL)) {
CGenErr();
}
}
{
extern float32 sample_a1_out_0_ai_426_init_;
float32 sample_a1_out_0_ai_426 = sample_a1_out_0_ai_426_init_;
heap->n_sample_a1_vi_ai = sample_a1_out_0_ai_426_init_;
if ((sample_a1_Run( int32DataType, heap->l_delta,
int32DataType, heap->l________________sh2,
int32DataType, heap->l_times,
floatDataType, &heap->n_sample_a1_vi_ai )) == eFail) CGenErr();
}
{
static uInt32 id = 0;
static NetworkVariableAttrs attrs = {
/* url */ _LVT("\\\\169.254.62.215\\Node1\\AI1"),
/* alias */ _LVT("VISN-WSN"),
/* buffering */ true,
/* buffer size limit */ 800 /* 0x320 */,
/* buffer value limit */ 50 /* 0x32 */
};
if (!NetworkVariableWrite(&id, attrs, NULL, &(heap->n_sample_a1_vi_ai), floatDataType, floatDataType, NULL)) {
CGenErr();
}
}
}
} /* end case */
break;
}
} /* end switch */
/**/
/* 等于？ */
/**/
heap->b________x___y_ = (heap->b_Case_Structure_CT == heap->b_While_____SR_1);
{ /* Select */
heap->b________x___y__CS = heap->b________x___y_;
/* begin case */
if ( heap->b________x___y__CS ) {
{
MemMove( &heap->c_Case_Structure_CT, &heap->c_While_____ST, sizeof( cl_A0000 ) );
}
} /* end case */
/* begin case */
else {
{
{ /* Select */
heap->b__________CS = heap->b_Case_Structure_CT;
/* begin case */
if ( heap->b__________CS ) {
/*********************************************************************************/
/* \275\370\310\353\276\257\261\250\304\243\312\275 */
/*********************************************************************************/
{
heap->l_mod_2 = 2;
heap->n_sampleInterval_1 = 1.0000000000000000000E+0;
heap->b_bell_1 = true;
{
heap->n_Constant_1 = 0;
{
heap->by_t_1 = 1;
heap->by_f_1 = 0;
/**/
/* 选择 */
/**/
if (heap->b_bell_1) {
heap->by______s__t_f_1 = heap->by_t_1;
}
else {
heap->by______s__t_f_1 = heap->by_f_1;
}
/* Inline C node */
{
uInt8 value = 0;
int8 unusedInput = 0;
value = heap->by______s__t_f_1;
unusedInput = heap->n_Constant_1;
{
#include "node3_inlineC__EA.h"
}
#undef log
#undef log2
#undef ln
}
}
{
/* Inline C node */
{
int8 unusedInput = 0;
unusedInput = heap->n_Constant_1;
{
#include "node3_inlineC__EC.h"
}
#undef log
#undef log2
#undef ln
}
}
}
{
heap->XNodeTun1B01 = 0;
/* Inline C node */
{
int16 error = 0;
float32 sampleInterval = 0.0;
error = heap->XNodeTun1B01;
sampleInterval = heap->n_sampleInterval_1;
{
#include "node3_inlineC__D6.h"
heap->XNodeTun1B16 = error;
}
#undef log
#undef log2
#undef ln
}
}
/* Bundle by name */
{
cl_A0000* cl_006 = NULL;
/* Cluster CopyOnModify */
MemMove( &heap->c_Case_Structure_CT, &heap->c_While_____ST, sizeof( cl_A0000 ) );
cl_006 = (cl_A0000*)&heap->c_Case_Structure_CT;
cl_006->el_0 = heap->l_mod_2;
}
}
} /* end case */
/* begin case */
else {
{
heap->n_sampleInterval = 5.0000000000000000000E+0;
heap->l_mod_1 = 0;
heap->b_bell = false;
{
heap->n_Constant = 0;
{
heap->by_t = 1;
heap->by_f = 0;
/**/
/* 选择 */
/**/
if (heap->b_bell) {
heap->by______s__t_f = heap->by_t;
}
else {
heap->by______s__t_f = heap->by_f;
}
/* Inline C node */
{
uInt8 value = 0;
int8 unusedInput = 0;
value = heap->by______s__t_f;
unusedInput = heap->n_Constant;
{
#include "node3_inlineC__C8.h"
}
#undef log
#undef log2
#undef ln
}
}
{
/* Inline C node */
{
int8 unusedInput = 0;
unusedInput = heap->n_Constant;
{
#include "node3_inlineC__CA.h"
}
#undef log
#undef log2
#undef ln
}
}
}
{
heap->XNodeTun2A50 = 0;
/* Inline C node */
{
int16 error = 0;
float32 sampleInterval = 0.0;
error = heap->XNodeTun2A50;
sampleInterval = heap->n_sampleInterval;
{
#include "node3_inlineC__B3.h"
heap->XNodeTun2A65 = error;
}
#undef log
#undef log2
#undef ln
}
}
/* Bundle by name */
{
cl_A0000* cl_007 = NULL;
/* Cluster CopyOnModify */
MemMove( &heap->c_Case_Structure_CT, &heap->c_While_____ST, sizeof( cl_A0000 ) );
cl_007 = (cl_A0000*)&heap->c_Case_Structure_CT;
cl_007->el_0 = heap->l_mod_1;
}
}
} /* end case */
} /* end switch */
}
} /* end case */
} /* end switch */
}
/* FreeLoopInputs. */
/* FreeLoopInputs. */
}
} /* end case */
break;
/* begin case */
case 2 : {
{
/*********************************************************************************/
/* \311\350\326\303\304\243\312\275\241\242\262\311\321\371\274\344\270\364\241\242\264\253\270\320\306\367\265\347\324\264\321\241\317\356\241\242\301\275\270\366\264\253\270\320\306\367\343\320\326\265 */
/* mod0\316\252\327\324\266\250\322\345\304\243\312\275\243\254\270\337\313\331\317\324\312\276\304\243\312\275 */
/* mod1\316\252\275\332\265\347\324\313\320\320\304\243\312\275 */
/*********************************************************************************/
/*********************************************************************************/
/* setmod0-1 */
/*********************************************************************************/
/*********************************************************************************/
/* redint */
/*********************************************************************************/
/*********************************************************************************/
/* setpow10 */
/*********************************************************************************/
{
{
heap->XNodeTun144C = 0;
heap->i_Constant = 0;
heap->by_Constant = 0;
heap->i_Constant_1 = 127;
/* Array initialize */
{
ArrDimSize i;
ArrDimSize size=1;
heap->a________________________ = PDAArrNew1D((ArrDimSize)heap->i_Constant_1, uCharDataType);
size = (ArrDimSize)heap->i_Constant_1;
if (size < 0) {
size = 0;
}
if (IsNotZero(&heap->by_Constant, uCharDataType)) {
MemSet(FirstElem(heap->a________________________), size, heap->by_Constant);
}
}
/* Inline C node */
{
int16 error = 0;
PDAArrPtr receivedUserMessage_nodeTempArrayHandle = NULL;
uInt8* receivedUserMessage = NULL;
int16 receivedUserMessageLength = 0;
error = heap->XNodeTun144C;
receivedUserMessage_nodeTempArrayHandle=PDAArrCopyOnModify( heap->a________________________ );
receivedUserMessage = (VoidHand)FirstElem(receivedUserMessage_nodeTempArrayHandle);
receivedUserMessageLength = heap->i_Constant;
{
#include "node3_inlineC__105.h"
heap->XNodeTun1450 = error;
heap->a_____C_____________ = receivedUserMessage_nodeTempArrayHandle;
heap->i_____C______________4 = receivedUserMessageLength;
}
#undef log
#undef log2
#undef ln
}
/* Array Subset */
{
Boolean bEmpty = false;
Boolean bNullInput=false;
ArrDimSize start0;
if (!heap->a_____C_____________) {heap->a_____C_____________ = PDAArrNewEmptyWithNDims( uCharDataType, (ArrDimSize)1 );bNullInput=true;}
{
ArrDimSize nDimSize0=0;
start0 = (ArrDimSize)0;
if (start0 < 0) {
start0 = 0;
}
if (start0 >= PDAArrNthDim(heap->a_____C_____________, (ArrDimSize)0)) {
start0 = PDAArrNthDim(heap->a_____C_____________, (ArrDimSize)0);
}
nDimSize0 = (ArrDimSize)heap->i_____C______________4;
if (nDimSize0 <= 0) {
nDimSize0 = 0;
}
if ((start0 + nDimSize0) > PDAArrNthDim(heap->a_____C_____________, (ArrDimSize)0)) {
nDimSize0 = PDAArrNthDim(heap->a_____C_____________, (ArrDimSize)0) - start0;
}
if (!(heap->a________________ = PDAArrNew1D((ArrDimSize)nDimSize0, uCharDataType))){
CGenErr();
}
}
{
ArrDimSize end0;
if (start0 >= PDAArrNthDim(heap->a_____C_____________, (ArrDimSize)0)) {
bEmpty = true;
}
end0 = start0 + (ArrDimSize)heap->i_____C______________4;
if ((end0 < 0) || (end0 <= start0)) {
bEmpty = true; }
if (end0 > PDAArrNthDim(heap->a_____C_____________, (ArrDimSize)0)) {
end0 = PDAArrNthDim(heap->a_____C_____________, (ArrDimSize)0);
PDAArrSetDim(heap->a________________, (ArrDimSize)0, (end0 - start0) );
}
if (!bEmpty) {
MemMove(NthElem(heap->a________________, 0), NthElem(heap->a_____C_____________, start0), (end0-start0)*DataSize(uCharDataType));
}
else {
MemHandleFree( heap->a________________ ); // Uninitialized
if (!(heap->a________________ = PDAArrNewEmptyWithNDims( uCharDataType, (ArrDimSize)1 ))) CGenErr();
}
if ((heap->a_____C_____________) && ((heap->a_____C_____________)->refcnt > 0)) {
if (((heap->a_____C_____________)->refcnt == 1) && ((heap->a_____C_____________)->staticArray == false)) {
(heap->a_____C_____________)->refcnt--;
MemHandleFree( heap->a_____C_____________ );
heap->a_____C_____________=NULL;
}
else
PDAArrFree(heap->a_____C_____________);
}
}
if (bNullInput) heap->a_____C_____________ = NULL;
}
/**/
/* 字节数组至字符串转换 */
/**/
if (!PDAArrToString(heap->a________________, &(heap->XNodeTun1454))) {
CGenErr();
}
}
heap->s_____________________________X = heap->XNodeTun1454;
PDAStrIncRefCnt(heap->s_____________________________X, (uInt16)2); /* XNode: tunnel list */
{
extern cl_A0000 set_red_state_out_0_set_24A_init_;
cl_A0000 set_red_state_out_0_set_24A = set_red_state_out_0_set_24A_init_;
heap->c_set_red_state_vi_set_ST_1 = set_red_state_out_0_set_24A;
if ((set_red_state_Run( StringDataType, heap->s_____________________________X,
0xA0000 | ClusterDataType, heap->c_While_____SR_1,
0xA0000 | ClusterDataType, &heap->c_set_red_state_vi_set_ST_1 )) == eFail) CGenErr();
}
if ((message_dio_control_Run( StringDataType, heap->s_____________________________X )) == eFail) CGenErr();
heap->s_____________________________S = heap->s_____________________________X;
}
/* FreeLoopInputs. */
{
heap->s_____________________________S_1 = heap->s_____________________________S;
PDAStrIncRefCnt(heap->s_____________________________S_1, (uInt16)1); /* SequenceTunnel */
MemMove( &heap->c_set_red_state_vi_set_ST_5, &heap->c_set_red_state_vi_set_ST_1, sizeof( cl_A0000 ) );
/* Unbundle by name */
{
cl_A0000* cl_008 = (cl_A0000*)&heap->c_set_red_state_vi_set_ST_5;
heap->l________________mod_1 = cl_008->el_0;
}
{ /* Select */
heap->l________________mod_CS_1 = heap->l________________mod_1;
MemMove( &heap->c_set_red_state_vi_set_CT, &heap->c_set_red_state_vi_set_ST_5, sizeof( cl_A0000 ) );
/* begin case */
if ( ( (heap->l________________mod_CS_1 == 1) ) ) {
{
heap->n_sampleInterval_3 = 6.0000000000000000000E+1;
heap->l_pow_2 = 100;
/* Free unwired input select tunnel. */
if ((set_ai_power_Run( int32DataType, heap->l_pow_2 )) == eFail) CGenErr();
{
heap->XNodeTunE47 = 0;
/* Inline C node */
{
int16 error = 0;
float32 sampleInterval = 0.0;
error = heap->XNodeTunE47;
sampleInterval = heap->n_sampleInterval_3;
{
#include "node3_inlineC__124.h"
heap->XNodeTunE5C = error;
}
#undef log
#undef log2
#undef ln
}
}
}
} /* end case */
/* begin case */
else {
{
heap->n_sampleInterval_2 = 5.0000000000000000000E+0;
{
heap->XNodeTunDD7 = 0;
/* Inline C node */
{
int16 error = 0;
float32 sampleInterval = 0.0;
error = heap->XNodeTunDD7;
sampleInterval = heap->n_sampleInterval_2;
{
#include "node3_inlineC__118.h"
heap->XNodeTunDF6 = error;
}
#undef log
#undef log2
#undef ln
}
}
/* Unbundle by name */
{
cl_A0000* cl_009 = (cl_A0000*)&heap->c_set_red_state_vi_set_CT;
heap->l________________pow = cl_009->el_2;
}
if ((set_ai_power_Run( int32DataType, heap->l________________pow )) == eFail) CGenErr();
}
} /* end case */
} /* end switch */
MemMove( &heap->c_Case_Structure_CT, &heap->c_set_red_state_vi_set_ST_5, sizeof( cl_A0000 ) );
}
/* FreeLoopInputs. */
if (heap->s_____________________________S && (((PDAStrPtr)heap->s_____________________________S)->refcnt > 0)) {
if ((--((PDAStrPtr)heap->s_____________________________S)->refcnt == 0) && (!((PDAStrPtr)heap->s_____________________________S)->staticStr)) {
MemHandleFree( heap->s_____________________________S );
heap->s_____________________________S=NULL;
}
}
/* FreeLoopInputs. */
{
node3_GlobalConstantsHeapPtr->i83B = PDAStrNewFromBuf(_LVT("received: "),(uInt32)10);
heap->s_Constant = node3_GlobalConstantsHeapPtr->i83B;
PDAStrIncRefCnt(heap->s_____________________________S_1, (uInt16)1); /* SequenceTunnel */
{
ControlDataItemPtr cdPtr = LVGetCurrentControlData();
CreateArgListStatic(heap->Args82F_1, 2, 1 );
argIn(heap->Args82F_1, 0).nType = StringDataType;
argIn(heap->Args82F_1, 0).pValue = (void *)&heap->s_Constant;
argIn(heap->Args82F_1, 1).nType = StringDataType;
argIn(heap->Args82F_1, 1).pValue = (void *)&heap->s_____________________________S_1;
argOut(heap->Args82F_1, 0).nType = StringDataType;
argOut(heap->Args82F_1, 0).pValue = (void *)&heap->s________________________;
if (!PDAStrConcat( (ArgList *)((ArgList **)heap->Args82F_1)[0], (ArgList *)((ArgList **)heap->Args82F_1)[1] )) {
CGenErr();
}
if (gAppStop) {
gAppStop=true;
return eFinished;
}
}
{
heap->XNodeTun84A = 0;
heap->s_________________________XT = heap->s________________________;
PDAStrIncRefCnt(heap->s_________________________XT, (uInt16)1); /* FrameTunnel */
/**/
/* 字符串长度 */
/**/
heap->l________________ = (int32)PDAStrLen(heap->s_________________________XT);
/**/
/* 字符串至字节数组转换 */
/**/
if (!PDAStrToArray(heap->s_________________________XT, &(heap->a______________________________))) {
CGenErr();
}
/* Inline C node */
{
int16 error = 0;
PDAArrPtr sendDebugMessage_nodeTempArrayHandle = NULL;
uInt8* sendDebugMessage = NULL;
int32 sendDebugMessageLength = 0;
error = heap->XNodeTun84A;
sendDebugMessage_nodeTempArrayHandle=PDAArrCopyOnModify( heap->a______________________________ );
sendDebugMessage = (VoidHand)FirstElem(sendDebugMessage_nodeTempArrayHandle);
sendDebugMessageLength = heap->l________________;
{
#include "node3_inlineC__130.h"
heap->XNodeTun84E = error;
}
/* Free input array without corresponding output in inline C node */
if ((sendDebugMessage_nodeTempArrayHandle) && ((sendDebugMessage_nodeTempArrayHandle)->refcnt > 0)) {
if (((sendDebugMessage_nodeTempArrayHandle)->refcnt == 1) && ((sendDebugMessage_nodeTempArrayHandle)->staticArray == false)) {
(sendDebugMessage_nodeTempArrayHandle)->refcnt--;
MemHandleFree( sendDebugMessage_nodeTempArrayHandle );
sendDebugMessage_nodeTempArrayHandle=NULL;
}
else
PDAArrFree(sendDebugMessage_nodeTempArrayHandle);
}
#undef log
#undef log2
#undef ln
}
}
}
/* FreeLoopInputs. */
if (heap->s_____________________________S_1 && (((PDAStrPtr)heap->s_____________________________S_1)->refcnt > 0)) {
if ((--((PDAStrPtr)heap->s_____________________________S_1)->refcnt == 0) && (!((PDAStrPtr)heap->s_____________________________S_1)->staticStr)) {
MemHandleFree( heap->s_____________________________S_1 );
heap->s_____________________________S_1=NULL;
}
}
heap->b_Case_Structure_CT = heap->b_While_____SR_1;
}
} /* end case */
break;
/* begin case */
case 3 : {
{
MemMove( &heap->c_Case_Structure_CT, &heap->c_While_____SR_1, sizeof( cl_A0000 ) );
{
heap->XNodeTun10B = 0;
heap->e_Network_Status = 0;
/* Inline C node */
{
int16 error = 0;
uInt32 networkStatus = 0;
error = heap->XNodeTun10B;
networkStatus = heap->e_Network_Status;
{
#include "node3_inlineC__13B.h"
heap->XNodeTunC63 = error;
heap->e_____C______________XT = networkStatus;
}
#undef log
#undef log2
#undef ln
}
}
{ /* Select */
heap->e_____C______________CS = heap->e_____C______________XT;
/* begin case */
if ( ( (heap->e_____C______________CS == 1) ) ) {
{
node3_GlobalConstantsHeapPtr->i23A = PDAStrNewFromBuf(_LVT("Node connected ..."),(uInt32)18);
heap->s_sendDebugMessage = node3_GlobalConstantsHeapPtr->i23A;
{
heap->XNodeTun24B = 0;
heap->s_sendDebugMessage_XT = heap->s_sendDebugMessage;
PDAStrIncRefCnt(heap->s_sendDebugMessage_XT, (uInt16)1); /* FrameTunnel */
/**/
/* 字符串长度 */
/**/
heap->l_________________1 = (int32)PDAStrLen(heap->s_sendDebugMessage_XT);
/**/
/* 字符串至字节数组转换 */
/**/
if (!PDAStrToArray(heap->s_sendDebugMessage_XT, &(heap->a_______________________________1))) {
CGenErr();
}
/* Inline C node */
{
int16 error = 0;
PDAArrPtr sendDebugMessage_nodeTempArrayHandle = NULL;
uInt8* sendDebugMessage = NULL;
int32 sendDebugMessageLength = 0;
error = heap->XNodeTun24B;
sendDebugMessage_nodeTempArrayHandle=PDAArrCopyOnModify( heap->a_______________________________1 );
sendDebugMessage = (VoidHand)FirstElem(sendDebugMessage_nodeTempArrayHandle);
sendDebugMessageLength = heap->l_________________1;
{
#include "node3_inlineC__148.h"
heap->XNodeTun251 = error;
}
/* Free input array without corresponding output in inline C node */
if ((sendDebugMessage_nodeTempArrayHandle) && ((sendDebugMessage_nodeTempArrayHandle)->refcnt > 0)) {
if (((sendDebugMessage_nodeTempArrayHandle)->refcnt == 1) && ((sendDebugMessage_nodeTempArrayHandle)->staticArray == false)) {
(sendDebugMessage_nodeTempArrayHandle)->refcnt--;
MemHandleFree( sendDebugMessage_nodeTempArrayHandle );
sendDebugMessage_nodeTempArrayHandle=NULL;
}
else
PDAArrFree(sendDebugMessage_nodeTempArrayHandle);
}
#undef log
#undef log2
#undef ln
}
}
}
} /* end case */
/* begin case */
else {
{
}
} /* end case */
} /* end switch */
heap->b_Case_Structure_CT = heap->b_While_____SR_1;
}
} /* end case */
break;
/* begin case */
case 4 : {
{
MemMove( &heap->c_Case_Structure_CT, &heap->c_While_____SR_1, sizeof( cl_A0000 ) );
heap->b_Case_Structure_CT = heap->b_While_____SR_1;
}
} /* end case */
break;
}
} /* end switch */
MemMove( &heap->c_Case_Structure_SR, &heap->c_Case_Structure_CT, sizeof( cl_A0000 ) );
MemMove(&node3_heap_lsr->c_While_____SR, &heap->c_Case_Structure_SR, sizeof(cl_A0000));
heap->b_Case_Structure_SR = heap->b_Case_Structure_CT;
node3_heap_lsr->b_While_____SR = heap->b_Case_Structure_SR;
}
(heap->l_While_____i)++;
}
while(!heap->b_Constant && !gAppStop && !gLastError);
node3_CleanupVIGlobalConstants();
return eFinished;
}
}
QString ConditionalAccessDescriptor::toString() const
{
return QString("Conditional Access: sid(0x%1) pid(0x%2) data_size(%3)")
.arg(SystemID(),0,16).arg(PID(),0,16).arg(DataSize());
}
int32 CTaskManagerPrefs::SortKeyInfoCount()
{
return (int32)(DataSize(PREF_SORT_KEY_INFO) / sizeof(sort_key_info));
}
