C++ idParser::Warning方法代码示例

/*
================
idDict::Parse
================
*/
bool idDict::Parse( idParser &parser ) {
	idToken	token;
	idToken	token2;
	bool	errors;

	errors = false;

	parser.ExpectTokenString( "{" );
	parser.ReadToken( &token );
	while( ( token.type != TT_PUNCTUATION ) || ( token != "}" ) ) {
		if ( token.type != TT_STRING ) {
			parser.Error( "Expected quoted string, but found '%s'", token.c_str() );
		}

		if ( !parser.ReadToken( &token2 ) ) {
			parser.Error( "Unexpected end of file" );
		}

		if ( FindKey( token ) ) {
			parser.Warning( "'%s' already defined", token.c_str() );
			errors = true;
		}
		Set( token, token2 );

		if ( !parser.ReadToken( &token ) ) {
			parser.Error( "Unexpected end of file" );
		}
	}

	return !errors;
}

/*
================
idTypeInfoGen::GetFloatConstant
================
*/
float idTypeInfoGen::GetFloatConstant( const char *scope, const char *name, idParser &src ) {
	idConstantInfo *constant = FindConstant( idStr( scope ) + name );
	if ( constant == NULL ) {
		constant = FindConstant( name );
	}
	if ( constant ) {
		return EvaluateFloatString( constant->value );
	}
	src.Warning( "unknown value '%s' in constant expression", name );
	return 0;
}

/*
================
sdPersistentRankInfo::Parse
================
*/
bool sdPersistentRankInfo::Parse( idParser& src ) {
	idToken token;

	while ( true ) {
		if ( src.ReadToken( &token ) == 0 ) {
			break;
		}

		if ( token.Icmp( "badge" ) == 0 ) {
			if ( !ParseBadge( src ) ) {
				return false;
			}
		} else {
			src.Warning( "Unexpected Token: '%s'", token.c_str() );
			return false;
		}
	}

	return true;
}

//.........这里部分代码省略.........
				time = TLTIME_END;
			} else {
				src.Error( "sdDeclToolTip::ParseTimeline number expected for 'onTime'" );
				return false;
			}

			timelinePair_t event;
			event.first = time;

			if ( timeline.Num() > 0 ) {
				timelinePair_t lastEvent = timeline.Back();
				if ( lastEvent.first > time && time != TLTIME_END ) {
					src.Error( "sdDeclToolTip::ParseTimeline time  events must be in increasing order: '%i'", time );
					return false;
				}
			}

			src.ReadToken( &token );

			if ( !token.Icmp( "guiEvent" ) ) {
				
				event.second.eventType = TL_GUIEVENT;

				if( !src.ExpectTokenType( TT_STRING, 0, &token ) ) {
					src.Error( "sdDeclToolTip::ParseTimeline string expected after 'guiEvent'" );
					return false;
				}

				event.second.arg1 = token;

			} else if ( !token.Icmp( "pause" ) ) {
				event.second.eventType = TL_PAUSE;
			} else if ( !token.Icmp( "unpause" ) ) {
				event.second.eventType = TL_UNPAUSE;
			} else if ( !token.Icmp( "showInventory" ) ) {

				event.second.eventType = TL_SHOWINVENTORY;

				if( !src.ExpectTokenType( TT_STRING, 0, &token ) ) {
					src.Error( "sdDeclToolTip::ParseTimeline string expected after 'guiEvent'" );
					return false;
				}

				event.second.arg1 = token;

			} else if ( !token.Icmp( "hideInventory" ) ) {
				event.second.eventType = TL_HIDEINVENTORY;
			} else if ( !token.Icmp( "waypointHighlight" ) )  {

				event.second.eventType = TL_WAYPOINTHIGHLIGHT;

				if( !src.ExpectTokenType( TT_STRING, 0, &token ) ) {
					src.Error( "sdDeclToolTip::ParseTimeline string expected after 'guiEvent'" );
					return false;
				}

				event.second.arg1 = token;

			} else if ( !token.Icmp( "lookAtTask" ) ) {

				event.second.eventType = TL_LOOKATTASK;

			} else {
				src.Error( "sdDeclToolTip::ParseTimeline unexpected timeline event '%s'", token.c_str() );
				return false;
			}


			timeline.Append( event );

		} else if ( !token.Icmp( "unpauseWeaponSlot" ) ) {

			if( !src.ExpectTokenType( TT_NUMBER, 0, &token ) ) {
				src.Error( "sdDeclToolTip::ParseTimeline number expected after 'unpauseWeaponSlot'" );
				return false;
			}

			unpauseWeaponSlot = token.GetIntValue();

			if ( unpauseWeaponSlot > 9 || unpauseWeaponSlot < 0 ) {
				src.Warning( "sdDeclToolTip::ParseTimeline 0-9 expected as value for 'unpauseWeaponSlot'" );
				unpauseWeaponSlot = -1;
			}

			unpauseKeyString.SetKey( va( "_weapon%i", unpauseWeaponSlot - 1 ) );

		} else if( !token.Cmp( "}" ) ) {

			break;

		} else {

			src.Error( "sdDeclToolTip::ParseTimeline Invalid Token '%s'", token.c_str() );
			return false;

		}
	}

	return true;
}

/*
====================
idModelExport::ParseExportSection
====================
*/
int idModelExport::ParseExportSection( idParser &parser ) {
	idToken	command;
	idToken	token;
	idStr	defaultCommands;
	idLexer lex;
	idStr	temp;
	idStr	parms;
	int		count;
	// only export sections that match our export mask
	if( g_exportMask.GetString()[ 0 ] ) {
		if( parser.CheckTokenString( "{" ) ) {
			parser.SkipBracedSection( false );
			return 0;
		}
		parser.ReadToken( &token );
		if( token.Icmp( g_exportMask.GetString() ) ) {
			parser.SkipBracedSection();
			return 0;
		}
		parser.ExpectTokenString( "{" );
	} else if( !parser.CheckTokenString( "{" ) ) {
		// skip the export mask
		parser.ReadToken( &token );
		parser.ExpectTokenString( "{" );
	}
	count = 0;
	lex.SetFlags( LEXFL_NOSTRINGCONCAT | LEXFL_ALLOWPATHNAMES | LEXFL_ALLOWMULTICHARLITERALS | LEXFL_ALLOWBACKSLASHSTRINGCONCAT );
	while( 1 ) {
		if( !parser.ReadToken( &command ) ) {
			parser.Error( "Unexpoected end-of-file" );
			break;
		}
		if( command == "}" ) {
			break;
		}
		if( command == "options" ) {
			parser.ParseRestOfLine( defaultCommands );
		} else if( command == "addoptions" ) {
			parser.ParseRestOfLine( temp );
			defaultCommands += " ";
			defaultCommands += temp;
		} else if( ( command == "mesh" ) || ( command == "anim" ) || ( command == "camera" ) ) {
			if( !parser.ReadToken( &token ) ) {
				parser.Error( "Expected filename" );
			}
			temp = token;
			parser.ParseRestOfLine( parms );
			if( defaultCommands.Length() ) {
				sprintf( temp, "%s %s", temp.c_str(), defaultCommands.c_str() );
			}
			if( parms.Length() ) {
				sprintf( temp, "%s %s", temp.c_str(), parms.c_str() );
			}
			lex.LoadMemory( temp, temp.Length(), parser.GetFileName() );
			Reset();
			if( ParseOptions( lex ) ) {
				const char *game = cvarSystem->GetCVarString( "fs_game" );
				if( strlen( game ) == 0 ) {
					game = BASE_GAMEDIR;
				}
				if( command == "mesh" ) {
					dest.SetFileExtension( MD5_MESH_EXT );
				} else if( command == "anim" ) {
					dest.SetFileExtension( MD5_ANIM_EXT );
				} else if( command == "camera" ) {
					dest.SetFileExtension( MD5_CAMERA_EXT );
				} else {
					dest.SetFileExtension( command );
				}
				idStr back = commandLine;
				sprintf( commandLine, "%s %s -dest %s -game %s%s", command.c_str(), src.c_str(), dest.c_str(), game, commandLine.c_str() );
				if( ConvertMayaToMD5() ) {
					count++;
				} else {
					parser.Warning( "Failed to export '%s' : %s", src.c_str(), Maya_Error.c_str() );
				}
			}
			lex.FreeSource();
		} else {
			parser.Error( "Unknown token: %s", command.c_str() );
			parser.SkipBracedSection( false );
			break;
		}
	}
	return count;
}

/*
================
sdPersistentRankInfo::ParseBadge
================
*/
bool sdPersistentRankInfo::ParseBadge( idParser& src ) {
	if ( !src.ExpectTokenString( "{" ) ) {
		return false;
	}

	sdBadge& badge = badges.Alloc();
	badge.category = "";
	badge.title = "";

	idToken token;

	while ( true ) {
		if ( src.ReadToken( &token ) == 0 ) {
			src.Warning( "Unexpected End of File" );
			return false;
		}

		if ( token.Icmp( "task" ) == 0 ) {
			idDict taskInfo;
			if ( !taskInfo.Parse( src ) ) {
				return false;
			}

			sdBadge::sdTask& task = badge.tasks.Alloc();
			task.Clear();
			task.total = taskInfo.GetFloat( "total" );
			task.text = taskInfo.GetString( "text" );

			const idKeyValue* match = NULL;
			while ( ( match = taskInfo.MatchPrefix( "field", match ) ) != NULL ) {
				task.fields.Alloc() = match->GetValue();
			}
			
		} else if ( token.Icmp( "category" ) == 0 ) {
			if ( src.ReadToken( &token ) == 0 ) {
				return false;
			}

			badge.category = token;
		} else if ( token.Icmp( "title" ) == 0 ) {
			if ( src.ReadToken( &token ) == 0 ) {
				return false;
			}

			badge.title = token;
		} else if ( token.Icmp( "level" ) == 0 ) {
			if ( src.ReadToken( &token ) == 0 ) {
				return false;
			}

			badge.level = token.GetIntValue();
		} else if ( token.Icmp( "alwaysAvailable" ) == 0 ) {
			badge.alwaysAvailable = true;
		}  else if ( token.Icmp( "}" ) == 0 ) {
			break;
		} else {
			src.Warning( "Unexpected Token: '%s'", token.c_str() );
			return false;
		}
	}

	return true;
}