static void AddIntAsVAL__4 (INTEGER num)
{
INTEGER n, nulls;
CHAR str[6];
__ASSERT(num >= 0 && num <= 99999, 1);
Strings_IntToStr(num, (void*)str, 6);
Add__2(0xb0);
Add__2('\"');
n = 0;
nulls = 0;
do {
if (str[__X(n, 6)] != '0') {
nulls = 0;
} else {
nulls += 1;
}
Add__2(str[__X(n, 6)]);
n += 1;
} while (!(str[__X(n, 6)] == 0x00));
if (nulls >= 3) {
*GenTapeLoader__1_s->loaderLen -= nulls;
Add__2('e');
Add__2((CHAR)(nulls + 48));
}
Add__2('\"');
}
void JsonExpressFormater::WriteExpression(stringx name, ref<JsonNode> node, ref<StringBuilder> sb, int level)
{
switch (node->GetType())
{
case JSN_String:
WriteValue(name, '\"' + node->TextValue() + '\"', sb, level);
break;
case JSN_Integer:
WriteValue(name, Converter::ToString(node->IntValue()), sb, level);
break;
case JSN_Boolean:
WriteValue(name, node->BoolValue() ? __X("true") : __X("false"), sb, level);
break;
case JSN_None:
WriteValue(name, __X("null"), sb, level);
break;
case JSN_Dictionary:
WriteSubDictionary(name, node, sb, level);
break;
case JSN_NodeList:
WriteSubList(name, node, sb, level);
break;
default:
cdec_throw(JsonException(EC_JSON_NotImplemented, 0));
}
}
static void ConsoleChar__2 (CHAR ch)
{
(*Cat__1_s->buf)[__X(*Cat__1_s->bufpos, 1024)] = ch;
*Cat__1_s->bufpos += 1;
if (*Cat__1_s->bufpos == 1023) {
(*Cat__1_s->buf)[__X(*Cat__1_s->bufpos, 1024)] = 0x00;
Console_String(*Cat__1_s->buf, 1024);
*Cat__1_s->bufpos = 0;
}
}
size_t CurlHeaderWriteCallback(void* buffer, size_t size, size_t nmemb, void* user_p)
{
ICurlResponseWriter* response = (ICurlResponseWriter*)user_p;
size_t cbop = size * nmemb;
stringx s = Encoding::get_UTF8()->GetString((BYTE*)buffer, cbop);
s = s.TrimRight();
if (s.StartsWith(__X("HTTP")))
{
// Console::WriteLine(__X("[HTTP State] ") + s);
response->SetHttpState(s);
}
else if (s.Length() != 0)
{
int pos = s.IndexOf(':');
ASSERT(pos > 0);
stringx key = s.Substring(0, pos).TrimRight();
stringx value = s.Substring(pos + 1).TrimLeft();
// Console::WriteLine(__X("[Header] Key=\"") + key + __X("\" Value=\"") + value + '\"');
response->AddHeader(key, value);
}
return cbop;
}
int main(int argc, char **argv)
{
__INIT(argc, argv);
__IMPORT(CmdLine__init);
__IMPORT(Console__init);
__IMPORT(Strings__init);
__REGMAIN("CmdLineTest", 0);
/* BEGIN */
CmdLineTest__for__2 = CmdLine_ParamCount;
CmdLineTest_n = 1;
while (CmdLineTest_n <= CmdLineTest__for__2) {
CmdLine_GetParam(CmdLineTest_n, (void*)CmdLineTest_param, 1024);
Console_WriteInt(CmdLineTest_n);
Console_WriteStr((CHAR*)":", 2);
Console_WriteStrLn(CmdLineTest_param, 1024);
CmdLineTest__for__1 = (SHORTINT)Strings_Length((void*)CmdLineTest_param, 1024) - 1;
CmdLineTest_i = 0;
while (CmdLineTest_i <= CmdLineTest__for__1) {
Console_WriteInt((SHORTINT)CmdLineTest_param[__X(CmdLineTest_i, 1024)]);
Console_WriteStr((CHAR*)",", 2);
CmdLineTest_i += 1;
}
Console_WriteLn();
CmdLineTest_n += 1;
}
__FINI;
}
static void Add__2 (SYSTEM_BYTE byte)
{
if ((LONGINT)*GenTapeLoader__1_s->loaderLen < GenTapeLoader__1_s->loader__len) {
GenTapeLoader__1_s->loader[__X(*GenTapeLoader__1_s->loaderLen, GenTapeLoader__1_s->loader__len)] = byte;
}
*GenTapeLoader__1_s->loaderLen += 1;
}
void ZXBasic_GenTapeLoader (INTEGER codeStartAddr, INTEGER *loaderLen, SYSTEM_BYTE *loader, LONGINT loader__len)
{
struct GenTapeLoader__1 _s;
_s.loaderLen = loaderLen;
_s.loader = (void*)loader; _s.loader__len = loader__len;
_s.lnk = GenTapeLoader__1_s;
GenTapeLoader__1_s = &_s;
__ASSERT(loader__len > 5, 1);
*loaderLen = 0;
if (codeStartAddr >= 23900 && codeStartAddr <= 65535) {
Add__2(0);
Add__2(10);
Add__2(0);
Add__2(0);
Add__2(0xfd);
AddIntAsVAL__4(codeStartAddr - 1);
Add__2(':');
Add__2(0xef);
Add__2('\"');
Add__2('\"');
Add__2(0xaf);
Add__2(':');
Add__2(0xf9);
Add__2(0xc0);
AddIntAsVAL__4(codeStartAddr);
Add__2(0x0d);
loader[__X(2, loader__len)] = (int)(*loaderLen - 4);
if ((LONGINT)*loaderLen > loader__len) {
*loaderLen = 0;
}
}
GenTapeLoader__1_s = _s.lnk;
}
void OCatCmd_Cat (void)
{
CHAR path[128];
INTEGER i;
Texts_Text T = NIL;
Texts_Reader R;
CHAR ch;
BOOLEAN tab;
CHAR buf[1024];
INTEGER bufpos;
struct Cat__1 _s;
_s.buf = (void*)buf;
_s.bufpos = &bufpos;
_s.lnk = Cat__1_s;
Cat__1_s = &_s;
path[0] = 0x00;
__NEW(T, Texts_TextDesc);
Args_Get(1, (void*)path, 128);
if (__STRCMP(path, "-t") == 0) {
tab = 1;
i = 2;
Args_Get(2, (void*)path, 128);
} else {
tab = 0;
i = 1;
}
while (path[0] != 0x00) {
if (Files_Old(path, 128) != NIL) {
Texts_Open(T, path, 128);
Texts_OpenReader(&R, Texts_Reader__typ, T, 0);
Texts_Read(&R, Texts_Reader__typ, &ch);
bufpos = 0;
while (!R.eot) {
if (ch >= ' ') {
ConsoleChar__2(ch);
} else if (ch == 0x09) {
if (tab) {
ConsoleChar__2(ch);
} else {
ConsoleChar__2(' ');
ConsoleChar__2(' ');
}
} else if (ch == 0x0d) {
ConsoleChar__2(0x0a);
}
Texts_Read(&R, Texts_Reader__typ, &ch);
}
buf[__X(bufpos, 1024)] = 0x00;
Console_String(buf, 1024);
} else {
Console_String((CHAR*)"OCat: cannot open ", 19);
Console_String(path, 128);
Console_Ln();
}
i += 1;
path[0] = 0x00;
Args_Get(i, (void*)path, 128);
}
Cat__1_s = _s.lnk;
}
void JsonExpressFormater::WriteSubDictionary(stringx name, ref<JsonNode> node, ref<StringBuilder> sb, int level)
{
WriteValue(name, __X("{"), sb, level);
WriteNewLine(sb);
ref<JsonNode::JsonNodeDictionary> dict = node->NodeDictionary();
int count = dict->Count();
foreach (ref<JsonNode>, subnode, dict)
{
ASSERT(subnode->GetName() != NULL);
WriteExpression(subnode->GetName(), subnode, sb, level + 1);
if (--count > 0)
sb->Append(',');
WriteNewLine(sb);
}
void JsonExpressFormater::WriteValue(stringx name, stringx value, ref<StringBuilder> sb, int level)
{
// Write indents
if (IndentChars != NULL)
for (int i = 0; i < level; ++i)
sb->Append(IndentChars);
// Write name
if (name != NULL)
{
sb->Append('\"');
sb->Append(name);
sb->Append(__X("\":"));
}
sb->Append(value);
}
void CurlEasy::SetProxy(stringx proxyHost, UINT proxyPort, CurlProxyType proxyType /* = CPT_SOCKS4 */)
{
stringx hostPort = proxyHost + __X(":") + Converter::ToString(proxyPort);
CURLcode code = curl_easy_setopt(
m_curl,
CURLOPT_PROXY,
Encoding::get_UTF8()->FromUnicode(hostPort).c_str()
);
VERIFY_CURL_CODE(code);
code = curl_easy_setopt(
m_curl,
CURLOPT_PROXYTYPE,
proxyType == CPT_SOCKS4 ? CURLPROXY_SOCKS4 : CURLPROXY_SOCKS5
);
VERIFY_CURL_CODE(code);
}
void testMapWin32Basic()
{
#ifdef X_OS_WINDOWS
stringx sampleFile = TestEnv::get_sample_path(__X("test_mapping.bin"));
File::Delete(sampleFile);
ref<FileStream> fs = gc_new<FileStream>(sampleFile, FileStream::AccessReadWrite, true);
const int n = 10000;
fs->SetLength(n * 4096);
for (int i = 0; i < n; ++i)
{
fs->Seek(i * 4096);
fs->Write(&i, 4);
}
ref<FileMappingWin32> map = gc_new<FileMappingWin32>(fs, true);
BYTE* pbase = (BYTE*)map->MapView(0, 0, true);
BYTE* p = pbase;
for (int i = 0; i < n; ++i)
{
UNITTEST_ASSERT(*(int*)p == i);
*(int*)p = -i;
p += 4096;
}
map->UnmapView(pbase);
map->Close();
int value;
for (int i = 0; i < n; ++i)
{
fs->Seek(i * 4096);
UNITTEST_ASSERT(fs->Read(&value, 4) == 4);
UNITTEST_ASSERT(value == -i);
}
fs->Close();
File::Delete(sampleFile);
#endif
}
CDEC_NS_BEGIN
// -------------------------------------------------------------------------- //
// DbConnectionManager
// -------------------------------------------------------------------------- //
void ConnectionManager::LoadXmlConfig(stringx path, ConnectionManager::Config& config)
{
ref<XmlDocument> doc = gc_new<XmlDocument>();
doc->Load(path);
ref<XmlElement> eDs = doc->get_DocumentElement();
if (eDs->get_NodeName() != __X("dbconfig"))
cdec_throw(Exception(EC_InvalidValue));
ref<XmlElement> eConfig = eDs->SelectSingleNode(__X("config"));
if (eConfig == NULL)
cdec_throw(Exception(EC_InvalidPtr));
config.Url = eConfig->get_Attribute(__X("dburl"))->get_Value();
config.Username = eConfig->get_Attribute(__X("uname"))->get_Value();
config.Password = eConfig->get_Attribute(__X("pwd"))->get_Value();
config.Database = eConfig->get_Attribute(__X("database"))->get_Value();
}
void setUp()
{
m_name = __X("TestLogWriter.log");
LogOutputFile::Init(m_name);
}
LONGINT SYSTEM_XCHK(LONGINT i, LONGINT ub) {return __X(i, ub);}
LONGINT SYSTEM_XCHK(LONGINT i, LONGINT ub, CHAR *mod, INTEGER pos) {return __X(i, ub, mod, pos);}
void testWriteWarn()
{
stringx message = __X("testWriteWarn");
YWARN << message;
testWriteHlp(LOG_WARNING, message, 4);
}
void testWriteClaim()
{
stringx message = __X("testWriteClaim");
YCLAIM << message;
testWriteHlp(LOG_CLAIM, message, 4);
}
void testWriteError()
{
stringx message = __X("testWriteError");
YERR << message;
testWriteHlp(LOG_ERROR, message, 4);
}
WriteValue(name, __X("{"), sb, level);
WriteNewLine(sb);
ref<JsonNode::JsonNodeDictionary> dict = node->NodeDictionary();
int count = dict->Count();
foreach (ref<JsonNode>, subnode, dict)
{
ASSERT(subnode->GetName() != NULL);
WriteExpression(subnode->GetName(), subnode, sb, level + 1);
if (--count > 0)
sb->Append(',');
WriteNewLine(sb);
}
ASSERT(count == 0);
WriteValue(NULL, __X("}"), sb, level);
}
void JsonExpressFormater::WriteSubList(stringx name, ref<JsonNode> node, ref<StringBuilder> sb, int level)
{
WriteValue(name, __X("["), sb, level);
WriteNewLine(sb);
ref<JsonNode::JsonNodeList> list = node->NodeList();
int count = list->Count();
foreach (ref<JsonNode>, subnode, list)
{
ASSERT(subnode->GetName() == NULL);
WriteExpression(NULL, subnode, sb, level + 1);
if (--count > 0)
sb->Append(',');
void testComposit()
{
ref<StringWriter> wr = gc_new<StringWriter>();
ref<XmlWriter> xmlw = gc_new<XmlWriter>(wr);
xmlw->BeginDocument(false, NULL);
xmlw->BeginElement(__X("library"));
xmlw->BeginElement(__X("book"));
xmlw->AddAttribute(__X("name"), __X("test"));
xmlw->AddAttribute(__X("alias"), __X(""));
xmlw->AddValue(__X("moon"));
xmlw->EndElement(__X("book"));
xmlw->BeginElement(__X("book"));
xmlw->EndElement(__X("book"));
xmlw->EndElement(__X("library"));
xmlw->EndDocument();
stringx xmltext = wr->GetStringBuilder()->ToString();
PCWSTR xmltext_t = __X("<library>\n <book name=\"test\" alias=\"\">moon</book>\n <book />\n</library>\n");
UNITTEST_ASSERT(xmltext == xmltext_t);
}
void testWriteInfo()
{
stringx message = __X("testWriteInfo");
YLOG << message;
testWriteHlp(LOG_INFORMATION, message, 4);
}
void CurlEasy::AddHeader(stringx key, stringx value)
{
stringx line = key + __X(": ") + value;
m_headers.push_back(Encoding::get_UTF8()->FromUnicode(line));
}
