// load given song
void Song::loadProject( const QString & fileName )
{
QDomNode node;
m_loadingProject = true;
Engine::projectJournal()->setJournalling( false );
m_oldFileName = m_fileName;
m_fileName = fileName;
DataFile dataFile( m_fileName );
// if file could not be opened, head-node is null and we create
// new project
if( dataFile.head().isNull() )
{
if( m_loadOnLaunch )
{
createNewProject();
}
m_fileName = m_oldFileName;
return;
}
m_oldFileName = m_fileName;
clearProject();
clearErrors();
DataFile::LocaleHelper localeHelper( DataFile::LocaleHelper::ModeLoad );
Engine::mixer()->requestChangeInModel();
// get the header information from the DOM
m_tempoModel.loadSettings( dataFile.head(), "bpm" );
m_timeSigModel.loadSettings( dataFile.head(), "timesig" );
m_masterVolumeModel.loadSettings( dataFile.head(), "mastervol" );
m_masterPitchModel.loadSettings( dataFile.head(), "masterpitch" );
if( m_playPos[Mode_PlaySong].m_timeLine )
{
// reset loop-point-state
m_playPos[Mode_PlaySong].m_timeLine->toggleLoopPoints( 0 );
}
if( !dataFile.content().firstChildElement( "track" ).isNull() )
{
m_globalAutomationTrack->restoreState( dataFile.content().
firstChildElement( "track" ) );
}
//Backward compatibility for LMMS <= 0.4.15
PeakController::initGetControllerBySetting();
// Load mixer first to be able to set the correct range for FX channels
node = dataFile.content().firstChildElement( Engine::fxMixer()->nodeName() );
if( !node.isNull() )
{
Engine::fxMixer()->restoreState( node.toElement() );
if( gui )
{
// refresh FxMixerView
gui->fxMixerView()->refreshDisplay();
}
}
node = dataFile.content().firstChild();
QDomNodeList tclist=dataFile.content().elementsByTagName("trackcontainer");
m_nLoadingTrack=0;
for( int i=0,n=tclist.count(); i<n; ++i )
{
QDomNode nd=tclist.at(i).firstChild();
while(!nd.isNull())
{
if( nd.isElement() && nd.nodeName() == "track" )
{
++m_nLoadingTrack;
if( nd.toElement().attribute("type").toInt() == Track::BBTrack )
{
n += nd.toElement().elementsByTagName("bbtrack").at(0)
.toElement().firstChildElement().childNodes().count();
}
nd=nd.nextSibling();
}
}
}
while( !node.isNull() )
{
if( node.isElement() )
{
if( node.nodeName() == "trackcontainer" )
{
( (JournallingObject *)( this ) )->restoreState( node.toElement() );
}
else if( node.nodeName() == "controllers" )
{
restoreControllerStates( node.toElement() );
}
else if( gui )
{
if( node.nodeName() == gui->getControllerRackView()->nodeName() )
{
gui->getControllerRackView()->restoreState( node.toElement() );
}
else if( node.nodeName() == gui->pianoRoll()->nodeName() )
{
gui->pianoRoll()->restoreState( node.toElement() );
}
else if( node.nodeName() == gui->automationEditor()->m_editor->nodeName() )
{
gui->automationEditor()->m_editor->restoreState( node.toElement() );
}
else if( node.nodeName() == gui->getProjectNotes()->nodeName() )
{
gui->getProjectNotes()->SerializingObject::restoreState( node.toElement() );
}
else if( node.nodeName() == m_playPos[Mode_PlaySong].m_timeLine->nodeName() )
{
m_playPos[Mode_PlaySong].m_timeLine->restoreState( node.toElement() );
}
}
}
node = node.nextSibling();
}
// quirk for fixing projects with broken positions of TCOs inside
// BB-tracks
Engine::getBBTrackContainer()->fixIncorrectPositions();
// Connect controller links to their controllers
// now that everything is loaded
ControllerConnection::finalizeConnections();
// resolve all IDs so that autoModels are automated
AutomationPattern::resolveAllIDs();
Engine::mixer()->doneChangeInModel();
ConfigManager::inst()->addRecentlyOpenedProject( fileName );
Engine::projectJournal()->setJournalling( true );
emit projectLoaded();
if ( hasErrors())
{
if ( gui )
{
QMessageBox::warning( NULL, tr("LMMS Error report"), errorSummary(),
QMessageBox::Ok );
}
else
{
QTextStream(stderr) << Engine::getSong()->errorSummary() << endl;
}
}
m_loadingProject = false;
m_modified = false;
m_loadOnLaunch = false;
if( gui && gui->mainWindow() )
{
gui->mainWindow()->resetWindowTitle();
}
}
//------------------------------------------------------------------------------
//
std::auto_ptr<XxDiffs> XxBuilderDirs2::process(
const QString& command,
XxBuffer& buffer1,
XxBuffer& buffer2
)
{
initLines();
QString path1 = buffer1.getName();
QString path2 = buffer2.getName();
QStringList filenames;
filenames.append( path1 );
filenames.append( path2 );
QStringList out_args;
QString executable;
XxUtil::splitArgs( command, filenames, executable, out_args );
QProcess diffProc;
diffProc.start( executable, out_args );
if ( ! diffProc.waitForStarted() ) {
throw XxIoError( XX_EXC_PARAMS );
}
diffProc.waitForReadyRead();
diffProc.setReadChannel( QProcess::StandardOutput );
std::vector<DirDiffType> types1;
std::vector<DirDiffType> types2;
QTextStream errors( &_errors );
// Note: for now we don't support recursive diffs built against a directory.
if ( _buildSolelyFromOutput || _isDiffRecursive ) {
buildSolelyFromOutput(
diffProc, errors, buffer1, buffer2, types1, types2
);
}
else {
buildAgainstReadDirectory(
diffProc, errors, buffer1, buffer2, types1, types2
);
}
#ifdef LOCAL_TRACE
XX_TRACE( "------------------------------" );
for ( unsigned int ii = 0; ii < types1.size(); ++ii ) {
XX_TRACE( typeString[ types1[ii] ] );
}
XX_TRACE( "------------------------------" );
XX_TRACE( "------------------------------" );
for ( unsigned int ii = 0; ii < types2.size(); ++ii ) {
XX_TRACE( typeString[ types2[ii] ] );
}
XX_TRACE( "------------------------------" );
#endif
XxFln fline1 = 1;
XxFln fline2 = 1;
{
// Create regions with it. Hopefully our searches resulted in something
// coherent w.r.t. to the quantities and pair matching of entries. Barf if
// it doesn't.
std::vector<DirDiffType>::const_iterator it1 = types1.begin();
std::vector<DirDiffType>::const_iterator it2 = types2.begin();
while ( it1 != types1.end() || it2 != types2.end() ) {
if ( it1 == types1.end() ) {
if ( *it2 != ONLY_IN ) {
throw XxInternalError( XX_EXC_PARAMS );
}
XxLine line( XxLine::INSERT_2, -1, fline2++ );
addLine( line );
++it2;
continue;
}
if ( it2 == types2.end() ) {
if ( *it1 != ONLY_IN ) {
throw XxInternalError( XX_EXC_PARAMS );
}
XxLine line( XxLine::INSERT_1, fline1++, -1 );
addLine( line );
++it1;
continue;
}
if ( *it1 == ONLY_IN ) {
XxLine line( XxLine::INSERT_1, fline1++, -1 );
addLine( line );
++it1;
}
else if ( *it2 == ONLY_IN ) {
XxLine line( XxLine::INSERT_2, -1, fline2++ );
addLine( line );
++it2;
}
else if ( *it1 == DIFFER ) {
if ( *it2 != *it1 ) {
throw XxInternalError( XX_EXC_PARAMS );
}
XxLine::Type dtype =
_ignoreFileChanges == true ? XxLine::SAME : XxLine::DIFF_ALL;
XxLine line( dtype, fline1++, fline2++ );
addLine( line );
++it1;
++it2;
}
else if ( *it1 == IDENTICAL ) {
if ( *it2 != *it1 ) {
throw XxInternalError( XX_EXC_PARAMS );
}
XxLine line( XxLine::SAME, fline1++, fline2++ );
addLine( line );
++it1;
++it2;
}
else if ( *it1 == COMMON_SUBDIR ) {
if ( *it2 != *it1 ) {
throw XxInternalError( XX_EXC_PARAMS );
}
XxLine line( XxLine::DIRECTORIES, fline1++, fline2++ );
addLine( line );
++it1;
++it2;
}
else {
XX_ASSERT( false );
}
}
}
// Create hunks.
if ( _lines.size() > 0 ) {
XxHunk curHunk = 0;
XxLine::Type prevType = _lines[0].getType();
_lines[0].setHunkId( curHunk );
for ( XxDln ii = 1; ii < XxDln(_lines.size()); ++ii ) {
XxLine& cline = _lines[ii];
if ( prevType != cline.getType() ) {
++curHunk;
prevType = cline.getType();
}
cline.setHunkId( curHunk );
}
}
diffProc.waitForFinished();
// Collect stderr.
QString errstr = diffProc.readAllStandardError();
if ( ! errstr.isEmpty() ) {
errors << errstr << endl;
}
_status = ( diffProc.exitStatus() == QProcess::NormalExit ) ? diffProc.exitCode() : 2;
// Saved error text.
errors << flush;
XX_LOCAL_TRACE( "Errors: " << _errors );
// If we've read no lines and there are diff errors then blow off
if ( ( fline1 == 1 ) && ( fline2 == 1 ) && hasErrors() ) {
throw XxIoError( XX_EXC_PARAMS );
}
std::auto_ptr<XxDiffs> ap( new XxDiffs( _lines, true ) );
return ap;
}
bool Form::valid()
{
return FormElement::valid() && root().size() > 0 && !hasErrors();
}
/// Configuration : TESTING
/// Function name : verifyScriptTranslationTestCase
// Description : Verify the results of a Script Translation test case
//
// CONST UINT iTestCaseID : [in] TestCase ID
// CONST OPERATION_DATA* pOperationData : [in] Operation data for the test case
//
// Return Value : TRUE if validated succesfully, FALSE otherwise
//
BOOL verifyScriptTranslationTestCase(CONST UINT iTestCaseID, CONST OPERATION_DATA* pOperationData)
{
OPERATION_RESULT eDesiredResult; // Correct result for the current TestCase
ERROR_QUEUE* pErrorQueue; // Convenience pointer for the thread error queue
BOOL bVerified; // Verifcation result, defaults to FALSE
// Prepare
pErrorQueue = pOperationData->pErrorQueue;
bVerified = FALSE;
/// Verify ErrorQueue and Operation Result
switch (iTestCaseID)
{
/// [050: MISSING SCRIPT TAG] - Check for 'Missing <Script> Tag' (+ 'Unexpected closing tag')
// [CRITICAL ERROR]
case TC_MISSING_SCRIPT_TAG:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 2, IDS_SCRIPT_TAG_MISSING, IDS_XML_UNEXPECTED_CLOSING_TAG);
eDesiredResult = OR_FAILURE;
break;
/// [051: MISSING CODEARRAY TAG] - Check for 'Missing <codearray> Tag' (+ 'Unexpected closing tag')
// [CRITICAL ERROR]
case TC_MISSING_CODEARRAY_TAG:
#ifdef _DEBUG
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 2, IDS_CODEARRAY_TAG_MISSING, IDS_XML_MISMATCHED_CLOSING_TAG);
#else
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 3, IDS_CODEARRAY_TAG_MISSING, IDS_XML_UNEXPECTED_CLOSING_BRACKET, IDS_XML_MISMATCHED_CLOSING_TAG);
#endif
eDesiredResult = OR_FAILURE;
break;
/// [052-056: MISSING SCRIPT PROPERTY TAG] - Check for 'Missing Property Tag' (+ 'Unexpected closing tag')
// [CRITICAL ERROR]
case TC_MISSING_NAME_TAG:
case TC_MISSING_DESCRIPTION_TAG:
case TC_MISSING_ENGINEVERSION_TAG:
case TC_MISSING_VERSION_TAG:
case TC_MISSING_ARGUMENTS_TAG:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_SCRIPT_PROPERTY_TAG_MISSING);
eDesiredResult = OR_FAILURE;
break;
/// [057: MISSING SOURCETEXT TAG] - Check for 'Missing Property Tag' (+ 'Unexpected closing tag')
// [NO ERROR]
case TC_MISSING_SOURCETEXT_TAG:
bVerified = !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [058: INCORRECT CODEARRAY SIZE] - Check for 'Invalid CodeArray'
// [CRITICAL ERROR]
case TC_CODEARRAY_INCORRECT_SIZE:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_CODEARRAY_INVALID);
eDesiredResult = OR_FAILURE;
break;
/// [059: INVALID STANDARD BRANCH] - Check for 'Invalid Standard Branch'
// [CRITICAL ERROR]
case TC_CODEARRAY_INVALID_STANDARD_BRANCH:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_CODEARRAY_STANDARD_BRANCH_INVALID);
eDesiredResult = OR_FAILURE;
break;
/// [060: EMPTY STANDARD BRANCH] - Check for 'Empty Standard Branch'
// [CRITICAL ERROR]
case TC_CODEARRAY_EMPTY_STANDARD_BRANCH:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_CODEARRAY_STANDARD_BRANCH_EMPTY);
eDesiredResult = OR_FAILURE;
break;
/// [061: INVALID AUXILIARY BRANCH] - Check for 'Invalid Auxiliary Branch'
// [CRITICAL ERROR]
case TC_CODEARRAY_INVALID_AUXILIARY_BRANCH:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_CODEARRAY_AUXILIARY_BRANCH_INVALID);
eDesiredResult = OR_FAILURE;
break;
/// [062: INVALID VARIABLES BRANCH] - Check for 'Invalid Variables Branch'
// [CRITICAL ERROR]
case TC_CODEARRAY_INVALID_VARIABLES_BRANCH:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_CODEARRAY_VARIABLES_BRANCH_INVALID);
eDesiredResult = OR_FAILURE;
break;
/// [063: MISSING COMMAND ID] - Check for 'Missing Command ID'
// [CRITICAL ERROR]
case TC_CODEARRAY_MISSING_COMMAND_ID:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_CODEARRAY_COMMAND_ID_MISSING);
eDesiredResult = OR_FAILURE;
break;
/// [065: MISSING SCRIPT DESCRIPTION] - No Error
// [NO ERROR]
case TC_MISSING_SCRIPT_DESCRIPTION:
bVerified = !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [064, 066, 067: MISSING SCRIPT NAME/VERSION/ENGINEVERSION] - Check for 'Missing Script property'
// [CRITICAL ERROR]
case TC_MISSING_SCRIPT_NAME:
case TC_MISSING_SCRIPT_VERSION:
case TC_MISSING_SCRIPT_ENGINEVERSION:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_SCRIPT_PROPERTY_TAG_MISSING);
eDesiredResult = OR_FAILURE;
break;
/// [068: ASSIGNMENT] - Ensure result is '$a = $b'
// [NO ERROR]
case TC_EXPRESSION_ASSIGNMENT:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("$a = $b"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [069: SIMPLE SMALL EXPRESSION] - Ensure result is '$a = $b + $c'
// [NO ERROR]
case TC_EXPRESSION_SIMPLE_SMALL:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("$a = $b + $c"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [070: SIMPLE LARGE EXPRESSION] - Ensure result is '$a = $b + $c - $d / $e * $f AND ($g OR ! $h)'
// [NO ERROR]
case TC_EXPRESSION_SIMPLE_LARGE:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("$a = $b + $c - $d / $e * $f AND ($g OR !$h)"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [071: SIMPLE HUGE EXPRESSION] - Ensure result is '$a = $b + $c - $d / $e * $f AND ($g OR !$h) + $c * $d - ($e * $f + ($g - $h)) OR $b AND $c'
// [NO ERROR]
case TC_EXPRESSION_SIMPLE_HUGE:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("$a = $b + $c - $d / $e * $f AND ($g OR !$h) + $c * $d - ($e * $f + ($g - $h)) OR $b AND $c"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [072: COMPLEX SMALL EXPRESSION] - Ensure result is '$a = $b AND ($c == {1 GJ Shield})'
// [NO ERROR]
case TC_EXPRESSION_COMPLEX_SMALL:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("$a = $b AND ($c == {1 GJ Shield})"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [073: COMPLEX LARGE EXPRESSION] - Ensure result is '$a = $b AND ($c == {1 GJ Shield}) OR (5 >= 8) AND 'Hello' == {Banshee Missile}'
// [NO ERROR]
case TC_EXPRESSION_COMPLEX_LARGE:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("$a = $b AND ($c == {1 GJ Shield}) OR (5 >= 8) AND 'Hello' == {Banshee Missile}"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [074: 'IF' CONDITIONAL] - Ensure result is 'if $a == $b'
// [NO ERROR]
case TC_CONDITIONAL_IF:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("if $a == $b"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [075: 'IF NOT' CONDITIONAL] - Ensure result is 'if not $a == $b'
// [NO ERROR]
case TC_CONDITIONAL_IF_NOT:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("if not $a == $b"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [076: 'SKIP IF' CONDITIONAL] - Ensure result is 'skip if $a == $b'
// [NO ERROR]
case TC_CONDITIONAL_SKIP_IF:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("skip if $a == $b"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [077: 'SKIP IF NOT' CONDITIONAL] - Ensure result is 'skip if not $a == $b'
// [NO ERROR]
case TC_CONDITIONAL_SKIP_IF_NOT:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("skip if not $a == $b"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [078: 'WHILE' CONDITIONAL] - Ensure result is 'while $a == $b'
// [NO ERROR]
case TC_CONDITIONAL_WHILE:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("while $a == $b"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [079: 'WHILE NOT' CONDITIONAL] - Ensure result is 'while not $a == $b'
// [NO ERROR]
case TC_CONDITIONAL_WHILE_NOT:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("while not $a == $b"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [080: 'ELSE' CONDITIONAL] - Ensure result is 'else'
// [NO ERROR]
case TC_CONDITIONAL_ELSE:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 1, TEXT("else"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [081: 'ELSE IF' CONDITIONAL] - Ensure result is 'else if $a == $b'
// [NO ERROR]
case TC_CONDITIONAL_ELSE_IF:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 1, TEXT("else if $c == $d"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [082: 'ELSE IF NOT' CONDITIONAL] - Ensure result is 'else if not $a == $b'
// [NO ERROR]
case TC_CONDITIONAL_ELSE_IF_NOT:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 1, TEXT("else if not $c == $d"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [083: COMMENT COMMAND] - Ensure result is '* Example script'
// [NO ERROR]
case TC_COMMAND_COMMENT:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("* Example script"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [084: DEFINE LABEL] - Ensure result is 'start:'
// [NO ERROR]
case TC_COMMAND_LABEL:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 1, TEXT("start:"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [085: INCREMENT] - Ensure result is 'inc $a'
// [NO ERROR]
case TC_COMMAND_INCREMENT:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 3, TEXT("inc $a"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [086: DECREMENT] - Ensure result is 'dec $a'
// [NO ERROR]
case TC_COMMAND_DECREMENT:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 4, TEXT("dec $a"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [087: WAIT] - Ensure result is '= wait 40 ms'
// [NO ERROR]
case TC_COMMAND_WAIT:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 5, TEXT("= wait 40 ms"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [088: GOTO LABEL] - Ensure result is 'goto label start:'
// [NO ERROR]
case TC_COMMAND_GOTO_LABEL:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 6, TEXT("goto label start:"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [089: GOTO SUBROUTINE] - Ensure result is 'gosub start:'
// [NO ERROR]
case TC_COMMAND_GOTO_SUBROUTINE:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 7, TEXT("gosub start:"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [090: BREAK] - Ensure result is 'break'
// [NO ERROR]
case TC_COMMAND_BREAK:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 8, TEXT("break"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [091: CONTINUE] - Ensure result is 'continue'
// [NO ERROR]
case TC_COMMAND_CONTINUE:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 9, TEXT("continue"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [092: END] - Ensure result is 'end'
// [NO ERROR]
case TC_COMMAND_END:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 10, TEXT("end"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [093: RETURN] - Ensure result is 'return'
// [NO ERROR]
case TC_COMMAND_RETURN:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 11, TEXT("return null"))
AND !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [094: COMMAND NODE COUNT MISMATCH] - Check for 'SourceValue count mismatch'
// [MINOR ERROR]
case TC_COMMAND_NODE_COUNT_MISMATCH:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_SCRIPT_SOURCEVALUE_SIZE_MISMATCH);
eDesiredResult = OR_SUCCESS;
break;
/// [095: INCORRECT COMMAND NODE COUNT] - Check for 'Command node count incorrect'
// [MINOR ERROR]
case TC_COMMAND_NODE_COUNT_INCORRECT:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_SCRIPT_COMMAND_NODE_COUNT_MISMATCH);
eDesiredResult = OR_SUCCESS;
break;
/// [096: INVALID PARAMETER TYPE] - Check for 'Invalid parameter type'
// [MINOR ERROR]
case TC_PARAMETER_INVALID_TYPE:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_SCRIPT_PARAMETER_TUPLE_TYPE_INVALID);
eDesiredResult = OR_SUCCESS;
break;
/// [097: INVALID CONDITIONAL] - Check for 'Invalid conditional'
// [MINOR ERROR]
case TC_PARAMETER_INVALID_CONDITIONAL:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_RETURN_OBJECT_CONDITIONAL_INVALID);
eDesiredResult = OR_SUCCESS;
break;
/// [098: INVALID VARIABLE] - Check for 'Invalid variable ID'
// [MINOR ERROR]
case TC_PARAMETER_INVALID_VARIABLE_ID:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_TRANSLATION_VARIABLE_INVALID);
eDesiredResult = OR_SUCCESS;
break;
/// [099: INVALID COMMAND] - Check for 'Command syntax not found'
// [MINOR ERROR]
case TC_PARAMETER_INVALID_COMMAND_ID:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_SCRIPT_COMMAND_SYNTAX_MISSING);
eDesiredResult = OR_SUCCESS;
break;
/// [100: INVALID LABEL NUMBER] - Check for 'Label number not found'
// [MINOR ERROR]
case TC_PARAMETER_INVALID_LABEL_ID:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_SCRIPT_LABEL_NUMBER_NOT_FOUND);
eDesiredResult = OR_SUCCESS;
break;
/// [101: INVALID RETURN VARIABLE] - Check for 'Return variable invalid'
// [MINOR ERROR]
case TC_PARAMETER_INVALID_RETURN_VARIABLE:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_RETURN_OBJECT_VARIABLE_INVALID);
eDesiredResult = OR_SUCCESS;
break;
/// [102-117: VALID PARAMETER TYPE] - Ensure no errors
// [NO ERROR]
case TC_PARAMETER_VALID_CONSTANT:
case TC_PARAMETER_VALID_DATATYPE:
case TC_PARAMETER_VALID_FLIGHT_RETURN:
case TC_PARAMETER_VALID_OBJECT_CLASS:
case TC_PARAMETER_VALID_OBJECT_COMMAND:
case TC_PARAMETER_VALID_OPERATOR:
case TC_PARAMETER_VALID_SCRIPTDEF:
case TC_PARAMETER_VALID_SECTOR:
case TC_PARAMETER_VALID_SHIP:
case TC_PARAMETER_VALID_STATION:
case TC_PARAMETER_VALID_STATION_SERIAL:
case TC_PARAMETER_VALID_TRANSPORT_CLASS:
case TC_PARAMETER_VALID_RACE:
case TC_PARAMETER_VALID_RELATION:
case TC_PARAMETER_VALID_WARE:
case TC_PARAMETER_VALID_WING_COMMAND:
bVerified = !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [118,120-125,128-130,134: INVALID PARAMETER TYPE] - Check for 'Invalid parameter type'
// [MINOR ERROR]
case TC_PARAMETER_INVALID_CONSTANT:
case TC_PARAMETER_INVALID_FLIGHT_RETURN:
case TC_PARAMETER_INVALID_OBJECT_CLASS:
case TC_PARAMETER_INVALID_OBJECT_COMMAND:
case TC_PARAMETER_INVALID_OPERATOR:
case TC_PARAMETER_INVALID_SCRIPTDEF:
case TC_PARAMETER_INVALID_SECTOR:
case TC_PARAMETER_INVALID_STATION_SERIAL:
case TC_PARAMETER_INVALID_TRANSPORT_CLASS:
case TC_PARAMETER_INVALID_RACE:
case TC_PARAMETER_INVALID_WING_COMMAND:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_TRANSLATION_PARAMETER_INVALID);
eDesiredResult = OR_SUCCESS;
break;
/// [119+131: INVALID DATATYPE] - Check for 'Invalid parameter type'
// [MINOR ERROR]
case TC_PARAMETER_INVALID_DATATYPE:
case TC_PARAMETER_INVALID_RELATION:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_TRANSLATION_TYPE_CONVERSION_FAILED);
eDesiredResult = OR_SUCCESS;
break;
/// [126+127,132+133: INVALID SHIP, STATION or WARE] - Check for 'Invalid ware'
// [MINOR ERROR]
case TC_PARAMETER_INVALID_SHIP:
case TC_PARAMETER_INVALID_STATION:
case TC_PARAMETER_INVALID_WARE_MAINTYPE:
case TC_PARAMETER_INVALID_WARE_SUBTYPE:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_TRANSLATION_WARE_INVALID);
eDesiredResult = OR_SUCCESS;
break;
/// [135+137: HUGE STRING or COMMENT] - Ensure no errors
// [NO ERROR]
case TC_PARAMETER_STRING_HUGE:
case TC_PARAMETER_COMMENT_HUGE:
bVerified = !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [136,138,139: INVALID CHARACTERS in STRING or COMMENT or LABEL NAME]
// [MINOR ERROR]
case TC_PARAMETER_STRING_ILLEGAL_CHARS:
case TC_PARAMETER_COMMENT_ILLEGAL_CHARS:
case TC_LABEL_NAME_ILLEGAL_CHARS:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 3, IDS_SCRIPT_SOURCEVALUE_SIZE_MISMATCH, IDS_XML_UNEXPECTED_CLOSING_BRACKET, IDS_SCRIPT_SOURCEVALUE_SIZE_MISMATCH);
eDesiredResult = OR_SUCCESS;
break;
/// [140,141: INVALID CHARACTERS in a SCRIPT NAME or DESCRIPTION]
// [MINOR ERROR]
case TC_SCRIPT_NAME_ILLEGAL_CHARS:
case TC_SCRIPT_DESCRIPTION_ILLEGAL_CHARS:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 5, IDS_XML_UNEXPECTED_OPENING_BRACKET, IDS_XML_UNEXPECTED_CLOSING_BRACKET, IDS_XML_MISMATCHED_CLOSING_TAG, IDS_XML_UNCLOSED_OPENING_TAG, IDS_XML_UNCLOSED_OPENING_TAG);
eDesiredResult = OR_SUCCESS;
break;
/// [142,143: INVALID CHARACTERS in an ARGUMENT NAME or DESCRIPTION]
// [MINOR ERROR]
case TC_ARGUMENT_NAME_ILLEGAL_CHARS:
case TC_ARGUMENT_DESCRIPTION_ILLEGAL_CHARS:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 2, IDS_XML_UNEXPECTED_OPENING_BRACKET, IDS_XML_UNEXPECTED_CLOSING_BRACKET);
eDesiredResult = OR_SUCCESS;
break;
/// [144: INVALID CHARACTERS in a SOURCE TEXT LINE]
// [MINOR ERROR]
case TC_SOURCE_TEXT_ILLEGAL_CHARS:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_XML_UNEXPECTED_CLOSING_BRACKET);
eDesiredResult = OR_SUCCESS;
break;
/// [145: INVALID ARGUMENT INDEX]
// [ERROR CANNOT BE DETECTED]
case TC_ARGUMENT_INVALID_INDEX:
bVerified = !hasErrors(pErrorQueue);
eDesiredResult = OR_SUCCESS;
break;
/// [146: INVALID ARGUMENT TYPE]
// [CRITICAL ERROR]
case TC_ARGUMENT_INVALID_TYPE:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_SCRIPT_ARGUMENT_TYPE_INVALID);
eDesiredResult = OR_FAILURE;
break;
/// [147: UNSUPPORTED ENGINE VERSION]
// [MINOR ERROR]
case TC_ENGINE_VERSION_UNSUPPORTED:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_SCRIPT_ENGINE_VERSION_MISMATCH);
eDesiredResult = OR_SUCCESS;
break;
/// [148: MISSING SCRIPT TARGET]
// [MINOR ERROR]
case TC_SCRIPT_CALL_TARGET_MISSING:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 2, IDS_XML_UNEXPECTED_CLOSING_BRACKET, IDS_SCRIPT_LOAD_IO_ERROR);
eDesiredResult = OR_SUCCESS;
break;
/// [149: SCRIPT TARGET CORRUPT]
// [MINOR ERROR]
case TC_SCRIPT_CALL_TARGET_CORRUPT:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 2, IDS_XML_UNEXPECTED_CLOSING_BRACKET, IDS_SCRIPT_PROPERTY_TAG_MISSING);
eDesiredResult = OR_SUCCESS;
break;
/// [150: SCRIPT TARGET VALID]
// [MINOR ERROR]
case TC_SCRIPT_CALL_TARGET_VALID:
bVerified = checkCommandTranslation(pOperationData->pScriptFile->pCommandList, 0, TEXT("$a = [THIS]-> call script 'script.valid' : iWaitTime=42 szExample='Fandango' bDestroy=[TRUE]"))
AND checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_XML_UNEXPECTED_CLOSING_BRACKET);
eDesiredResult = OR_SUCCESS;
break;
/// [151: GAME STRING REFERENCE NOT FOUND]
// [MINOR ERROR]
case TC_GAME_STRING_REFERENCE_NOT_FOUND:
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 1, IDS_TRANSLATION_GAME_STRING_REFERENCE_NOT_FOUND);
eDesiredResult = OR_SUCCESS;
break;
}
/*
/// [0: ] - Check for ''
// [CRITICAL ERROR]
case :
bVerified = checkErrorQueueMessages(pErrorQueue, iTestCaseID, 2, IDS, IDS);
eDesiredResult = OR_FAILURE;
break;
*/
// [CHECK] Operation result
if (eDesiredResult != pOperationData->eResult)
{
CONSOLE("WARNING: TC.%03u Operation Result is '%s' when it should be '%s'", iTestCaseID, szOperationResults[pOperationData->eResult], szOperationResults[eDesiredResult]);
bVerified = FALSE;
}
// Return result
return bVerified;
}
bool ObjParser::parse( std::istream& input )
{
reset();
// Read each line of the .obj file
while ( readNextLine( input ) && !hasErrors() )
{
// Skip lines that are empty
if ( isCurrentLineEmpty() )
{
continue;
}
// Split the input line into "words' that are separated by
// spaces. The first word is the next obj file command, the others
// that follow are arguments to that command
std::vector<std::string> tokens;
tokenizeCommandString( lineText(), tokens );
assert( tokens.size() > 0 );
// What kind of command is this?
if ( tokens[0] == "v" )
{
processVertexPosition( tokens );
}
else if ( tokens[0] == "vt" )
{
processVertexTexCoord( tokens );
}
else if ( tokens[0] == "vn" )
{
processVertexNormal( tokens );
}
else if ( tokens[0] == "g" )
{
processGroup( tokens );
}
else if ( tokens[0] == "f" )
{
processFace( tokens );
}
else if ( tokens[0] == "usemtl" )
{
processMaterial( tokens );
}
else if ( tokens[0] == "mtllib" )
{
processMaterialLib( tokens );
}
else if ( tokens[0] == "s" )
{
// ignore smoothing groups
}
else
{
raiseError("Unknown .obj command encountered");
continue;
}
}
// Make sure the last group has at least one face in it
if ( m_objdata->currentGroup.empty() == false )
{
if ( m_objdata->groups[ m_objdata->currentGroupIndex ].count == 0 )
{
raiseError("The last active group didn't have any faces");
}
}
// Now we're done, make sure to return if the parsing was successful or
// not
return !hasErrors();
}
