bool Tokenizer::SkipToOneOfChars(const wxChar* chars, bool supportNesting)
{
// skip everything until we find any one of chars
while (1)
{
while (NotEOF() && !CharInString(CurrentChar(), chars))
{
if (CurrentChar() == '"' || CurrentChar() == '\'')
{
// this is the case that match is inside a string!
wxChar ch = CurrentChar();
MoveToNextChar();
SkipToChar(ch);
}
MoveToNextChar();
// make sure we skip comments
if (CurrentChar() == '/')
SkipComment(); // this will decide if it is a comment
// use 'while' here to cater for consecutive blocks to skip (e.g. sometemplate<foo>(bar)
// must skip <foo> and immediately after (bar))
// because if we don't, the next block won't be skipped ((bar) in the example) leading to weird
// parsing results
bool done = false;
while (supportNesting && !done)
{
switch (CurrentChar())
{
case '{': SkipBlock('{'); break;
case '(': SkipBlock('('); break;
case '[': SkipBlock('['); break;
case '<': // don't skip if << operator
if (NextChar() == '<')
MoveToNextChar(2); // skip it and also the next '<' or the next '<' leads to a SkipBlock('<');
else
SkipBlock('<');
break;
default: done = true; break;
}
}
}
if (PreviousChar() != '\\')
break;
else
{
// check for "\\"
if (m_TokenIndex - 2 >= 0 && m_Buffer.GetChar(m_TokenIndex - 2) == '\\')
break;
}
MoveToNextChar();
}
if (IsEOF())
return false;
return true;
}
static int SkipEnd(struct stream *s, const rar_block_t *hdr)
{
if (!(hdr->flags & RAR_BLOCK_END_HAS_NEXT))
return -1;
if (SkipBlock(s, hdr))
return -1;
/* Now, we need to look for a marker block,
* It seems that there is garbage at EOF */
for (;;) {
bstr peek = stream_peek(s, rar_marker_size);
if (peek.len < rar_marker_size)
return -1;
if (!memcmp(peek.start, rar_marker, rar_marker_size))
break;
if (!stream_skip(s, 1))
return -1;
}
/* Skip marker and archive blocks */
if (IgnoreBlock(s, RAR_BLOCK_MARKER))
return -1;
if (IgnoreBlock(s, RAR_BLOCK_ARCHIVE))
return -1;
return 0;
}
static int SkipEnd(stream_t *s, const rar_block_t *hdr)
{
if (!(hdr->flags & RAR_BLOCK_END_HAS_NEXT))
return VLC_EGENERIC;
if (SkipBlock(s, hdr))
return VLC_EGENERIC;
/* Now, we need to look for a marker block,
* It seems that there is garbage at EOF */
for (;;) {
const uint8_t *peek;
if (stream_Peek(s, &peek, rar_marker_size) < rar_marker_size)
return VLC_EGENERIC;
if (!memcmp(peek, rar_marker, rar_marker_size))
break;
if (stream_Read(s, NULL, 1) != 1)
return VLC_EGENERIC;
}
/* Skip marker and archive blocks */
if (IgnoreBlock(s, RAR_BLOCK_MARKER))
return VLC_EGENERIC;
if (IgnoreBlock(s, RAR_BLOCK_ARCHIVE))
return VLC_EGENERIC;
return VLC_SUCCESS;
}
cFrame* cAseLoader::Load( char* szFullPath )
{
fopen_s(&m_fp, szFullPath, "r");
while(char* szToken = GetToken())
{
if(IsEqual(szToken, ID_SCENE))
{
SkipBlock();
}
else if(IsEqual(szToken, ID_MATERIAL_LIST))
{
ProcessMATERIAL_LIST();
}
else if(IsEqual(szToken, ID_GEOMETRY))
{
cFrame* pFrame = ProcessGEOMOBJECT();
m_mapFrame[pFrame->GetFrameName()] = pFrame;
if(m_pRoot == NULL)
m_pRoot = pFrame;
}
}
fclose(m_fp);
if(m_pRoot)
m_pRoot->SetOriginLocalTM(NULL);
return m_pRoot;
}
static int IgnoreBlock(struct stream *s, int block)
{
/* */
rar_block_t bk;
if (PeekBlock(s, &bk) || bk.type != block)
return -1;
return SkipBlock(s, &bk);
}
static int IgnoreBlock(stream_t *s, int block)
{
/* */
rar_block_t bk;
if (PeekBlock(s, &bk) || bk.type != block)
return VLC_EGENERIC;
return SkipBlock(s, &bk);
}
bool Tokenizer::SkipUnwanted()
{
while (SkipWhiteSpace() || SkipComment())
;
wxChar c = CurrentChar();
const unsigned int startIndex = m_TokenIndex;
if (c == _T('#'))
{
const PreprocessorType type = GetPreprocessorType();
if (type != ptOthers)
{
HandleConditionPreprocessor(type);
c = CurrentChar();
}
}
// skip [XXX][YYY]
if (m_State & tsSkipSubScrip)
{
while (c == _T('[') )
{
SkipBlock('[');
SkipWhiteSpace();
if (IsEOF())
return false;
c = CurrentChar();
}
}
// skip the following = or ?
if (m_State & tsSkipEqual)
{
if (c == _T('='))
{
if (!SkipToOneOfChars(_T(",;}"), true, true, false))
return false;
}
}
else if (m_State & tsSkipQuestion)
{
if (c == _T('?'))
{
if (!SkipToOneOfChars(_T(";}"), false, true))
return false;
}
}
// skip the following white space and comments
while (SkipWhiteSpace() || SkipComment())
;
if (startIndex != m_TokenIndex && CurrentChar() == _T('#'))
return SkipUnwanted();
return NotEOF();
}
// expect we are not in a C-string.
bool Tokenizer::SkipToOneOfChars(const wxChar* chars, bool supportNesting, bool skipPreprocessor, bool skipAngleBrace)
{
while (NotEOF() && !CharInString(CurrentChar(), chars))
{
MoveToNextChar();
while (SkipString() || SkipComment())
;
// use 'while' here to cater for consecutive blocks to skip (e.g. sometemplate<foo>(bar)
// must skip <foo> and immediately after (bar))
// because if we don't, the next block won't be skipped ((bar) in the example) leading to weird
// parsing results
bool done = false;
while (supportNesting && !done)
{
switch (CurrentChar())
{
case '#':
if (skipPreprocessor)
SkipToEOL(true);
else
done = true;
break;
case '{': SkipBlock('{'); break;
case '(': SkipBlock('('); break;
case '[': SkipBlock('['); break;
case '<': // don't skip if << operator
if (skipAngleBrace)
{
if (NextChar() == '<')
MoveToNextChar(2); // skip it and also the next '<' or the next '<' leads to a SkipBlock('<');
else
SkipBlock('<');
break;
}
default: done = true; break;
}
}
}
return NotEOF();
}
void SkipBlock2()
{
cha=cha2;
inptr=inptr2;
SkipBlock();
cha2=cha;
inptr=inptr2;
linenum2=linenumber;
FindStopTok();
}
cFrame* cAseLoader::ProcessGEOMOBJECT()
{
cFrame* pFrame = new cFrame;
int nLevel = 0;
do
{
char* szToken = GetToken();
if(IsEqual(szToken, "{"))
{
++nLevel;
}
else if(IsEqual(szToken, "}"))
{
--nLevel;
}
else if(IsEqual(szToken, ID_NODE_NAME))
{
pFrame->SetFrameName(GetToken());
}
else if(IsEqual(szToken, ID_NODE_PARENT))
{
std::string sParentName(GetToken());
m_mapFrame[sParentName]->AddChild(pFrame);
}
else if(IsEqual(szToken, ID_NODE_TM))
{
ProcessNODE_TM(pFrame);
}
else if(IsEqual(szToken, ID_MESH))
{
ProcessMESH(pFrame);
}
else if(IsEqual(szToken, ID_TM_ANIMATION))
{
SkipBlock();
}
else if(IsEqual(szToken, ID_MATERIAL_REF))
{
pFrame->SetMtlTex(m_vecMtlTex[GetInteger()]);
}
} while (nLevel > 0);
return pFrame;
}
AseFrame* AseLoader::Load( char* filename )
{
char fullPath[1024];
strcpy_s(fullPath, ASE_DIRECTORY);
strcat_s(fullPath, filename);
fopen_s(&filePointer, fullPath, "r");
if ( filePointer )
{
while ( true )
{
char* aseToken = GetToken();
if ( aseToken == nullptr )
break;
if ( IsEqual(aseToken, ID_SCENE) )
{
SkipBlock();
}
else if ( IsEqual(aseToken, ID_MATERIAL_LIST) )
{
Process_MATERIAL_LIST();
}
else if ( IsEqual(aseToken, ID_GEOMETRY) )
{
AseFrame* frame = new AseFrame;
if ( rootFrame == nullptr )
rootFrame = frame;
Process_GEOMOBJECT(frame);
}
}
fclose(filePointer);
}
for ( auto iter = materialTextures.begin(); iter != materialTextures.end(); ++iter )
{
SAFE_RELEASE(*iter);
}
rootFrame->CalcOrigLocalTransform(nullptr);
return rootFrame;
}
static void ReadMacro(CParser& p)
{
IdeMacro macro;
if(p.IsString()) {
macro.menu = p.ReadString();
if(p.Char(':'))
macro.submenu = p.ReadString();
}
if(!p.IsChar('{'))
macro.hotkey = ParseKeyDesc(p);
EscLambda& l = macro.code.CreateLambda();
const char *t = p.GetPtr();
l.filename = p.GetFileName();
l.line = p.GetLine();
if(!p.Char('{'))
p.ThrowError("missing '{'");
SkipBlock(p);
l.code = String(t, p.GetPtr());
Array<IdeMacro>& mlist = UscMacros();
if(macro.hotkey) {
int f = FindFieldIndex(mlist, &IdeMacro::hotkey, macro.hotkey);
if(f >= 0) {
PutConsole(NFormat("%s(%d): duplicate macro hotkey %s\n", l.filename, l.line, GetKeyDesc(macro.hotkey)));
const EscLambda& lambda = UscMacros()[f].code.GetLambda();
PutConsole(NFormat("%s(%d): previously defined here\n", lambda.filename, lambda.line));
}
}
if(!IsNull(macro.menu)) {
for(int i = 0; i < mlist.GetCount(); i++)
if(mlist[i].menu == macro.menu && mlist[i].submenu == macro.submenu) {
PutConsole(NFormat("%s(%d): duplicate macro menu item (%s:%s)\n",
l.filename, l.line, macro.menu, macro.submenu));
const EscLambda& lambda = UscMacros()[i].code.GetLambda();
PutConsole(NFormat("%s(%d): previously defined here\n", lambda.filename, lambda.line));
break;
}
}
mlist.Add(macro);
}
int RarParse(stream_t *s, int *count, rar_file_t ***file)
{
*count = 0;
*file = NULL;
/* Skip marker */
if (IgnoreBlock(s, RAR_BLOCK_MARKER))
return VLC_EGENERIC;
/* Skip archive */
if (IgnoreBlock(s, RAR_BLOCK_ARCHIVE))
return VLC_EGENERIC;
/* */
for (;;) {
rar_block_t bk;
int ret;
if (PeekBlock(s, &bk))
break;
switch(bk.type) {
case RAR_BLOCK_END:
ret = SkipEnd(s, &bk);
break;
case RAR_BLOCK_FILE:
ret = SkipFile(s, count, file, &bk);
break;
default:
ret = SkipBlock(s, &bk);
break;
}
if (ret)
break;
}
return VLC_SUCCESS;
}
static bool SkipBlock(const char*& s, const char *end)
{
CrashIf(s >= end || *s != '{');
s++;
while (s < end && *s != '}') {
if (*s == '"' || *s == '\'') {
if (!SkipQuotedString(s, end))
return false;
}
else if (*s == '{') {
if (!SkipBlock(s, end))
return false;
}
else if (*s == '\\' && s < end - 1)
s += 2;
else if (!SkipWsAndComments(s, end))
s++;
}
if (s == end)
return false;
s++;
return true;
}
int RarParse(stream_t *s, int *count, rar_file_t ***file)
{
*count = 0;
*file = NULL;
const rar_pattern_t *pattern = FindVolumePattern(s->psz_path);
int volume_offset = 0;
char *volume_mrl;
if (asprintf(&volume_mrl, "%s://%s",
s->psz_access, s->psz_path) < 0)
return VLC_EGENERIC;
stream_t *vol = s;
for (;;) {
/* Skip marker & archive */
if (IgnoreBlock(vol, RAR_BLOCK_MARKER) ||
IgnoreBlock(vol, RAR_BLOCK_ARCHIVE)) {
if (vol != s)
stream_Delete(vol);
free(volume_mrl);
return VLC_EGENERIC;
}
/* */
bool has_next = false;
for (;;) {
rar_block_t bk;
int ret;
if (PeekBlock(vol, &bk))
break;
switch(bk.type) {
case RAR_BLOCK_END:
ret = SkipEnd(vol, &bk);
has_next = ret && (bk.flags & RAR_BLOCK_END_HAS_NEXT);
break;
case RAR_BLOCK_FILE:
ret = SkipFile(vol, count, file, &bk, volume_mrl);
break;
default:
ret = SkipBlock(vol, &bk);
break;
}
if (ret)
break;
}
if (vol != s)
stream_Delete(vol);
if (!has_next || !pattern ||
(*count > 0 && !(*file)[*count -1]->is_complete)) {
free(volume_mrl);
return VLC_SUCCESS;
}
/* Open next volume */
const int volume_index = pattern->start + volume_offset++;
if (volume_index > pattern->stop) {
free(volume_mrl);
return VLC_SUCCESS;
}
char *volume_base;
if (asprintf(&volume_base, "%s://%.*s",
s->psz_access,
(int)(strlen(s->psz_path) - strlen(pattern->match)), s->psz_path) < 0) {
free(volume_mrl);
return VLC_SUCCESS;
}
free(volume_mrl);
if (asprintf(&volume_mrl, pattern->format, volume_base, volume_index) < 0)
volume_mrl = NULL;
free(volume_base);
if (!volume_mrl)
return VLC_SUCCESS;
vol = stream_UrlNew(s, volume_mrl);
if (!vol) {
free(volume_mrl);
return VLC_SUCCESS;
}
}
}
static int SkipFile(stream_t *s, int *count, rar_file_t ***file,
const rar_block_t *hdr, const char *volume_mrl)
{
const uint8_t *peek;
int min_size = 7+21;
if (hdr->flags & RAR_BLOCK_FILE_HAS_HIGH)
min_size += 8;
if (hdr->size < (unsigned)min_size)
return VLC_EGENERIC;
if (stream_Peek(s, &peek, min_size) < min_size)
return VLC_EGENERIC;
/* */
uint32_t file_size_low = GetDWLE(&peek[7+4]);
uint8_t method = peek[7+18];
uint16_t name_size = GetWLE(&peek[7+19]);
uint32_t file_size_high = 0;
if (hdr->flags & RAR_BLOCK_FILE_HAS_HIGH)
file_size_high = GetDWLE(&peek[7+25]);
const uint64_t file_size = ((uint64_t)file_size_high << 32) | file_size_low;
char *name = calloc(1, name_size + 1);
if (!name)
return VLC_EGENERIC;
const int name_offset = (hdr->flags & RAR_BLOCK_FILE_HAS_HIGH) ? (7+33) : (7+25);
if (name_offset + name_size <= hdr->size) {
const int max_size = name_offset + name_size;
if (stream_Peek(s, &peek, max_size) < max_size) {
free(name);
return VLC_EGENERIC;
}
memcpy(name, &peek[name_offset], name_size);
}
rar_file_t *current = NULL;
if (method != 0x30) {
msg_Warn(s, "Ignoring compressed file %s (method=0x%2.2x)", name, method);
goto exit;
}
/* */
if( *count > 0 )
current = (*file)[*count - 1];
if (current &&
(current->is_complete ||
strcmp(current->name, name) ||
(hdr->flags & RAR_BLOCK_FILE_HAS_PREVIOUS) == 0))
current = NULL;
if (!current) {
if (hdr->flags & RAR_BLOCK_FILE_HAS_PREVIOUS)
goto exit;
current = malloc(sizeof(*current));
if (!current)
goto exit;
TAB_APPEND(*count, *file, current);
current->name = name;
current->size = file_size;
current->is_complete = false;
current->real_size = 0;
TAB_INIT(current->chunk_count, current->chunk);
name = NULL;
}
/* Append chunks */
rar_file_chunk_t *chunk = malloc(sizeof(*chunk));
if (chunk) {
chunk->mrl = strdup(volume_mrl);
chunk->offset = stream_Tell(s) + hdr->size;
chunk->size = hdr->add_size;
chunk->cummulated_size = 0;
if (current->chunk_count > 0) {
rar_file_chunk_t *previous = current->chunk[current->chunk_count-1];
chunk->cummulated_size += previous->cummulated_size +
previous->size;
}
TAB_APPEND(current->chunk_count, current->chunk, chunk);
current->real_size += hdr->add_size;
}
if ((hdr->flags & RAR_BLOCK_FILE_HAS_NEXT) == 0)
current->is_complete = true;
exit:
/* */
free(name);
/* We stop on the first non empty file if we cannot seek */
if (current) {
bool can_seek = false;
stream_Control(s, STREAM_CAN_SEEK, &can_seek);
if (!can_seek && current->size > 0)
return VLC_EGENERIC;
}
if (SkipBlock(s, hdr))
return VLC_EGENERIC;
return VLC_SUCCESS;
}
//vfc add bGetValue
bool Tokenizer::SkipUnwanted(bool bGetValue)
{
while (CurrentChar() == '#' ||
(!m_IsOperator && CurrentChar() == '=') ||
(!m_IsOperator && CurrentChar() == '[') ||
CurrentChar() == '?' ||
(CurrentChar() == '/' && (NextChar() == '/' || NextChar() == '*') ))
{
bool skipPreprocessor = false; // used for #include
while (m_Buffer.Mid(m_TokenIndex, 2) == _T("//") ||
m_Buffer.Mid(m_TokenIndex, 2) == _T("/*"))
{
// C/C++ style comments
SkipComment();
if (IsEOF())
return false;
if (!SkipWhiteSpace())
return false;
}
while (CurrentChar() == '#')
{
// preprocessor directives
// we only care for #include and #define, for now
unsigned int backupIdx = m_TokenIndex;
MoveToNextChar();
SkipWhiteSpace();
if ((CurrentChar() == 'i' && NextChar() == 'n') || // in(clude)
(CurrentChar() == 'i' && NextChar() == 'f') || // if(|def|ndef)
(CurrentChar() == 'e' && NextChar() == 'l') || // el(se|if)
(CurrentChar() == 'e' && NextChar() == 'n') || // en(dif)
(m_Options.wantPreprocessor && CurrentChar() == 'd' && NextChar() == 'e')) // de(fine)
{
// ok, we have something like #in(clude)
m_LastWasPreprocessor = true;
m_LastPreprocessor.Clear();
m_TokenIndex = backupIdx; // keep #
skipPreprocessor = true;
break;
}
else
{
// skip the rest for now...
SkipToEOL(false);
if (!SkipWhiteSpace())
return false;
}
if (skipPreprocessor)
break;
}
while (CurrentChar() == '[')
{
// array subscripts
// skip them for now...
SkipBlock('[');
if (!SkipWhiteSpace())
return false;
}
while (CurrentChar() == '=')
{
// skip assignments
// TODO: what happens with operators?
if (bGetValue == true)
{
MoveToNextChar();
SkipWhiteSpace();
return true;
}
else if (!SkipToOneOfChars(_T(",;}"), true))
return false;
}
while (CurrentChar() == '?')
{
// skip "condition ? true : false"
// TODO: what happens with operators?
if (!SkipToOneOfChars(_T(";}")))
return false;
}
if (skipPreprocessor)
break;
}
return true;
}
//vfc add bGetValue
wxString Tokenizer::DoGetToken(bool bGetValue, bool bTemplate)
{
if (IsEOF())
return wxEmptyString;
if (!SkipWhiteSpace())
return wxEmptyString;
if (m_SkipUnwantedTokens && !SkipUnwanted(bGetValue))
return wxEmptyString;
// if m_SkipUnwantedTokens is false, we need to handle comments here too
if (!m_SkipUnwantedTokens)
SkipComment();
int start = m_TokenIndex;
wxString m_Str;
wxChar c = CurrentChar();
if (c == '_' || wxIsalpha(c))
{
// keywords, identifiers, etc.
// operator== is cheaper than wxIsalnum, also MoveToNextChar already includes IsEOF
while ( ( CurrentChar() == '_' ||
wxIsalnum(CurrentChar()) ) && MoveToNextChar() )
;
if (IsEOF())
return wxEmptyString;
m_Str = m_Buffer.Mid(start, m_TokenIndex - start);
m_IsOperator = m_Str.IsSameAs(TokenizerConsts::operator_str);
}
#ifdef __WXMSW__ // This is a Windows only bug!
else if (c == 178 || c == 179 || c == 185) // fetch ?and ?
{
m_Str = c;
MoveToNextChar();
}
#endif
else if (wxIsdigit(CurrentChar()))
{
// numbers
while (NotEOF() && CharInString(CurrentChar(), _T("0123456789.abcdefABCDEFXxLl")))
MoveToNextChar();
if (IsEOF())
return wxEmptyString;
m_Str = m_Buffer.Mid(start, m_TokenIndex - start);
m_IsOperator = false;
}
else if (CurrentChar() == '"' ||
CurrentChar() == '\'')
{
// string, char, etc.
wxChar match = CurrentChar();
MoveToNextChar(); // skip starting ' or "
if (!SkipToChar(match))
return wxEmptyString;
MoveToNextChar(); // skip ending ' or "
m_Str = m_Buffer.Mid(start, m_TokenIndex - start);
}
else if (CurrentChar() == ':')
{
if (NextChar() == ':')
{
MoveToNextChar();
MoveToNextChar();
m_Str.assign(TokenizerConsts::colon_colon); // this only copies a pointer, but operator= allocates memory and does a memcpy!
}
else
{
MoveToNextChar();
m_Str.assign(TokenizerConsts::colon);
}
}
else if (CurrentChar() == '<' && bTemplate)
{
wxChar match = _T('>');
MoveToNextChar();
if (!SkipToOneOfChars(_T(">\r\n")),false)
return wxEmptyString;
MoveToNextChar();
wxString tmp = m_Buffer.Mid(start+1,m_TokenIndex-start-2);
tmp.Trim();
m_Str = _T("<");
m_Str += tmp;
m_Str += _T(">");//m_Buffer.Mid(start, m_TokenIndex - start);
}
else if (CurrentChar() == '(')
{
m_IsOperator = false;
// skip blocks () []
if (!SkipBlock(CurrentChar()))
return wxEmptyString;
wxString tmp = m_Buffer.Mid(start, m_TokenIndex - start);
// tmp.Replace(_T("\t"), _T(" ")); // replace tabs with spaces
// tmp.Replace(_T("\n"), _T(" ")); // replace LF with spaces
// tmp.Replace(_T("\r"), _T(" ")); // replace CR with spaces
{ // this is much faster:
size_t i;
while((i = tmp.find_first_of(TokenizerConsts::tabcrlf)) != wxString::npos)
//tmp[i] = _T(' ');
tmp.SetAt(i,_T(' '));
}
// fix-up arguments (remove excessive spaces/tabs/newlines)
for (unsigned int i = 0; i < tmp.Length() - 1; ++i)
{
//skip spaces before '=' and ','
if (tmp.GetChar(i) == ' ' && (tmp.GetChar(i + 1) == ',' || tmp.GetChar(i + 1) == '='))
continue;
if (tmp.GetChar(i) == '/' && tmp.GetChar(i + 1) == '*')
{
// skip C comments
i += 2;
while (i < tmp.Length() - 1)
{
if (tmp.GetChar(i) == '*' && tmp.GetChar(i + 1) == '/')
break;
++i;
}
if (i >= tmp.Length() - 1 || tmp.GetChar(i + 1) != '/')
continue; // we failed...
i += 2;
}
else if (tmp.GetChar(i) == '=')
{
// skip default assignments
++i;
int level = 0; // nesting parenthesis
while (i < tmp.Length())
{
if (tmp.GetChar(i) == '(')
++level;
else if (tmp.GetChar(i) == ')')
--level;
if ((tmp.GetChar(i) == ',' && level == 0) ||
(tmp.GetChar(i) == ')' && level < 0))
break;
++i;
}
if (i < tmp.Length() && tmp.GetChar(i) == ',')
--i;
continue; // we are done here
}
if (i < tmp.Length() - 1)
{
if ((tmp.GetChar(i) == ' ') && (tmp.GetChar(i + 1) == ' '))
continue; // skip excessive spaces
// in case of c-style comments "i" might already be tmp.Length()
// thus do only add the current char otherwise.
// otherwise the following statement:
// m_Str << _T(')');
// below would add another closing bracket.
m_Str << tmp.GetChar(i);
}
}
m_Str << _T(')'); // add closing parenthesis (see "i < tmp.Length() - 1" in previous "for")
// m_Str.Replace(_T(" "), _T(" ")); // replace two-spaces with single-space (introduced if it skipped comments or assignments)
// m_Str.Replace(_T("( "), _T("("));
// m_Str.Replace(_T(" )"), _T(")"));
//Str.Replace is massive overkill here since it has to allocate one new block per replacement
CompactSpaces(m_Str);
}
else
{
if (CurrentChar() == '{')
++m_NestLevel;
else if (CurrentChar() == '}')
--m_NestLevel;
m_Str = CurrentChar();
MoveToNextChar();
}
if (m_LastWasPreprocessor && !m_Str.IsSameAs(_T("#")) && !m_LastPreprocessor.IsSameAs(_T("#")))
{
if (!m_LastPreprocessor.IsSameAs(TokenizerConsts::include_str))
{
// except for #include and #if[[n]def], all other preprocessor directives need only
// one word exactly after the directive, e.g. #define THIS_WORD
SkipToEOL();
}
m_LastPreprocessor.Clear();
}
if (m_LastWasPreprocessor)
m_LastPreprocessor << m_Str;
m_LastWasPreprocessor = false;
return m_Str;
}
const CssProperty *CssPullParser::NextProperty()
{
if (currPos == s)
inlineStyle = inProps = true;
else if (!inProps)
return nullptr;
GetNextProperty:
SkipWsAndComments(currPos, end);
if (currPos == end)
return nullptr;
if (*currPos == '}') {
currPos++;
inProps = false;
return nullptr;
}
if (*currPos == '{') {
if (!SkipBlock(currPos, end))
return nullptr;
goto GetNextProperty;
}
if (*currPos == ';') {
currPos++;
goto GetNextProperty;
}
const char *name = currPos;
// skip identifier
while (currPos < end && !str::IsWs(*currPos) && *currPos != ':' &&
*currPos != ';' && *currPos != '{' && *currPos != '}') {
currPos++;
}
SkipWsAndComments(currPos, end);
if (currPos == end || *currPos != ':')
goto GetNextProperty;
prop.type = FindCssProp(name, currPos - name);
currPos++;
SkipWsAndComments(currPos, end);
prop.s = currPos;
// skip value
const char *valEnd = currPos;
while (currPos < end && *currPos != ';' && *currPos != '}') {
if (*currPos == '"' || *currPos == '\'') {
if (!SkipQuotedString(currPos, end))
return nullptr;
valEnd = currPos;
}
else if (*currPos == '{') {
if (!SkipBlock(currPos, end))
return nullptr;
valEnd = currPos;
}
else if (*currPos == '\\' && currPos < end - 1) {
currPos += 2;
valEnd = currPos;
}
else if (!SkipWsAndComments(currPos, end)) {
valEnd = ++currPos;
}
}
prop.sLen = valEnd - prop.s;
return ∝
}
bool CompileCase(int column, int param)
{
param = param; // stop warning
if (!BlockStack_CompileConstant())
{
return false;
}
if (!CompileExpression())
{
return false;
}
if (!g_pElementizer->GetElement(type_end))
{
return false;
}
int savedSourcePtr = g_pElementizer->GetSourcePtr();
int otherSourcePtr = 0;
bool bOther = false;
int caseCount = 0;
bool bEof = false;
while (!bEof)
{
if (!g_pElementizer->GetNext(bEof))
{
return false;
}
if (bEof)
{
break;
}
if (g_pElementizer->GetType() == type_end)
{
continue;
}
s_column = g_pElementizer->GetColumn();
g_pElementizer->Backup();
if (s_column <= column)
{
break;
}
if (bOther) // if we have OTHER: it should have been the last case, so we shouldn't get here again
{
g_pCompilerData->error = true;
g_pCompilerData->error_msg = g_pErrorStrings[error_omblc];
return false;
}
if (g_pElementizer->GetType() == type_other)
{
bOther = true;
if (!g_pElementizer->GetNext(bEof)) // get/skip 'other'
{
return false;
}
otherSourcePtr = g_pCompilerData->source_start; // save the pointer to the beginning of 'other'
}
else
{
caseCount++;
if (caseCount > case_limit)
{
g_pCompilerData->error = true;
g_pCompilerData->error_msg = g_pErrorStrings[error_loxce];
return false;
}
while (1)
{
bool bRange = false;
if (!CompileRange(bRange))
{
return false;
}
if (!EnterObj(bRange ? 0x0E : 0x0D)) // enter bytecode for case range or case value into obj
{
return false;
}
if (!BlockStack_CompileAddress(caseCount))
{
return false;
}
if (!g_pElementizer->CheckElement(type_comma))
{
break;
}
}
}
if (!g_pElementizer->GetElement(type_colon))
{
return false;
}
if (!SkipBlock(s_column))
{
return false;
}
}
if (caseCount == 0)
{
g_pCompilerData->error = true;
g_pCompilerData->error_msg = g_pErrorStrings[error_nce];
return false;
}
if (bOther)
{
// set the source pointer to where the OTHER is at, then get it to set the column
g_pElementizer->SetSourcePtr(otherSourcePtr);
if (!g_pElementizer->GetNext(bEof))
{
return false;
}
int new_column = g_pElementizer->GetColumn();
// skip the colon
if (!g_pElementizer->GetNext(bEof))
{
return false;
}
if (!CompileBlock(new_column))
{
return false;
}
}
if (!EnterObj(0x0C)) // casedone, end of range checks
{
return false;
}
g_pElementizer->SetSourcePtr(savedSourcePtr);
caseCount = 0;
bOther = false;
bEof = false;
while(!bEof)
{
if (!g_pElementizer->GetNext(bEof))
{
return false;
}
if (bEof)
{
break;
}
if (g_pElementizer->GetType() == type_end)
{
continue;
}
s_column = g_pElementizer->GetColumn();
g_pElementizer->Backup();
if (s_column <= column)
{
break;
}
if (g_pElementizer->GetType() == type_other)
{
// skip over other, already compiled
if (!g_pElementizer->GetNext(bEof))
{
return false;
}
if (!g_pElementizer->GetNext(bEof))
{
return false;
}
if (!SkipBlock(s_column))
{
return false;
}
}
else
{
// skip over range/values(s), allready compiled
while (1)
{
if (!SkipRange())
{
return false;
}
if (!g_pElementizer->CheckElement(type_comma))
{
break;
}
}
caseCount++;
BlockStack_Write(caseCount, g_pCompilerData->obj_ptr);
if (!g_pElementizer->GetElement(type_colon))
{
return false;
}
if (!CompileBlock(s_column))
{
return false;
}
if (!EnterObj(0x0C)) // casedone
{
return false;
}
}
}
BlockStack_Write(0, g_pCompilerData->obj_ptr);
return true;
}
static int SkipFile(struct stream *s, int *count, rar_file_t ***file,
const rar_block_t *hdr, const char *volume_mrl)
{
int min_size = 7+21;
if (hdr->flags & RAR_BLOCK_FILE_HAS_HIGH)
min_size += 8;
if (hdr->size < (unsigned)min_size)
return -1;
bstr data = stream_peek(s, min_size);
if (data.len < min_size)
return -1;
const uint8_t *peek = (uint8_t *)data.start;
/* */
uint32_t file_size_low = AV_RL32(&peek[7+4]);
uint8_t method = peek[7+18];
uint16_t name_size = AV_RL16(&peek[7+19]);
uint32_t file_size_high = 0;
if (hdr->flags & RAR_BLOCK_FILE_HAS_HIGH)
file_size_high = AV_RL32(&peek[7+29]);
const uint64_t file_size = ((uint64_t)file_size_high << 32) | file_size_low;
char *name = calloc(1, name_size + 1);
if (!name)
return -1;
const int name_offset = (hdr->flags & RAR_BLOCK_FILE_HAS_HIGH) ? (7+33) : (7+25);
if (name_offset + name_size <= hdr->size) {
const int max_size = name_offset + name_size;
bstr namedata = stream_peek(s, max_size);
if (namedata.len < max_size) {
free(name);
return -1;
}
memcpy(name, &namedata.start[name_offset], name_size);
}
rar_file_t *current = NULL;
if (method != 0x30) {
MP_WARN(s, "Ignoring compressed file %s (method=0x%2.2x)\n", name, method);
goto exit;
}
/* */
if( *count > 0 )
current = (*file)[*count - 1];
if (current &&
(current->is_complete ||
strcmp(current->name, name) ||
(hdr->flags & RAR_BLOCK_FILE_HAS_PREVIOUS) == 0))
current = NULL;
if (!current) {
if (hdr->flags & RAR_BLOCK_FILE_HAS_PREVIOUS)
goto exit;
current = calloc(1, sizeof(*current));
if (!current)
goto exit;
MP_TARRAY_APPEND(NULL, *file, *count, current);
current->name = name;
current->size = file_size;
current->is_complete = false;
current->real_size = 0;
current->chunk_count = 0;
current->chunk = NULL;
name = NULL;
}
/* Append chunks */
rar_file_chunk_t *chunk = malloc(sizeof(*chunk));
if (chunk) {
chunk->mrl = strdup(volume_mrl);
chunk->offset = stream_tell(s) + hdr->size;
chunk->size = hdr->add_size;
chunk->cummulated_size = 0;
if (current->chunk_count > 0) {
rar_file_chunk_t *previous = current->chunk[current->chunk_count-1];
chunk->cummulated_size += previous->cummulated_size +
previous->size;
}
MP_TARRAY_APPEND(NULL, current->chunk, current->chunk_count, chunk);
current->real_size += hdr->add_size;
}
if ((hdr->flags & RAR_BLOCK_FILE_HAS_NEXT) == 0)
current->is_complete = true;
exit:
/* */
free(name);
/* We stop on the first non empty file if we cannot seek */
if (current) {
bool can_seek = s->end_pos > 0;
if (!can_seek && current->size > 0)
return -1;
}
if (SkipBlock(s, hdr))
return -1;
return 0;
}
int RarParse(struct stream *s, int *count, rar_file_t ***file)
{
*count = 0;
*file = NULL;
const rar_pattern_t *pattern = FindVolumePattern(s->url);
int volume_offset = 0;
char *volume_mrl;
if (asprintf(&volume_mrl, "%s", s->url) < 0)
return -1;
struct stream *vol = s;
for (;;) {
/* Skip marker & archive */
if (IgnoreBlock(vol, RAR_BLOCK_MARKER) ||
IgnoreBlock(vol, RAR_BLOCK_ARCHIVE)) {
if (vol != s)
free_stream(vol);
free(volume_mrl);
return -1;
}
/* */
int has_next = -1;
for (;;) {
rar_block_t bk;
int ret;
if (PeekBlock(vol, &bk))
break;
switch(bk.type) {
case RAR_BLOCK_END:
ret = SkipEnd(vol, &bk);
has_next = ret && (bk.flags & RAR_BLOCK_END_HAS_NEXT);
break;
case RAR_BLOCK_FILE:
ret = SkipFile(vol, count, file, &bk, volume_mrl);
break;
default:
ret = SkipBlock(vol, &bk);
break;
}
if (ret)
break;
}
if (has_next < 0 && *count > 0 && !(*file)[*count -1]->is_complete)
has_next = 1;
if (vol != s)
free_stream(vol);
if (!has_next || !pattern)
goto done;
/* Open next volume */
const int volume_index = pattern->start + volume_offset++;
if (volume_index > pattern->stop)
goto done;
char *volume_base;
if (asprintf(&volume_base, "%.*s",
(int)(strlen(s->url) - strlen(pattern->match)), s->url) < 0) {
goto done;
}
free(volume_mrl);
if (pattern->start) {
if (asprintf(&volume_mrl, pattern->format, volume_base, volume_index) < 0)
volume_mrl = NULL;
} else {
if (asprintf(&volume_mrl, pattern->format, volume_base,
'r' + volume_index / 100, volume_index % 100) < 0)
volume_mrl = NULL;
}
free(volume_base);
if (!volume_mrl)
goto done;
vol = stream_create(volume_mrl, STREAM_READ | STREAM_NO_FILTERS,
s->cancel, s->global);
if (!vol)
goto done;
}
done:
free(volume_mrl);
if (*count == 0) {
talloc_free(*file);
return -1;
}
return 0;
}
// Start the importer!
int AsciiImp::DoImport(const TCHAR *name,ImpInterface *ii,Interface *i, BOOL suppressPrompts)
{
int status = 1;
int lastProgress = 0;
int progress;
BOOL fileValid = FALSE;
mtlTab.ZeroCount();
mtlTab.Shrink();
// Grab the interface pointer.
ip = i;
impip = ii;
// Prompt the user with our dialogbox.
if (!DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_ASCIIIMPORT_DLG),
ip->GetMAXHWnd(), ImportDlgProc, (LPARAM)this)) {
return 1;
}
// Open the stream
pStream = _tfopen(name,_T("rt"));
if (!pStream) {
return 0;
}
// Get the file size
fseek(pStream, 0, SEEK_END);
long fsize = ftell(pStream);
fseek(pStream, 0, SEEK_SET);
if(resetScene) {
impip->NewScene();
}
TCHAR* token = NULL;
token = GetToken();
if (token) {
if (Compare(token, ID_FILEID)) {
fileVersion = (int)GetFloat();
if (fileVersion >= 200 && fileVersion <= 200) {
fileValid = TRUE;
}
}
}
if (!fileValid) {
BadFile();
fclose(pStream);
return FALSE;
}
#ifndef USE_IMPNODES
ip->DisableSceneRedraw();
#endif
// Startup the progress bar.
ip->ProgressStart(_T("Importing file..."), TRUE, fn, NULL);
long fpos = 0;
while ((token = GetToken()) != NULL) {
if (ip->GetCancel()) {
status = 0;
break;
}
// Update the progress meter
// We will eliminate flicker by only calling this when it changes.
fpos = ftell(pStream);
progress = 100*fpos/fsize;
if (progress != lastProgress) {
ip->ProgressUpdate(progress);
}
lastProgress = progress;
DebugPrint(_T("Token: %s\n"), token);
if (Compare(token, ID_SCENE)) {
ImportSceneParams();
}
else if (Compare(token, ID_MATERIAL_LIST)) {
ImportMaterialList();
}
else if (Compare(token, ID_GEOMETRY)) {
ImportGeomObject();
}
else if (Compare(token, ID_SHAPE)) {
ImportShape();
}
else if (Compare(token, ID_HELPER)) {
ImportHelper();
}
else if (Compare(token, ID_CAMERA)) {
ImportCamera();
}
else if (Compare(token, ID_LIGHT)) {
ImportLight();
}
else if (Compare(token, ID_COMMENT)) {
GetToken();
}
#ifndef USE_IMPNODES
// ImpNodes doesn't support group creation!
else if (Compare(token, ID_GROUP)) {
groupMgr.BeginGroup(GetString());
GetToken(); // BlockBegin
GetToken(); // GroupDummy HelperObject
GetToken(); // GroupDummy BlockBegin
SkipBlock(); // GroupDummy
}
else if (Compare(token, _T("}"))) {
groupMgr.EndGroup(ip);
}
#endif
}
ip->ProgressEnd();
#ifndef USE_IMPNODES
ip->EnableSceneRedraw();
#endif
// Close the stream
fclose(pStream);
return status;
}
HRESULT KG3DAnimationTagContainer::_Load(LPCSTR strFileName)
{
HRESULT hrResult = E_FAIL;
HRESULT hrRetCode = E_FAIL;
IFile* pFile = NULL;
FileHeader Header;
AnimationTagBlockHeader BlockHeader;
unsigned long uRetCode = 0;
IKG3DAnimationTag* pNewTag = NULL;
Clear();
KG_PROCESS_ERROR(strFileName);
pFile = g_OpenFile(strFileName);
KGLOG_PROCESS_ERROR(pFile);
uRetCode = pFile->Read(&Header, sizeof(FileHeader));
KGLOG_PROCESS_ERROR(uRetCode == sizeof(FileHeader));
KG_PROCESS_ERROR(Header.dwMask == FileHeader::s_dwMask);
strncpy(m_szAnimationName, Header.strAnimationFileName, _countof(m_szAnimationName) - 1);
m_szAnimationName[_countof(m_szAnimationName) - 1] = '\0';
hrRetCode = g_cClipTable.LoadResourceFromFile(m_szAnimationName, 0, 0, &m_pClip);
KGLOG_COM_PROCESS_ERROR(hrRetCode);
switch(Header.dwVersion)
{
case FileHeader::s_dwCurrentVersion:
{
for (DWORD i = 0; i < Header.dwNumBlock; i++)
{
Item NewItem;
uRetCode = pFile->Read(&BlockHeader, sizeof(AnimationTagBlockHeader));
KGLOG_PROCESS_ERROR(uRetCode == sizeof(AnimationTagBlockHeader));
if (BlockHeader.dwNumKeyFrames == 0)
{
hrRetCode = SkipBlock(&BlockHeader, pFile);
KGLOG_COM_PROCESS_ERROR(hrRetCode);
continue;
}
pNewTag = GetNewInstance(static_cast<enuTagType>(BlockHeader.dwType));
KG_PROCESS_ERROR(pNewTag);
hrRetCode = pNewTag->LoadFromFile(pFile, BlockHeader.dwVersion, BlockHeader.dwNumKeyFrames);
KG_COM_PROCESS_ERROR(hrRetCode);
pNewTag->SetParentModel(m_pModel);
NewItem.pTag = pNewTag;
NewItem.Type = static_cast<enuTagType>(BlockHeader.dwType);
m_vecTags.push_back(NewItem);
pNewTag = NULL;
}
}
break;
default:
_ASSERTE(0);
}
m_IsLoaded = TRUE;
hrResult = S_OK;
Exit0:
SAFE_DELETE(pNewTag);
KG_COM_RELEASE(pFile);
return hrResult;
}
int RarParse(stream_t *s, int *count, rar_file_t ***file, unsigned int *pi_nbvols,
bool b_extonly)
{
*count = 0;
*file = NULL;
*pi_nbvols = 1;
if( s->psz_url == NULL )
return VLC_EGENERIC;
const rar_pattern_t *pattern = FindVolumePattern(s->psz_url, b_extonly);
int volume_offset = 0;
char *volume_mrl = strdup(s->psz_url);
if (volume_mrl == NULL)
return VLC_ENOMEM;
stream_t *vol = s;
for (;;) {
/* Skip marker & archive */
if (IgnoreBlock(vol, RAR_BLOCK_MARKER) ||
IgnoreBlock(vol, RAR_BLOCK_ARCHIVE)) {
if (vol != s)
stream_Delete(vol);
free(volume_mrl);
return VLC_EGENERIC;
}
/* */
int has_next = -1;
for (;;) {
rar_block_t bk;
int ret;
if (PeekBlock(vol, &bk))
break;
switch(bk.type) {
case RAR_BLOCK_END:
ret = SkipEnd(vol, &bk);
has_next = ret && (bk.flags & RAR_BLOCK_END_HAS_NEXT);
break;
case RAR_BLOCK_FILE:
ret = SkipFile(vol, count, file, &bk, volume_mrl);
break;
default:
ret = SkipBlock(vol, &bk);
break;
}
if (ret)
break;
}
if (has_next < 0 && *count > 0 && !(*file)[*count -1]->is_complete)
has_next = 1;
if (vol != s)
stream_Delete(vol);
free(volume_mrl);
if (!has_next || !pattern)
return VLC_SUCCESS;
/* Open next volume */
const int volume_index = pattern->start + volume_offset++;
if (volume_index > pattern->stop)
return VLC_SUCCESS;
char *volume_base = strndup(s->psz_url,
strlen(s->psz_url) - strlen(pattern->match));
if (volume_base == NULL)
return VLC_SUCCESS;
if (pattern->start) {
if (asprintf(&volume_mrl, pattern->format, volume_base, volume_index) < 0)
volume_mrl = NULL;
} else {
if (asprintf(&volume_mrl, pattern->format, volume_base,
'r' + volume_index / 100, volume_index % 100) < 0)
volume_mrl = NULL;
}
free(volume_base);
if (!volume_mrl)
return VLC_SUCCESS;
const int s_flags = s->i_flags;
s->i_flags |= OBJECT_FLAGS_NOINTERACT;
vol = stream_UrlNew(s, volume_mrl);
s->i_flags = s_flags;
if (!vol) {
free(volume_mrl);
return VLC_SUCCESS;
}
(*pi_nbvols)++;
}
}
