void CTunage::PostURL()
{
if ( wxGetApp().Prefs.sTunageURL == wxT("") )
return;
// create a valid URL
wxString urltext( wxGetApp().Prefs.sTunageURL );
ParseTags( urltext );
urltext = wxURL::ConvertToValidURI( urltext );
wxURL url( urltext );
if ( url.GetError() != wxURL_NOERR )
{
wxMessageBox( wxT("Could not parse Tunage URL"), wxT("Tunage error"), wxOK | wxICON_WARNING );
return;
}
// connect to URL
wxYield();
wxInputStream *data = url.GetInputStream();
if ( !data )
{
wxMessageBox( wxT("Could not access URL"), wxT("Tunage error"), wxOK | wxICON_WARNING );
}
delete data;
}
void CTunage::WriteFile()
{
if ( ( wxGetApp().Prefs.sTunageFilename == wxT("") ) || ( wxGetApp().Prefs.sTunageFileLine == wxT("") ) )
return;
if ( !wxGetApp().Prefs.bTunageAppendFile )
{
if ( wxFileExists( wxGetApp().Prefs.sTunageFilename ) )
wxRemoveFile( wxGetApp().Prefs.sTunageFilename );
}
wxTextFile Out;
Out.Create( wxGetApp().Prefs.sTunageFilename );
Out.Open();
if ( !Out.IsOpened() )
return;
wxString line( wxGetApp().Prefs.sTunageFileLine );
ParseTags( line );
Out.AddLine( line );
Out.Write( Out.GuessType() );
Out.Close();
}
void CTunage::RunApp()
{
if ( wxGetApp().Prefs.sTunageCmdLine == wxT("") )
return;
wxString cmd( wxGetApp().Prefs.sTunageCmdLine );
ParseTags( cmd );
wxExecute( cmd );
}
BOOL CEventPropertiesFireTriggerDialog::HandleMessage( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
m_hDialog = hwndDlg;
bool handled = false;
BOOL bret = InternalHandleMessage( &g_Params, hwndDlg, uMsg, wParam, lParam, handled );
if ( handled )
return bret;
switch(uMsg)
{
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc;
hdc = BeginPaint(hwndDlg, &ps);
DrawSpline( hdc, GetControl( IDC_STATIC_SPLINE ), g_Params.m_pEvent );
EndPaint(hwndDlg, &ps);
return FALSE;
}
break;
case WM_VSCROLL:
{
RECT rcOut;
GetSplineRect( GetControl( IDC_STATIC_SPLINE ), rcOut );
InvalidateRect( hwndDlg, &rcOut, TRUE );
UpdateWindow( hwndDlg );
return FALSE;
}
break;
case WM_INITDIALOG:
{
InitDialog( hwndDlg );
}
return FALSE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
{
HWND control = GetControl( IDC_EVENTCHOICES );
if ( control )
{
SendMessage( control, WM_GETTEXT, (WPARAM)sizeof( g_Params.m_szParameters ), (LPARAM)g_Params.m_szParameters );
}
GetDlgItemText( m_hDialog, IDC_EVENTNAME, g_Params.m_szName, sizeof( g_Params.m_szName ) );
if ( !g_Params.m_szName[ 0 ] )
{
Q_snprintf( g_Params.m_szName, sizeof( g_Params.m_szName ), "Firetrigger %s", g_Params.m_szParameters );
}
char szTime[ 32 ];
GetDlgItemText( m_hDialog, IDC_STARTTIME, szTime, sizeof( szTime ) );
g_Params.m_flStartTime = atof( szTime );
GetDlgItemText( m_hDialog, IDC_ENDTIME, szTime, sizeof( szTime ) );
g_Params.m_flEndTime = atof( szTime );
// Parse tokens from tags
ParseTags( &g_Params );
EndDialog( hwndDlg, 1 );
}
break;
case IDCANCEL:
EndDialog( hwndDlg, 0 );
break;
case IDC_CHECK_ENDTIME:
{
g_Params.m_bHasEndTime = SendMessage( GetControl( IDC_CHECK_ENDTIME ), BM_GETCHECK, 0, 0 ) == BST_CHECKED ? true : false;
if ( !g_Params.m_bHasEndTime )
{
ShowWindow( GetControl( IDC_ENDTIME ), SW_HIDE );
}
else
{
ShowWindow( GetControl( IDC_ENDTIME ), SW_RESTORE );
}
}
break;
case IDC_CHECK_RESUMECONDITION:
{
g_Params.m_bResumeCondition = SendMessage( GetControl( IDC_CHECK_RESUMECONDITION ), BM_GETCHECK, 0, 0 ) == BST_CHECKED ? true : false;
}
break;
case IDC_EVENTCHOICES:
{
HWND control = (HWND)lParam;
if ( control )
{
SendMessage( control, WM_GETTEXT, (WPARAM)sizeof( g_Params.m_szParameters ), (LPARAM)g_Params.m_szParameters );
}
}
break;
case IDC_ABSOLUTESTART:
{
g_Params.m_bUsesTag = false;
UpdateTagRadioButtons( &g_Params );
}
break;
case IDC_RELATIVESTART:
{
g_Params.m_bUsesTag = true;
UpdateTagRadioButtons( &g_Params );
}
break;
}
return TRUE;
}
return FALSE;
}
int Parser::Parse()
{
Tag *tagList;
TypeDecl *typeDecl;
Statement *stmt;
// keep going until there are no more tokens!
while(t)
{
TOKEN allowed[] =
{
TOK_LENGTHIS, TOK_SIZEIS, TOK_IGNORE, TOK_STRING,
TOK_OFFSET, TOK_ALIGN, TOK_BITFLAG, TOK_STYLE, TOK_DISPLAY,
TOK_ENDIAN, TOK_SWITCHIS, TOK_CASE, TOK_NAME,
TOK_ENUM, TOK_EXPORT, TOK_ASSOC,
TOK_NULL
};
// save any whitespace before the tags
FILEREF fileRef;
lex_fileref(&fileRef);
if(!ParseTags(&tagList, allowed))
return 0;
//
// Decide what kind of statement/construct we need to parse
//
switch(t)
{
case TOK_INCLUDE:
// include-statement (not the same as #include which
// is a C-preprocessor thing)
if((stmt = ParseInclude()) == 0)
{
return 0;
}
curFile->stmtList.push_back(stmt);
break;
default:
size_t s1 = globalFileHistory.size();
// anything else must be a type-declaration
if((typeDecl = ParseTypeDecl(tagList, globalIdentifierList, false, true)) == 0)
return 0;
size_t s2 = globalFileHistory.size();
// store in the global list
typeDecl->fileRef = fileRef;
globalTypeDeclList.push_back(typeDecl);
//curFile->typeDeclList.push_back(typeDecl);
curFile->stmtList.push_back(new Statement(typeDecl));
// every type-declaration must end with a ';'
if(!Expected(';'))
return 0;
// record any whitespace that appears after the type-decl
lex_fileref(&typeDecl->postRef);
break;
}
}
ExportStructs();
return (errcount == 0) ? 1 : 0;
}
// Parse file - returns 0 if successful
int LicutSVG::Parse( const char *svgPath )
{
FILE *f = fopen( svgPath, "r" );
if (!f)
{
printf( "Failed to open %s (errno=%d: %s)\n", svgPath, errno, strerror(errno) );
return -1;
}
struct stat fileInfo;
if (0 != fstat( fileno(f), &fileInfo ))
{
printf( "Failed to get size of %s (errno=%d: %s)\n", svgPath, errno, strerror(errno) );
fclose( f );
return -1;
}
// If size is greater than the process stack limit we'll get a stack overflow fault
// here. Use malloc / free if over 1mb *FIXME*
if (fileInfo.st_size < 1 || fileInfo.st_size > 0x10000)
{
printf( "Invalid file size %lu for %s - must be > 0 and <= 1mb\n", fileInfo.st_size, svgPath );
fclose( f );
return -1;
}
char *data = (char *)alloca( fileInfo.st_size + 1 );
size_t bytesRead = fread( data, sizeof(char), fileInfo.st_size, f );
if (bytesRead < fileInfo.st_size)
{
printf( "Failed to read contents of %s (%lu requested, %d read, errno=%d: %s)\n",
svgPath, fileInfo.st_size, bytesRead, errno, strerror(errno) );
fclose( f );
return -1;
}
fclose( f );
// NULL-terminate it
data[bytesRead] = '\0';
int success = -1;
/****
Simple state machine parser
This is a simplistic, tiny xml parser which doesn't handle CDATA or escapes
It operates destructively on data, parsing recursively from the outside in
and setting the end of each tag (</{tagname}> or /> or --> or ?>) to '\0'
Also null-terminates the name of each tag
Limited to tag identification for 1024 levels
****/
char * tagStack[1024];
tagStack[0] = (char *)"";
int stackLevel = 0;
char * tagData = data;
if (ParseTags( tagData, stackLevel, tagStack, false ) >= 1)
{
success = 0;
}
else
{
printf( "Did not parse any tags!\n" );
}
return success;
}
// Parse a single node tag recursively at the current level
// Returns 1 if parsed or 0 if not a tag
int LicutSVG::ParseTag( char *& s, int stackLevel, char *tagStack[1024], bool ignore )
{
if (!*s) return 0;
// Skip leading whitespace
s += strspn( s, " \t\r\n" );
if (!*s) return 0;
// Expected: <tag, <!-- or <?
if (s[0] != '<')
{
printf( "%s() level %d - unexpected character %c\n", __FUNCTION__, stackLevel, *s );
if (s[0]) s++;
return 0;
}
int gotTag = 0;
// Ignore comments
if (s[1] == '!' && s[2] == '-' && s[3] == '-')
{
if (m_verbose) printf( "Skipping comment [%s]\n", _fmt_sample( s, 6 ) );
char *end = strstr( s, "-->" );
if (end)
{
s = &end[3];
}
else
{
s += strlen( s );
}
}
// Ignore directives
else if (s[1] == '?')
{
char *end = strstr( s, "?>" );
if (end)
{
if (m_verbose)
{
printf( "Got directive [%s]...", _fmt_sample( s, 6 ) );
printf( "%s\n", _fmt_sample( &end[-4], 5 ) );
}
s = &end[2];
}
else
{
printf( "Unexpected missing end for [%s]\n", _fmt_sample( s, 4 ) );
s += strlen( s );
}
}
else
{
gotTag = 1;
// Get tag name
char *tagName = &s[1];
tagName += strspn( tagName, " \t\r\n" );
// Name ends in whitespace or end of tag
s = &tagName[strcspn( tagName, "/> \t\r\n" )];
bool foundEnd = false;
bool closedTag = false; // tag ends with />
char *tagEnd;
char *tagNext = NULL;
if (*s == '/')
{
foundEnd = true;
closedTag = true;
tagEnd = &s[1];
tagEnd += strspn( tagEnd, " \t\r\n" );
tagNext = &tagEnd[1];
}
else if (*s == '>')
{
foundEnd = true;
tagEnd = s;
tagNext = &tagEnd[1];
}
// Terminate name
*s = '\0';
if (m_verbose) printf( "Tag: %s end:%c closed:%c\n", tagName, foundEnd?'Y' : 'n', closedTag ? 'Y' : 'n' );
// Find end of tag
if (!foundEnd)
{
s++;
int attrCount = 0;
int attrWithValueCount = 0;
if (m_verbose) printf( "Searching for end starting %s\n", _fmt_sample( s, 4 ) );
while (*s != '/' && *s != '>' && *s)
{
// Parse attribute [ = "value" ]
s += strspn( s, " \t\r\n" );
if (*s == '/' || *s == '>') break;
char *attrName = s;
int attrNameLength = strcspn( attrName, "= \t\r\n" );
s += attrNameLength;
s += strspn( s, " \t\r\n" );
attrCount++;
char *attrValue = NULL;
// Check for value
if (*s == '=')
{
attrWithValueCount++;
s++;
s += strspn( s, " \t\r\n" );
// Unquoted values are not kosher but we'll parse them anyway
if (*s == '"')
{
s++;
attrValue = s;
s += strcspn( s, "\"" );
*s = '\0';
s++;
}
else
{
attrValue = s;
s += strcspn( s, " \t\r\n" );
*s = '\0';
s++;
}
}
attrName[attrNameLength] = '\0';
if (m_verbose) printf( " [%d] %s=%s\n", attrCount, attrName, attrValue );
if (!strcmp( tagName, "svg" ))
{
if (!strcmp( attrName, "width" ))
{
printf( "svg width=%s\n", attrValue );
m_width = atoi( attrValue );
}
else if (!strcmp( attrName, "height" ))
{
printf( "svg height=%s\n", attrValue );
m_height = atoi( attrValue );
}
}
if (!ignore && !strcmp( tagName, "g" ))
{
if (!strcmp( attrName, "id" ) && attrValue != NULL)
{
// FIXME if we wanted to use some layers as guide, the id or label could be
// configurable
printf( "layer id=%s\n", attrValue );
}
}
if (!ignore && !strcmp( tagName, "path" ))
{
if (!strcmp( attrName, "d" ) && attrValue != NULL)
{
int setsParsed = ParseDrawList( attrValue );
printf( "path d len=%d sets=%d\n", strlen(attrValue), setsParsed );
}
}
}
if (m_verbose) printf( "Exited attr parse [%s]\n", _fmt_sample( s, 4 ) );
// Complain if end not found
if (*s == '>')
{
if (m_verbose) printf( "Got end > [%s]\n", _fmt_sample( s, 4 ) );
foundEnd = true;
tagNext = &s[1];
}
else if (*s == '/')
{
if (m_verbose) printf( "Got end /> [%s]\n", _fmt_sample( s, 4 ) );
foundEnd = true;
closedTag = true;
tagNext = &s[1];
tagNext += strspn( tagNext, " \t\r\n" );
s = tagNext;
tagNext++;
}
else
{
printf( "Error: tag %s is not properly closed, ends with [%s]\n", tagName, _fmt_sample( s, 4 ) );
if (!*s) s++;
}
}
// Recurse into container tag
if (foundEnd && !closedTag)
{
// Skip > from end of tag opening
// If we have a tag with no attributes, we may already have NUL
if (*s == '>' || *s == '\0') s++;
// Skip quoted values and find </tagname>
if (m_verbose) printf( "Searching for end of tag %s in %s\n", tagName, _fmt_sample( s, 8 ) );
char *containerStart = s;
char *containerEnd = s;
bool foundContainerEnd = false;
while (!foundContainerEnd && containerEnd != NULL)
{
containerEnd = strpbrk( containerEnd, "\"<" );
if (!containerEnd) break;
if (*containerEnd == '"')
{
containerEnd = strchr( &containerEnd[1], '"' );
if (containerEnd == NULL) break;
containerEnd++;
}
else
{
char *containerEndTagStart = containerEnd;
containerEnd++;
if (*containerEnd == '/')
{
containerEnd++;
int closeLength = strcspn( containerEnd, "> \t\r\n" );
if (closeLength == strlen( tagName ) && !strncmp( containerEnd, tagName, closeLength ))
{
foundEnd = true;
foundContainerEnd = true;
tagNext = &containerEnd[closeLength];
tagNext += strspn( tagNext, " \t\r\n" );
// Skip final >
tagNext++;
*containerEndTagStart = '\0';
}
}
}
}
if (foundContainerEnd)
{
// containerStart is null-terminated
if (stackLevel >= 1023)
{
printf( "Error: cannot parse %s at level %d - stack overflow\n", tagName, stackLevel );
}
else
{
// If container starts with something other than <, treat it as an immediate value
char *valueCandidate = containerStart;
valueCandidate += strspn( valueCandidate, " \t\r\n" );
if (*valueCandidate != '<')
{
if (m_verbose) printf( "Got tag enclosed value [%s]\n", valueCandidate );
}
else
{
stackLevel++;
tagStack[stackLevel] = tagName;
if (m_verbose) printf( "Entering level %d container tag %s [%s]\n", stackLevel, tagName, _fmt_sample( containerStart, 4 ) );
ParseTags( containerStart, stackLevel, tagStack, ignore );
stackLevel--;
if (m_verbose) printf( "Returned to level %d tag %s\n", stackLevel, tagName );
}
}
}
else
{
printf( "Did not find container end\n" );
}
} // Found container tag
// Skip to next tag
if (tagNext != NULL)
{
s = tagNext;
if (m_verbose)
{
printf( "Ending parse with [%s] - ", _fmt_sample( &s[-4], 4 ) );
printf( "next [%s]\n", _fmt_sample( s, 4 ) );
}
}
// else parsing error occurred
else
{
printf( "Parsing error occurred, no next tag\n" );
}
}
// Skip trailing whitespace
if (*s) s += strspn( s, " \t\r\n" );
if (m_verbose) printf( "exiting %s() returning %d\n", __FUNCTION__, gotTag );
return gotTag;
}