void SSL_HandShakeMessage::PerformActionL(DataStream::DatastreamAction action, uint32 arg1, uint32 arg2)
{
switch(action)
{
case DataStream::KReadAction:
case DataStream::KWriteAction:
{
uint32 step = arg1;
int record_item_id = (int) arg2;
if(record_item_id == DataStream_SequenceBase::STRUCTURE_START)
{
if(action == DataStream::KWriteAction)
spec.enable_length = (connstate->version.Major() >= 3);
else
length.SetEnableRecord(connstate->version.Major() >= 3);
dummy.ResetRecord();
dummy.SetEnableRecord(TRUE);
}
LoadAndWritableList::PerformActionL(action, step, record_item_id);
if(action == DataStream::KReadAction)
{
if(record_item_id == RECORD_TAG)
{
if(connstate->version.Major() < 3)
SetTag((SSL_HandShakeType)(((uint32) GetTag()) | 0x100)); // Convert 8 bit value into the SSL v2 message type
LEAVE_IF_ERROR(SetMessage((SSL_HandShakeType) GetTag()));
}
else if(record_item_id == STRUCTURE_FINISHED)
{
if(dummy.GetLength() != 0 && GetTag() != SSL_Client_Hello)
RaiseAlert(SSL_Fatal,SSL_Illegal_Parameter);
}
}
}
break;
default:
LoadAndWritableList::PerformActionL(action, arg1, arg2);
}
}
bool HouseKeeperTask::CheckRun(QDateTime now)
{
LOG(VB_GENERAL, LOG_DEBUG, QString("Checking to run %1").arg(GetTag()));
bool check = false;
if (!m_confirm && (check = DoCheckRun(now)))
// if m_confirm is already set, the task is already in the queue
// and should not be queued a second time
m_confirm = true;
return check;
}
void JCall::OnPlay()
{
if (!m_pObject)
{
Init();
}
if (m_pObject)
{
m_pObject->CallMethod( m_Method.c_str(), GetTag() );
}
} // JCall::OnPlay
FString FXmlNode::GetAttribute(const FString& InTag) const
{
for(auto Iter(Attributes.CreateConstIterator()); Iter; Iter++)
{
if(Iter->GetTag() == InTag)
{
return Iter->GetValue();
}
}
return FString();
}
result_t CYamlScalar::SaveToFile ( yaml_emitter_t* _pEmitter ) const
{
result_t result_t = eResult_OK;
yaml_event_t event;
yaml_scalar_event_initialize ( &event, (yaml_char_t*)GetAnchor(), (yaml_char_t*)GetTag(), (yaml_char_t*)GetValue(), int(m_Value.Size()), 1, 0, CYamlScalar::ToYamlStyle(m_Style) );
ex_check_return ( Flush( _pEmitter, &event ), "Flush failed" );
return eResult;
}
int mainprog(void)
{
int res=0;
/* Initialisation des listes */
InitChListe(&PLCs);
res=OpenDb(DBHOST,USER,PASS,DB);
if (res<0) {Log(LOG_CRIT,"OpenDb (%d) : %s\n",res,MysqlErrorMsg);return(res);}
else
{
Plc_count=GetPlcList(NULL,&CONTROLLERs);
if (Plc_count<0) Log(LOG_CRIT,"Get Plc count error (%d) : %s\n",Plc_count,MysqlErrorMsg);
else
{
if (Plc_count==0) Log(LOG_NOTICE,"There is no Plcs\n");
else Log(LOG_NOTICE,"There is : %d Plcs\n",Plc_count);
}
Tag_count=GetCount("select * from DEFINITION");
if (Tag_count<0) Log(LOG_CRIT,"Get Tag count error (%d) : %s\n",Tag_count,MysqlErrorMsg);
else
{
if (Tag_count==0) Log(LOG_NOTICE,"There is no Tags\n");
else Log(LOG_NOTICE,"There is : %d Tags\n",Tag_count);
}
if ((Plc_count>0)&&(Tag_count>0))
{
Tag_count=0;
Plc_count=GetPlcList(&PLCs,&CONTROLLERs);
if (PLCs.Count>0)
{
Log(LOG_NOTICE,"There is %d PLC to create\n",PLCs.Count);
ELEMENT *elt=GetFirst(&PLCs);
while (elt!=NULL)
{
PLC *plc=elt->Data;
res=GetTag(plc);
if (res>0) Tag_count+=res;
else
{
if (res==0) Log(LOG_NOTICE,"(%s) there is no Tag for PLC : %s\n",MysqlErrorMsg,plc->PlcName);
else Log(LOG_CRIT,"Get Tag error (%d) : %s for PLC : %s\n",res,MysqlErrorMsg,plc->PlcName);
}
Optimise(plc);
elt=GetNext(&PLCs,elt);
}
} else Log(LOG_CRIT,"Get Plc error (%d) : %s\n",res,MysqlErrorMsg);
// Appel Logger
if (Tag_count>0) res=Logger(&PLCs);
} else Log(LOG_WARNING,"There is nothing to do. exiting...\n");
CloseDb;
}
return(res);
}
void JAnmSound::ResInit()
{
if (!g_pSoundServer)
{
return;
}
m_SoundID = g_pSoundServer->GetSoundID( m_File.c_str(), GetTag() );
if (GetDuration() == 0.0f)
{
SetDuration( g_pSoundServer->GetTotalTime( m_SoundID ) );
}
} // JAnmSound::OnStop
const std::string MaybeType::GetValueSeparator(const Indent& indent,
const void* value) const {
ostringstream buffer;
auto sum_instance = static_cast<const Sum*>(value);
auto tag = sum_instance->GetTag();
if (*tag == *MaybeTypeSpecifier::VARIANT_NAME) {
buffer << "\n" << indent + 1;
} else if (*tag == *TypeTable::GetNilName()) {
buffer << " ";
}
return buffer.str();
}
Boolean IccServiceTable::IsAvailable(
/* [in] */ Int32 service)
{
Int32 offset = service / 8;
if (offset >= mServiceTable->GetLength()) {
// Note: Enums are zero-based, but the TS service numbering is one-based
Logger::E(GetTag(), String("isAvailable for service ") + StringUtils::ToString(service + 1)
+ String(" fails, max service is ")
+ StringUtils::ToString(mServiceTable->GetLength() * 8));
return FALSE;
}
Int32 bit = service % 8;
return ((*mServiceTable)[offset] & (1 << bit)) != 0;
}
void serialize(PyrSlot * slot)
{
if (IsFloat(slot)) {
emitter << slotRawFloat(slot);
return;
}
switch (GetTag(slot)) {
case tagNil:
emitter << YAML::Null;
return;
case tagInt:
emitter << slotRawInt(slot);
return;
case tagFalse:
emitter << false;
return;
case tagTrue:
emitter << true;
return;
case tagObj:
serialize(slotRawObject(slot));
return;
case tagSym:
emitter << YAML::DoubleQuoted << slotRawSymbol(slot)->name;
return;
default:
printf ("type: %d\n", GetTag(slot));
throw std::runtime_error("YAMLSerializer: not implementation for this type");
}
}
bool CRoomTemplate::SaveRoomTemplate()
{
if (!m_pLevelTheme)
return false;
char szThemeDirName[MAX_PATH];
Q_snprintf(szThemeDirName, sizeof(szThemeDirName), "tilegen/roomtemplates/%s", m_pLevelTheme->m_szName);
g_pFullFileSystem->CreateDirHierarchy( szThemeDirName, "GAME" );
char szFullFileName[MAX_PATH];
Q_snprintf( szFullFileName, sizeof(szFullFileName), "tilegen/roomtemplates/%s/%s.roomtemplate", m_pLevelTheme->m_szName, m_FullName );
KeyValues *pRoomTemplateKeyValues = new KeyValues( m_FullName );
pRoomTemplateKeyValues->SetInt( "TilesX", m_nTilesX );
pRoomTemplateKeyValues->SetInt( "TilesY", m_nTilesY );
pRoomTemplateKeyValues->SetInt( "SpawnWeight", m_nSpawnWeight );
pRoomTemplateKeyValues->SetString( "RoomTemplateDescription", m_Description );
pRoomTemplateKeyValues->SetString( "Soundscape", m_Soundscape );
pRoomTemplateKeyValues->SetInt( "TileType", m_nTileType );
// exits
int iExits = m_Exits.Count();
for (int i=0; i<iExits; i++)
{
KeyValues *pkvSubSection = new KeyValues("EXIT");
pkvSubSection->SetInt("XPos", m_Exits[i]->m_iXPos);
pkvSubSection->SetInt("YPos", m_Exits[i]->m_iYPos);
pkvSubSection->SetInt("ExitDirection", (int) m_Exits[i]->m_ExitDirection);
pkvSubSection->SetInt("ZChange", m_Exits[i]->m_iZChange);
pkvSubSection->SetString("ExitTag", m_Exits[i]->m_szExitTag);
pkvSubSection->SetBool("ChokeGrow", m_Exits[i]->m_bChokepointGrowSource);
pRoomTemplateKeyValues->AddSubKey(pkvSubSection);
}
// tags
KeyValues *pkvSubSection = new KeyValues("Tags");
for ( int i=0; i<GetNumTags(); i++ )
{
pkvSubSection->AddSubKey( new KeyValues( "tag", NULL, GetTag( i ) ) );
}
pRoomTemplateKeyValues->AddSubKey(pkvSubSection);
if (!pRoomTemplateKeyValues->SaveToFile(g_pFullFileSystem, szFullFileName, "GAME"))
{
Msg("Error: Failed to save room template %s\n", szFullFileName);
return false;
}
return true;
}
size_t psXMLString::GetWithinTagSection(int start, const char* tagName,
psXMLString& tagSection)
{
size_t end = FindMatchingEndTag( start, tagName );
if ( end == (size_t)-1 )
tagSection = psString("");
else
{
psXMLTag startTag;
GetTag(start, startTag);
start+=(int)startTag.Length();
GetSubString(tagSection, start, end);
}
return tagSection.Length();
}
void GraphBase::BaseStore(wxString path, wxString tag)
{
int i;
TextFile outfile;
wxString text, filename, filetag;
filename = "gbase-" + tag + ".dat";
//outfile.New(initpath + "/Graphs/" + filename);
outfile.New(path + "/" + filename);
for(i=0; i<numgraphs; i++) {
outfile.WriteLine(graphstore[i].StoreDat(GetTag(i)));
//outfile.WriteLine(text.Format
}
outfile.Close();
}
RenderString::RenderString(ResourcePtr<FontBase> font, const unsigned int& size, const std::u16string& text) :
mFont(font), mSize(size), mAppendString(text) {
if (mFont) { // if we have a valid font...
mRBDData.mTextureID = mFont->GetTextureID(); // update the texture id of the batch data
float fontSize = static_cast<float>(mFont->GetFontSize()); // get the size of the font
mTextScale = glm::vec2(mSize / fontSize, mSize / fontSize); // calculate the scale factor for the render string
mFontType = mFont->GetType();
}
UpdateRenderString(); // ensure all characters are ready to be rendered
mRBDData.mTag = GetTag(); // update the tag of the batch data
}
CCollectionFile::CCollectionFile(CFileDataIO* in_data)
{
UINT tagcount = in_data->ReadUInt32();
for (UINT i = 0; i < tagcount; i++)
{
CTag* toadd = new CTag(in_data, true);
if (toadd)
taglist.Add(toadd);
}
CTag* pTagHash = GetTag(FT_FILEHASH);
if(pTagHash)
SetFileHash(pTagHash->GetHash());
else
ASSERT(0);
// here we have two choices
// - if the server/client sent us a filetype, we could use it (though it could be wrong)
// - we always trust our filetype list and determine the filetype by the extension of the file
//
// if we received a filetype from server, we use it.
// if we did not receive a filetype, we determine it by examining the file's extension.
//
// but, in no case, we will use the receive file type when adding this search result to the download queue, to avoid
// that we are using 'wrong' file types in part files. (this has to be handled when creating the part files)
const CString& rstrFileType = GetStrTagValue(FT_FILETYPE);
SetFileName(GetStrTagValue(FT_FILENAME), false, rstrFileType.IsEmpty());
SetFileSize(GetIntTagValue(FT_FILESIZE));
if (!rstrFileType.IsEmpty())
{
if (_tcscmp(rstrFileType, _T(ED2KFTSTR_PROGRAM))==0)
{
CString strDetailFileType = GetFileTypeByName(GetFileName());
if (!strDetailFileType.IsEmpty())
SetFileType(strDetailFileType);
else
SetFileType(rstrFileType);
}
else
SetFileType(rstrFileType);
}
if(!GetFileSize() || !GetFileName().Compare(_T("")))
ASSERT(0);
}
inline int prOpFloat(VMGlobals *g, int numArgsPushed)
{
PyrSlot *a, *b;
PyrSymbol *msg;
a = g->sp - 1;
b = g->sp;
switch (GetTag(b)) {
case tagInt :
SetRaw(a, Functor::run(slotRawFloat(a), (double)slotRawInt(b)));
break;
case tagChar :
case tagPtr :
case tagNil :
case tagFalse :
case tagTrue :
goto send_normal_2;
case tagSym :
SetSymbol(a, slotRawSymbol(b));
break;
case tagObj :
if (isKindOf(slotRawObject(b), class_signal))
SetObject(a, Functor::signal_fx(g, slotRawFloat(a), slotRawObject(b)));
else
goto send_normal_2;
break;
default :
SetRaw(a, Functor::run(slotRawFloat(a), slotRawFloat(b)));
break;
}
g->sp-- ; // drop
g->numpop = 0;
#if TAILCALLOPTIMIZE
g->tailCall = 0;
#endif
return errNone;
send_normal_2:
if (numArgsPushed != -1) // special case flag meaning it is a primitive
return errFailed; // arguments remain on the stack
msg = gSpecialBinarySelectors[g->primitiveIndex];
sendMessage(g, msg, 2);
return errNone;
}
void JSlidePiece::OnMouse( JMouseEvent& e )
{
if (e.MouseKey() == mkLeft && e.Action() == aKeyDown &&
IsVisible())
{
if (GetTag() == m_pSlideGame->GetCatchID())
{
m_pSlideGame->OnTakeRight();
}
else
{
m_pSlideGame->OnTakeWrong();
}
SetVisible( false );
StartFalling();
e.Consume();
}
} // JSlidePiece::OnMouse
void DailyHouseKeeperTask::CalculateWindow(void)
{
PeriodicHouseKeeperTask::CalculateWindow();
QDate date = GetLastRun().addDays(1).date();
QDateTime tmp = QDateTime(date, QTime(m_windowHour.first, 0));
if (GetLastRun().addSecs(m_windowElapsed.first) < tmp)
m_windowElapsed.first = GetLastRun().secsTo(tmp);
tmp = QDateTime(date, QTime(m_windowHour.second, 30));
// we want to make sure this gets run before the end of the day
// so add a 30 minute buffer prior to the end of the window
if (GetLastRun().addSecs(m_windowElapsed.second) > tmp)
m_windowElapsed.second = GetLastRun().secsTo(tmp);
LOG(VB_GENERAL, LOG_DEBUG, QString("%1 Run window between %2 - %3.")
.arg(GetTag()).arg(m_windowElapsed.first).arg(m_windowElapsed.second));
}
void main()
{
//Goes in OnItemActivate in module properties
object oUsed = GetItemActivated();
if(GetTag(oUsed)=="Intontimento")
{
object oPC = GetItemActivator();
object oShadow = GetObjectByTag("Shadow");
effect eParalyze = EffectCutsceneImmobilize();
effect eVisualParalyze = EffectVisualEffect(VFX_FNF_SOUND_BURST_SILENT);
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eParalyze, oShadow, 10.0f);
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eVisualParalyze, oShadow, 5.0f);
}
}
static int addMsgSlot(big_scpacket *packet, PyrSlot *slot)
{
switch (GetTag(slot)) {
case tagInt :
packet->addi(slotRawInt(slot));
break;
case tagSym :
packet->adds(slotRawSymbol(slot)->name);
break;
case tagObj :
if (isKindOf(slotRawObject(slot), class_string)) {
PyrString *stringObj = slotRawString(slot);
packet->adds(stringObj->s, stringObj->size);
} else if (isKindOf(slotRawObject(slot), class_int8array)) {
PyrInt8Array *arrayObj = slotRawInt8Array(slot);
packet->addb(arrayObj->b, arrayObj->size);
} else if (isKindOf(slotRawObject(slot), class_array)) {
PyrObject *arrayObj = slotRawObject(slot);
big_scpacket packet2;
if (arrayObj->size > 1 && isKindOfSlot(arrayObj->slots+1, class_array)) {
makeSynthBundle(&packet2, arrayObj->slots, arrayObj->size, true);
} else {
int error = makeSynthMsgWithTags(&packet2, arrayObj->slots, arrayObj->size);
if (error != errNone)
return error;
}
packet->addb((uint8*)packet2.data(), packet2.size());
}
break;
case tagNil :
case tagTrue :
case tagFalse :
case tagChar :
case tagPtr :
break;
default :
if (gUseDoubles) packet->addd(slotRawFloat(slot));
else packet->addf(slotRawFloat(slot));
break;
}
return errNone;
}
bool PyrGC::SanityMarkObj(PyrObject *objA, PyrObject *fromObj, int level)
{
if (objA->IsPermanent()) return true;
if (objA->IsMarked()) return true;
if (objA->size > MAXINDEXSIZE(objA)) {
fprintf(stderr, "obj indexed size larger than max: %d > %ld\n", objA->size, MAXINDEXSIZE(objA));
//dumpObject((PyrObject*)objA);
return false;
}
objA->SetMark(); // mark it
if (!BlackToWhiteCheck(objA))
return false;
if (objA->obj_format <= obj_slot) {
// scan it
int size = objA->size;
if (size > 0) {
PyrSlot *slot = objA->slots;
for (int j=size; j--; ++slot) {
PyrObject * objB = NULL;
int tag = GetTag(slot);
if (tag == tagObj && slotRawObject(slot))
objB = slotRawObject(slot);
if (objB) {
/*
if (level > 40) {
fprintf(stderr, "40 levels deep!\n");
dumpBadObject(objA);
dumpBadObject(objB);
return false;
} */
bool err = SanityMarkObj(objB, objA, level + 1);
if (!err)
return false;
}
}
}
}
return true;
}
const std::string MaybeType::ValueToString(const TypeTable& type_table,
const Indent& indent, const_shared_ptr<void> value) const {
ostringstream buffer;
auto sum_instance = static_pointer_cast<const Sum>(value);
auto tag = sum_instance->GetTag();
buffer << "{" << *tag << "}";
if (*tag == *TypeTable::GetNilName()) {
} else if (*tag == *MaybeTypeSpecifier::VARIANT_NAME) {
auto type_result = m_base_type_specifier->GetType(type_table, RESOLVE);
if (ErrorList::IsTerminator(type_result->GetErrors())) {
auto type = type_result->GetData<TypeDefinition>();
auto inner_value = sum_instance->GetValue();
buffer << type->GetValueSeparator(indent, inner_value.get());
buffer << type->ValueToString(type_table, indent + 1, inner_value);
} else {
buffer << "<undefined type>";
}
} else {
buffer << "<undefined variant>";
}
return buffer.str();
}
//retrieve string (pattern) by number
//called by Parse when '\0'-'\9' found
BOOL COXRegExpression::GetPattern(int nNumber, CString &sPattern)
{
if (nNumber<0 ||nNumber>9)
return FALSE;
int nIndex=0;
for (int n=0;n<GetTagCount();n++)
{
tRegExpTag* pTag=GetTag(n);
if (pTag->nType==OX_REGEXP_TAG_PATTERN)
{
if (nIndex==nNumber)
{
sPattern=pTag->sValue;
return TRUE;
}
else
nIndex++;
}
}
return FALSE;
}
// ============================== INPUT HANDLING ========================================
long TpartEditForm::DoControlClick( long arg, void *ptr )
{
#ifdef __MWERKS__
#pragma unused(ptr)
#endif
tag_entry* e;
tag new_id;
switch( arg )
{
case 11801: // Choose a tag
new_id = pick_tag_of_type('spri', GetTag( 11801 ), fEntry );
if(new_id != 0) SetTag( 11801, 'spri', new_id );
break;
case 11802: // Open tag window
e = get_entry('spri', GetTag( 11801 ) );
if(e) TRevengeApp::OpenItem( e );
break;
case 11805: // Choose a tag
new_id = pick_tag_of_type('amso', GetTag( 11805 ), fEntry );
if(new_id != 0) SetTag( 11805, 'amso', new_id );
break;
case 11806: // Open tag window
e = get_entry('amso', GetTag( 11805 ) );
if(e) TRevengeApp::OpenItem( e );
break;
case 11807: // Choose a tag
new_id = pick_tag_of_type('lpgr', GetTag( 11807 ), fEntry );
if(new_id != 0) SetTag( 11807, 'lpgr', new_id );
break;
case 11808: // Open tag window
e = get_entry('lpgr', GetTag( 11807 ) );
if(e) TRevengeApp::OpenItem( e );
break;
default:
return -1;
}
return 0;
}
ECode IccServiceTable::ToString(
/* [out] */ String* result)
{
VALIDATE_NOT_NULL(result);
AutoPtr<ArrayOf<IInterface*> > values = GetValues();
Int32 numBytes = mServiceTable->GetLength();
StringBuilder builder(GetTag());
builder.Append('[');
builder.Append(numBytes * 8);
builder.Append(String("]={ "));
Boolean addComma = FALSE;
for (Int32 i = 0; i < numBytes; i++) {
Byte currentByte = (*mServiceTable)[i];
for (Int32 bit = 0; bit < 8; bit++) {
if ((currentByte & (1 << bit)) != 0) {
if (addComma) {
builder.Append(", ");
}
else {
addComma = TRUE;
}
Int32 ordinal = (i * 8) + bit;
if (ordinal < values->GetLength()) {
builder.Append((*values)[ordinal]);
}
else {
builder.Append('#');
builder.Append(ordinal + 1); // service number (one-based)
}
}
}
}
builder.Append(" }");
builder.ToString(result);
return NOERROR;
}
inline
void Vector::Copy(const Vector& x)
{
CopyImpl(x);
ObjectChanged();
// Also copy any cached scalar values from the original vector
// ToDo: Check if that is too much overhead
TaggedObject::Tag x_tag = x.GetTag();
if (x_tag == x.nrm2_cache_tag_) {
nrm2_cache_tag_ = GetTag();
cached_nrm2_ = x.cached_nrm2_;
}
if (x_tag == x.asum_cache_tag_) {
asum_cache_tag_ = GetTag();
cached_asum_ = x.cached_asum_;
}
if (x_tag == x.amax_cache_tag_) {
amax_cache_tag_ = GetTag();
cached_amax_ = x.cached_amax_;
}
if (x_tag == x.max_cache_tag_) {
max_cache_tag_ = GetTag();
cached_max_ = x.cached_max_;
}
if (x_tag == x.min_cache_tag_) {
min_cache_tag_ = GetTag();
cached_min_ = x.cached_min_;
}
if (x_tag == x.sum_cache_tag_) {
sum_cache_tag_ = GetTag();
cached_sum_ = x.cached_sum_;
}
if (x_tag == x.sumlogs_cache_tag_) {
sumlogs_cache_tag_ = GetTag();
cached_sumlogs_ = x.cached_sumlogs_;
}
}
HRESULT KG3DAnimationTagContainer::Start(float fSpeed,
int nOffsetTime,
DWORD dwType,
enuAnimationControllerPriority Priority)
{
HRESULT hr = E_FAIL;
HRESULT hRetCode = E_FAIL;
IKG3DAnimationController* pController = NULL;
KG_PROCESS_ERROR(m_pModel);
KG_PROCESS_ERROR(m_szAnimationName[0] != '\0');
if(!m_pClip)
{
hr = g_cClipTable.LoadResourceFromFile(m_szAnimationName, 0, 0, &m_pClip);
KG_COM_PROCESS_ERROR(hr);
}
switch(dwType)
{
case ENU_ANIMATIONPLAY_ADDCURRENT_ONCE:
case ENU_ANIMATIONPLAY_ADDCURRENT:
{
KG3DAnimationMotionTag* pMotionTag = dynamic_cast<KG3DAnimationMotionTag*>(GetTag(TAGTYPE_MOTION));
if (pMotionTag)
{
UINT uStartFrame = pMotionTag->GetMotionStart();
nOffsetTime = m_pClip->ConvertFrameToTime(uStartFrame);
}
}
break;
}
hr = m_pModel->Helper_PlayAnimationNormal(dwType,
m_szAnimationName,
fSpeed,
nOffsetTime,
NULL,
Priority,
MPAT_TAGGED,
this,m_pClip);
KGLOG_COM_PROCESS_ERROR(hr);
pController = m_pModel->GetAnimationController(Priority);
KG_PROCESS_ERROR(pController);
pController->AddAnimationControllerUpdateNotifier(this);
for (size_t i = 0; i < m_vecTags.size(); i++)
{
IKG3DAnimationTag* pTag = m_vecTags[i].pTag;
if (pTag)
{
pTag->SetAnimationSpeed(fSpeed);
pTag->Reset();
}
}
hRetCode = S_OK;
Exit0:
return hRetCode;
}
char GetChar(int source) {
CheckNodeId(source);
GetTag(source, kChar);
return GetRawByte(&incoming_buffers[source]);
}
SSL_ContentType SSL_Record_Base::GetType() const
{
return (SSL_ContentType) GetTag();
}
OP_STATUS SSL_HandShakeMessage::SetMessage( SSL_HandShakeType item)
{
if ((SSL_HandShakeType) GetTag() != item || msg == NULL)
{
LoadAndWritableList *temp;
if(msg != NULL)
{
temp = msg;
msg = NULL;
ServerKeys = NULL;
OP_DELETE(temp);
}
temp = NULL;
switch (item)
{
case SSL_Client_Hello :
temp = OP_NEW(SSL_Client_Hello_st, ());
break;
case SSL_Server_Hello :
temp = OP_NEW(SSL_Server_Hello_st, ());
break;
case SSL_Certificate :
temp = OP_NEW(SSL_Certificate_st, ());
break;
case SSL_Server_Key_Exchange :
temp = ServerKeys = OP_NEW(SSL_Server_Key_Exchange_st, ());
break;
case SSL_CertificateRequest :
temp = CertRequest = OP_NEW(SSL_CertificateRequest_st, ());
break;
case SSL_Certificate_Verify :
temp = OP_NEW(SSL_CertificateVerify_st, ());
break;
case SSL_Client_Key_Exchange :
temp = OP_NEW(SSL_Client_Key_Exchange_st, ());
break;
case SSL_Finished :
temp = OP_NEW(SSL_Finished_st, ());
break;
case SSL_Server_Hello_Done :
temp = OP_NEW(SSL_Hello_Done_st, ());
break;
case TLS_NextProtocol :
temp = OP_NEW(SSL_NextProtocol_st, ());
break;
#ifndef TLS_NO_CERTSTATUS_EXTENSION
case TLS_CertificateStatus:
temp = OP_NEW(TLS_CertificateStatusResponse, ());
break;
#endif
default : break;
}
msg = temp;
if(msg == NULL && (item != SSL_NONE && item != SSL_Server_Hello_Done &&
item != SSL_Hello_Request))
{
RaiseAlert(SSL_Internal, SSL_Allocation_Failure);
return OpStatus::ERR_NO_MEMORY;
}
SetTag(item);
if(connstate != NULL)
{
if(item == SSL_Server_Key_Exchange)
ServerKeys->SetCommState(connstate);
else if(item == SSL_CertificateRequest)
CertRequest->SetCommState(connstate);
}
dummy.ResetRecord();
}
