mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-10-17 17:59:19 +02:00
3876945ef3
A baked heightfield was trusted for as long as its file was readable, and the logic container while the .scn was older than it: an edited include went unnoticed by both, and node keys leaned on file dates, so merely touching a file changed them. And cooking only ever happened as a side effect of starting a scenery. Every cooked artifact now has a manifest beside it - <scenario>.ehf.deps, <scenario>.logic.deps - listing each file it was made from with its size, modification time and a hash of its content (simulation/cookdeps). The parser records what it includes as it reads, so the list is exactly what the load read. An artifact is current when every listed file still has its content: size and time are the quick check, and when either differs the content is hashed, so a touched or copied file does not force a rebuild and an edited one always does. A file added to the scenery cannot be in a manifest; the files read are compared with it after the load, and a mismatch sends the terrain to be baked on the next start - the new file's nodes, whose keys are unknown, are drawn as geometry meanwhile - and the logic, cooked from the loaded state, is cooked at once. The terrain depends on what the scenario includes and not on the scenario file itself, which the launcher rewrites on every start; the logic depends on both, since events can be written in either, and costs milliseconds to cook again. With the manifest vouching for file content, a triangle node's key is its file, line, include parameters and placement, without the date. -cook loads a scenery, brings whatever is stale up to date, and quits: the step that prepares a scenery ahead of play. It closes the window directly, as there is no simulation to wind down; a quit command waited a minute in the queue for one. Baking on a first start stays as the fallback, and -nobaketerrain still turns it off. Tried on a copy of baltyk with a terrain include of its own: a fresh cook bakes and cooks everything, a second finds nothing to do, a touched file changes nothing, an edited include is caught by its hash and both artifacts are rebuilt, and a new include has the logic recooked at once and the terrain on the next run. A cooking run of baltyk takes 5.5 s with nothing stale and 10.7 s with everything to do.
190 lines
6.3 KiB
C++
190 lines
6.3 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// cParser -- generic class for parsing text data, either from file or provided string
|
|
module;
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <limits>
|
|
#include <mutex>
|
|
#include <ostream>
|
|
#include <type_traits>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
#include <cstddef>
|
|
#include <istream>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <deque>
|
|
#include <memory>
|
|
|
|
export module eu07.utilities.parser;
|
|
import eu07.glm;
|
|
|
|
export {
|
|
|
|
class cParser //: public std::stringstream
|
|
{
|
|
public:
|
|
// parameters:
|
|
enum buffertype
|
|
{
|
|
buffer_FILE,
|
|
buffer_TEXT
|
|
};
|
|
// constructors:
|
|
cParser(std::string const &Stream, buffertype const Type = buffer_TEXT, std::string Path = "", bool const Loadtraction = true, std::vector<std::string> Parameters = std::vector<std::string>(), bool allowRandom = false );
|
|
// destructor:
|
|
virtual ~cParser();
|
|
// methods:
|
|
template <typename Type_>
|
|
cParser &
|
|
operator>>( Type_ &Right );
|
|
template <typename Output_>
|
|
Output_
|
|
getToken( bool const ToLower = true, char const *Break = "\n\r\t ;" ) {
|
|
getTokens( 1, ToLower, Break );
|
|
Output_ output;
|
|
*this >> output;
|
|
return output; };
|
|
inline
|
|
void
|
|
ignoreToken() {
|
|
std::string out;
|
|
readToken(out); };
|
|
inline
|
|
bool
|
|
expectToken( std::string const &Value ) {
|
|
std::string out;
|
|
readToken(out);
|
|
return out == Value; };
|
|
inline
|
|
bool
|
|
eof() {
|
|
return mStream->eof(); };
|
|
inline
|
|
bool
|
|
ok() {
|
|
return !mStream->fail(); };
|
|
cParser &
|
|
autoclear( bool const Autoclear );
|
|
inline
|
|
bool
|
|
autoclear() const {
|
|
return m_autoclear; }
|
|
bool
|
|
getTokens( unsigned int Count = 1, bool ToLower = true, char const *Break = "\n\r\t ;" );
|
|
std::string readTokenFromStream(bool ToLower, const char *Break);
|
|
void stripFirstTokenBOM(std::string &token, bool ToLower, const char *Break);
|
|
void substituteParameters(std::string &token, bool ToLower);
|
|
void skipIncludeBlock();
|
|
// returns next incoming token, if any, without removing it from the set
|
|
inline
|
|
std::string
|
|
peek() const {
|
|
return false == tokens.empty() ? tokens.front() : ""; }
|
|
// inject string as internal include
|
|
void injectString(const std::string &str);
|
|
|
|
// returns percentage of file processed so far
|
|
int getProgress() const;
|
|
int getFullProgress() const;
|
|
//
|
|
static std::size_t countTokens( std::string const &Stream, std::string Path = "" );
|
|
// add custom definition of text which should be ignored when retrieving tokens
|
|
void addCommentStyle( std::string const &Commentstart, std::string const &Commentend );
|
|
// returns name of currently open file, or empty string for text type stream
|
|
std::string Name() const;
|
|
// returns number of currently processed line
|
|
std::size_t Line() const;
|
|
// parameters of the innermost file being read, the (pN) values its include line gave
|
|
std::vector<std::string> const & Parameters() const;
|
|
// collects into Into the path of every file this parser includes, and every file those
|
|
// include in turn. what a cooked artifact of a scenery depends on is exactly this list
|
|
void track_includes( std::shared_ptr<std::vector<std::string>> Into ) { mIncluded = std::move( Into ); }
|
|
// returns number of currently processed line in main file, -1 if inside include
|
|
int LineMain() const;
|
|
bool expandIncludes = true;
|
|
bool allowRandomIncludes = false;
|
|
bool skipComments = true;
|
|
|
|
private:
|
|
void startIncludeFromParser(cParser &srcParser, bool ToLower, std::string includefile);
|
|
bool handleIncludeIfPresent(std::string &token, bool ToLower, const char *Break);
|
|
// methods:
|
|
void readToken(std::string& out, bool ToLower = true, const char *Break = "\n\r\t ;");
|
|
static std::vector<std::string> readParameters( cParser &Input );
|
|
std::string readQuotes( char const Quote = '\"' );
|
|
void skipComment( std::string const &Endmark );
|
|
bool findQuotes( std::string &String );
|
|
bool trimComments( std::string &String );
|
|
std::size_t count();
|
|
// members:
|
|
bool m_autoclear { true }; // unretrieved tokens are discarded when another read command is issued (legacy behaviour)
|
|
std::shared_ptr<std::vector<std::string>> mIncluded; // where included files are recorded, if anywhere
|
|
bool LoadTraction { true }; // load traction?
|
|
std::shared_ptr<std::istream> mStream; // relevant kind of buffer is attached on creation.
|
|
std::string mFile; // name of the open file, if any
|
|
std::string mPath; // path to open stream, for relative path lookups.
|
|
std::streamoff mSize { 0 }; // size of open stream, for progress report.
|
|
std::size_t mLine { 0 }; // currently processed line
|
|
bool mIncFile { false }; // the parser is processing an *.inc file
|
|
bool mFirstToken { true }; // processing first token in the current file; helper used when checking for utf bom
|
|
typedef std::map<std::string, std::string> commentmap;
|
|
commentmap mComments {
|
|
commentmap::value_type( "/*", "*/" ),
|
|
commentmap::value_type( "//", "\n" ) };
|
|
std::shared_ptr<cParser> mIncludeParser; // child class to handle include directives.
|
|
std::vector<std::string> parameters; // parameter list for included file.
|
|
std::deque<std::string> tokens;
|
|
};
|
|
|
|
|
|
} // export -- out-of-line member definitions and explicit
|
|
// specialisations are not namespace-scope declarations, so they cannot
|
|
// carry `export`; the class itself is exported and that is what counts.
|
|
template <>
|
|
glm::vec3
|
|
cParser::getToken( bool const ToLower, const char *Break );
|
|
|
|
|
|
template<typename Type_>
|
|
cParser&
|
|
cParser::operator>>( Type_ &Right ) {
|
|
|
|
if( true == this->tokens.empty() ) { return *this; }
|
|
|
|
std::stringstream converter( this->tokens.front() );
|
|
converter >> Right;
|
|
this->tokens.pop_front();
|
|
|
|
return *this;
|
|
}
|
|
|
|
template<>
|
|
cParser&
|
|
cParser::operator>>( std::string &Right );
|
|
|
|
template<>
|
|
cParser&
|
|
cParser::operator>>( bool &Right );
|
|
|
|
template<>
|
|
bool
|
|
cParser::getToken<bool>( bool const ToLower, const char *Break );
|
|
export {
|
|
|
|
} // export
|