BOOL DisasmView_CheckForJump(const WORD* memory, WORD /*address*/, int* pDelta)
{
WORD instr = *memory;
// BR, BNE, BEQ, BGE, BLT, BGT, BLE
// BPL, BMI, BHI, BLOS, BVC, BVS, BHIS, BLO
if ((instr & 0177400) >= 0000400 && (instr & 0177400) < 0004000 ||
(instr & 0177400) >= 0100000 && (instr & 0177400) < 0104000)
{
*pDelta = ((int)(char)(instr & 0xff)) + 1;
return TRUE;
}
// SOB
if ((instr & ~(WORD)0777) == PI_SOB)
{
*pDelta = -(GetDigit(instr, 1) * 4 + GetDigit(instr, 0)) + 1;
return TRUE;
}
// CALL, JMP
if (instr == 0004767 || instr == 0000167)
{
*pDelta = ((short)(memory[1]) + 4) / 2;
return TRUE;
}
return FALSE;
}
int
HexToBuf(char *inString, SECItem *outbuf)
{
int len = strlen(inString);
int outlen = len+1/2;
int trueLen = 0;
outbuf->data = PORT_Alloc(outlen);
if (outbuf->data) {
return -1;
}
while (*inString) {
int digit1, digit2;
digit1 = GetDigit(*inString++);
digit2 = GetDigit(*inString++);
if ((digit1 == -1) || (digit2 == -1)) {
PORT_Free(outbuf->data);
outbuf->data = NULL;
return -1;
}
outbuf->data[trueLen++] = digit1 << 4 | digit2;
}
outbuf->len = trueLen;
return 0;
}
void
COUNTING_SORT_DIGIT(int* A, int lengthA, int* B, int digit)// k = 9 because 0..9
{
int C[10] = {0};
int i, j;
int tempDigit;
for (i = 0; i <= 9; i++) {
C[i] = 0;
}
for (j = 0; j < lengthA; j++) {
tempDigit = GetDigit(A[j], digit);
C[tempDigit] = C[tempDigit] + 1;
#ifdef DEBUG
printf("tempDigit: %d, C[%d]: %d\n", tempDigit, tempDigit, C[tempDigit]);
#endif
}
for (i = 1; i <= 9; i++) {
C[i] = C[i] + C[i-1];
}
#ifdef DEBUG
printf("Array C in digit %d:\n", digit);
printArray(C, 10);
#endif
for (j = lengthA - 1; j >= 0; j--) {
tempDigit = GetDigit(A[j], digit);
B[C[tempDigit] - 1] = A[j];
C[tempDigit] = C[tempDigit] - 1;
#ifdef DEBUG
printf("j = %d, tempDigit = %d, C[tempDigit] - 1 = %d\n", j, tempDigit, C[tempDigit]);
printArray(B, lengthA);
#endif
}
}
// Returns the digit with the k'th element.
IntPair ProcessDigit(const int* source, int count, int place, int k,
std::vector<int>& dest) {
for(int i(0); i < 80; ++i)
printf("-");
printf("\n%d's place:\n\n", place);
// Build the histogram by counting the number of elements with each digit.
int hist[10] = { 0 };
for(int i(0); i < count; ++i)
++hist[GetDigit(source[i], place)];
// Scan the histogram and find which radix digit k maps into.
int scan[10];
int kDigit;
scan[0] = 0;
for(int i(1); i < 10; ++i) {
scan[i] = scan[i - 1] + hist[i - 1];
if((k >= scan[i]) && (k < (scan[i] + hist[i])))
kDigit = i;
}
// Print the counts and scans.
printf("Frequency and scan of %d's digit:\n", place);
for(int i(0); i < 10; ++i) {
printf("%d: %3d %3d %c\n", i, hist[i], scan[i],
(kDigit == i) ? '*' : ' ');
}
// Extract all the elements with a kDigit.
int kCount = hist[kDigit];
dest.resize(kCount);
for(int i(0), j(0); i < count; ++i) {
int x = source[i];
if(kDigit == GetDigit(x, place))
dest[j++] = x;
}
printf("\nValues after filter (%d values):\n", kCount);
PrintArray(&dest[0], kCount, place / 10);
printf("\n");
// Return kDigit and scan[kDigit].
return IntPair(kDigit, scan[kDigit]);
}
int main()
{
while (scanf("%d%d", &nN, &nB) == 2)
{
int nDigit = GetDigit(nN, nB);
int nZero = GetZero(nN, nB);
printf("%d %d\n", nZero, nDigit);
}
return 0;
}
bool GetPosValueByExpression(char * pCmdStr, int *pslValue)
{
if (GetPosExpression(pCmdStr, pslValue) == true)
{
return true;
}
else if (GetDigit(pCmdStr,pslValue) == true)
{
return true;
}
return false;
}
void FGManager::IncrementFrequency(){
unsigned int freq = fg->GetWaveFromSlotMasterIndex(m_slot)->GetFrequency();
unsigned int add = 1;
for (int i = 0; i < m_scale; i++){
add *= 10;
}
if (GetDigit(freq, m_scale) == 9){
freq -= (9 * add);
} else{
freq += add;
}
fg->GetWaveFromSlotMasterIndex(m_slot)->SetFrequency(freq);
}
void FGManager::IncrementGain(){
unsigned int gain = fg->GetWaveFromSlotMasterIndex(m_slot)->GetGain();
unsigned int add = 1;
for (int i = 0; i < m_scale; i++){
add *= 10;
}
if (GetDigit(gain, m_scale) == 0){
gain += (9 * add);
}
else{
gain -= add;
}
fg->GetWaveFromSlotMasterIndex(m_slot)->SetGain(gain);
}
bool HfnParseActionP(char * pCmdStr, ACTION_ST * pstAction)
{
s32 slSpdSeq = 0;
if (pCmdStr == NULL
|| (*pCmdStr != 'P' && *pCmdStr != 'p'))
{
return false;
}
pCmdStr++;// 跳过字符[pP]
if (GetDigit(pCmdStr,&slSpdSeq) == false)
{
ERRINFO("速度指针解析错误");
return false;
}
pstAction->m_iActionType = ACTION_TYPE_SPD;
pstAction->m_stActionPos.m_slPos = slSpdSeq;
return true;
}
int CBVHElem::SetChanels( char* srcchar )
{
int setflag;
char* valuehead = srcchar;
valuehead = GetDigit( valuehead, &chanelnum, &setflag );
if( !setflag || !valuehead ){
DbgOut( L"bvhelem : SetChanels : GetDigit chanelnum error !!!\n" );
_ASSERT( 0 );
return 1;
}
if( (chanelnum != 3) && (chanelnum != 6) ){
DbgOut( L"bvhelem : SetChanels : chanelnum %d is not typical value : not supported error !!!\n", chanelnum );
_ASSERT( 0 );
return 1;
}
int chanelno;
for( chanelno = 0; chanelno < chanelnum; chanelno++ ){
if( !valuehead ){
DbgOut( L"bvhelem : SetChanels : no more params error !!!\n" );
_ASSERT( 0 );
return 1;
}
valuehead = GetChanelType( valuehead, &(chanels[chanelno]), &setflag );
if( !setflag ){
DbgOut( L"bvhelem : SetChanels : GetChanelType %d error !!!\n", chanelno );
_ASSERT( 0 );
return 1;
}
}
return 0;
}
void CXTPCalendarTimeZones::ParseDisplayStr(LPCTSTR str, int& rnOffset, CString& rstrPlace) const
{
// (GMT + 02:00) Athens, ...
// (GMT-02:00) place, ...
//----------------------------------------------
// (GMT - 02 : 00) place, ...
//0 1 2 3 4 5
//----------------------------------------------
rnOffset = 0;
rstrPlace.Empty();
int nSign = 0, nHr = 0, nMin = 0;
int nState = 0;
for (const TCHAR* pCh = (LPCTSTR)str; pCh && *pCh != 0; pCh = _tcsinc(pCh))
{
if (nState == 0 && *pCh == _T('('))
{
nState = 1;
}
else if (nState == 1)
{
if (*pCh == _T('+'))
{
nSign = 1;
nState = 2;
}
else if (*pCh == _T('-'))
{
nSign = -1;
nState = 2;
}
}
else if (nState == 2)
{
if (GetDigit(*pCh) >= 0)
{
nHr *= 10;
nHr += GetDigit(*pCh);
}
else if (*pCh == _T(':'))
{
nState = 3;
}
}
else if (nState == 3)
{
if (GetDigit(*pCh) >= 0)
{
nMin *= 10;
nMin += GetDigit(*pCh);
}
else if (*pCh == _T(')'))
{
nState = 4;
}
}
else if (nState == 4)
{
if (*pCh != _T(' '))
{
rstrPlace = pCh;
break;
}
}
}
//---------------------------------------
rnOffset = nSign * (nHr * 60 + nMin);
}
CFGTOKEN CfgFile::Scan()
{
CFGTOKEN ret;
int i;
char c;
ret.id = TINVALID;
loop:
c = Input();
if(c=='\t' || c==' '){
goto loop;
} else if(c=='\n' || c==';'){
ReadLine();
goto loop;
} else if(isdigit(c) || c=='.'){
m_nTextLen = 0;
if( GetDigit(c) > 0 ) ret.id = TREAL; else ret.id = TINTEGER;
if(m_nTextLen == 1 && m_szText[0]=='.') goto reterr;
if(m_nTextLen == 0) goto reterr;
Gather('\0');
if( ret.id == TINTEGER ){
ret.v.nval = atoi(m_szText);
} else if( ret.id == TREAL ){
ret.v.fval = (float)atof(m_szText);
}
return ret;
reterr:
ret.id = TINVALID;
return ret;
}
// SYMBOL
else if( isalpha(c) ){
m_nTextLen=0;
Gather(c);
for( c = Input(); isalpha(c) || isdigit(c); c=Input() ) Gather(c);
Unput(c);
Gather('\0');
for( i=0; rwords[i].val != TINVALID; i++ ){
if( strcmp(m_szText, rwords[i].szText) == 0 ){
break;
}
}
if( rwords[i].val != TINVALID ){
ret.id = rwords[i].val;
return ret;
} else {
ret.id = TSYMBOL;
ret.v.szval = strdup(m_szText);
return ret;
}
}
// STRING CONSTANT
else if(c == '\"'){
m_nTextLen = 0;
for( c = Input(); ; c=Input() ){
if(c == '\"'){
if((c=Input()) == '\"'){
Gather('\\');
Gather('\"');
} else {
break;
}
} else if(c == '\\'){
c=Input();
Gather(c);
if(c == '\n') ReadLine();
} else if(c == '\n'){
ret.id = TINVALID;
ReadLine();
return ret;
} else {
Gather(c);
}
}
Unput(c);
Gather('\0');
ret.id = TSTRING;
ret.v.szval = strdup(m_szText);
return ret;
} else if(c == '='){
ret.id = TEQUAL;
} else if(c == '!'){
ret.id = TSECTION;
} else if(c == '-'){
ret.id = TUNARY;
} else if(c == EOF){
ret.id = TEOF;
}
return ret;
}
int TXT_DrawTextEx( void *dest, int draw_mode2, int sx, int sy, int w, int h, int pixh_w, int pich_h, int *px2, int *py2, RECT *clip,
int font, char *str, int color, int text_cnt, int step_cnt, int r, int g, int b, int alph, int kage, int cnt_flag, char *normal_str, int kaigyou_musi )
{
int digit;
int px = sx, py = sy;
int cnt = 0;
int cnt2 = 0;
int kflag = 0;
int cno = color;
int fno = font&0xff, fno2 = font&0xff;
int tag_cnt = 0;
int tag_param[16];
int tag_back[16];
int draw_flag=0;
int accent_flag=0;
char rubi_str[64];
RGB32 rgb;
int rfno = 16;
int alph2=alph;
int wait=0;
int speed=10;
int step=0;
int end_flag=0;
int amari=0;
int kaig=0;
int px_bak=0;
int hankaku_err=0;
static int hankaku_err_flag=0;
if(font&0xff00 && hankaku_err_flag==0){
hankaku_err_flag=1;
hankaku_err=1;
}
font = font&0xff;
enum{
TAG_DIGIT,
TAG_COLOR,
TAG_FONT,
TAG_RUBI,
TAG_ACCENT,
TAG_SPEED,
TAG_WAIT,
};
TXT_GetMsgSpeed( -1 );
if(str==NULL){
return 0;
}
while( cnt2 < text_cnt || text_cnt==-1 || ( cnt2==text_cnt && !amari) ) {
amari = TXT_GetMsgSpeed(-2);
if(wait){
wait--;
cnt2++;
continue;
}
if(alph==-1){
if(text_cnt==-1){ alph2 = 256; }
else { alph2 = LIM(text_cnt-cnt2, 0, 16)*16; }
if(step<step_cnt){ alph2 = 256; }
}
switch( str[cnt] ){
case '\0':
if( tag_cnt ){
DebugBox( NULL, "�^�O���J�����܂܂ɂȂ��Ă��܂��B�K�����Ă�������" );
}
end_flag=1;
break;
case '\n':
if(!kaig){
px_bak=px;
px = sx;
py += fno2+pich_h;
fno2 = fno;
if(normal_str) { *normal_str = '\n'; normal_str++; }
}
kaig=0;
break;
case '^':
draw_flag = 1;
str[cnt] = ' ';
break;
case '~':
str[cnt] = ',';
draw_flag = 1;
break;
case '\\':
cnt++;
switch( str[cnt] ){
case 'n':
if(!kaig){
px_bak=px;
px = sx;
py += fno2+pich_h;
fno2 = fno;
if(normal_str) { *normal_str = '\n'; normal_str++; }
}
kaig=0;
break;
case 'k':
if(step>=step_cnt && step_cnt!=-1 ){
end_flag=1;
}
step++;
break;
case '^': case '~':
case '<': case '>':
case '|': case '\\':
draw_flag = 1;
break;
}
break;
case '<':
cnt++;
if( tag_cnt >= 15 ){
DebugBox( NULL, "�^�O���J���߂��ł��B�l�`�w �P�T" );
break;
}
switch( str[cnt] ){
case 'd': case 'D':
tag_param[tag_cnt] = TAG_DIGIT;
tag_back[tag_cnt] = 0;
tag_cnt++;
cnt++;
if( GetDigit( str, &cnt, &digit ) ){
}
break;
case 'c': case 'C':
tag_param[tag_cnt] = TAG_COLOR;
tag_back[tag_cnt] = cno;
tag_cnt++;
cnt++;
if( GetDigit( str, &cnt, &digit ) ){
cno = digit;
}
break;
case 'f': case 'F':
tag_param[tag_cnt] = TAG_FONT;
tag_back[tag_cnt] = fno;
tag_cnt++;
cnt++;
if( GetDigit( str, &cnt, &digit ) ){
fno = digit;
fno2 = max(fno,fno2);
}
break;
case 'r': case 'R':
tag_param[tag_cnt] = TAG_RUBI;
tag_back[tag_cnt] = px;
tag_cnt++;
break;
case 'a': case 'A':
tag_param[tag_cnt] = TAG_ACCENT;
tag_cnt++;
accent_flag = 1;
break;
case 's': case 'S':
tag_param[tag_cnt] = TAG_SPEED;
tag_back[tag_cnt] = speed;
tag_cnt++;
cnt++;
if( GetDigit( str, &cnt, &digit ) ){
switch(digit){
case 0: speed = 100;break;
case 1: speed = 80; break;
case 2: speed = 60; break;
case 3: speed = 40; break;
case 4: speed = 20; break;
case 5: speed = 10; break;
case 6: speed = 6; break;
case 7: speed = 4; break;
case 8: speed = 2; break;
case 9: speed = 1; break;
case 10:speed = 0; break;
}
}
break;
case 'w': case 'W':
tag_param[tag_cnt] = TAG_WAIT;
tag_back[tag_cnt] = 0;
tag_cnt++;
cnt++;
if( GetDigit( str, &cnt, &digit ) ){
wait = digit*2;
}
break;
}
break;
case '|':
cnt++;
switch(tag_param[tag_cnt-1]){
case TAG_RUBI:
{
int i=0,rx,pw=0;
while(str[cnt]!='>'){
rubi_str[i++] = str[cnt++];
}
rubi_str[i] = '\0';
rgb = BMP_ChangeBright_Full( FCT[cno], r, g, b );
rx = ((px-tag_back[tag_cnt-1]) - i*rfno/2)/2;
if(rx<=0){
pw=0;
}else{
if( (0x21 <= rubi_str[0] && rubi_str[0] <= 0x7e) || (0xa1 <= rubi_str[0] && rubi_str[0] <= 0xdf) ){
pw = rx*2/(i);
}else{
pw = rx*2/(i/2);
}
rx = pw/2;
}
rx = tag_back[tag_cnt-1]+rx;
if(!cnt_flag) FNT_DrawText( dest, draw_mode2, rx, py-rfno-1,pw,0, rubi_str, rfno, clip, rgb.r, rgb.g, rgb.b, alph2, (kage)?kage-1:0 );
}
cnt--;
break;
}
break;
case '>':
if( tag_cnt <= 0 ){
DebugBox( NULL, "���^�O( > )�̐����A�J��������葽���Ȃ��Ă��܂�" );
break;
}
tag_cnt--;
if(!TH2_Flag){
switch( tag_param[tag_cnt] ){
case TAG_DIGIT: break;
case TAG_COLOR: cno = tag_back[tag_cnt]; break;
case TAG_FONT:
fno = tag_back[tag_cnt];
if(px==sx){
fno2 = fno;
}else{
fno2 = max(fno,fno2);
}
break;
case TAG_RUBI: break;
case TAG_ACCENT: accent_flag = 0; break;
case TAG_SPEED: speed = tag_back[tag_cnt]; break;
case TAG_WAIT: break;
}
}
break;
default:
draw_flag = 1;
break;
}
if(draw_flag){
draw_flag = 0;
rgb = BMP_ChangeBright_Full( FCT[cno], r, g, b );
if( (0x00<=str[cnt] && str[cnt]<0x80) || (0xa0<=str[cnt] && str[cnt]<0xe0) ) {
if(normal_str) { *normal_str = str[cnt]; normal_str++; }
if(!cnt_flag) FNT_DrawChar( dest, draw_mode2, px, py, str[cnt], fno, clip, rgb.r, rgb.g, rgb.b, alph2, kage, 1 );
cnt2 += TXT_GetMsgSpeed( speed );
if(accent_flag){
if(!cnt_flag) FNT_DrawChar( dest, draw_mode2, px+(fno-rfno/2)/2, py-rfno+1, '�', rfno, clip, rgb.r, rgb.g, rgb.b, alph2, (kage)?kage-1:0, 1 );
}
px += fno/2+pixh_w;
kaig=0;
if(hankaku_err){
DebugBox( NULL, "ToHert2�ł͔��p������͎g�p�ł��܂���I" );
}
}else{
if(normal_str) { *(WORD*)normal_str = *(WORD*)&str[cnt]; normal_str+=2; }
if(!cnt_flag) FNT_DrawChar( dest, draw_mode2, px, py, *(WORD*)&str[cnt], fno, clip, rgb.r, rgb.g, rgb.b, alph2, kage, 0 );
cnt++;
cnt2 += TXT_GetMsgSpeed( speed );
if(accent_flag){
if(!cnt_flag) FNT_DrawChar( dest, draw_mode2, px+(fno-rfno/2)/2, py-rfno+1, '�', rfno, clip, rgb.r, rgb.g, rgb.b, alph2, (kage)?kage-1:0, 1 );
}
px += fno+pixh_w;
kaig=0;
}
}
if(end_flag)break;
cnt++;
if( px-sx >= w*font-fno+1 ){
if( tag_param[tag_cnt-1]!=TAG_RUBI ){
if( kflag==1 ){
if( strncmp( &str[ cnt ], "�@", 2 ) )
{
kflag = 0;
px_bak = px;
px = sx;
py += fno2+pich_h;
fno2 = fno;
kaig=1;
}
}else{
if(
strncmp( &str[ cnt ], "�B", 2 ) && strncmp( &str[ cnt ], "�A", 2 ) &&
strncmp( &str[ cnt ], "�C", 2 ) && strncmp( &str[ cnt ], "�D", 2 ) &&
strncmp( &str[ cnt ], "�E", 2 ) && strncmp( &str[ cnt ], "�c", 2 ) &&
strncmp( &str[ cnt ], "�[", 2 ) && strncmp( &str[ cnt ], "�[", 2 ) &&
strncmp( &str[ cnt ], "�F", 2 ) && strncmp( &str[ cnt ], "�G", 2 ) &&
strncmp( &str[ cnt ], "�H", 2 ) && strncmp( &str[ cnt ], "�I", 2 ) &&
strncmp( &str[ cnt ], "�n", 2 ) && strncmp( &str[ cnt ], "�h", 2 ) &&
strncmp( &str[ cnt ], "�@", 2 ) && strncmp( &str[ cnt ], "�j", 2 ) &&
strncmp( &str[ cnt ], "�v", 2 ) && strncmp( &str[ cnt ], "�x", 2 ) &&
strncmp( &str[ cnt ], "�D", 2 ) && strncmp( &str[ cnt ], "�C", 2 ) &&
strncmp( &str[ cnt ], "�B", 2 ) && strncmp( &str[ cnt ], "�A", 2 ) &&
strncmp( &str[ cnt ], "�F", 2 ) && strncmp( &str[ cnt ], "�F", 2 ) &&
strncmp( &str[ cnt ], "�G", 2 ) && strncmp( &str[ cnt ], "�E", 2 ) && strncmp( &str[ cnt ], "�@", 2 ) )
{
px_bak = px;
px = sx;
py += fno2+pich_h;
fno2 = fno;
kaig=1;
}else{
kflag=1;
}
}
}
}
if( py-sy >= h*(font+pich_h)-(fno+pich_h)+1 ){
static int err=0;
if( py-sy==h*(font+pich_h) && px==sx ){
}else{
if(err==0){
err=1;
}
break;
}
}
}
if(px2){
if(kaigyou_musi){
*px2=px;
if(py2) *py2 = py;
}else{
if(px==sx && py!=sy && (px_bak-sx <= w*font) ){
*px2=px_bak;
if(py2) *py2 = py- (fno2+pich_h);
}else{
*px2=px;
if(py2) *py2 = py;
}
}
}else{
if(py2) *py2 = py;
}
return (cnt_flag) ? cnt2 : (px==sx)? py-sy : py-sy+fno;
}
TRISTATE CTextParser::GetOctal(unsigned long long int* pulli, int* piNumDigits)
{
unsigned long long int iNum;
int iTemp;
TRISTATE tReturn;
int i;
PushPosition();
SkipWhiteSpace();
tReturn = GetExactCharacter('0', FALSE);
if (tReturn != TRITRUE)
{
PopPosition();
return tReturn;
}
*pulli = 0;
i = 0;
if (!mbOutsideText)
{
iNum = 0;
for (;;)
{
if (!mbOutsideText)
{
tReturn = GetDigit(&iTemp, 8);
if (tReturn == TRITRUE)
{
i++;
iNum *= 8;
iNum += iTemp;
}
else if ((tReturn == TRIFALSE) || (tReturn == TRIERROR))
{
*pulli = iNum;
if (piNumDigits)
{
*piNumDigits = i;
}
PassPosition();
return TRITRUE;
}
}
else
{
if (i > 0)
{
*pulli = iNum;
if (piNumDigits)
{
*piNumDigits = i;
}
PassPosition();
return TRITRUE;
}
PopPosition();
SetErrorSyntaxError();
return TRIERROR;
}
}
}
else
{
PopPosition();
SetErrorEndOfFile();
return TRIERROR;
}
}
TRISTATE CTextParser::GetHexadecimalPart(unsigned long long int* pulli, int* piNumDigits, int iMaxDigits)
{
unsigned long long int iNum;
int iTemp;
TRISTATE tReturn;
int i;
*pulli = 0;
if (!mbOutsideText)
{
iNum = 0;
i = 0;
for (;;)
{
if (!mbOutsideText)
{
tReturn = GetDigit(&iTemp, 16);
if (tReturn == TRITRUE)
{
i++;
iNum *= 16;
iNum += iTemp;
if (i == iMaxDigits)
{
*pulli = iNum;
if (piNumDigits)
{
*piNumDigits = i;
}
return TRITRUE;
}
}
else if ((tReturn == TRIFALSE) || (tReturn == TRIERROR))
{
*pulli = iNum;
if (piNumDigits)
{
*piNumDigits = i;
}
return TRITRUE;
}
}
else
{
if (i > 0)
{
*pulli = iNum;
if (piNumDigits)
{
*piNumDigits = i;
}
return TRITRUE;
}
SetErrorSyntaxError();
return TRIERROR;
}
}
}
else
{
SetErrorEndOfFile();
return TRIERROR;
}
}
TRISTATE CTextParser::GetDigits(unsigned long long int* pulli, int* piSign, int* piNumDigits, BOOL bSkipWhiteSpace, BOOL bTestSign)
{
unsigned long long int iNum;
int iSign;
int iTemp;
TRISTATE tReturn;
BOOL bFirstDigit;
int i;
//This still needs to be failed on the case where the number is larger than MAX_ULONG.
PushPosition();
if (bSkipWhiteSpace)
{
SkipWhiteSpace();
}
*pulli = 0;
i = 0;
if (!mbOutsideText)
{
iNum = 0;
if (bTestSign)
GetSign(&iSign);
else
iSign = 1;
bFirstDigit = TRUE;
for (;;)
{
if (!mbOutsideText)
{
tReturn = GetDigit(&iTemp);
if (tReturn == TRITRUE)
{
i++;
iNum *= 10;
iNum += iTemp;
}
else if ((tReturn == TRIFALSE) || (tReturn == TRIERROR))
{
break;
}
bFirstDigit = FALSE;
}
else
{
break;
}
}
if (bFirstDigit)
{
//might already have got a sign... so reset the parser.
PopPosition();
return TRIFALSE;
}
else
{
*piSign = iSign;
*pulli = iNum;
if (piNumDigits)
{
*piNumDigits = i;
}
PassPosition();
return TRITRUE;
}
}
else
{
PopPosition();
SetErrorEndOfFile();
return TRIERROR;
}
}
static void RxProc()
{
uint16_t t;
if (BufferSize <= 0 || SkipRx) {
SkipRx = 0;
Radio.Rx(RxTimeout);
return;
}
switch (Buffer[0]) {
case 'a': // from master
Mode = TRP_RESP;
SID = Buffer[1];
CurCount = 0;
EndCount = GetDigit(&Buffer[2]);
AccRssi = RssiValue;
AccSnr = SnrValue;
debug("TRP Req: %c %d (RSSI:%d, SNR:%d)\r\n",
SID, EndCount, RssiValue, SnrValue);
SendTRPResp();
break;
case 'b': // from slave
if (Mode == TRP_REQ) {
CurCount++;
if (memcmp(&Buffer[2],
&Buffer[2 + 3], 3) == 0) {
// finished
ReportTRP();
Mode = NO_ACT;
RxTimeout = 0;
break;
}
} else {
RxTimeout = RX_TRP_TIMEOUT;
}
Radio.Rx(RxTimeout);
break;
case 'c': // from master
if (Mode != TIS_RESP || SID != Buffer[1]) {
SID = Buffer[1];
CurCount = 0;
Mode = TIS_RESP;
AccRssi = 0;
AccSnr = 0;
}
CurCount++;
AccRssi += RssiValue;
AccSnr += SnrValue;
t = GetDigit(&Buffer[2]);
EndCount = GetDigit(&Buffer[2] + 3);
//debug("TIS Req: %d/%d (RSSI:%d, SNR:%d)\r\n", t, EndCount, RssiValue, SnrValue);
if (t + 1 == EndCount) {
SendTISResp();
} else {
RxTimeout = RX_TRP_TIMEOUT;
Radio.Rx(RxTimeout);
}
break;
case 'd': // from slave
if (Mode == TIS_REQ) {
CurCount = GetDigit(&Buffer[2]);
debug("TIS Result: %d, %d (RSSI:%d, SNR:%d)\r\n", CurCount, EndCount, RssiValue, SnrValue);
Mode = NO_ACT;
StartTIS(100);
break;
}
RxTimeout = 0;
Radio.Rx(RxTimeout);
break;
default:
Radio.Rx(RxTimeout);
break;
}
}
