N_NIMCALL(NimStringDesc*, ntgetClockStr)(void) {
NimStringDesc* result0;
Timeinfo_sGezGiKtnmyCJvsDB0xApg ti0;
time_t LOC1;
NimStringDesc* LOC2;
NimStringDesc* LOC3;
NimStringDesc* LOC4;
NimStringDesc* LOC5;
result0 = (NimStringDesc*)0;
memset((void*)(&ti0), 0, sizeof(ti0));
ti0.Sup.m_type = (&NTI_sGezGiKtnmyCJvsDB0xApg);
LOC1 = (time_t)0;
LOC1 = gettime_wqmoaGqnr3gMTpWruGQ3FA();
chckNil((void*)(&ti0));
memset((void*)(&ti0), 0, sizeof(ti0));
ti0.Sup.m_type = (&NTI_sGezGiKtnmyCJvsDB0xApg);
getlocaltime_Ql5lAb5s0QPmy9b8QhS3ucg(LOC1, (&ti0));
LOC2 = (NimStringDesc*)0;
LOC3 = (NimStringDesc*)0;
LOC3 = nsuIntToStr(((NI) (ti0.hour)), ((NI) 2));
LOC4 = (NimStringDesc*)0;
LOC4 = nsuIntToStr(((NI) (ti0.minute)), ((NI) 2));
LOC5 = (NimStringDesc*)0;
LOC5 = nsuIntToStr(((NI) (ti0.second)), ((NI) 2));
LOC2 = rawNewString(LOC3->Sup.len + LOC4->Sup.len + LOC5->Sup.len + 2);
appendString(LOC2, LOC3);
appendChar(LOC2, 58);
appendString(LOC2, LOC4);
appendChar(LOC2, 58);
appendString(LOC2, LOC5);
result0 = LOC2;
return result0;
}
N_NIMCALL(NimStringDesc*, ntgetClockStr)(void) {
NimStringDesc* result;
Timeinfo105404 ti;
time_t LOC1;
NimStringDesc* LOC2;
NimStringDesc* LOC3;
NimStringDesc* LOC4;
NimStringDesc* LOC5;
result = 0;
memset((void*)(&ti), 0, sizeof(ti));
ti.Sup.m_type = (&NTI105404);
LOC1 = 0;
LOC1 = gettime_105438();
chckNil((void*)(&ti));
memset((void*)(&ti), 0, sizeof(ti));
ti.Sup.m_type = (&NTI105404);
getlocaltime_105440(LOC1, (&ti));
LOC2 = 0;
LOC3 = 0;
LOC3 = nsuIntToStr(((NI) (ti.hour)), ((NI) 2));
LOC4 = 0;
LOC4 = nsuIntToStr(((NI) (ti.minute)), ((NI) 2));
LOC5 = 0;
LOC5 = nsuIntToStr(((NI) (ti.second)), ((NI) 2));
LOC2 = rawNewString(LOC3->Sup.len + LOC4->Sup.len + LOC5->Sup.len + 2);
appendString(LOC2, LOC3);
appendChar(LOC2, 58);
appendString(LOC2, LOC4);
appendChar(LOC2, 58);
appendString(LOC2, LOC5);
result = LOC2;
return result;
}
N_NIMCALL(NimStringDesc*, ntgetClockStr)(void) {
NimStringDesc* Result_30014;
TY28602 Ti_30015;
NI LOC1;
NimStringDesc* LOC2;
NimStringDesc* LOC3;
NimStringDesc* LOC4;
NimStringDesc* LOC5;
Result_30014 = 0;
memset((void*)&Ti_30015, 0, sizeof(Ti_30015));
LOC1 = Gettime_28616();
Ti_30015 = Getlocaltime_28618(LOC1);
Ti_30015.Sup.m_type = NTI28602;
LOC2 = 0;
LOC3 = 0;
LOC3 = nsuIntToStr(((NI) (Ti_30015.Hour)), 2);
LOC4 = 0;
LOC4 = nsuIntToStr(((NI) (Ti_30015.Minute)), 2);
LOC5 = 0;
LOC5 = nsuIntToStr(((NI) (Ti_30015.Second)), 2);
LOC2 = rawNewString(LOC3->Sup.len + LOC4->Sup.len + LOC5->Sup.len + 2);
appendString(LOC2, LOC3);
appendChar(LOC2, 58);
appendString(LOC2, LOC4);
appendChar(LOC2, 58);
appendString(LOC2, LOC5);
Result_30014 = LOC2;
return Result_30014;
}
N_NIMCALL(NimStringDesc*, ntgetDateStr)(void) {
NimStringDesc* Result_30003;
TY28602 Ti_30004;
NI LOC1;
NimStringDesc* LOC2;
NimStringDesc* LOC3;
NimStringDesc* LOC4;
NimStringDesc* LOC5;
Result_30003 = 0;
memset((void*)&Ti_30004, 0, sizeof(Ti_30004));
LOC1 = Gettime_28616();
Ti_30004 = Getlocaltime_28618(LOC1);
Ti_30004.Sup.m_type = NTI28602;
LOC2 = 0;
LOC3 = 0;
LOC3 = nimIntToStr(Ti_30004.Year);
LOC4 = 0;
LOC4 = nsuIntToStr((NI32)(Ti_30004.Month + 1), 2);
LOC5 = 0;
LOC5 = nsuIntToStr(((NI) (Ti_30004.Monthday)), 2);
LOC2 = rawNewString(LOC3->Sup.len + LOC4->Sup.len + LOC5->Sup.len + 2);
appendString(LOC2, LOC3);
appendChar(LOC2, 45);
appendString(LOC2, LOC4);
appendChar(LOC2, 45);
appendString(LOC2, LOC5);
Result_30003 = LOC2;
return Result_30003;
}
N_NIMCALL(NimStringDesc*, ntgetDateStr)(void) {
NimStringDesc* result;
Timeinfo102408 ti;
time_t LOC1;
NimStringDesc* LOC2;
NimStringDesc* LOC3;
NimStringDesc* LOC4;
NimStringDesc* LOC5;
result = 0;
memset((void*)(&ti), 0, sizeof(ti));
ti.Sup.m_type = (&NTI102408);
LOC1 = 0;
LOC1 = gettime_102452();
chckNil((void*)(&ti));
memset((void*)(&ti), 0, sizeof(ti));
ti.Sup.m_type = (&NTI102408);
getlocaltime_102457(LOC1, (&ti));
LOC2 = 0;
LOC3 = 0;
LOC3 = nimIntToStr(((NI) (ti.year)));
LOC4 = 0;
LOC4 = nsuIntToStr(((NI) ((NI)(((NI) (ti.month)) + ((NI) 1)))), ((NI) 2));
LOC5 = 0;
LOC5 = nsuIntToStr(((NI) (ti.monthday)), ((NI) 2));
LOC2 = rawNewString(LOC3->Sup.len + LOC4->Sup.len + LOC5->Sup.len + 2);
appendString(LOC2, LOC3);
appendChar(LOC2, 45);
appendString(LOC2, LOC4);
appendChar(LOC2, 45);
appendString(LOC2, LOC5);
result = LOC2;
return result;
}
N_NIMCALL(NimStringDesc*, Tocchar_155007)(NIM_CHAR C_155009) {
NimStringDesc* Result_155176;
NimStringDesc* LOC1;
NimStringDesc* LOC2;
NimStringDesc* LOC3;
Result_155176 = 0;
switch (((NU8)(C_155009))) {
case 0 ... 31:
case 128 ... 255:
LOC1 = 0;
LOC2 = 0;
LOC2 = nsuToOctal(C_155009);
LOC1 = rawNewString(LOC2->Sup.len + 1);
appendChar(LOC1, 92);
appendString(LOC1, LOC2);
Result_155176 = LOC1;
break;
case 39:
case 34:
case 92:
LOC3 = 0;
LOC3 = rawNewString(2);
appendChar(LOC3, 92);
appendChar(LOC3, C_155009);
Result_155176 = LOC3;
break;
default:
Result_155176 = nimCharToStr(C_155009);
break;
}
return Result_155176;
}
N_NIMCALL(NimStringDesc*, shortendir_114403)(NimStringDesc* dir) {
NimStringDesc* result;
NimStringDesc* prefix;
NimStringDesc* LOC1;
NimStringDesc* LOC2;
NimStringDesc* LOC8;
nimfr("shortenDir", "options.nim")
result = 0;
nimln(196, "options.nim");
nimln(196, "options.nim");
LOC1 = 0;
nimln(196, "options.nim");
LOC2 = 0;
LOC2 = getprefixdir_114311();
LOC1 = rawNewString(LOC2->Sup.len + 1);
appendString(LOC1, LOC2);
appendChar(LOC1, 47);
prefix = LOC1;
nimln(197, "options.nim");
{
NIM_BOOL LOC5;
nimln(197, "options.nim");
LOC5 = 0;
LOC5 = nsuStartsWith(dir, prefix);
if (!LOC5) goto LA6;
nimln(198, "options.nim");
nimln(198, "options.nim");
nimln(198, "options.nim");
nimln(198, "options.nim");
result = copyStr(dir, prefix->Sup.len);
goto BeforeRet;
} LA6: ;
nimln(199, "options.nim");
nimln(199, "options.nim");
LOC8 = 0;
LOC8 = rawNewString(gprojectpath_114198->Sup.len + 1);
appendString(LOC8, gprojectpath_114198);
appendChar(LOC8, 47);
prefix = LOC8;
nimln(200, "options.nim");
{
NIM_BOOL LOC11;
nimln(200, "options.nim");
LOC11 = 0;
LOC11 = nsuStartsWith(dir, prefix);
if (!LOC11) goto LA12;
nimln(201, "options.nim");
nimln(201, "options.nim");
nimln(201, "options.nim");
nimln(201, "options.nim");
result = copyStr(dir, prefix->Sup.len);
goto BeforeRet;
} LA12: ;
nimln(202, "options.nim");
result = copyString(dir);
BeforeRet: ; popFrame();
return result;
}
//---------------------------------------------------------------
void StreamWriter::appendValues ( unsigned int number, unsigned int number2 )
{
prepareToAddContents();
if ( mOpenTags.back().mHasText ) appendChar ( ' ' );
appendNumber ( number );
appendChar ( ' ' );
appendNumber ( number2 );
mOpenTags.back().mHasText = true;
}
N_NIMCALL(NimStringDesc*, Shortendir_41200)(NimStringDesc* Dir_41202) {
NimStringDesc* Result_41203;
NimStringDesc* Prefix_41204;
NimStringDesc* LOC1;
NimStringDesc* LOC2;
NIM_BOOL LOC4;
NimStringDesc* LOC7;
NimStringDesc* LOC8;
NIM_BOOL LOC10;
NimStringDesc* LOC13;
NIM_BOOL LOC15;
Result_41203 = 0;
Prefix_41204 = 0;
LOC1 = 0;
LOC2 = 0;
LOC2 = Getprefixdir_41109();
LOC1 = rawNewString(LOC2->Sup.len + 1);
appendString(LOC1, LOC2);
appendChar(LOC1, 92);
Prefix_41204 = LOC1;
LOC4 = nsuStartsWith(Dir_41202, Prefix_41204);
if (!LOC4) goto LA5;
Result_41203 = copyStr(Dir_41202, Prefix_41204->Sup.len);
goto BeforeRet;
LA5:
;
LOC7 = 0;
LOC8 = 0;
LOC8 = nosgetCurrentDir();
LOC7 = rawNewString(LOC8->Sup.len + 1);
appendString(LOC7, LOC8);
appendChar(LOC7, 92);
Prefix_41204 = LOC7;
LOC10 = nsuStartsWith(Dir_41202, Prefix_41204);
if (!LOC10) goto LA11;
Result_41203 = copyStr(Dir_41202, Prefix_41204->Sup.len);
goto BeforeRet;
LA11:
;
LOC13 = 0;
LOC13 = rawNewString(Projectpath_41113->Sup.len + 1);
appendString(LOC13, Projectpath_41113);
appendChar(LOC13, 92);
Prefix_41204 = LOC13;
LOC15 = nsuStartsWith(Dir_41202, Prefix_41204);
if (!LOC15) goto LA16;
Result_41203 = copyStr(Dir_41202, Prefix_41204->Sup.len);
goto BeforeRet;
LA16:
;
Result_41203 = copyString(Dir_41202);
BeforeRet:
;
return Result_41203;
}
//---------------------------------------------------------------
void StreamWriter::appendURIAttribute ( const String &name, const COLLADABU::URI &uri )
{
COLLADABU_ASSERT ( !mOpenTags.back().mHasContents );
appendChar ( ' ' );
appendNCNameString ( name );
appendChar ( '=' );
appendChar ( '\"' );
appendString ( COLLADABU::StringUtils::translateToXML(uri.getURIString()) );
appendChar ( '\"' );
}
//---------------------------------------------------------------
void StreamWriter::appendAttribute ( const String &name, const int val )
{
COLLADABU_ASSERT ( !mOpenTags.back().mHasContents );
appendChar ( ' ' );
appendNCNameString ( name );
appendChar ( '=' );
appendChar ( '\"' );
appendNumber ( val );
appendChar ( '\"' );
}
//---------------------------------------------------------------
void StreamWriter::appendValues ( long long number1, long long number2 )
{
prepareToAddContents();
if ( mOpenTags.back().mHasText )
appendChar ( ' ' );
appendNumber ( number1 );
appendChar ( ' ' );
appendNumber ( number2 );
mOpenTags.back().mHasText = true;
}
//---------------------------------------------------------------
void StreamWriter::appendValues ( const double values[], const size_t length )
{
prepareToAddContents();
if ( mOpenTags.back().mHasText ) appendChar ( ' ' );
for ( size_t i=0; i<length; ++i )
{
appendNumber ( values[i] );
appendChar ( ' ' );
}
mOpenTags.back().mHasText = true;
}
//---------------------------------------------------------------
void StreamWriter::appendAttribute ( const String &name, const String &value )
{
COLLADABU_ASSERT ( !mOpenTags.back().mHasContents );
if ( !value.empty() )
{
appendChar ( ' ' );
appendNCNameString ( name );
appendChar ( '=' );
appendChar ( '\"' );
appendString ( value );
appendChar ( '\"' );
}
}
//---------------------------------------------------------------
void StreamWriter::appendValues ( const float number1, const float number2, const float number3 )
{
prepareToAddContents();
if ( mOpenTags.back().mHasText )
appendChar ( ' ' );
appendNumber ( number1 );
appendChar ( ' ' );
appendNumber ( number2 );
appendChar ( ' ' );
appendNumber ( number3 );
mOpenTags.back().mHasText = true;
}
//---------------------------------------------------------------
void StreamWriter::appendValues ( const std::vector<unsigned long> &values )
{
prepareToAddContents();
if ( mOpenTags.back().mHasText ) appendChar ( ' ' );
std::vector<unsigned long>::const_iterator it = values.begin();
for ( ; it!=values.end(); ++it )
{
appendNumber ( *it );
appendChar ( ' ' );
}
mOpenTags.back().mHasText = true;
}
void ByteStringExtractor::outputString() {
if(m_strLength >= (int)m_minLength) {
appendChar('\0');
printString(m_buf);
}
m_strLength = 0;
}
N_NIMCALL(void, setstyle_190601_4182131368)(FILE* f0, Style190404Set style0) {
{
Style190404 s_190837_4182131368;
NI i_190851_4182131368;
s_190837_4182131368 = (Style190404)0;
i_190851_4182131368 = ((NI) 1);
{
while (1) {
if (!(i_190851_4182131368 <= ((NI) 8))) goto LA3;
{
NimStringDesc* LOC8;
NimStringDesc* LOC9;
if (!((style0 &(1U<<((NU)((((Style190404) (i_190851_4182131368))- 1))&7U)))!=0)) goto LA6;
s_190837_4182131368 = ((Style190404) (i_190851_4182131368));
LOC8 = (NimStringDesc*)0;
LOC9 = (NimStringDesc*)0;
LOC9 = nimIntToStr(((NI) (s_190837_4182131368)));
LOC8 = rawNewString(LOC9->Sup.len + 3);
appendString(LOC8, ((NimStringDesc*) &T4182131368_2));
appendString(LOC8, LOC9);
appendChar(LOC8, 109);
write_14891_1689653243(f0, LOC8);
}
LA6: ;
i_190851_4182131368 += ((NI) 1);
} LA3: ;
}
}
}
N_NIMCALL(NimStringDesc*, Togeneratedfile_41105)(NimStringDesc* Path_41107, NimStringDesc* Ext_41108) {
NimStringDesc* Result_41231;
TY33337 LOC1;
NimStringDesc* Head_41232;
NimStringDesc* Tail_41233;
NimStringDesc* LOC5;
TY42966 LOC6;
Result_41231 = 0;
memset((void*)&LOC1, 0, sizeof(LOC1));
nosSplitPath(Path_41107, &LOC1);
Head_41232 = 0;
Head_41232 = copyString(LOC1.Head);
Tail_41233 = 0;
Tail_41233 = copyString(LOC1.Tail);
if (!(0 < Head_41232->Sup.len)) goto LA3;
LOC5 = 0;
LOC5 = rawNewString(Head_41232->Sup.len + 1);
appendString(LOC5, Head_41232);
appendChar(LOC5, 92);
Head_41232 = Shortendir_41200(LOC5);
LA3:
;
memset((void*)&LOC6, 0, sizeof(LOC6));
LOC6[0] = copyString(Projectpath_41113);
LOC6[1] = copyString(((NimStringDesc*) &TMP191651));
LOC6[2] = copyString(Head_41232);
LOC6[3] = nosChangeFileExt(Tail_41233, Ext_41108);
Result_41231 = nosJoinPathOpenArray(LOC6, 4);
return Result_41231;
}
N_NIMCALL(NimStringDesc*, getvalue_112975)(tstringtable112610* t, NU8 flags, NimStringDesc* key) {
NimStringDesc* result;
nimfr("getValue", "strtabs.nim")
result = 0;
nimln(150, "strtabs.nim");
{
NIM_BOOL LOC3;
nimln(150, "strtabs.nim");
LOC3 = 0;
LOC3 = nsthasKey(t, key);
if (!LOC3) goto LA4;
nimln(150, "strtabs.nim");
nimln(150, "strtabs.nim");
result = nstGet(t, key);
goto BeforeRet;
} LA4: ;
nimln(152, "strtabs.nim");
{
nimln(730, "system.nim");
if (!((flags &(1<<((((NU8) 0))&7)))!=0)) goto LA8;
nimln(152, "strtabs.nim");
nimln(152, "strtabs.nim");
result = getenv_104625(key);
} goto LA6;
LA8: ;
{
nimln(153, "strtabs.nim");
result = copyString(((NimStringDesc*) &TMP284));
} LA6: ;
nimln(154, "strtabs.nim");
{
nimln(154, "strtabs.nim");
nimln(154, "strtabs.nim");
if (!(result->Sup.len == 0)) goto LA13;
nimln(155, "strtabs.nim");
{
NimStringDesc* LOC19;
nimln(730, "system.nim");
if (!((flags &(1<<((((NU8) 2))&7)))!=0)) goto LA17;
nimln(155, "strtabs.nim");
nimln(155, "strtabs.nim");
LOC19 = 0;
LOC19 = rawNewString(key->Sup.len + 1);
appendChar(LOC19, 36);
appendString(LOC19, key);
result = LOC19;
} goto LA15;
LA17: ;
{
nimln(156, "strtabs.nim");
nimln(730, "system.nim");
if (!!(((flags &(1<<((((NU8) 1))&7)))!=0))) goto LA21;
nimln(156, "strtabs.nim");
raiseformatexception_112955(key); } goto LA15;
LA21: ;
LA15: ;
} LA13: ;
BeforeRet: ; popFrame();
return result;
}N_NIMCALL(void, TMP298)(void* p, NI op) {
/**
* function splitByChar(SLIST *strList, struct String *src, char c, int start)
*
* Purpose: Helper function to split a string into a list of strings
* based on a char. Note: strings are added in alphabetical order to strList.
**/
int splitByChar(SLIST *strList, struct String *src, char c, int start)
{
int i = start;
int retval = -1;
struct String *newStr;
newStr = createStr(); //Allocate and initialize newStr
//Iterate through src->buf
while (i < src->strLen)
{
if (src->buf[i] == c)
{
//appendChar(newStr, 0);
retval = i + 1;
break;
}
else
{
appendChar(newStr, src->buf[i]);
i++;
}
}
//Empty String
if ((newStr->buf[0] == '\0'))
destroyStr(newStr);
else if(start == i)
destroyStr(newStr);
//non-empty string, add to list
else
addStr(strList, newStr);
return retval;
}
N_NIMCALL(void, Commandgendepend_191410)(NimStringDesc* Filename_191412) {
TY105006 LOC1;
TY105006 LOC2;
NimStringDesc* LOC3;
NimStringDesc* LOC4;
NimStringDesc* LOC5;
Semanticpasses_191408();
LOC1 = Gendependpass_187004();
Registerpass_105028(&LOC1);
LOC2 = Cleanuppass_186161();
Registerpass_105028(&LOC2);
Compileproject_191405(Filename_191412);
Generatedot_187006(Filename_191412);
LOC3 = 0;
LOC4 = 0;
LOC4 = nosChangeFileExt(Filename_191412, ((NimStringDesc*) &TMP197496));
LOC5 = 0;
LOC5 = nosChangeFileExt(Filename_191412, ((NimStringDesc*) &TMP197497));
LOC3 = rawNewString(LOC4->Sup.len + LOC5->Sup.len + 13);
appendString(LOC3, ((NimStringDesc*) &TMP197495));
appendString(LOC3, LOC4);
appendChar(LOC3, 32);
appendString(LOC3, LOC5);
Execexternalprogram_70570(LOC3);
}
N_NIMCALL(NimStringDesc*, normExt_3yxSdoh5oykvpUqYYeaz2g)(NimStringDesc* ext) {
NimStringDesc* result;
result = (NimStringDesc*)0;
{
NIM_BOOL T3_;
T3_ = (NIM_BOOL)0;
T3_ = ((ext) && (ext)->Sup.len == 0);
if (T3_) goto LA4_;
T3_ = ((NU8)(ext->data[((NI) 0)]) == (NU8)(46));
LA4_: ;
if (!T3_) goto LA5_;
result = copyString(ext);
}
goto LA1_;
LA5_: ;
{
NimStringDesc* T8_;
T8_ = (NimStringDesc*)0;
T8_ = rawNewString(ext->Sup.len + 1);
appendChar(T8_, 46);
appendString(T8_, ext);
result = T8_;
}
LA1_: ;
return result;
}
int localExtract(char *fInput, SLIST *wordList)
{
FILE *fp;
char c;
struct String *buffer = createStr();
//Attempt to open file
fp = fopen(fInput, "r");
if (fp == NULL)
{
printf("Unable to open file: %s\n", fInput);
return -1;
}
while((c = fgetc(fp)) != EOF)
appendChar(buffer, c);
fclose(fp);
//Truncate and clean string to be ready for parsing
truncateStr(buffer);
charSplit(wordList, buffer, ' ');
rmStopWords(wordList);
destroyStr(buffer); //free allocated memory
return 0;
}
void charSplit(SLIST *strList, struct String *src, char c)
{
int i = 0;
struct String *tempStr = createStr();
while (i <= src->strLen)
{
if ((src->buf[i]) == c && (tempStr->strLen != 0)) {
//add tempStr contents to strList, clear tempStr
//printf("tempStr contents: %s\n", tempStr->buf);
addLit(strList, tempStr->buf);
clearBufStr(tempStr);
i++;
}
else if ((src->buf[i]) == c && (tempStr->strLen == 0)) {
i++;
}
else {
appendChar(tempStr, src->buf[i]);
i++;
}
}
if (tempStr->strLen != 0)
{
addLit(strList, tempStr->buf);
}
destroyStr(tempStr);
}
N_NIMCALL(NimStringDesc*, normext_118526)(NimStringDesc* ext) {
NimStringDesc* result;
result = 0;
{
NIM_BOOL LOC3;
LOC3 = 0;
LOC3 = ((ext) && (ext)->Sup.len == 0);
if (LOC3) goto LA4;
LOC3 = ((NU8)(ext->data[((NI) 0)]) == (NU8)(46));
LA4: ;
if (!LOC3) goto LA5;
result = copyString(ext);
}
goto LA1;
LA5: ;
{
NimStringDesc* LOC8;
LOC8 = 0;
LOC8 = rawNewString(ext->Sup.len + 1);
appendChar(LOC8, 46);
appendString(LOC8, ext);
result = LOC8;
}
LA1: ;
return result;
}
N_NIMCALL(void, setstyle_179601)(FILE* f, NU8 style) {
{
NU8 s_179837;
NI i_179851;
s_179837 = 0;
i_179851 = ((NI) 1);
{
while (1) {
if (!(i_179851 <= ((NI) 8))) goto LA3;
{
NimStringDesc* LOC8;
NimStringDesc* LOC9;
if (!((style &(1U<<((NU)((((NU8) (i_179851))- 1))&7U)))!=0)) goto LA6;
s_179837 = ((NU8) (i_179851));
LOC8 = 0;
LOC9 = 0;
LOC9 = nimIntToStr(((NI) (s_179837)));
LOC8 = rawNewString(LOC9->Sup.len + 3);
appendString(LOC8, ((NimStringDesc*) &TMP433));
appendString(LOC8, LOC9);
appendChar(LOC8, 109);
write_15489(f, LOC8);
}
LA6: ;
i_179851 += ((NI) 1);
} LA3: ;
}
}
}
N_NIMCALL(NimStringDesc*, Completegeneratedfilepath_41101)(NimStringDesc* F_41103, NIM_BOOL Createsubdir_41104) {
NimStringDesc* Result_41248;
TY33337 LOC1;
NimStringDesc* Head_41249;
NimStringDesc* Tail_41250;
NimStringDesc* LOC5;
NimStringDesc* LOC6;
NimStringDesc* Subdir_41261;
TY69026 LOC7;
TSafePoint TMP191662;
NimStringDesc* LOC11;
Result_41248 = 0;
memset((void*)&LOC1, 0, sizeof(LOC1));
nosSplitPath(F_41103, &LOC1);
Head_41249 = 0;
Head_41249 = copyString(LOC1.Head);
Tail_41250 = 0;
Tail_41250 = copyString(LOC1.Tail);
if (!(0 < Head_41249->Sup.len)) goto LA3;
LOC5 = 0;
LOC5 = rawNewString(Head_41249->Sup.len + 1);
appendString(LOC5, Head_41249);
appendChar(LOC5, 92);
LOC6 = 0;
LOC6 = Shortendir_41200(LOC5);
Head_41249 = Removetrailingdirsep_41211(LOC6);
LA3:
;
Subdir_41261 = 0;
memset((void*)&LOC7, 0, sizeof(LOC7));
LOC7[0] = copyString(Projectpath_41113);
LOC7[1] = copyString(((NimStringDesc*) &TMP191651));
LOC7[2] = copyString(Head_41249);
Subdir_41261 = nosJoinPathOpenArray(LOC7, 3);
if (!Createsubdir_41104) goto LA9;
pushSafePoint(&TMP191662);
TMP191662.status = setjmp(TMP191662.context);
if (TMP191662.status == 0) {
noscreateDir(Subdir_41261);
popSafePoint();
} else {
popSafePoint();
if (getCurrentException()->Sup.m_type == NTI422) {
LOC11 = 0;
LOC11 = rawNewString(Subdir_41261->Sup.len + 25);
appendString(LOC11, ((NimStringDesc*) &TMP191663));
appendString(LOC11, Subdir_41261);
Writeln_41265(stdout, LOC11);
exit(1);
TMP191662.status = 0;
popCurrentException();
}
}
if (TMP191662.status != 0) reraiseException();
LA9:
;
Result_41248 = nosJoinPath(Subdir_41261, Tail_41250);
return Result_41248;
}
N_NIMCALL(void, encodestr_199031)(NimStringDesc* s, NimStringDesc** result) {
NI i_199048;
NI HEX3Atmp_199057;
NI TMP2101;
NI res_199059;
nimfr("encodeStr", "rodutils.nim")
i_199048 = 0;
HEX3Atmp_199057 = 0;
nimln(29, "rodutils.nim");
nimln(29, "rodutils.nim");
nimln(29, "rodutils.nim");
TMP2101 = subInt(s->Sup.len, 1);
HEX3Atmp_199057 = (NI32)(TMP2101);
nimln(1451, "system.nim");
res_199059 = 0;
nimln(1452, "system.nim");
while (1) {
nimln(1452, "system.nim");
if (!(res_199059 <= HEX3Atmp_199057)) goto LA1;
nimln(1451, "system.nim");
i_199048 = res_199059;
nimln(30, "rodutils.nim");
if ((NU)(i_199048) > (NU)(s->Sup.len)) raiseIndexError();
switch (((NU8)(s->data[i_199048]))) {
case 97 ... 122:
case 65 ... 90:
case 48 ... 57:
case 95:
{
nimln(31, "rodutils.nim");
if ((NU)(i_199048) > (NU)(s->Sup.len)) raiseIndexError();
(*result) = addChar((*result), s->data[i_199048]);
}
break;
default:
{
NimStringDesc* LOC4;
NimStringDesc* LOC5;
nimln(32, "rodutils.nim");
nimln(32, "rodutils.nim");
LOC4 = 0;
nimln(32, "rodutils.nim");
nimln(32, "rodutils.nim");
if ((NU)(i_199048) > (NU)(s->Sup.len)) raiseIndexError();
LOC5 = 0;
LOC5 = nsuToHex(((NI64) (((NU8)(s->data[i_199048])))), 2);
LOC4 = rawNewString(LOC5->Sup.len + 1);
appendChar(LOC4, 92);
appendString(LOC4, LOC5);
(*result) = resizeString((*result), LOC4->Sup.len + 0);
appendString((*result), LOC4);
}
break;
}
nimln(1454, "system.nim");
res_199059 = addInt(res_199059, 1);
} LA1: ;
popFrame();
}
//---------------------------------------------------------------
void StreamWriter::appendValues( const Color& val )
{
prepareToAddContents();
if ( mOpenTags.back().mHasText )
appendChar ( ' ' );
appendNumber ( val.getRed() );
appendChar ( ' ' );
appendNumber ( val.getGreen() );
appendChar ( ' ' );
appendNumber ( val.getBlue() );
appendChar ( ' ' );
appendNumber ( val.getAlpha() );
mOpenTags.back().mHasText = true;
}
