static int32_t chunk_body(AsyncState* pState, int32_t n)
{
asyncReadFrom* pThis = (asyncReadFrom*)pState;
_parser p(pThis->m_strLine);
char ch;
int64_t sz = 0;
p.skipSpace();
if (!qisxdigit(p.get()))
return CHECK_ERROR(Runtime::setError("HttpMessage: bad chunk size."));
while (qisxdigit(ch = p.get())) {
sz = (sz << 4) + qhex(ch);
p.skip();
}
if (sz) {
if (pThis->m_pThis->m_maxBodySize >= 0
&& sz + pThis->m_contentLength > pThis->m_pThis->m_maxBodySize * 1024 * 1024)
return CHECK_ERROR(Runtime::setError("HttpMessage: body is too huge."));
pThis->set(chunk_body_end);
return pThis->m_stm->copyTo(pThis->m_body, sz,
pThis->m_copySize, pThis);
}
pThis->set(chunk_end);
return pThis->m_stm->readLine(HTTP_MAX_LINE, pThis->m_strLine,
pThis);
}
//--------------------------------------------------------------------------
int idaapi accept_file(linput_t *li, char fileformatname[MAX_FILE_FORMAT_NAME], int n)
{
char str[80];
if ( n) return(0 );
qlgets(str, sizeof(str), li);
const char *p = str;
while ( *p == ' ' ) p++;
int type = 0;
if ( qisxdigit((uchar)*(p+1)) && qisxdigit((uchar)*(p+2))) switch(*p ) {
case ':':
p = "Intel Hex Object Format";
type = f_HEX;
break;
case ';':
p = "MOS Technology Hex Object Format";
type = f_MEX;
break;
case 'S':
p = "Intel S-record Format";
type = f_SREC;
default:
break;
}
if ( type) qstrncpy(fileformatname, p, MAX_FILE_FORMAT_NAME );
return(type);
}
//-----------------------------------------------------------------------
// temporary solution for v4.7
static ea_t idaapi h8_extract_address(ea_t screen_ea, const char *string, int x)
{
size_t len = strlen(string);
if ( len == 0 || x > len ) return BADADDR;
if ( x == len ) x--;
const char *ptr = string + x;
while ( ptr > string && qisxdigit(ptr[-1]) ) ptr--;
const char *start = ptr;
while ( qisxdigit(ptr[0]) ) ptr++;
len = ptr - start;
char buf[MAXSTR];
memcpy(buf, start, len);
buf[len] = '\0';
ea_t ea = BADADDR;
str2ea(buf, &ea, screen_ea);
return ea;
}
result_t gd_base::color(const char *color, int32_t &retVal)
{
if (*color == '#')
color ++;
if (!qisxdigit(color[0]) || !qisxdigit(color[1]) || !qisxdigit(color[2]))
return CHECK_ERROR(CALL_E_INVALIDARG);
if (!color[3])
retVal = gdTrueColor(qhex(color[0]) * 17,
qhex(color[1]) * 17,
qhex(color[2]) * 17);
else
{
if (!qisxdigit(color[3]) || !qisxdigit(color[4]) || !qisxdigit(color[5])
|| color[6])
return CHECK_ERROR(CALL_E_INVALIDARG);
retVal = gdTrueColor((qhex(color[0]) << 4) | qhex(color[1]),
(qhex(color[2]) << 4) | qhex(color[3]),
(qhex(color[4]) << 4) | qhex(color[5]));
}
return 0;
}
void Url::parseHost(const char*& url, exlib::string& hostname, exlib::string& port)
{
const char* p1 = url;
const char* p2 = NULL;
char ch;
if (*p1 == '[') {
p1++;
while ((ch = *p1) && (qisxdigit(ch) || ch == ':' || ch == '.'))
p1++;
if (ch == ']')
ch = *++p1;
else
url++;
} else {
while ((ch = *p1)
&& (qisascii(ch) || qisdigit(ch) || ch == '.' || ch == '_' || ch == '-' || ch < 0))
p1++;
}
if (ch == ':') {
p2 = p1 + 1;
while ((ch = *p2) && qisdigit(ch))
p2++;
}
if (*url == '[')
hostname.assign(url + 1, p1 - url - 2);
else
hostname.assign(url, p1 - url);
if (hostname.length() > 0) {
qstrlwr(&hostname[0]);
punycode_base::toASCII(hostname, hostname);
}
if (p2)
port.assign(p1 + 1, p2 - p1 - 1);
else
port.clear();
url = p2 ? p2 : p1;
}
result_t ParseJsonString(v8::Local<v8::Value> &retVal)
{
wstring str;
Advance();
while (c0_ != '"') {
if (c0_ >= 0 && c0_ < 0x20)
return ReportUnexpectedCharacter();
if (c0_ != '\\') {
int32_t beg_pos = position_;
while (c0_ != '"' && c0_ != '\\')
{
Advance();
if (c0_ >= 0 && c0_ < 0x20)
return ReportUnexpectedCharacter();
}
str.append(utf8to16String(source_ + beg_pos, position_ - beg_pos));
} else {
Advance();
switch (c0_) {
case '"':
case '\\':
case '/':
str.append(1, c0_);
break;
case 'b':
str.append(1, '\x08');
break;
case 'f':
str.append(1, '\x0c');
break;
case 'n':
str.append(1, '\x0a');
break;
case 'r':
str.append(1, '\x0d');
break;
case 't':
str.append(1, '\x09');
break;
case 'u': {
uint16_t value = 0;
for (int32_t i = 0; i < 4; i++) {
Advance();
if (!qisxdigit(c0_))
return ReportUnexpectedCharacter();
value = value * 16 + qhex(c0_);
}
str.append(1, value);
break;
}
default:
return ReportUnexpectedCharacter();
}
Advance();
}
}
AdvanceSkipWhitespace();
retVal = v8::String::NewFromTwoByte(isolate->m_isolate,
(const uint16_t*)str.c_str(),
v8::String::kNormalString,
(int32_t) str.length());
return 0;
}
