void Configuration::FillFromConfigAttributes(const char * attributes)
{
// Initializing map.
arguments.clear();
size_t len = 0;
// Getting list length. List is terminated by two '\0'.
while (attributes[len] || attributes[len + 1])
++len;
++len;
ParseAttributeList(attributes, len, '\0', arguments);
ArgumentMap::const_iterator it = arguments.find(Key::address);
if (it != arguments.end())
{
// Parsing address.
ParseAddress(it->second, endPoint);
}
else
{
endPoint.host = GetStringValue(Key::server, DefaultValue::server);
endPoint.port = static_cast<uint16_t>(GetIntValue(Key::port, DefaultValue::port));
}
}
bool Var::Equals(Var* rvalue) {
switch(type) {
case vtInt: {
return GetIntValue() == rvalue->GetIntValue();
}
case vtFloat: {
return GetFloatValue() == rvalue->GetFloatValue();
}
case vtString: {
char* lvaluetext = GetStringValue();
char* rvaluetext = rvalue->GetStringValue();
bool result = !strcmp(lvaluetext,rvaluetext);
delete[] lvaluetext;
delete[] rvaluetext;
return result;
}
case vtFloat3: {
return float3value == rvalue->float3value;
}
case vtObject: {
return objectvalue == rvalue->objectvalue; // compare pointers...
}
default: {
return false;
}
}
}
bool CIniFileProcessor::GetIRSFacilityID(short& iVal) // unique function to retrieve the id from a unique ini file only for use with IRS
{
CString irsinipath;
TCHAR foo[64];
CIniFileProcessor::GetULFullPath(eIRININAME, irsinipath);
// Get value from the real ini file source
// We do it this way (always reloading the file content) as it may change externally, and it resides in a different file from the FDMS.ini anyway
DWORD dw =
GetPrivateProfileString(
m_Entry[eFACILITYID].section,
m_Entry[eFACILITYID].name,
m_Entry[eFACILITYID].defIniValue,
foo,sizeof(foo),irsinipath);
if (dw == 0)
{
return false;
}
if (m_Entry[eFACILITYID].iniValue != NULL)
{
delete [] m_Entry[eFACILITYID].iniValue;
}
m_Entry[eFACILITYID].iniValue = new TCHAR[strlen(foo)+1];
foo[strlen(foo)] = 0; // redundant
strcpy(m_Entry[eFACILITYID].iniValue, foo);
iVal = (short)GetIntValue(eFACILITYID);
return true;
}
//读取第nParamIndex个参数，该参数为整型
int CScript::GetIntParam(char* strCmd, int nParamIndex)
{
int nCmdLen = strlen(strCmd);
int nStartOfParam = __PassCmdName(strCmd, nCmdLen);
if(nStartOfParam == nCmdLen)
return DEMO::ERROR_INT_PARAM;
int nParamNum = 0;
m_bScanningStr = false;
for(int j=nStartOfParam+1; j<nCmdLen; j++)
{
if(strCmd[j] == '\"')
m_bScanningStr = !m_bScanningStr;
//跳过分隔符
if(__IsDelimiter(strCmd[j]))
nParamNum++;
//读取到数字参数，读取并转换为数字
if(nParamNum == nParamIndex &&
(strCmd[j] == '-' || (strCmd[j] >= '0' && strCmd[j] <= '9')))
{
return GetIntValue(strCmd, nCmdLen, j);
}
}
return DEMO::ERROR_INT_PARAM;
}
LRESULT CMainFrame::OnRuning(WPARAM wParam, LPARAM lParam)
{
#ifndef _DEBUG
BeforeWorkPro();
BeforeWork();
#endif
if (GetIntValue(PK_PortCtrlMode) != PCM_USE_WEEK)
{
Sleep(500);//延时用于打开吸泵
}
vector<TRACK> _vecTrack;
//1.获取加工数据
if(GetData(_vecTrack) == false)
{
OnCloseLoop(NULL, NULL);
Home();
return 0;
}
//2. 把数据丢进控制卡模块驱动硬件
Run(_vecTrack);
return 0;
}
void Configuration::FillFromConnectString(const char* str, size_t len)
{
// Initializing map.
arguments.clear();
// Initializing DSN to empty string.
arguments[Key::dsn].clear();
// Ignoring terminating zero byte if present.
// Some Driver Managers pass zero-terminated connection string
// while others don't.
if (len && !str[len - 1])
--len;
ParseAttributeList(str, len, ';', arguments);
ArgumentMap::const_iterator it = arguments.find(Key::address);
if (it != arguments.end())
{
// Parsing address.
ParseAddress(it->second, endPoint);
}
else
{
endPoint.host = GetStringValue(Key::server, DefaultValue::server);
endPoint.port = static_cast<uint16_t>(GetIntValue(Key::port, DefaultValue::port));
}
}
// 上分
void OnPushScore(char Id) {
struct stUserInfo *pUser = GetUserInfo(Id);
int Total = GetIntValue(UD_TOTALSCORE+Id);
// 没开锁
if (!(ConstDownKey[Id] & KEY_LOCK)) {
return;
}
Total += GetIntValue(UD_PUSHSCORE_RATIO);
// 总分
SetIntValue(UD_TOTALSCORE+Id, Total);
// 上分
SetIntValue(UD_PUSHSCORE+Id, GetIntValue(UD_PUSHSCORE+Id)+GetIntValue(UD_PUSHSCORE_RATIO));
}
float CGUISliderControl::GetProportion(RangeSelector selector /* = RangeSelectorLower */) const
{
if (m_iType == SPIN_CONTROL_TYPE_FLOAT)
return (GetFloatValue(selector) - m_fStart) / (m_fEnd - m_fStart);
else if (m_iType == SPIN_CONTROL_TYPE_INT)
return (float)(GetIntValue(selector) - m_iStart) / (float)(m_iEnd - m_iStart);
return 0.01f * GetPercentage(selector);
}
/* 获取section段第一个键为key的int值，成功返回获取的值，否则返回默认值 */
void IniFile::GetIntValueOrDefault(const string §ion, const string &key, int *value, int defaultValue)
{
if (GetIntValue(section, key, value) != 0) {
*value = defaultValue;
}
return;
}
// 下分
void OnPollScore(char Id) {
struct stUserInfo *pUser = GetUserInfo(Id);
int LocalTotal = GetIntValue(UD_TOTALSCORE+Id);
int Total = LocalTotal - pUser->TotalBetScore;
// 正在退币,不能下分
if (IsPollingCoin(Id)) {
return;
}
// 没开锁
if (!(ConstDownKey[Id] & KEY_LOCK)) {
return;
}
// 减总分
if (Total > GetIntValue(UD_POLLSCORE_RATIO)) {
Total -= GetIntValue(UD_POLLSCORE_RATIO);
LocalTotal -= GetIntValue(UD_POLLSCORE_RATIO);
SetIntValue(UD_TOTALSCORE+Id, LocalTotal); // 保存总分
SetIntValue(UD_POLLSCORE+Id, GetIntValue(UD_POLLSCORE+Id)+GetIntValue(UD_POLLSCORE_RATIO)); // 保存下分
} else {
LocalTotal -= Total;
SetIntValue(UD_TOTALSCORE+Id, LocalTotal); // 保存总分
SetIntValue(UD_POLLSCORE+Id, GetIntValue(UD_POLLSCORE+Id)+Total); // 保存下分
}
}
void CDialogCCD::OnBnClickedReload()
{
//参数初始化
ParamMLoadFile();
MCardParamLoad();
ImageCalcParamLoad();
g_nWorkMode = GetIntValue(PK_WorkMode);
}
void SetThro()
{
//char type = GetUartChar();
uint8_t value;
//if(type=='t')
{
value = GetIntValue();
Thro = value;
}
}
void InitUserData(void)
{
char Idx;
for (Idx = 0; Idx < PLAYER_COUNT; Idx++) {
ALLBITS |= (1<<Idx);
}
if (READINTVALUE(UD_FIRSTRUN_FLAG) == FIRSTRUN_FLAG) {
ReadUserData();
if (GetCharValue(UD_START_SAVE)) {
RecoverPlayerData();
}
if (GetCharValue(UD_UNSAVE_SCORE)) {
SaveBetWinScore();
}
} else {
ClearUserData();
SetIntValue(UD_FIRSTRUN_FLAG, FIRSTRUN_FLAG);
}
#ifdef _NO_PRINT
SetCharValue(UD_IF_PRINT, 0);
#endif
#ifdef _TEST_
#define Debug lite_printf
//ClearUserData();
//SetIntValue(UD_FIRSTRUN_FLAG, FIRSTRUN_FLAG);-
SetCharValue(UD_IF_PRINT, 0);
//SetCharValue(UD_BETTIME, 5);
//SetCharValue(UD_EXTRA_CODE_DIFFICULT, 1); // 外5门设定难度
//SetIntValue(UD_ROUNDLOSS_BOOM, 1000000); // 当轮输爆机
//SetIntValue(UD_STAGEWIN_BOOM, 20000000); // 当期max loss
//SetIntValue(UD_STAGELOSS_BOOM, 300000000); // 当期max win
// for (Idx = 0; Idx < UD_MAXCHAR_STATE; Idx++) {
// Debug("%p = %d/%d\n", UserDataCharArray + Idx, READCHARVALUE(Idx), UserDataCharArray[Idx]);
// }
// for (Idx = 0; Idx < UD_MAXSHORT_STATE; Idx++) {
// Debug("%p = %d/%d\n", UserDataShortArray + Idx, READSHORTVALUE(Idx), UserDataShortArray[Idx]);
// }
for (Idx = 0; Idx < UD_MAXINT_STATE; Idx++) {
Debug("%p = %d/%d\n", UserDataIntArray + Idx, READINTVALUE(Idx), UserDataIntArray[Idx]);
}
// for (Idx = 0; Idx < UD_MAXLONGLONG_STATE; Idx++) {
// Debug("%p = %d/", UserDataLongLongArray + Idx, READLONGLONGVALUE(Idx));
// Debug("%d\n", UserDataLongLongArray[Idx]);
// }
Debug("UUID:\n");
for (Idx = 0; Idx < USB_PLAYER_COUNT; Idx++) {
Debug("%p:%d/%d\n", UserDataIntArray+UD_INVALID_INT+Idx, GetIntValue(UD_USB_UUID+Idx), READINTVALUE(UD_USB_UUID+Idx));
}
SetIntValue(UD_USB_UUID + 5, 123456);
SetIntValue(UD_USB_UUID + 6, 876543210);
#endif
}
CMainFrame::CMainFrame()
{
//参数初始化
ParamMLoadFile();
MCardParamLoad();
ImageCalcParamLoad();
m_bIsLoopWork = FALSE;
m_nLineCount = 0;
m_timeTotal = CTimeSpan(0);
g_nWorkMode = GetIntValue(PK_WorkMode);
}
static bool controlExpression(char relOp, expADT expL, expADT expR, environmentADT env){
valueADT leftV, rightV;
leftV = Eval(expL, env);
rightV = Eval(expR, env);
if(ValueType(leftV) == IntValue && ValueType(rightV) == IntValue ){
switch(relOp){
case '<':
return (GetIntValue(leftV) < GetIntValue(rightV));
case '>':
return (GetIntValue(leftV) > GetIntValue(rightV));
case '=':
return (GetIntValue(leftV) == GetIntValue(rightV));
default:
Error("Reloperator %c is not valid.\n", relOp);
break;
}
}
else
Error("\nCompared expressions is not Integers\n");
}
int main(){
int Num_TestCase=0,total_credit=0,num_item=0,count=0,arr[10000],i=0;
Num_TestCase=GetIntValue();
//printf("\n%d\n",Num_TestCase);
while(count < Num_TestCase) {
//printf("\n******* ENTRY %d*********",count+1);
total_credit=GetIntValue();
num_item=GetIntValue();
//printf("\n%d",total_credit);
//printf("\n%d\n",num_item);
i=0;
while(i<num_item){
arr[i]=GetIntValue();
//printf("%d ",arr[i]);
i++;
}
StoreCredit(arr,total_credit,num_item,count);
//printf("\n******* Completed %d*********\n\n",count+1);
count++;
}
//fclose(f1);
return 0;
}
// 接收投退币个数
// ***退币流程*** //
// 1.押分板按下退币,发送消息
// 2.主卡从接收到消息开始倒计时5S
// 3.押分板每次退一个币就发送一条消息到主卡
// 4.主卡每接收到退币个数即重新倒计时
// 5.如果在倒计时内不接收到来自押分板的退币个数消息,即表示退币完毕
// 6.在倒计时内不可押分
void Process_CoinInfo(unsigned char Id, unsigned char *Data) {
short PushCoinCount,PollCoinCount;
int TotalScore = GetIntValue(UD_TOTALSCORE + Id);
int PushScore, PollScore;
PushCoinCount = GET_U16(Data); Data += 2; // 投币个数
PollCoinCount = GET_U16(Data); Data += 2; // 退币个数
PushScore = PushCoinCount*GetIntValue(UD_PUSHCOIN_RATIO);
PollScore = PollCoinCount*GetIntValue(UD_POLLCOIN_RATIO);
// 处理投币
if (PushScore > 0) {
SetIntValue(UD_PUSHSCORE + Id, GetIntValue(UD_PUSHSCORE + Id) + PushScore);
SetIntValue(UD_TOTALSCORE + Id, TotalScore+PushScore);
}
// 处理退币
if (PollScore > 0) {
if (TotalScore >= PollScore) {
SetIntValue(UD_POLLSCORE + Id, GetIntValue(UD_POLLSCORE + Id) + PollScore);
SetIntValue(UD_TOTALSCORE + Id, TotalScore - PollScore);
}
// 重新设置退币倒计时
UpdatePollingCoinTime(Id, 5);
}
// 更新总分
if (TotalScore != GetIntValue(UD_TOTALSCORE + Id)) {
Set_Score(Id);
}
}
bool Var::Less(Var* rvalue) {
switch(type) {
case vtInt: {
return GetIntValue() < rvalue->GetIntValue();
}
case vtFloat: {
return GetFloatValue() < rvalue->GetFloatValue();
}
default: {
return false;
}
}
}
NS_IMETHODIMP
nsPop3IncomingServer::GetOfflineSupportLevel(int32_t *aSupportLevel)
{
NS_ENSURE_ARG_POINTER(aSupportLevel);
nsresult rv;
rv = GetIntValue("offline_support_level", aSupportLevel);
if (*aSupportLevel != OFFLINE_SUPPORT_LEVEL_UNDEFINED) return rv;
// set default value
*aSupportLevel = OFFLINE_SUPPORT_LEVEL_NONE;
return NS_OK;
}
static int EvalCompound(expADT exp, environmentADT env){
char op;
int lhs, rhs;
valueADT lValue, rValue;
op = ExpOperator(exp);
lValue = Eval(ExpLHS(exp), NewClosure(env));
rValue = Eval(ExpRHS(exp), NewClosure(env));
lhs = GetIntValue(lValue);
rhs = GetIntValue(rValue);
switch (op) {
case '+': return (lhs + rhs);
case '-': return (lhs - rhs);
case '*': return (lhs * rhs);
case '/': if (rhs == 0) Error("Division by zero\n"); else return (lhs / rhs);
default: Error("Illegal operator");
}
}
// 重新计算上局押分
void SaveBetWinScore(void) {
char ID;
for (ID = 0; ID < PLAYER_COUNT; ID++) {
if (GetIntValue(UD_TOTALSCORE+ID) >= GetIntValue(UD_LAST_TOTAL_BET+ID) && GetIntValue(UD_LAST_WON_SCORE+ID) >= 0) {
SetIntValue(UD_TOTALSCORE+ID, GetIntValue(UD_TOTALSCORE+ID)+GetIntValue(UD_LAST_WON_SCORE+ID)-GetIntValue(UD_LAST_TOTAL_BET+ID));
}
// 如果某个玩家的分数为负,则清0
if (GetIntValue(UD_TOTALSCORE+ID) < 0) {
SetIntValue(UD_TOTALSCORE+ID, GetIntValue(UD_PLAYER_PROFIT+ID) + GetIntValue(UD_POLLSCORE+ID) - GetIntValue(UD_PUSHSCORE+ID));
if (GetIntValue(UD_TOTALSCORE+ID) < 0) {
SetIntValue(UD_TOTALSCORE+ID, 0);
}
}
SetIntValue(UD_LAST_WON_SCORE+ID, 0);
SetIntValue(UD_LAST_TOTAL_BET+ID, 0);
}
// 复位标志
SetCharValue(UD_UNSAVE_SCORE, 0);
}
BOOL FarEditCtrl::Validate()
{
BOOL ret = TRUE;
if (fValidateFunc != NULL)
ret = fValidateFunc (fItem->Data, fValidateUserParam);
if (ret)
{
if (fIntValuePtr)
*fIntValuePtr = GetIntValue();
if (fStringPtr)
*fStringPtr = fItem->Data;
}
return ret;
}
Configuration::Configuration(std::string path)
: ConfigurationReader(path) {
hostSpeed = GetDoubleValue("Host.speed", 2900.0);
processorLevel = GetProcessorTypeValue("CPU.level");
speed = GetDoubleValue("CPU.speed", 2.0);
pollIntervalMilliseconds = GetIntValue("CPU.pollIntervalMilliseconds", 10);
inputAddress = GetUShortValue("IO.inputAddress");
outputAddress = GetUShortValue("IO.outputAddress");
romPath = GetStringValue("ROM.path");
romLoadAddress = GetUShortValue("ROM.loadAddress");
ramPath = GetStringValue("RAM.path");
ramLoadAddress = GetUShortValue("RAM.loadAddress");
bbcLanguageRomPath = GetStringValue("BBC.language.path");
bbcOSRomPath = GetStringValue("BBC.OS.path");
bbcVduEmulation = GetBooleanValue("BBC.VDUEmulation");
startAddress = GetUShortValue("run.startAddress");
resetStart = GetBooleanValue("run.resetStart");
stopBreak = GetBooleanValue("run.stopBreak");
breakInstruction = GetByteValue("run.breakInstruction", 0x00);
stopWhenLoopDetected = GetBooleanValue("run.stopWhenLoopDetected");
stopAddress = GetUShortValue("run.stopAddress");
stopAddressEnabled = stopAddress != 0;
#ifdef _DEBUG
disassemble = GetBooleanValue("debug.disassemble");
disassemblyLogPath = GetStringValue("debug.disassemblyLogPath");
debugFile = GetStringValue("debug.debugFile");
countInstructions = GetBooleanValue("debug.countInstructions");
profileAddresses = GetBooleanValue("debug.profileAddresses");
#else
disassemble = GetBooleanValue("release.disassemble");
disassemblyLogPath = GetStringValue("release.disassemblyLogPath");
debugFile = GetStringValue("release.debugFile");
countInstructions = GetBooleanValue("release.countInstructions");
profileAddresses = GetBooleanValue("release.profileAddresses");
#endif
}
char *ldl_attribute::GetValueText()
{
static char buf[1024];
switch(m_type) {
case ATTRIBUTE_TYPE_BOOL:
sprintf(buf, "%s", GetBoolValue() ? "true" : "false");
break;
case ATTRIBUTE_TYPE_INT:
sprintf(buf, "%d", GetIntValue());
break;
case ATTRIBUTE_TYPE_DOUBLE:
sprintf(buf, "%lf", GetFloatValue());
break;
case ATTRIBUTE_TYPE_STRING:
sprintf(buf, "%s", GetStringValue());
break;
}
return buf;
}
void IntegerListConfigControl::OnAction( wxCommandEvent& event )
{
int i_action = event.GetId() - wxID_HIGHEST;
module_config_t *p_item;
p_item = config_FindConfig( p_this, GetName().mb_str() );
if( !p_item ) return;
if( i_action < 0 || i_action >= p_item->i_action ) return;
vlc_value_t val;
val.i_int = GetIntValue();
p_item->ppf_action[i_action]( p_this, GetName().mb_str(), val, val, 0 );
if( p_item->b_dirty )
{
combo->Clear();
UpdateCombo( p_item );
p_item->b_dirty = false;
}
}
void RegistryKey::PrintValue(WCHAR *keyName, WCHAR *valueName,
WCHAR *msg)
{
int value = GetIntValue(keyName, valueName);
switch (value) {
case J2D_ACCEL_UNVERIFIED:
printf("%S: %s\n", msg, "UNVERIFIED");
break;
case J2D_ACCEL_TESTING:
printf("%S: %s\n", msg, "TESTING (may indicate crash during test)");
break;
case J2D_ACCEL_FAILURE:
printf("%S: %s\n", msg, "FAILURE");
break;
case J2D_ACCEL_SUCCESS:
printf("%S: %s\n", msg, "SUCCESS");
break;
default:
printf("No registry value for key, value %S, %S\n",
keyName, valueName);
break;
}
}
// -------------------------------------------------------------------
// PopulateArrayWithValue
// -------------------------------------------------------------------
void SFSUserVariable::PopulateArrayWithValue(boost::shared_ptr<ISFSArray> arr)
{
switch(type)
{
case VARIABLETYPE_UNKNOWN :
break;
case VARIABLETYPE_NULL :
arr->AddNull();
break;
case VARIABLETYPE_BOOL:
arr->AddBool(GetBoolValue());
break;
case VARIABLETYPE_INT:
arr->AddInt(GetIntValue());
break;
case VARIABLETYPE_DOUBLE:
arr->AddDouble(GetDoubleValue());
break;
case VARIABLETYPE_STRING:
arr->AddUtfString(GetStringValue());
break;
case VARIABLETYPE_OBJECT:
arr->AddSFSObject(GetSFSObjectValue());
break;
case VARIABLETYPE_ARRAY:
arr->AddSFSArray(GetSFSArrayValue());
break;
}
}
bool CMainFrame::GetData(vector<TRACK>& trackers_)
{
bool _nRet = false;
int _nAixsNum = GetIntValue(PK_AxisNum);
int _nPCount = 0;
switch(g_nWorkMode)
{
case WM_ORIG:
{
_nRet = TransfDataFromFileToCNC(g_vecUnit, _nAixsNum, trackers_);
}
break;
case WM_TEMPLATE:
{
if(!GetImage(&g_image))
{
return false;
}
if (!m_dialogCCD.ParseFileList())
{
return false;
}
_nRet = GetTrackByTemplateArea(&g_image, m_dialogCCD.m_vecFile,
trackers_, _nPCount);
}
break;
case WM_CONTOUR:
{
if(false == GetImage(&g_image))
{
return false;
}
TRACK _track;
_nRet = GetImageMaxContourMM(&g_image, _track);
if (!_track.empty())
{
trackers_.push_back(_track);
}
}
break;
case WM_RANGE:
{
#if 0
if(GetImage(&g_image) == false)
{
return false;
}
double _fLength = 0.;
POINTST _ptCenter;
if(GetImageMaxContourKeys(&g_image, _fLength, _ptCenter) == false)
{
return false;
}
#endif
}
break;
default:
break;
}
if (_nRet)
{
m_nLineCount += _nPCount;
}
if (trackers_.empty())
{
return false;
}
return _nRet;
}
void SelectProjectJob::Perform() {
if (ReaProject* proj = EnumProjects(GetIntValue(), NULL, 0)) // project number is 0-based
SelectProjectInstance(proj);
}
void *Asc2Bin(const char *source, int &count, const char *spec)
{
char *dest = 0;
count = 0;
int cnt = 0;
int size = 0;
Atype types[MAXARG];
const char *ctype = spec;
while (*ctype)
{
switch (ToLower(*ctype))
{
case 'f':
size += sizeof(float);
types[cnt] = AT_FLOAT;
cnt++;
break;
case 'd':
size += sizeof(int);
types[cnt] = AT_INT;
cnt++;
break;
case 'c':
size += sizeof(char);
types[cnt] = AT_CHAR;
cnt++;
break;
case 'b':
size += sizeof(char);
types[cnt] = AT_BYTE;
cnt++;
break;
case 'h':
size += sizeof(short);
types[cnt] = AT_SHORT;
cnt++;
break;
case 'p':
size += sizeof(const char*);
types[cnt] = AT_STR;
cnt++;
break;
case 'x':
if (1)
{
Atype type = AT_HEX4;
int sz = 4;
switch (ctype[1])
{
case '1':
type = AT_HEX1;
sz = 1;
ctype++;
break;
case '2':
type = AT_HEX2;
sz = 2;
ctype++;
break;
case '4':
type = AT_HEX4;
sz = 4;
ctype++;
break;
}
types[cnt] = type;
size += sz;
cnt++;
}
break;
}
if (cnt == MAXARG)
{
return 0;
}
// over flowed the maximum specification!
ctype++;
}
int reserve_count = 16;
dest = new char[reserve_count *size];
memset(dest, 0, reserve_count *size); // zero out memory
char *dst = (char*)dest; // where we are storing the results
while (1)
{
for (int j = 0; j < cnt; j++)
{
source = SkipWhitespace(source); // skip white spaces.
if (*source == 0)
// we hit the end of the input data before we successfully parsed all input!
{
return dest;
}
switch (types[j])
{
case AT_FLOAT:
if (1)
{
float *v = (float*)dst;
*v = GetFloatValue(source, &source);
dst += sizeof(float);
}
break;
case AT_INT:
if (1)
{
int *v = (int*)dst;
*v = GetIntValue(source, &source);
dst += sizeof(int);
}
break;
case AT_CHAR:
if (1)
{
*dst++ = *source++;
}
break;
case AT_BYTE:
if (1)
{
char *v = (char*)dst;
*v = GetIntValue(source, &source);
dst += sizeof(char);
}
break;
case AT_SHORT:
if (1)
{
short *v = (short*)dst;
*v = GetIntValue(source, &source);
dst += sizeof(short);
}
break;
case AT_STR:
if (1)
{
const char **ptr = (const char **)dst;
*ptr = source;
dst += sizeof(const char*);
while (*source && !IsWhitespace(*source))
{
source++;
}
}
break;
case AT_HEX1:
if (1)
{
unsigned int hex = GetHEX1(source, &source);
unsigned char *v = (unsigned char*)dst;
*v = hex;
dst += sizeof(unsigned char);
}
break;
case AT_HEX2:
if (1)
{
unsigned int hex = GetHEX2(source, &source);
unsigned short *v = (unsigned short*)dst;
*v = hex;
dst += sizeof(unsigned short);
}
break;
case AT_HEX4:
if (1)
{
unsigned int hex = GetHEX4(source, &source);
unsigned int *v = (unsigned int*)dst;
*v = hex;
dst += sizeof(unsigned int);
}
break;
default: /*nothing*/ break;
}
}
count++;
if (count >= reserve_count)
{
char *old_dest = (char*)dest;
reserve_count *= 2;
dest = new char[reserve_count *size];
memset(dest, 0, reserve_count *size); // zero out memory
memcpy(dest, old_dest, reserve_count / 2 * size); // copy the old data.
int dist = (int)(dst - old_dest);
dst = &dest[dist]; // the new destination.
delete old_dest; // free up the old data.
}
}
return dest;
}
