// don't count ezquake color sequence
int strlen_color(const char *str)
{
int len = 0;
if ( !str )
return 0;
while ( str[0] )
{
if (str[0] == '&')
{
if (str[1] == 'c' && HexToInt(str[2]) >= 0 && HexToInt(str[3]) >= 0 && HexToInt(str[4]) >= 0)
{
str += 5; // skip "&cRGB"
continue;
}
else if (str[1] == 'r')
{
str += 2; // skip "&r"
continue;
}
}
len++;
str++;
}
return len;
}
COLORREF SVGPaintParser::ScanHexColor()
{
const uni_char *color_string = tokenizer.CurrentString();
unsigned c = tokenizer.CurrentCharacter();
unsigned n = 0;
while (c >= 'a' && c <= 'f' ||
c >= 'A' && c <= 'F' ||
c >= '0' && c <= '9')
{
c = tokenizer.Shift(n);
}
if (n != 3 && n != 6)
return USE_DEFAULT_COLOR;
n /= 3; // Length per component
unsigned r = HexToInt(color_string, n);
unsigned g = HexToInt(color_string + n, n);
unsigned b = HexToInt(color_string + 2 * n, n);
if (n == 1)
r *= 0x11, g *= 0x11, b *= 0x11;
return OP_RGB(r, g, b);
}
// skip ezquake color sequence
void Util_SkipEZColors(char *dst, const char *src, size_t size)
{
if ( !dst || !src )
Sys_Error("Util_SkipColors: invalid input params");
if ( !size )
return; // no space
while ( src[0] && size )
{
if ( src[0] == '&' )
{
if ( src[1] == 'c' && HexToInt(src[2]) >= 0 && HexToInt(src[3]) >= 0 && HexToInt(src[4]) >= 0 )
{
src += 5; // skip "&cRGB"
continue;
}
else if ( src[1] == 'r' )
{
src += 2; // skip "&r"
continue;
}
}
*dst++ = *src++;
size--;
}
if ( !size )
dst--; // seems we truncate string, step back for null terminator
dst[0] = 0;
}
ECode UriCodec::Decode(
/* [in] */ const String& s,
/* [in] */ Boolean convertPlus,
/* [in] */ ICharset* charset,
/* [in] */ Boolean throwOnFailure,
/* [out] */ String* decodedString)
{
VALIDATE_NOT_NULL(decodedString);
if (s.IndexOf('%') == -1 && (!convertPlus || s.IndexOf('+') == -1)) {
*decodedString = s;
return NOERROR;
}
StringBuilder result(s.GetByteLength());
AutoPtr<IByteArrayOutputStream> out;
CByteArrayOutputStream::New((IByteArrayOutputStream**)&out);
IOutputStream* os = IOutputStream::Probe(out);
AutoPtr<ArrayOf<Char32> > char32Array = s.GetChars();
for (Int32 i = 0; i < s.GetLength();) {
Char32 c = (*char32Array)[i];
if (c == '%') {
do {
Int32 d1, d2;
if (i + 2 < s.GetLength()
&& (d1 = HexToInt((*char32Array)[i + 1])) != -1
&& (d2 = HexToInt((*char32Array)[i + 2])) != -1) {
os->Write((Byte) ((d1 << 4) + d2));
}
else if (throwOnFailure) {
return E_ILLEGAL_ARGUMENT_EXCEPTION;
}
else {
// TODO: unicode escape
const char* chars = "\ufffd";
AutoPtr<ArrayOf<Byte> > replacement = GetBytes(chars, charset);
os->Write(replacement, 0, replacement->GetLength());
}
i += 3;
} while (i < s.GetLength() && (*char32Array)[i] == '%');
AutoPtr<ArrayOf<Byte> > bytes;
out->ToByteArray((ArrayOf<Byte>**)&bytes);
//result.append(new String(out.toByteArray(), charset);
result.Append(String((char*)bytes->GetPayload()));
out->Reset();
}
else {
if (convertPlus && c == '+') {
c = ' ';
}
result.AppendChar(c);
i++;
}
}
*decodedString = result.ToString();
return NOERROR;
}
void HexToBinary(stream::IStream& stream, const WString& hexText)
{
const wchar_t* buffer = hexText.Buffer();
vint count = hexText.Length() / 2;
for (vint i = 0; i < count; i++)
{
vuint8_t byte = (vuint8_t)(HexToInt(buffer[0]) * 16 + HexToInt(buffer[1]));
buffer += 2;
stream.Write(&byte, 1);
}
}
// Intel-HEXファイルを読み込んでバッファに格納
bool LoadIntelHEX(const wchar_t *filepath, char *buf, char *used, unsigned int size, unsigned int start_address){
FILE *fp;
// ファイルを開く
_wfopen_s(&fp, filepath, L"r,ccs=UNICODE");
if (fp == NULL) return false;
// バッファを0xFFで初期化
memset(buf, 0xFF, size);
if (used != nullptr)
memset(used, 0, size);
// Intel-Hexをデコード
bool err = false;
unsigned int ext_address = 0;
for(int cnt = 0; cnt < 10000; cnt++){
wchar_t line[128];
wchar_t *ptr;
ptr = fgetws(line, 128, fp);
if (ptr == nullptr){err = true; break;}
if (*ptr++ != ':'){err = true; break;}
unsigned int length, offset, type;
length = HexToInt(ptr, &ptr, 2);
offset = HexToInt(ptr, &ptr, 4);
type = HexToInt(ptr, &ptr, 2);
if (type == 0){
// データ
unsigned int address = ext_address + offset - start_address;
for(unsigned int cnt = 0; cnt < length; cnt++){
if (address < 0) continue;
if (size <= address) break;//{err = true; break;}
buf[address] = HexToInt(ptr, &ptr, 2);
if (used != nullptr)
used[address] = 1;
address++;
}
//if (err == true)
// break;
}else if (type == 1){
// エンド
break;
}else if (type == 4){
// 拡張リニアアドレス
ext_address = HexToInt(ptr, &ptr, 4) << 16;
}
}
fclose(fp);
return !err;
}
bool JumpropesCommon::HttpClient::isEndOfChunkedData() {
if ( iChunkScanLastSize == 0 ) {
return true;
}
StringVectorRange searchRange;
// nog geen chunklength string gevonden
if ( iChunkScanLastSize == -1 ) {
bWaitForChunk = true;
searchRange.start_ind = lastChunkRange.end_ind;
searchRange.start_pos = lastChunkRange.end_pos;
connection->bufferlock.lockWhenAvailable( GFLOCK_INFINITEWAIT );
bool bPos = connection->receivedData.pos( &searchRange, crlf, strlen(crlf) );
if ( bPos ) {
bWaitForChunk = false;
StringVectorRange tmpRange;
tmpRange.start_ind = lastChunkRange.end_ind;
tmpRange.start_pos = lastChunkRange.end_pos;
tmpRange.end_ind = searchRange.start_ind;
tmpRange.end_pos = searchRange.start_pos;
connection->receivedData.endMinusOne( &tmpRange );
lastChunkRange.end_ind = searchRange.end_ind;
lastChunkRange.end_pos = searchRange.end_pos + 1;
String *tmp = connection->receivedData.copy( &tmpRange );
tmp->ltrim_ansi();
tmp->uppercase_ansi();
iChunkScanLastSize = HexToInt( tmp );
delete tmp;
}
connection->bufferlock.unlock();
}
if ( iChunkScanLastSize == 0 ) {
return true;
}
if ( !bWaitForChunk ) {
// do stuff
connection->bufferlock.lockWhenAvailable( GFLOCK_INFINITEWAIT );
if ( ( connection->receivedData.getLength( lastChunkRange.end_ind ) - lastChunkRange.end_pos ) >= iChunkScanLastSize ) {
String *tmpData = connection->receivedData.copy( lastChunkRange.end_ind, lastChunkRange.end_pos, iChunkScanLastSize );
onContent.execute( tmpData );
delete tmpData;
lastChunkRange.end_pos += iChunkScanLastSize + strlen(crlf);
iChunkScanLastSize = -1;
}
connection->bufferlock.unlock();
}
return false;
}
/**
* extracts the debug addr's from the output of backtrace_symbols()
*/
static uintptr_t ExtractAddr(const StackFrame& frame)
{
// frame.symbol examples:
//
// ./spring() [0x84b7b5]
// /usr/lib/libc.so.6(abort+0x16a) [0x7fc022c69e6a]
// /usr/lib/libstdc++.so.6(+0x5eea1) [0x7fc023551ea1]
uintptr_t addr = INVALID_ADDR_INDICATOR;
const std::string& line = frame.symbol;
size_t begin = line.find_last_of('[');
size_t end = std::string::npos;
if (begin != std::string::npos) {
end = line.find_last_of(']');
}
if ((begin != std::string::npos) && (end != std::string::npos)) {
addr = HexToInt(line.substr(begin+1, end-begin-1).c_str());
}
begin = line.find_last_of('(');
end = line.find_last_of(')');
if (end - begin != 1) {
Dl_info info;
if (dladdr(frame.ip, &info) != 0) {
addr = (uintptr_t)frame.ip - (uintptr_t)info.dli_fbase;
}
}
return addr;
}
int main(){
int i;
char HexArray[]="C0B0A0FF";
HexToInt(HexArray,8);
HexToBinary(HexArray,8);
return 0;
}
bool CheckIdent(userrec* user)
{
int ip[4];
char* ident;
char newip[16];
int len = strlen(user->ident);
if(len == 8)
ident = user->ident;
else if(len == 9 && *user->ident == '~')
ident = user->ident+1;
else
return false;
for(int i = 0; i < 4; i++)
if(!HexToInt(ip[i], ident + i*2))
return false;
snprintf(newip, 16, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
user->Extend("cgiirc_realhost", new std::string(user->host));
user->Extend("cgiirc_realip", new std::string(user->GetIPString()));
user->RemoveCloneCounts();
#ifdef IPV6
if (user->GetProtocolFamily() == AF_INET6)
inet_pton(AF_INET6, newip, &((sockaddr_in6*)user->ip)->sin6_addr);
else
#endif
inet_aton(newip, &((sockaddr_in*)user->ip)->sin_addr);
ServerInstance->AddLocalClone(user);
ServerInstance->AddGlobalClone(user);
user->CheckClass();
try
{
strlcpy(user->host, newip, 16);
strlcpy(user->dhost, newip, 16);
strlcpy(user->ident, "~cgiirc", 8);
bool cached;
CGIResolver* r = new CGIResolver(this, ServerInstance, NotifyOpers, newip, false, user, user->GetFd(), "IDENT", cached);
ServerInstance->AddResolver(r, cached);
}
catch (...)
{
strlcpy(user->host, newip, 16);
strlcpy(user->dhost, newip, 16);
strlcpy(user->ident, "~cgiirc", 8);
user->InvalidateCache();
if(NotifyOpers)
ServerInstance->WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), but i could not resolve their hostname!", user->nick, user->host);
}
/*strlcpy(user->host, newip, 16);
strlcpy(user->dhost, newip, 16);
strlcpy(user->ident, "~cgiirc", 8);*/
return true;
}
int Bettysoft::Crypt::Crypt::readPadding(const char *path){
std::ifstream ifOpenReadVersion(path,std::ios::binary);
ifOpenReadVersion.seekg(8,std::ios::beg);
char chPadding[3];
ifOpenReadVersion.getline(chPadding,3);
ifOpenReadVersion.seekg(0,std::ios::beg);
ifOpenReadVersion.close();
return HexToInt(chPadding[0],chPadding[1]);
};
LPVOID CCommonUtils::HexToBinary(BSTR bstrHex, ULONG* pulSize)
{
LPBYTE lpRet = NULL;
UINT len = ::SysStringLen(bstrHex);
UINT pos = 0;
if(len & 1)
{
// Invalid length, must be a multiple of 2 characters
throw _com_error(E_INVALIDARG);
}
lpRet = static_cast<LPBYTE>(LocalAlloc(LPTR, len / 2));
if(lpRet == NULL)
{
throw _com_error(E_FAIL);
}
for(pos = 0; pos < len; pos += 2)
{
int unib = HexToInt(bstrHex[pos]);
int lnib = HexToInt(bstrHex[pos+1]);
if((unib < 0) || (lnib < 0))
{
break;
}
lpRet[pos/2] = static_cast<BYTE>((unib << 4) | (lnib));
}
if(pos == len)
{
*pulSize = len / 2;
}
else
{
(void)LocalFree(lpRet);
lpRet = NULL;
throw _com_error(E_INVALIDARG);
}
return lpRet;
}
static void
DecodeStringToBinary(
byte *p,
size_t size,
char *str)
{
#ifdef BINARY_IS_BASE64
DecodeBase64(p,size,str,strlen(str));
#else
int i;
for ( i = 0 ; i < size ; i ++ , p ++ ) {
if ( *str == '\\' ) {
str ++;
switch (*str) {
case 'b':
*p = '\b';
str ++;
break;
case 'f':
*p = '\f';
str ++;
break;
case 'n':
*p = '\n';
str ++;
break;
case 'r':
*p = '\r';
str ++;
break;
case 't':
*p = '\t';
str ++;
break;
case 'u':
str ++;
*p = (unsigned char)HexToInt(str,2);
str += 2;
break;
default:
*p = *str;
str ++;
break;
}
} else {
*p = *str;
str ++;
}
}
#endif
}
ECode UriCodec::Validate(
/* [in] */ const String& uri,
/* [in] */ Int32 start,
/* [in] */ Int32 end,
/* [in] */ const String& name,
/* [out] */ String* result)
{
VALIDATE_NOT_NULL(result);
*result = NULL;
AutoPtr<ArrayOf<Char32> > char32Array = uri.GetChars();
for(Int32 i = start; i < end;) {
Char32 ch = (*char32Array)[i];
if ((ch >= 'a' && ch <= 'z')
|| (ch >= 'A' && ch <= 'Z')
|| (ch >= '0' && ch <= '9')
|| IsRetained(ch)){
++i;
}
else if (ch == '%'){
if(i + 2 >= end){
return E_URI_SYNTAX_EXCEPTION;
}
Int32 d1 = HexToInt((*char32Array)[i+1]);
Int32 d2 = HexToInt((*char32Array)[i+2]);
if (d1 == -1 || d2 == -1) {
return E_URI_SYNTAX_EXCEPTION;
}
i += 3;
}
else{
return E_URI_SYNTAX_EXCEPTION;
}
}
*result = uri.Substring(start, end);
return NOERROR;
}
/**
* extracts the debug addr's from the output of backtrace_symbols()
*/
static uintptr_t ExtractAddr(const std::string& line)
{
// example address: "0x89a8206"
uintptr_t addr = INVALID_ADDR_INDICATOR;
size_t begin = line.find_last_of('[');
size_t end = std::string::npos;
if (begin != std::string::npos) {
end = line.find_last_of(']');
}
if ((begin != std::string::npos) && (end != std::string::npos)) {
addr = HexToInt(line.substr(begin+1, end-begin-1).c_str());
}
return addr;
}
uint32_t ParseFlags(std::string string)
{
if(CheckHex(string))
{
return HexToInt(string);
}
else
{
uint32_t flags = 0;
std::vector<std::string> v = Explode(string, "|");
for(std::vector<std::string>::iterator it = v.begin(); it != v.end(); ++it)
{
std::string par = ToLower(Trim((*it)));
if(!par.length()) continue;
uint32_t flag = 0;
bool erase = false;
if(par[0] == '-')
{
erase = true;
par.erase(0, 1);
}
if(par == "pvm")
flag = SVF_PVM;
else if(par == "muted")
flag = SVF_MUTED;
else if(par == "closed")
flag = SVF_CLOSED;
else if(par == "advanced_pvm")
flag = SVF_ADVPVM;
else if(par == "nohealing")
flag = SVF_NOHEALING;
else if(par == "noobsrv")
flag = SVF_NOOBSRV;
else if(par == "softcore")
flag = SVF_SOFTCORE;
else if(par == "nodrop")
flag = SVF_NODROP;
else if(par == "fnodrop")
flag = SVF_FNODROP;
if(!flag) continue;
if(!erase) flags |= flag;
else flags &= ~flag;
}
return flags;
}
}
bool DoFlashLock(CMD_TBL *cptr, int argc, char **argv)
{
long i, addr, len, cnt;
// error.
if (argc < 2){
printf(cptr->usage);
return false;
}
switch (argc){
// "lock [addr]".
case 2 :
if (!StrCmp(argv[1], "loader")){
addr = (long)LOADER_SRAM_BASE;
len = (long)LOADER_SRAM_MAX_SIZE;
}
else if (!StrCmp(argv[1], "kernel")){
addr = (long)KERNEL_SRAM_BASE;
len = (long)KERNEL_MAX_SIZE;
}
else if (!StrCmp(argv[1], "root")){
addr = (long)ROOT_SRAM_BASE;
len = (long)ROOT_MAX_SIZE;
}
else {
if (!HexToInt(argv[1], &addr, 32)){
printf(cptr->usage);
return false;
}
len = (long)FLASH_BLOCK_SIZE;
}
break;
// "lock [addr] [len]".
default :
printf(cptr->usage);
return false;
break;
}
// lock of flash blocks.
cnt = len/FLASH_BLOCK_SIZE + ((len&(FLASH_BLOCK_SIZE-1)) ? 1 : 0);
for (i=0; i<cnt; i++, addr+=FLASH_BLOCK_SIZE){
if (!FlashLock((FUNIT *)addr)) return false;
}
return true;
} // DoFlashLock.
const Number IntegerLiteralParser::ParseHexadecimal()
{
// Assert( NeedChar() == 'x' )
IntegerBuilder integerBuilder;
Advance();
if (AtEnd() || NotInClass(CharClass::HEXADECIMAL))
{
ThrowError("Hexadecimal digit expected");
}
try
{
do
{
integerBuilder.OnHexadecimalDigit(HexToInt(GetChar()));
Advance();
if (AtEnd())
{
return integerBuilder.Release();
}
}
while (InClass(CharClass::HEXADECIMAL));
}
catch (const IntegerBuilder::OverflowError &)
{
ThrowError("Hexadecimal number is too big");
}
if (InClass(CharClass::LETTER))
{
ThrowError("Hexadecimal digit expected");
}
return integerBuilder.Release();
}
void ReplaceHexFormWithOrdinals( TString& astring )
{
int sl = astring.Length();
for( int i=1; i<=sl; i++ )
{
if( astring[i]=='\\' )
if( i<sl )
if( astring[i+1]=='\\' )
{
astring.Delete( i, 1 );
sl--;
}
else
{
if( astring[i+1]!='x' || i+3>sl )
throw TException( "String '"+astring+"' not in CSV format." );
char c = HexToInt( astring.c_str() + (i+1), 2 );
astring[i] = c;
astring.Delete( i+1, 3 );
sl -= 3;
}
}
}
bool BaseIndex::IsIndexValueValid(char* hexValue)
{
ULONG value;
bool retFlag = true;
if (0 == strcmp(hexValue, ""))
{
return true;
}
if (CheckIfHex(hexValue))
{
char* subStr = new char[strlen(hexValue)];
SubString(subStr, (const char*) hexValue, 2, (strlen(hexValue) - 2));
value = HexToInt(subStr);
delete[] subStr;
}
else
{
return true;
}
if (NULL != this->lowLimit)
{
if (0 != strcmp(this->lowLimit, ""))
{
ULONG lowlimitValue;
if (CheckIfHex((char*) this->lowLimit))
{
char* subStr = new char[strlen(lowLimit)];
SubString(subStr, lowLimit, 2, strlen(lowLimit) - 2);
lowlimitValue = HexToInt(subStr);
delete[] subStr;
}
else
{
lowlimitValue = atoi(lowLimit);
}
if (value >= lowlimitValue)
{
retFlag = true;
}
else
{
ocfmException objException;
objException._ocfmRetCode.code =
OCFM_ERR_VALUE_NOT_WITHIN_RANGE;
objException._ocfmRetCode.errorString = new char[150];
objException._ocfmRetCode.errorString[0] = 0;
sprintf(objException._ocfmRetCode.errorString,
"The entered value(%s) is less than the lower limit(%s)",
hexValue, this->lowLimit);
throw objException;
//bFlag = false;
//return bFlag;
}
}
}
if (NULL != this->highLimit)
{
if (0 != strcmp(this->highLimit, ""))
{
ULONG ulHighLimit;
if (CheckIfHex((char*) this->highLimit))
{
char* subStr = new char[strlen(highLimit)];
SubString(subStr, highLimit, 2, (strlen(highLimit) - 2));
ulHighLimit = HexToInt(subStr);
delete[] subStr;
}
else
{
ulHighLimit = atoi(highLimit);
}
if (value <= ulHighLimit)
{
retFlag = true;
}
else
{
ocfmException objException;
objException._ocfmRetCode.code =
OCFM_ERR_VALUE_NOT_WITHIN_RANGE;
objException._ocfmRetCode.errorString = new char[150];
objException._ocfmRetCode.errorString[0] = 0;
sprintf(objException._ocfmRetCode.errorString,
"The entered value(%s) is greater than the upper limit(%s)",
hexValue, this->highLimit);
throw objException;
//bFlag = false;
}
}
}
return retFlag;
}
bool DoEraseFlashBlocks(CMD_TBL *cptr, int argc, char **argv)
{
ulong addr=0, len, end;
switch (argc){
case 2 :
if (!StrCmp(argv[1], "kernel")){
addr = (long)KERNEL_SRAM_BASE;
len = (long)KERNEL_MAX_SIZE;
}
else if (!StrCmp(argv[1], "root")){
addr = (long)ROOT_SRAM_BASE;
len = (long)ROOT_MAX_SIZE;
}
else if (!StrCmp(argv[1], "loader")){
addr = (long)LOADER_SRAM_BASE;
len = (long)LOADER_MAX_SIZE;
}
else {
printf(cptr->usage);
return false;
}
if ((long)addr%FLASH_BLOCK_SIZE){
printf("addr is not flash block base.\n");
return false;
}
// erase flash blocks.
printf("Erase flash blocks from 0x%08lx to 0x%08lx.\n", addr, (long)addr+len-1);
if (!EraseFlashBlocks((FUNIT *)addr, len)) return false;
printf("\tDone.\n");
break;
// "erase [addr] [len]".
case 3 :
// error.
if (!HexToInt(argv[2], &len, 32)){
printf(cptr->usage);
return false;
}
if ((long)addr%FLASH_BLOCK_SIZE){
printf("addr is not flash block base.\n");
return false;
}
// erase flash blocks.
end = addr + len;
for (; addr<end; addr+=FLASH_BLOCK_SIZE){
if (!EraseOneFlashBlock((FUNIT *)addr)) return false;
}
break;
// error.
default :
printf(cptr->usage);
return false;
break;
}
return true;
} // DoEraseOneFlashBlock.
bool DoWriteToFlashBlocks(CMD_TBL *cptr, int argc, char **argv)
{
long dest=0, src=0, len, wsize;
switch (argc){
case 2 :
if (!StrCmp(argv[1], "kernel")){
dest = (long)KERNEL_SRAM_BASE;
src = (long)KERNEL_DRAM_BASE;
len = (long)KERNEL_MAX_SIZE;
printf("Saving kernel to flash...\n");
}
else if (!StrCmp(argv[1], "root")){
dest = (long)ROOT_SRAM_BASE;
src = (long)ROOT_DRAM_BASE;
len = (long)ROOT_MAX_SIZE;
printf("Saving root to flash...\n");
}
else if (!StrCmp(argv[1], "loader")){
dest = (long)LOADER_SRAM_BASE;
src = (long)LOADER_DRAM_BASE;
len = (long)LOADER_MAX_SIZE;
printf("Saving bootloader to flash...\n");
}
else {
printf(cptr->usage);
return false;
}
break;
// "flash [dest] [src] [len]".
case 4 :
if (!HexToInt(argv[1], &dest, 32) || !HexToInt(argv[2], &src, 32) ||
!HexToInt(argv[3], &len, 32)){
printf(cptr->usage);
return false;
}
if (dest % FLASH_BLOCK_SIZE){
printf("dest is not Flash Block Base.\n");
return false;
}
break;
default :
printf(cptr->usage);
return false;
break;
}
// erase flash blocks.
printf("Erase flash blocks from 0x%08lx to 0x%08lx.\n", dest, (long)dest+len-1);
if (!EraseFlashBlocks((FUNIT *)dest, len)) return false;
printf("\tDone.\n");
// write to flash.
printf("Write to flash...\n");
wsize = FLASH_BLOCK_SIZE;
do{
printf("\tWriting at 0x%08lx...", (ulong)dest);
if (!WriteToFlashBuffer((FUNIT *)dest, (FUNIT *)src)) break;
dest += FLASH_BLOCK_SIZE;
src += FLASH_BLOCK_SIZE;
ClearLine();
} while((len -= FLASH_BLOCK_SIZE) >0);
printf("\tWriting at 0x%08lx\r\n", (ulong)dest);
printf("\tDone\n");
IT(dest) = FlashCMD(READ_ARRAY);
return true;
} // DoWriteToFlashBlocks.
//---------------------------------------------------------------------------
char HexToChar(const UnicodeString & Hex, uintptr_t MinChars)
{
return static_cast<char>(HexToInt(Hex, MinChars));
}
bool CTextReader::Open(const char* filename, Resolution res)
{
_res = res;
// Open the file
FILE* file=fopen(filename,"rt");
if (file==NULL)
{
fprintf(stderr, "Could not open '%s' - %s (%i)\n", filename, strerror(errno), errno);
return false;
}
// Parse the file
parseState state = psReady;
int ch;
int pos=-1;
bool ReadNextChar = true;
int data;
char buf[512];
int bufPos=0;
while ( !ReadNextChar || ((ch=fgetc(file)) >= 0) )
{
ReadNextChar = true;
pos++;
switch (state)
{
case psReady:
switch (ch)
{
case '[':
state = psComment;
bufPos=0;
break;
case '/':
state = psSlash;
break;
case '0':
state = psLeadingZero;
break;
case '1':
QueueBit(1);
break;
case 'S':
case 'L':
case '?':
case '<':
case '>':
QueueCycleKind(ch);
break;
case ' ':
case '\t':
case '\n':
case '\r':
break;
default:
fprintf(stderr, "Error parsing input text file, unexpected character '%c' at %i\n", (char)ch, pos);
fclose(file);
return false;
}
break;
case psComment:
if (ch==']')
{
state = psReady;
// Data format comment?
if (strncmp(buf, "format:", 7)==0)
{
strcpy(_dataFormat, buf+7);
}
}
else
{
if (bufPos+1 < sizeof(buf))
{
buf[bufPos++]=ch;
buf[bufPos]='\0';
}
}
break;
case psSlash:
if (ch=='/')
state = psComment;
else
{
fprintf(stderr, "Error parsing input text file, unexpected character '%c' at %i\n", (char)ch, pos);
fclose(file);
return false;
}
break;
case psLineComment:
if (ch=='\r' || ch=='\n')
{
state = psReady;
}
break;
case psLeadingZero:
if (ch=='x')
{
state = psHexHi;
}
else
{
QueueBit(0);
state = psReady;
ReadNextChar = false;
}
break;
case psHexHi:
case psHexLo:
int nib = HexToInt(ch);
if (nib<0)
{
fprintf(stderr, "Error parsing input text file, syntax error in hex byte unexpected '%c' at %i\n", (char)ch, pos);
fclose(file);
return false;
}
if (state==psHexHi)
{
data = nib << 4;
state = psHexLo;
}
else
{
data |= nib;
QueueByte(data);
state = psReady;
}
break;
}
}
fclose(file);
if (state != psReady)
{
fprintf(stderr, "Error parsing input text file, unexpected EOF\n");
return false;
}
// All good
return true;
}
static int
ParseID( UBYTE* string,
LONG* manufacturer,
WORD* product,
BYTE* revision,
LONG* serial )
{
int chars = 0;
*manufacturer = ISAPNP_MAKE_ID( ToUpper( string[ 0 ] ),
ToUpper( string[ 1 ] ),
ToUpper( string[ 2 ] ) );
*product = ( HexToInt( string[ 3 ] ) << 8 ) |
( HexToInt( string[ 4 ] ) << 4 ) |
( HexToInt( string[ 5 ] ) );
if( *product == -1 )
{
return 0;
}
*revision = HexToInt( string[ 6 ] );
if( *revision == -1 )
{
return 0;
}
chars = 7;
if( serial != NULL )
{
if( string[ 7 ] == '/' )
{
int conv = StrToLong( string + 8, serial );
if( conv == -1 )
{
return 0;
}
else
{
chars += conv;
}
}
else if( string[ 7 ] == 0 || string[ 7 ] != ' ' )
{
*serial = -1;
}
else
{
return 0;
}
}
else
{
if( string[ 7 ] != 0 && string[ 7 ] != ' ' )
{
return 0;
}
}
return chars;
}
