string_view refactor

This commit is contained in:
Jack Andersen 2017-11-12 20:13:53 -10:00
parent 942032688d
commit 4111d49d64
28 changed files with 388 additions and 406 deletions

View File

@ -2,7 +2,7 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR) # because of CMAKE_CXX_STANDARD cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR) # because of CMAKE_CXX_STANDARD
project(hecl) project(hecl)
set(CMAKE_CXX_STANDARD 14) set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD_REQUIRED ON)
if(MSVC) if(MSVC)

View File

@ -51,8 +51,8 @@ public:
LogModule.report(logvisor::Fatal, LogModule.report(logvisor::Fatal,
_S("hecl cook can only process multiple items in the same project; ") _S("hecl cook can only process multiple items in the same project; ")
_S("'%s' and '%s' are different projects"), _S("'%s' and '%s' are different projects"),
m_fallbackProj->getProjectRootPath().getAbsolutePath().c_str(), m_fallbackProj->getProjectRootPath().getAbsolutePath().data(),
root.getAbsolutePath().c_str()); root.getAbsolutePath().data());
m_selectedItems.emplace_back(*m_useProj, subPath); m_selectedItems.emplace_back(*m_useProj, subPath);
} }
} }

View File

@ -159,9 +159,9 @@ public:
for (SpecExtractPass& ds : m_specPasses) for (SpecExtractPass& ds : m_specPasses)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" MAGENTA BOLD "Using DataSpec %s:" NORMAL "\n"), ds.m_entry->m_name); hecl::Printf(_S("" MAGENTA BOLD "Using DataSpec %s:" NORMAL "\n"), ds.m_entry->m_name.data());
else else
hecl::Printf(_S("Using DataSpec %s:\n"), ds.m_entry->m_name); hecl::Printf(_S("Using DataSpec %s:\n"), ds.m_entry->m_name.data());
int lineIdx = 0; int lineIdx = 0;
ds.m_instance->doExtract(m_einfo, ds.m_instance->doExtract(m_einfo,

View File

@ -23,9 +23,9 @@ class ToolPackage final : public ToolBase
void CheckFile(const hecl::ProjectPath& path) void CheckFile(const hecl::ProjectPath& path)
{ {
if (!hecl::StrCmp(path.getLastComponent(), _S("!world.blend"))) if (!hecl::StrCmp(path.getLastComponent().data(), _S("!world.blend")))
AddSelectedItem(path); AddSelectedItem(path);
else if (!hecl::StrCmp(path.getLastComponent(), _S("!original_ids.yaml"))) else if (!hecl::StrCmp(path.getLastComponent().data(), _S("!original_ids.yaml")))
{ {
auto pathComps = path.getPathComponents(); auto pathComps = path.getPathComponents();
if (pathComps.size() == 2 && pathComps[0] != _S("out")) if (pathComps.size() == 2 && pathComps[0] != _S("out"))
@ -100,8 +100,8 @@ public:
LogModule.report(logvisor::Fatal, LogModule.report(logvisor::Fatal,
_S("hecl package can only process multiple items in the same project; ") _S("hecl package can only process multiple items in the same project; ")
_S("'%s' and '%s' are different projects"), _S("'%s' and '%s' are different projects"),
m_fallbackProj->getProjectRootPath().getAbsolutePath().c_str(), m_fallbackProj->getProjectRootPath().getAbsolutePath().data(),
root.getAbsolutePath().c_str()); root.getAbsolutePath().data());
FindSelectedItems({*m_useProj, subPath}, true); FindSelectedItems({*m_useProj, subPath}, true);
} }
@ -172,7 +172,7 @@ public:
hecl::Printf(_S("ABOUT TO PACKAGE:\n")); hecl::Printf(_S("ABOUT TO PACKAGE:\n"));
for (auto& item : m_selectedItems) for (auto& item : m_selectedItems)
hecl::Printf(_S("%s\n"), item.getRelativePath().c_str()); hecl::Printf(_S("%s\n"), item.getRelativePath().data());
if (continuePrompt()) if (continuePrompt())
{ {
@ -180,7 +180,7 @@ public:
for (const hecl::ProjectPath& path : m_selectedItems) for (const hecl::ProjectPath& path : m_selectedItems)
{ {
if (!m_useProj->packagePath(path, {}, m_fast, &cp)) if (!m_useProj->packagePath(path, {}, m_fast, &cp))
LogModule.report(logvisor::Error, _S("Unable to package %s"), path.getAbsolutePath().c_str()); LogModule.report(logvisor::Error, _S("Unable to package %s"), path.getAbsolutePath().data());
} }
cp.waitUntilComplete(); cp.waitUntilComplete();
} }

View File

@ -95,10 +95,10 @@ public:
for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY) for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" BOLD CYAN "%s" NORMAL "\n"), spec->m_name); hecl::Printf(_S("" BOLD CYAN "%s" NORMAL "\n"), spec->m_name.data());
else else
hecl::Printf(_S("%s\n"), spec->m_name); hecl::Printf(_S("%s\n"), spec->m_name.data());
hecl::Printf(_S(" %s\n"), spec->m_desc); hecl::Printf(_S(" %s\n"), spec->m_desc.data());
} }
return 0; return 0;
} }
@ -109,9 +109,9 @@ public:
for (auto& spec : specs) for (auto& spec : specs)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" BOLD CYAN "%s" NORMAL ""), spec.spec.m_name); hecl::Printf(_S("" BOLD CYAN "%s" NORMAL ""), spec.spec.m_name.data());
else else
hecl::Printf(_S("%s"), spec.spec.m_name); hecl::Printf(_S("%s"), spec.spec.m_name.data());
if (spec.active) if (spec.active)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
@ -119,7 +119,7 @@ public:
else else
hecl::Printf(_S(" [ENABLED]")); hecl::Printf(_S(" [ENABLED]"));
} }
hecl::Printf(_S("\n %s\n"), spec.spec.m_desc); hecl::Printf(_S("\n %s\n"), spec.spec.m_desc.data());
} }
return 0; return 0;
} }
@ -137,7 +137,7 @@ public:
hecl::ToLower(compName); hecl::ToLower(compName);
if (!itName.compare(compName)) if (!itName.compare(compName))
{ {
opSpecs.push_back(spec.spec.m_name); opSpecs.emplace_back(spec.spec.m_name);
break; break;
} }
} }

2
hecl/extern/athena vendored

@ -1 +1 @@
Subproject commit b55f26513179f4c5ea57f788c9e491f429be521b Subproject commit f5dabee0a785d30476937296e999db442f1005f9

2
hecl/extern/boo vendored

@ -1 +1 @@
Subproject commit 420dcee55234c718f757cb6370bbef4779bc4470 Subproject commit cb5d22eed61f6de468e3e3bc718c705b398b6c65

View File

@ -26,7 +26,7 @@
#include "hecl/HMDLMeta.hpp" #include "hecl/HMDLMeta.hpp"
#include <athena/Types.hpp> #include <athena/Types.hpp>
#include <athena/MemoryWriter.hpp> #include <athena/MemoryWriter.hpp>
#include <optional.hpp> #include "optional.hpp"
namespace hecl namespace hecl
{ {
@ -389,7 +389,7 @@ public:
if (m_parent->m_loadedType != BlendType::Mesh && if (m_parent->m_loadedType != BlendType::Mesh &&
m_parent->m_loadedType != BlendType::Actor) m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not a MESH or ACTOR blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not a MESH or ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("MESHAABB"); m_parent->_writeStr("MESHAABB");
char readBuf[256]; char readBuf[256];
@ -786,11 +786,11 @@ public:
Mesh::SurfProgFunc surfProg=[](int){}); Mesh::SurfProgFunc surfProg=[](int){});
/** Compile mesh by name (AREA blends only) */ /** Compile mesh by name (AREA blends only) */
Mesh compileMesh(const std::string& name, HMDLTopology topology, int skinSlotCount=10, Mesh compileMesh(std::string_view name, HMDLTopology topology, int skinSlotCount=10,
Mesh::SurfProgFunc surfProg=[](int){}); Mesh::SurfProgFunc surfProg=[](int){});
/** Compile collision mesh by name (AREA blends only) */ /** Compile collision mesh by name (AREA blends only) */
ColMesh compileColMesh(const std::string& name); ColMesh compileColMesh(std::string_view name);
/** Compile all meshes as collision meshes (CMESH blends only) */ /** Compile all meshes as collision meshes (CMESH blends only) */
std::vector<ColMesh> compileColMeshes(); std::vector<ColMesh> compileColMeshes();
@ -806,7 +806,7 @@ public:
std::vector<Light> compileLights(); std::vector<Light> compileLights();
/** Compile GUI into FRME data (FRAME blends only) */ /** Compile GUI into FRME data (FRAME blends only) */
void compileGuiFrame(const std::string& pathOut, int version); void compileGuiFrame(std::string_view pathOut, int version);
/** Gather all texture paths in scene */ /** Gather all texture paths in scene */
std::vector<ProjectPath> getTextures(); std::vector<ProjectPath> getTextures();
@ -901,11 +901,11 @@ public:
Actor compileActor(); Actor compileActor();
Actor compileActorCharacterOnly(); Actor compileActorCharacterOnly();
Actor::Action compileActionChannelsOnly(const std::string& name); Actor::Action compileActionChannelsOnly(std::string_view name);
std::vector<std::string> getArmatureNames(); std::vector<std::string> getArmatureNames();
std::vector<std::string> getSubtypeNames(); std::vector<std::string> getSubtypeNames();
std::vector<std::string> getActionNames(); std::vector<std::string> getActionNames();
std::vector<std::string> getSubtypeOverlayNames(const std::string& name); std::vector<std::string> getSubtypeOverlayNames(std::string_view name);
struct Matrix3f struct Matrix3f
{ {
@ -913,10 +913,10 @@ public:
inline atVec3f& operator[](size_t idx) {return m[idx];} inline atVec3f& operator[](size_t idx) {return m[idx];}
inline const atVec3f& operator[](size_t idx) const {return m[idx];} inline const atVec3f& operator[](size_t idx) const {return m[idx];}
}; };
std::unordered_map<std::string, Matrix3f> getBoneMatrices(const std::string& name); std::unordered_map<std::string, Matrix3f> getBoneMatrices(std::string_view name);
bool renderPvs(const std::string& path, const atVec3f& location); bool renderPvs(std::string_view path, const atVec3f& location);
bool renderPvsLight(const std::string& path, const std::string& lightName); bool renderPvsLight(std::string_view path, std::string_view lightName);
MapArea compileMapArea(); MapArea compileMapArea();
MapUniverse compileMapUniverse(); MapUniverse compileMapUniverse();

View File

@ -66,16 +66,16 @@ public:
using EType = DNACVAR::EType; using EType = DNACVAR::EType;
using EFlags = DNACVAR::EFlags; using EFlags = DNACVAR::EFlags;
CVar(const std::string& name, const std::string& value, const std::string& help, EType type, EFlags flags, CVarManager& parent); CVar(std::string_view name, std::string_view value, std::string_view help, EType type, EFlags flags, CVarManager& parent);
CVar(const std::string& name, const std::string& value, const std::string& help, EFlags flags, CVarManager& parent); CVar(std::string_view name, std::string_view value, std::string_view help, EFlags flags, CVarManager& parent);
CVar(const std::string& name, float value, const std::string& help, EFlags flags, CVarManager& parent); CVar(std::string_view name, float value, std::string_view help, EFlags flags, CVarManager& parent);
CVar(const std::string& name, bool value, const std::string& help, EFlags flags, CVarManager& parent); CVar(std::string_view name, bool value, std::string_view help, EFlags flags, CVarManager& parent);
CVar(const std::string& name, int value, const std::string& help, EFlags flags, CVarManager& parent); CVar(std::string_view name, int value, std::string_view help, EFlags flags, CVarManager& parent);
CVar(const std::string& name, const atVec4f& value, const std::string& help, EFlags flags, CVarManager& parent); CVar(std::string_view name, const atVec4f& value, std::string_view help, EFlags flags, CVarManager& parent);
const std::string& name() const { return m_name; } std::string_view name() const { return m_name; }
const std::string& rawHelp() const { return m_help; } std::string_view rawHelp() const { return m_help; }
std::string help() const; std::string help() const;
atVec4f toVec4f(bool* isValid = nullptr) const; atVec4f toVec4f(bool* isValid = nullptr) const;
@ -89,8 +89,8 @@ public:
bool fromFloat(float val); bool fromFloat(float val);
bool fromBoolean(bool val); bool fromBoolean(bool val);
bool fromInteger(int val); bool fromInteger(int val);
bool fromLiteral(const std::string& val); bool fromLiteral(std::string_view val);
bool fromLiteral(const std::wstring& val); bool fromLiteral(std::wstring_view val);
bool isFloat() const { return m_type == EType::Float; } bool isFloat() const { return m_type == EType::Float; }
bool isBoolean() const { return m_type == EType::Boolean; } bool isBoolean() const { return m_type == EType::Boolean; }

View File

@ -16,7 +16,7 @@ class CVarManager final
{ {
using CVarContainer = DNACVAR::CVarContainer; using CVarContainer = DNACVAR::CVarContainer;
template <typename T> template <typename T>
CVar* _newCVar(const std::string& name, const std::string& help, const T& value, CVar::EFlags flags) CVar* _newCVar(std::string_view name, std::string_view help, const T& value, CVar::EFlags flags)
{ {
CVar* ret(new CVar(name, value, help, flags, *this)); CVar* ret(new CVar(name, value, help, flags, *this));
if (registerCVar(ret)) if (registerCVar(ret))
@ -41,20 +41,20 @@ public:
~CVarManager(); ~CVarManager();
void update(); void update();
CVar* newCVar(const std::string& name, const std::string& help, const atVec4f& value, CVar::EFlags flags) CVar* newCVar(std::string_view name, std::string_view help, const atVec4f& value, CVar::EFlags flags)
{ return _newCVar<atVec4f>(name, help, value, flags); } { return _newCVar<atVec4f>(name, help, value, flags); }
CVar* newCVar(const std::string& name, const std::string& help, const std::string& value, CVar::EFlags flags) CVar* newCVar(std::string_view name, std::string_view help, std::string_view value, CVar::EFlags flags)
{ return _newCVar<std::string>(name, help, value, flags); } { return _newCVar<std::string_view>(name, help, value, flags); }
CVar* newCVar(const std::string& name, const std::string& help, bool value, CVar::EFlags flags) CVar* newCVar(std::string_view name, std::string_view help, bool value, CVar::EFlags flags)
{ return _newCVar<bool>(name, help, value, flags); } { return _newCVar<bool>(name, help, value, flags); }
CVar* newCVar(const std::string& name, const std::string& help, float value, CVar::EFlags flags) CVar* newCVar(std::string_view name, std::string_view help, float value, CVar::EFlags flags)
{ return _newCVar<float>(name, help, value, flags); } { return _newCVar<float>(name, help, value, flags); }
CVar* newCVar(const std::string& name, const std::string& help, int value, CVar::EFlags flags) CVar* newCVar(std::string_view name, std::string_view help, int value, CVar::EFlags flags)
{ return _newCVar<int>(name, help, value, flags); } { return _newCVar<int>(name, help, value, flags); }
bool registerCVar(CVar* cvar); bool registerCVar(CVar* cvar);
CVar* findCVar(std::string name); CVar* findCVar(std::string_view name);
std::vector<CVar*> archivedCVars() const; std::vector<CVar*> archivedCVars() const;
std::vector<CVar*> cvars() const; std::vector<CVar*> cvars() const;

View File

@ -145,11 +145,11 @@ extern std::vector<const struct DataSpecEntry*> DATA_SPEC_REGISTRY;
*/ */
struct DataSpecEntry struct DataSpecEntry
{ {
const SystemChar* m_name; SystemStringView m_name;
const SystemChar* m_desc; SystemStringView m_desc;
std::function<IDataSpec*(Project&, DataSpecTool)> m_factory; std::function<IDataSpec*(Project&, DataSpecTool)> m_factory;
DataSpecEntry(const SystemChar* name, const SystemChar* desc, DataSpecEntry(SystemStringView name, SystemStringView desc,
std::function<IDataSpec*(Project& project, DataSpecTool)>&& factory) std::function<IDataSpec*(Project& project, DataSpecTool)>&& factory)
: m_name(name), m_desc(desc), m_factory(std::move(factory)) {} : m_name(name), m_desc(desc), m_factory(std::move(factory)) {}
}; };
@ -228,10 +228,10 @@ protected:
{return FourCC("NULL");} {return FourCC("NULL");}
public: public:
ObjectBase(const SystemString& path) ObjectBase(SystemStringView path)
: m_path(path) {} : m_path(path) {}
const SystemString& getPath() const {return m_path;} SystemStringView getPath() const {return m_path;}
}; };
@ -278,12 +278,12 @@ public:
std::vector<std::string> m_lines; std::vector<std::string> m_lines;
FILE* m_lockedFile = NULL; FILE* m_lockedFile = NULL;
public: public:
ConfigFile(const Project& project, const SystemString& name, ConfigFile(const Project& project, SystemStringView name,
const SystemString& subdir=_S("/.hecl/")); SystemStringView subdir=_S("/.hecl/"));
std::vector<std::string>& lockAndRead(); std::vector<std::string>& lockAndRead();
void addLine(const std::string& line); void addLine(std::string_view line);
void removeLine(const std::string& refLine); void removeLine(std::string_view refLine);
bool checkForLine(const std::string& refLine); bool checkForLine(std::string_view refLine);
void unlockAndDiscard(); void unlockAndDiscard();
bool unlockAndCommit(); bool unlockAndCommit();
}; };

View File

@ -29,17 +29,16 @@ class Diagnostics
std::string m_backend = "Backend"; std::string m_backend = "Backend";
std::string sourceDiagString(const SourceLocation& l, bool ansi=false) const; std::string sourceDiagString(const SourceLocation& l, bool ansi=false) const;
public: public:
void reset(const std::string& name, const std::string& source) {m_name = name; m_source = source;} void reset(std::string_view name, std::string_view source) {m_name = name; m_source = source;}
void reset(const std::string& name) {m_name = name; m_source.clear();} void reset(std::string_view name) {m_name = name; m_source.clear();}
void setBackend(const std::string& backend) {m_backend = backend;} void setBackend(std::string_view backend) {m_backend = backend;}
void setBackend(const char* backend) {m_backend = backend;}
void reportParserErr(const SourceLocation& l, const char* format, ...); void reportParserErr(const SourceLocation& l, const char* format, ...);
void reportLexerErr(const SourceLocation& l, const char* format, ...); void reportLexerErr(const SourceLocation& l, const char* format, ...);
void reportCompileErr(const SourceLocation& l, const char* format, ...); void reportCompileErr(const SourceLocation& l, const char* format, ...);
void reportBackendErr(const SourceLocation& l, const char* format, ...); void reportBackendErr(const SourceLocation& l, const char* format, ...);
const std::string& getName() const {return m_name;} std::string_view getName() const {return m_name;}
const std::string& getSource() const {return m_source;} std::string_view getSource() const {return m_source;}
}; };
class Parser class Parser
@ -61,11 +60,11 @@ public:
}; };
private: private:
Diagnostics& m_diag; Diagnostics& m_diag;
const std::string* m_source = nullptr; std::string_view m_source;
std::string::const_iterator m_sourceIt; std::string_view::const_iterator m_sourceIt;
std::vector<TokenType> m_parenStack; std::vector<TokenType> m_parenStack;
bool m_reset = false; bool m_reset = false;
void skipWhitespace(std::string::const_iterator& it); void skipWhitespace(std::string_view::const_iterator& it);
public: public:
struct Token struct Token
{ {
@ -107,7 +106,7 @@ public:
return nullptr; return nullptr;
} }
}; };
void reset(const std::string& source); void reset(std::string_view source);
Token consumeToken(); Token consumeToken();
SourceLocation getLocation() const; SourceLocation getLocation() const;
@ -399,7 +398,7 @@ class Frontend
Parser m_parser; Parser m_parser;
Lexer m_lexer; Lexer m_lexer;
public: public:
IR compileSource(const std::string& source, const std::string& diagName) IR compileSource(std::string_view source, std::string_view diagName)
{ {
Hash hash(source); Hash hash(source);
m_diag.reset(diagName, source); m_diag.reset(diagName, source);

View File

@ -24,13 +24,13 @@ class FileStoreManager
SystemString m_domain; SystemString m_domain;
SystemString m_storeRoot; SystemString m_storeRoot;
public: public:
FileStoreManager(const SystemString& domain); FileStoreManager(SystemStringView domain);
const SystemString& getDomain() const {return m_domain;} SystemStringView getDomain() const {return m_domain;}
/** /**
* @brief Returns the full path to the file store, including domain * @brief Returns the full path to the file store, including domain
* @return Full path to store e.g /home/foo/.hecl/bar * @return Full path to store e.g /home/foo/.hecl/bar
*/ */
const SystemString& getStoreRoot() const {return m_storeRoot;} SystemStringView getStoreRoot() const {return m_storeRoot;}
}; };
/** /**
@ -57,7 +57,7 @@ class ShaderTag : public Hash
}; };
public: public:
ShaderTag() = default; ShaderTag() = default;
ShaderTag(const std::string& source, uint8_t c, uint8_t u, uint8_t w, uint8_t s, uint8_t t, boo::Primitive pt, ShaderTag(std::string_view source, uint8_t c, uint8_t u, uint8_t w, uint8_t s, uint8_t t, boo::Primitive pt,
Backend::ReflectionType reflectionType, bool depthTest, bool depthWrite, bool backfaceCulling) Backend::ReflectionType reflectionType, bool depthTest, bool depthWrite, bool backfaceCulling)
: Hash(source), m_colorCount(c), m_uvCount(u), m_weightCount(w), m_skinSlotCount(s), m_texMtxCount(t), : Hash(source), m_colorCount(c), m_uvCount(u), m_weightCount(w), m_skinSlotCount(s), m_texMtxCount(t),
m_primitiveType(uint8_t(pt)), m_reflectionType(uint8_t(reflectionType)), m_primitiveType(uint8_t(pt)), m_reflectionType(uint8_t(reflectionType)),
@ -273,17 +273,17 @@ public:
* for encoding the pipeline state. This must be called before building shaders */ * for encoding the pipeline state. This must be called before building shaders */
void setRenderTargetSamples(unsigned samps) {m_factory->m_rtHint = samps;} void setRenderTargetSamples(unsigned samps) {m_factory->m_rtHint = samps;}
std::shared_ptr<ShaderPipelines> buildShader(const ShaderTag& tag, const std::string& source, std::shared_ptr<ShaderPipelines> buildShader(const ShaderTag& tag, std::string_view source,
const std::string& diagName, std::string_view diagName,
boo::IGraphicsDataFactory& factory); boo::IGraphicsDataFactory& factory);
std::shared_ptr<ShaderPipelines> buildShader(const ShaderTag& tag, const hecl::Frontend::IR& ir, std::shared_ptr<ShaderPipelines> buildShader(const ShaderTag& tag, const hecl::Frontend::IR& ir,
const std::string& diagName, std::string_view diagName,
boo::IGraphicsDataFactory& factory); boo::IGraphicsDataFactory& factory);
std::shared_ptr<ShaderPipelines> buildExtendedShader(const ShaderTag& tag, const std::string& source, std::shared_ptr<ShaderPipelines> buildExtendedShader(const ShaderTag& tag, std::string_view source,
const std::string& diagName, std::string_view diagName,
boo::IGraphicsDataFactory& factory); boo::IGraphicsDataFactory& factory);
std::shared_ptr<ShaderPipelines> buildExtendedShader(const ShaderTag& tag, const hecl::Frontend::IR& ir, std::shared_ptr<ShaderPipelines> buildExtendedShader(const ShaderTag& tag, const hecl::Frontend::IR& ir,
const std::string& diagName, std::string_view diagName,
boo::IGraphicsDataFactory& factory); boo::IGraphicsDataFactory& factory);
}; };

View File

@ -15,7 +15,8 @@
#include <wchar.h> #include <wchar.h>
#endif #endif
#include <string> #include <string>
#include <string.h> #include <string_view>
#include <cstring>
#include <algorithm> #include <algorithm>
namespace hecl namespace hecl
@ -29,6 +30,7 @@ namespace hecl
typedef wchar_t SystemChar; typedef wchar_t SystemChar;
static inline size_t StrLen(const SystemChar* str) {return wcslen(str);} static inline size_t StrLen(const SystemChar* str) {return wcslen(str);}
typedef std::wstring SystemString; typedef std::wstring SystemString;
typedef std::wstring_view SystemStringView;
static inline void ToLower(SystemString& str) static inline void ToLower(SystemString& str)
{std::transform(str.begin(), str.end(), str.begin(), towlower);} {std::transform(str.begin(), str.end(), str.begin(), towlower);}
static inline void ToUpper(SystemString& str) static inline void ToUpper(SystemString& str)
@ -41,6 +43,7 @@ typedef struct _stat Sstat;
typedef char SystemChar; typedef char SystemChar;
static inline size_t StrLen(const SystemChar* str) {return strlen(str);} static inline size_t StrLen(const SystemChar* str) {return strlen(str);}
typedef std::string SystemString; typedef std::string SystemString;
typedef std::string_view SystemStringView;
static inline void ToLower(SystemString& str) static inline void ToLower(SystemString& str)
{std::transform(str.begin(), str.end(), str.begin(), tolower);} {std::transform(str.begin(), str.end(), str.begin(), tolower);}
static inline void ToUpper(SystemString& str) static inline void ToUpper(SystemString& str)

View File

@ -49,11 +49,11 @@ struct DataSpecEntry;
extern unsigned VerbosityLevel; extern unsigned VerbosityLevel;
extern logvisor::Module LogModule; extern logvisor::Module LogModule;
std::string WideToUTF8(const std::wstring& src); std::string WideToUTF8(std::wstring_view src);
std::string Char16ToUTF8(const std::u16string& src); std::string Char16ToUTF8(std::u16string_view src);
std::wstring Char16ToWide(const std::u16string& src); std::wstring Char16ToWide(std::u16string_view src);
std::wstring UTF8ToWide(const std::string& src); std::wstring UTF8ToWide(std::string_view src);
std::u16string UTF8ToChar16(const std::string& src); std::u16string UTF8ToChar16(std::string_view src);
/* humanize_number port from FreeBSD's libutil */ /* humanize_number port from FreeBSD's libutil */
enum class HNFlags enum class HNFlags
@ -77,63 +77,51 @@ ENABLE_BITWISE_ENUM(HNScale)
std::string HumanizeNumber(int64_t quotient, size_t len, const char* suffix, int scale, HNFlags flags); std::string HumanizeNumber(int64_t quotient, size_t len, const char* suffix, int scale, HNFlags flags);
#if HECL_UCS2 #if HECL_UCS2
class SystemUTF8View class SystemUTF8Conv
{ {
std::string m_utf8; std::string m_utf8;
public: public:
explicit SystemUTF8View(const SystemString& str) explicit SystemUTF8Conv(SystemStringView str)
: m_utf8(WideToUTF8(str)) {} : m_utf8(WideToUTF8(str)) {}
operator const std::string&() const {return m_utf8;} std::string_view str() const {return m_utf8;}
const std::string& str() const {return m_utf8;}
const char* c_str() const {return m_utf8.c_str();} const char* c_str() const {return m_utf8.c_str();}
std::string operator+(const std::string& other) const {return m_utf8 + other;} std::string operator+(std::string_view other) const {return m_utf8 + other;}
std::string operator+(const char* other) const {return m_utf8 + other;}
}; };
inline std::string operator+(const std::string& lhs, const SystemUTF8View& rhs) {return lhs + std::string(rhs);} inline std::string operator+(std::string_view lhs, const SystemUTF8Conv& rhs) {return lhs + std::string(rhs);}
inline std::string operator+(const char* lhs, const SystemUTF8View& rhs) {return lhs + std::string(rhs);} class SystemStringConv
class SystemStringView
{ {
std::wstring m_sys; std::wstring m_sys;
public: public:
explicit SystemStringView(const std::string& str) explicit SystemStringConv(std::string_view str)
: m_sys(UTF8ToWide(str)) {} : m_sys(UTF8ToWide(str)) {}
operator const std::wstring&() const {return m_sys;} SystemStringView sys_str() const {return m_sys;}
const std::wstring& sys_str() const {return m_sys;}
const SystemChar* c_str() const {return m_sys.c_str();} const SystemChar* c_str() const {return m_sys.c_str();}
std::wstring operator+(const std::wstring& other) const {return m_sys + other;} std::wstring operator+(const std::wstring_view other) const {return m_sys + other;}
std::wstring operator+(const wchar_t* other) const {return m_sys + other;}
}; };
inline std::wstring operator+(const std::wstring& lhs, const SystemStringView& rhs) {return lhs + std::wstring(rhs);} inline std::wstring operator+(std::wstring_view lhs, const SystemStringConv& rhs) {return lhs + std::wstring(rhs);}
inline std::wstring operator+(const wchar_t* lhs, const SystemStringView& rhs) {return lhs + std::wstring(rhs);}
#else #else
class SystemUTF8View class SystemUTF8Conv
{ {
const std::string& m_utf8; std::string_view m_utf8;
public: public:
explicit SystemUTF8View(const SystemString& str) explicit SystemUTF8Conv(SystemStringView str)
: m_utf8(str) {} : m_utf8(str) {}
operator const std::string&() const {return m_utf8;} std::string_view str() const {return m_utf8;}
const std::string& str() const {return m_utf8;} const char* c_str() const {return m_utf8.data();}
const char* c_str() const {return m_utf8.c_str();} std::string operator+(std::string_view other) const {return std::string(m_utf8) + other.data();}
std::string operator+(const std::string& other) const {return std::string(m_utf8) + other;}
std::string operator+(const char* other) const {return std::string(m_utf8) + other;}
}; };
inline std::string operator+(const std::string& lhs, const SystemUTF8View& rhs) {return lhs + std::string(rhs);} inline std::string operator+(std::string_view lhs, const SystemUTF8Conv& rhs) {return std::string(lhs) + rhs.c_str();}
inline std::string operator+(const char* lhs, const SystemUTF8View& rhs) {return lhs + std::string(rhs);} class SystemStringConv
class SystemStringView
{ {
const std::string& m_sys; std::string_view m_sys;
public: public:
explicit SystemStringView(const std::string& str) explicit SystemStringConv(std::string_view str)
: m_sys(str) {} : m_sys(str) {}
operator const std::string&() const {return m_sys;} SystemStringView sys_str() const {return m_sys;}
const std::string& sys_str() const {return m_sys;} const SystemChar* c_str() const {return m_sys.data();}
const SystemChar* c_str() const {return m_sys.c_str();} std::string operator+(std::string_view other) const {return std::string(m_sys) + other.data();}
std::string operator+(const std::string& other) const {return m_sys + other;}
std::string operator+(const char* other) const {return m_sys + other;}
}; };
inline std::string operator+(const std::string& lhs, const SystemStringView& rhs) {return lhs + std::string(rhs);} inline std::string operator+(std::string_view lhs, const SystemStringConv& rhs) {return std::string(lhs) + rhs.c_str();}
inline std::string operator+(const char* lhs, const SystemStringView& rhs) {return lhs + std::string(rhs);}
#endif #endif
void SanitizePath(std::string& path); void SanitizePath(std::string& path);
@ -226,7 +214,7 @@ static SystemString GetcwdStr()
return SystemString(); return SystemString();
} }
static inline bool IsAbsolute(const SystemString& path) static inline bool IsAbsolute(SystemStringView path)
{ {
#if _WIN32 #if _WIN32
if (path.size() && (path[0] == _S('\\') || path[0] == _S('/'))) if (path.size() && (path[0] == _S('\\') || path[0] == _S('/')))
@ -532,9 +520,9 @@ public:
operator bool() const {return hash != 0;} operator bool() const {return hash != 0;}
Hash(const void* buf, size_t len) Hash(const void* buf, size_t len)
: hash(XXH64((uint8_t*)buf, len, 0)) {} : hash(XXH64((uint8_t*)buf, len, 0)) {}
Hash(const std::string& str) Hash(std::string_view str)
: hash(XXH64((uint8_t*)str.data(), str.size(), 0)) {} : hash(XXH64((uint8_t*)str.data(), str.size(), 0)) {}
Hash(const std::wstring& str) Hash(std::wstring_view str)
: hash(XXH64((uint8_t*)str.data(), str.size()*2, 0)) {} : hash(XXH64((uint8_t*)str.data(), str.size()*2, 0)) {}
Hash(uint64_t hashin) Hash(uint64_t hashin)
: hash(hashin) {} : hash(hashin) {}
@ -576,21 +564,21 @@ public:
*/ */
struct CaseInsensitiveCompare struct CaseInsensitiveCompare
{ {
bool operator()(const std::string& lhs, const std::string& rhs) const bool operator()(std::string_view lhs, std::string_view rhs) const
{ {
#if _WIN32 #if _WIN32
if (_stricmp(lhs.c_str(), rhs.c_str()) < 0) if (_stricmp(lhs.data(), rhs.data()) < 0)
#else #else
if (strcasecmp(lhs.c_str(), rhs.c_str()) < 0) if (strcasecmp(lhs.data(), rhs.data()) < 0)
#endif #endif
return true; return true;
return false; return false;
} }
#if _WIN32 #if _WIN32
bool operator()(const std::wstring& lhs, const std::wstring& rhs) const bool operator()(std::wstring_view lhs, std::wstring_view rhs) const
{ {
if (_wcsicmp(lhs.c_str(), rhs.c_str()) < 0) if (_wcsicmp(lhs.data(), rhs.data()) < 0)
return true; return true;
return false; return false;
} }
@ -627,10 +615,7 @@ private:
std::vector<Entry> m_entries; std::vector<Entry> m_entries;
public: public:
DirectoryEnumerator(const hecl::SystemString& path, Mode mode=Mode::DirsThenFilesSorted, DirectoryEnumerator(SystemStringView path, Mode mode=Mode::DirsThenFilesSorted,
bool sizeSort=false, bool reverse=false, bool noHidden=false)
: DirectoryEnumerator(path.c_str(), mode, sizeSort, reverse, noHidden) {}
DirectoryEnumerator(const hecl::SystemChar* path, Mode mode=Mode::DirsThenFilesSorted,
bool sizeSort=false, bool reverse=false, bool noHidden=false); bool sizeSort=false, bool reverse=false, bool noHidden=false);
operator bool() const {return m_entries.size() != 0;} operator bool() const {return m_entries.size() != 0;}
@ -671,7 +656,7 @@ public:
* @brief Construct a representation of a project root path * @brief Construct a representation of a project root path
* @param path valid filesystem-path (relative or absolute) to project root * @param path valid filesystem-path (relative or absolute) to project root
*/ */
ProjectRootPath(const SystemString& path) : m_projRoot(path) ProjectRootPath(SystemStringView path) : m_projRoot(path)
{ {
SanitizePath(m_projRoot); SanitizePath(m_projRoot);
m_hash = Hash(m_projRoot); m_hash = Hash(m_projRoot);
@ -681,14 +666,14 @@ public:
* @brief Access fully-canonicalized absolute path * @brief Access fully-canonicalized absolute path
* @return Absolute path reference * @return Absolute path reference
*/ */
const SystemString& getAbsolutePath() const {return m_projRoot;} SystemStringView getAbsolutePath() const {return m_projRoot;}
/** /**
* @brief Make absolute path project relative * @brief Make absolute path project relative
* @param absPath Absolute path * @param absPath Absolute path
* @return SystemString of path relative to project root * @return SystemString of path relative to project root
*/ */
SystemString getProjectRelativeFromAbsolute(const SystemString& absPath) const SystemString getProjectRelativeFromAbsolute(SystemStringView absPath) const
{ {
if (absPath.size() > m_projRoot.size()) if (absPath.size() > m_projRoot.size())
{ {
@ -705,7 +690,7 @@ public:
} }
} }
LogModule.report(logvisor::Fatal, "unable to resolve '%s' as project relative '%s'", LogModule.report(logvisor::Fatal, "unable to resolve '%s' as project relative '%s'",
absPath.c_str(), m_projRoot.c_str()); absPath.data(), m_projRoot.c_str());
return SystemString(); return SystemString();
} }
@ -729,12 +714,12 @@ public:
* @brief Obtain c-string of final path component * @brief Obtain c-string of final path component
* @return Final component c-string (may be empty) * @return Final component c-string (may be empty)
*/ */
const SystemChar* getLastComponent() const SystemStringView getLastComponent() const
{ {
size_t pos = m_projRoot.rfind(_S('/')); size_t pos = m_projRoot.rfind(_S('/'));
if (pos == SystemString::npos) if (pos == SystemString::npos)
return m_projRoot.c_str() + m_projRoot.size(); return {};
return m_projRoot.c_str() + pos + 1; return {m_projRoot.c_str() + pos + 1, size_t(m_projRoot.size() - pos - 1)};
} }
}; };
@ -813,12 +798,12 @@ public:
* @param project previously constructed Project to use root path of * @param project previously constructed Project to use root path of
* @param path valid filesystem-path (relative or absolute) to subpath * @param path valid filesystem-path (relative or absolute) to subpath
*/ */
ProjectPath(Database::Project& project, const SystemString& path) {assign(project, path);} ProjectPath(Database::Project& project, SystemStringView path) {assign(project, path);}
void assign(Database::Project& project, const SystemString& path); void assign(Database::Project& project, SystemStringView path);
#if HECL_UCS2 #if HECL_UCS2
ProjectPath(Database::Project& project, const std::string& path) {assign(project, path);} ProjectPath(Database::Project& project, std::string_view path) {assign(project, path);}
void assign(Database::Project& project, const std::string& path); void assign(Database::Project& project, std::string_view path);
#endif #endif
/** /**
@ -826,12 +811,12 @@ public:
* @param parentPath previously constructed ProjectPath which ultimately connects to a ProjectRootPath * @param parentPath previously constructed ProjectPath which ultimately connects to a ProjectRootPath
* @param path valid filesystem-path (relative or absolute) to subpath * @param path valid filesystem-path (relative or absolute) to subpath
*/ */
ProjectPath(const ProjectPath& parentPath, const SystemString& path) {assign(parentPath, path);} ProjectPath(const ProjectPath& parentPath, SystemStringView path) {assign(parentPath, path);}
void assign(const ProjectPath& parentPath, const SystemString& path); void assign(const ProjectPath& parentPath, SystemStringView path);
#if HECL_UCS2 #if HECL_UCS2
ProjectPath(const ProjectPath& parentPath, const std::string& path) {assign(parentPath, path);} ProjectPath(const ProjectPath& parentPath, std::string_view path) {assign(parentPath, path);}
void assign(const ProjectPath& parentPath, const std::string& path); void assign(const ProjectPath& parentPath, std::string_view path);
#endif #endif
/** /**
@ -882,13 +867,13 @@ public:
* @brief Access fully-canonicalized absolute path * @brief Access fully-canonicalized absolute path
* @return Absolute path reference * @return Absolute path reference
*/ */
const SystemString& getAbsolutePath() const {return m_absPath;} SystemStringView getAbsolutePath() const {return m_absPath;}
/** /**
* @brief Access fully-canonicalized project-relative path * @brief Access fully-canonicalized project-relative path
* @return Relative pointer to within absolute-path or "." for project root-directory (use isRoot to detect) * @return Relative pointer to within absolute-path or "." for project root-directory (use isRoot to detect)
*/ */
const SystemString& getRelativePath() const SystemStringView getRelativePath() const
{ {
if (m_relPath.size()) if (m_relPath.size())
return m_relPath; return m_relPath;
@ -923,44 +908,43 @@ public:
* @brief Obtain c-string of final path component (stored within relative path) * @brief Obtain c-string of final path component (stored within relative path)
* @return Final component c-string (may be empty) * @return Final component c-string (may be empty)
*/ */
const SystemChar* getLastComponent() const SystemStringView getLastComponent() const
{ {
size_t pos = m_relPath.rfind(_S('/')); size_t pos = m_relPath.rfind(_S('/'));
if (pos == SystemString::npos) if (pos == SystemString::npos)
return m_relPath.c_str() + m_relPath.size(); return {};
return m_relPath.c_str() + pos + 1; return {m_relPath.c_str() + pos + 1, m_relPath.size() - pos - 1};
} }
const char* getLastComponentUTF8() const SystemStringView getLastComponentUTF8() const
{ {
size_t pos = m_relPath.rfind(_S('/')); size_t pos = m_relPath.rfind(_S('/'));
#if HECL_UCS2 #if HECL_UCS2
if (pos == SystemString::npos) if (pos == SystemString::npos)
return m_utf8RelPath.c_str() + m_utf8RelPath.size(); return {};
return m_utf8RelPath.c_str() + pos + 1; return {m_utf8RelPath.c_str() + pos + 1, size_t(m_utf8RelPath.size() - pos - 1)};
#else #else
if (pos == SystemString::npos) if (pos == SystemString::npos)
return m_relPath.c_str() + m_relPath.size(); return {};
return m_relPath.c_str() + pos + 1; return {m_relPath.c_str() + pos + 1, size_t(m_relPath.size() - pos - 1)};
#endif #endif
} }
/** /**
* @brief Obtain c-string of extension of final path component (stored within relative path) * @brief Obtain c-string of extension of final path component (stored within relative path)
* @return Final component extension c-string (may be nullptr) * @return Final component extension c-string (may be empty)
*/ */
const SystemChar* getLastComponentExt() const SystemStringView getLastComponentExt() const
{ {
const SystemChar* lastCompOrig = getLastComponent(); SystemStringView lastCompOrig = getLastComponent().data();
const SystemChar* lastComp = lastCompOrig; const SystemChar* end = lastCompOrig.data() + lastCompOrig.size();
while (*lastComp != _S('\0')) const SystemChar* lastComp = end;
++lastComp; while (lastComp != lastCompOrig.data())
while (lastComp != lastCompOrig)
{ {
if (*lastComp == _S('.')) if (*lastComp == _S('.'))
return lastComp + 1; return {lastComp + 1, size_t(end - lastComp - 1)};
--lastComp; --lastComp;
} }
return nullptr; return {};
} }
/** /**
@ -1038,7 +1022,7 @@ public:
* @brief Access fully-canonicalized absolute path in UTF-8 * @brief Access fully-canonicalized absolute path in UTF-8
* @return Absolute path reference * @return Absolute path reference
*/ */
const std::string& getAbsolutePathUTF8() const std::string_view getAbsolutePathUTF8() const
{ {
#if HECL_UCS2 #if HECL_UCS2
return m_utf8AbsPath; return m_utf8AbsPath;
@ -1047,7 +1031,7 @@ public:
#endif #endif
} }
const std::string& getRelativePathUTF8() const std::string_view getRelativePathUTF8() const
{ {
#if HECL_UCS2 #if HECL_UCS2
return m_utf8RelPath; return m_utf8RelPath;
@ -1056,12 +1040,12 @@ public:
#endif #endif
} }
const SystemString& getAuxInfo() const SystemStringView getAuxInfo() const
{ {
return m_auxInfo; return m_auxInfo;
} }
const std::string& getAuxInfoUTF8() const std::string_view getAuxInfoUTF8() const
{ {
#if HECL_UCS2 #if HECL_UCS2
return m_utf8AuxInfo; return m_utf8AuxInfo;
@ -1074,25 +1058,15 @@ public:
* @brief Construct a path with the aux info overwritten with specified string * @brief Construct a path with the aux info overwritten with specified string
* @param auxStr string to replace existing auxInfo with * @param auxStr string to replace existing auxInfo with
*/ */
ProjectPath ensureAuxInfo(const SystemChar* auxStr) const ProjectPath ensureAuxInfo(SystemStringView auxStr) const
{ {
return ProjectPath(getProject(), getRelativePath() + _S('|') + auxStr); return ProjectPath(getProject(), SystemString(getRelativePath()) + _S('|') + auxStr.data());
}
ProjectPath ensureAuxInfo(const SystemString& auxStr) const
{
return ProjectPath(getProject(), getRelativePath() + _S('|') + auxStr);
} }
#if HECL_UCS2 #if HECL_UCS2
ProjectPath ensureAuxInfo(const char* auxStr) const ProjectPath ensureAuxInfo(std::string_view auxStr) const
{ {
return ProjectPath(getProject(), getRelativePath() + _S('|') + UTF8ToWide(auxStr)); return ProjectPath(getProject(), SystemString(getRelativePath()) + _S('|') + UTF8ToWide(auxStr));
}
ProjectPath ensureAuxInfo(const std::string& auxStr) const
{
return ProjectPath(getProject(), getRelativePath() + _S('|') + UTF8ToWide(auxStr));
} }
#endif #endif
@ -1244,23 +1218,21 @@ public:
class StringUtils class StringUtils
{ {
public: public:
static bool BeginsWith(const SystemString& str, const SystemChar* test) static bool BeginsWith(SystemStringView str, SystemStringView test)
{ {
size_t len = StrLen(test); if (test.size() > str.size())
if (len > str.size())
return false; return false;
return !StrNCmp(str.data(), test, len); return !StrNCmp(str.data(), test.data(), test.size());
} }
static bool EndsWith(const SystemString& str, const SystemChar* test) static bool EndsWith(SystemStringView str, SystemStringView test)
{ {
size_t len = StrLen(test); if (test.size() > str.size())
if (len > str.size())
return false; return false;
return !StrNCmp(&*(str.end() - len), test, len); return !StrNCmp(&*(str.end() - test.size()), test.data(), test.size());
} }
static std::string TrimWhitespace(const std::string& str) static std::string TrimWhitespace(std::string_view str)
{ {
auto bit = str.begin(); auto bit = str.begin();
while (bit != str.cend() && isspace(*bit)) while (bit != str.cend() && isspace(*bit))
@ -1272,23 +1244,21 @@ public:
} }
#if HECL_UCS2 #if HECL_UCS2
static bool BeginsWith(const std::string& str, const char* test) static bool BeginsWith(std::string_view str, std::string_view test)
{ {
size_t len = strlen(test); if (test.size() > str.size())
if (len > str.size())
return false; return false;
return !strncmp(str.data(), test, len); return !strncmp(str.data(), test.data(), test.size());
} }
static bool EndsWith(const std::string& str, const char* test) static bool EndsWith(std::string_view str, std::string_view test)
{ {
size_t len = strlen(test); if (test.size() > str.size())
if (len > str.size())
return false; return false;
return !strncmp(&*(str.end() - len), test, len); return !strncmp(&*(str.end() - test.size()), test.data(), test.size());
} }
static SystemString TrimWhitespace(const SystemString& str) static SystemString TrimWhitespace(SystemStringView str)
{ {
auto bit = str.begin(); auto bit = str.begin();
while (bit != str.cend() && iswspace(*bit)) while (bit != str.cend() && iswspace(*bit))
@ -1328,7 +1298,7 @@ public:
* @param path absolute or relative file path to search from * @param path absolute or relative file path to search from
* @return Newly-constructed root path (bool-evaluating to false if not found) * @return Newly-constructed root path (bool-evaluating to false if not found)
*/ */
ProjectRootPath SearchForProject(const SystemString& path); ProjectRootPath SearchForProject(SystemStringView path);
/** /**
* @brief Search from within provided directory for the project root * @brief Search from within provided directory for the project root
@ -1336,7 +1306,7 @@ ProjectRootPath SearchForProject(const SystemString& path);
* @param subpathOut remainder of provided path assigned to this ProjectPath * @param subpathOut remainder of provided path assigned to this ProjectPath
* @return Newly-constructed root path (bool-evaluating to false if not found) * @return Newly-constructed root path (bool-evaluating to false if not found)
*/ */
ProjectRootPath SearchForProject(const SystemString& path, SystemString& subpathOut); ProjectRootPath SearchForProject(SystemStringView path, SystemString& subpathOut);
/** /**
* @brief Test if given path is a PNG (based on file header) * @brief Test if given path is a PNG (based on file header)

View File

@ -35,6 +35,8 @@ template <> struct hash<std::pair<uint32_t,uint32_t>>
}; };
} }
using namespace std::literals;
namespace hecl namespace hecl
{ {
@ -603,14 +605,14 @@ bool BlenderConnection::createBlend(const ProjectPath& path, BlendType type)
"BlenderConnection::createBlend() musn't be called with stream active"); "BlenderConnection::createBlend() musn't be called with stream active");
return false; return false;
} }
_writeStr(("CREATE \"" + path.getAbsolutePathUTF8() + "\" " + BlendTypeStrs[int(type)] + _writeStr(("CREATE \""s + path.getAbsolutePathUTF8().data() + "\" " + BlendTypeStrs[int(type)] +
" \"" + m_startupBlend + "\"").c_str()); " \"" + m_startupBlend + "\"").c_str());
char lineBuf[256]; char lineBuf[256];
_readStr(lineBuf, sizeof(lineBuf)); _readStr(lineBuf, sizeof(lineBuf));
if (!strcmp(lineBuf, "FINISHED")) if (!strcmp(lineBuf, "FINISHED"))
{ {
/* Delete immediately in case save doesn't occur */ /* Delete immediately in case save doesn't occur */
hecl::Unlink(path.getAbsolutePath().c_str()); hecl::Unlink(path.getAbsolutePath().data());
m_loadedBlend = path; m_loadedBlend = path;
m_loadedType = type; m_loadedType = type;
return true; return true;
@ -628,7 +630,7 @@ bool BlenderConnection::openBlend(const ProjectPath& path, bool force)
} }
if (!force && path == m_loadedBlend) if (!force && path == m_loadedBlend)
return true; return true;
_writeStr(("OPEN \"" + path.getAbsolutePathUTF8() + "\"").c_str()); _writeStr(("OPEN \""s + path.getAbsolutePathUTF8().data() + "\"").c_str());
char lineBuf[256]; char lineBuf[256];
_readStr(lineBuf, sizeof(lineBuf)); _readStr(lineBuf, sizeof(lineBuf));
if (!strcmp(lineBuf, "FINISHED")) if (!strcmp(lineBuf, "FINISHED"))
@ -680,8 +682,8 @@ void BlenderConnection::deleteBlend()
{ {
if (m_loadedBlend) if (m_loadedBlend)
{ {
hecl::Unlink(m_loadedBlend.getAbsolutePath().c_str()); hecl::Unlink(m_loadedBlend.getAbsolutePath().data());
BlenderLog.report(logvisor::Info, _S("Deleted '%s'"), m_loadedBlend.getAbsolutePath().c_str()); BlenderLog.report(logvisor::Info, _S("Deleted '%s'"), m_loadedBlend.getAbsolutePath().data());
m_loadedBlend = ProjectPath(); m_loadedBlend = ProjectPath();
} }
} }
@ -930,10 +932,10 @@ BlenderConnection::DataStream::Mesh::Material::Material
conn._readBuf(&bufSz, 4); conn._readBuf(&bufSz, 4);
std::string readStr(bufSz, ' '); std::string readStr(bufSz, ' ');
conn._readBuf(&readStr[0], bufSz); conn._readBuf(&readStr[0], bufSz);
SystemStringView absolute(readStr); SystemStringConv absolute(readStr);
SystemString relative = SystemString relative =
conn.m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(absolute); conn.m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(absolute.sys_str());
texs.emplace_back(conn.m_loadedBlend.getProject().getProjectWorkingPath(), relative); texs.emplace_back(conn.m_loadedBlend.getProject().getProjectWorkingPath(), relative);
} }
@ -1227,7 +1229,7 @@ BlenderConnection::DataStream::MapUniverse::World::World(BlenderConnection& conn
path.assign(pathLen, '\0'); path.assign(pathLen, '\0');
conn._readBuf(&path[0], pathLen); conn._readBuf(&path[0], pathLen);
hecl::SystemStringView sysPath(path); hecl::SystemStringConv sysPath(path);
worldPath.assign(conn.m_loadedBlend.getProject().getProjectWorkingPath(), sysPath.sys_str()); worldPath.assign(conn.m_loadedBlend.getProject().getProjectWorkingPath(), sysPath.sys_str());
} }
} }
@ -1242,7 +1244,7 @@ BlenderConnection::DataStream::MapUniverse::MapUniverse(BlenderConnection& conn)
path.assign(pathLen, '\0'); path.assign(pathLen, '\0');
conn._readBuf(&path[0], pathLen); conn._readBuf(&path[0], pathLen);
hecl::SystemStringView sysPath(path); hecl::SystemStringConv sysPath(path);
SystemString pathRel = SystemString pathRel =
conn.m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(sysPath.sys_str()); conn.m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(sysPath.sys_str());
hexagonPath.assign(conn.m_loadedBlend.getProject().getProjectWorkingPath(), pathRel); hexagonPath.assign(conn.m_loadedBlend.getProject().getProjectWorkingPath(), pathRel);
@ -1324,10 +1326,10 @@ BlenderConnection::DataStream::Actor::Subtype::Subtype(BlenderConnection& conn)
{ {
meshPath.assign(bufSz, ' '); meshPath.assign(bufSz, ' ');
conn._readBuf(&meshPath[0], bufSz); conn._readBuf(&meshPath[0], bufSz);
SystemStringView meshPathAbs(meshPath); SystemStringConv meshPathAbs(meshPath);
SystemString meshPathRel = SystemString meshPathRel =
conn.m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(meshPathAbs); conn.m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(meshPathAbs.sys_str());
mesh.assign(conn.m_loadedBlend.getProject().getProjectWorkingPath(), meshPathRel); mesh.assign(conn.m_loadedBlend.getProject().getProjectWorkingPath(), meshPathRel);
} }
@ -1349,10 +1351,10 @@ BlenderConnection::DataStream::Actor::Subtype::Subtype(BlenderConnection& conn)
{ {
meshPath.assign(bufSz, ' '); meshPath.assign(bufSz, ' ');
conn._readBuf(&meshPath[0], bufSz); conn._readBuf(&meshPath[0], bufSz);
SystemStringView meshPathAbs(meshPath); SystemStringConv meshPathAbs(meshPath);
SystemString meshPathRel = SystemString meshPathRel =
conn.m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(meshPathAbs); conn.m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(meshPathAbs.sys_str());
overlayMeshes.emplace_back(std::move(overlayName), overlayMeshes.emplace_back(std::move(overlayName),
ProjectPath(conn.m_loadedBlend.getProject().getProjectWorkingPath(), meshPathRel)); ProjectPath(conn.m_loadedBlend.getProject().getProjectWorkingPath(), meshPathRel));
} }
@ -1432,7 +1434,7 @@ BlenderConnection::DataStream::compileMesh(HMDLTopology topology,
{ {
if (m_parent->m_loadedType != BlendType::Mesh) if (m_parent->m_loadedType != BlendType::Mesh)
BlenderLog.report(logvisor::Fatal, _S("%s is not a MESH blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not a MESH blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[128]; char req[128];
snprintf(req, 128, "MESHCOMPILE %s %d", snprintf(req, 128, "MESHCOMPILE %s %d",
@ -1448,43 +1450,43 @@ BlenderConnection::DataStream::compileMesh(HMDLTopology topology,
} }
BlenderConnection::DataStream::Mesh BlenderConnection::DataStream::Mesh
BlenderConnection::DataStream::compileMesh(const std::string& name, BlenderConnection::DataStream::compileMesh(std::string_view name,
HMDLTopology topology, HMDLTopology topology,
int skinSlotCount, int skinSlotCount,
Mesh::SurfProgFunc surfProg) Mesh::SurfProgFunc surfProg)
{ {
if (m_parent->m_loadedType != BlendType::Area) if (m_parent->m_loadedType != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[128]; char req[128];
snprintf(req, 128, "MESHCOMPILENAME %s %s %d", name.c_str(), snprintf(req, 128, "MESHCOMPILENAME %s %s %d", name.data(),
MeshOutputModeString(topology), skinSlotCount); MeshOutputModeString(topology), skinSlotCount);
m_parent->_writeStr(req); m_parent->_writeStr(req);
char readBuf[256]; char readBuf[256];
m_parent->_readStr(readBuf, 256); m_parent->_readStr(readBuf, 256);
if (strcmp(readBuf, "OK")) if (strcmp(readBuf, "OK"))
BlenderLog.report(logvisor::Fatal, "unable to cook mesh '%s': %s", name.c_str(), readBuf); BlenderLog.report(logvisor::Fatal, "unable to cook mesh '%s': %s", name.data(), readBuf);
return Mesh(*m_parent, topology, skinSlotCount, surfProg); return Mesh(*m_parent, topology, skinSlotCount, surfProg);
} }
BlenderConnection::DataStream::ColMesh BlenderConnection::DataStream::ColMesh
BlenderConnection::DataStream::compileColMesh(const std::string& name) BlenderConnection::DataStream::compileColMesh(std::string_view name)
{ {
if (m_parent->m_loadedType != BlendType::Area) if (m_parent->m_loadedType != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[128]; char req[128];
snprintf(req, 128, "MESHCOMPILENAMECOLLISION %s", name.c_str()); snprintf(req, 128, "MESHCOMPILENAMECOLLISION %s", name.data());
m_parent->_writeStr(req); m_parent->_writeStr(req);
char readBuf[256]; char readBuf[256];
m_parent->_readStr(readBuf, 256); m_parent->_readStr(readBuf, 256);
if (strcmp(readBuf, "OK")) if (strcmp(readBuf, "OK"))
BlenderLog.report(logvisor::Fatal, "unable to cook collision mesh '%s': %s", name.c_str(), readBuf); BlenderLog.report(logvisor::Fatal, "unable to cook collision mesh '%s': %s", name.data(), readBuf);
return ColMesh(*m_parent); return ColMesh(*m_parent);
} }
@ -1494,7 +1496,7 @@ BlenderConnection::DataStream::compileColMeshes()
{ {
if (m_parent->m_loadedType != BlendType::ColMesh) if (m_parent->m_loadedType != BlendType::ColMesh)
BlenderLog.report(logvisor::Fatal, _S("%s is not a CMESH blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not a CMESH blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[128]; char req[128];
snprintf(req, 128, "MESHCOMPILECOLLISIONALL"); snprintf(req, 128, "MESHCOMPILECOLLISIONALL");
@ -1525,7 +1527,7 @@ BlenderConnection::DataStream::compileAllMeshes(HMDLTopology topology,
{ {
if (m_parent->m_loadedType != BlendType::Area) if (m_parent->m_loadedType != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[128]; char req[128];
snprintf(req, 128, "MESHCOMPILEALL %s %d %f", snprintf(req, 128, "MESHCOMPILEALL %s %d %f",
@ -1545,7 +1547,7 @@ std::vector<BlenderConnection::DataStream::Light> BlenderConnection::DataStream:
{ {
if (m_parent->m_loadedType != BlendType::Area) if (m_parent->m_loadedType != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("LIGHTCOMPILEALL"); m_parent->_writeStr("LIGHTCOMPILEALL");
@ -1566,14 +1568,14 @@ std::vector<BlenderConnection::DataStream::Light> BlenderConnection::DataStream:
return ret; return ret;
} }
void BlenderConnection::DataStream::compileGuiFrame(const std::string& pathOut, int version) void BlenderConnection::DataStream::compileGuiFrame(std::string_view pathOut, int version)
{ {
if (m_parent->m_loadedType != BlendType::Frame) if (m_parent->m_loadedType != BlendType::Frame)
BlenderLog.report(logvisor::Fatal, _S("%s is not a FRAME blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not a FRAME blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[512]; char req[512];
snprintf(req, 512, "FRAMECOMPILE '%s' %d", pathOut.c_str(), version); snprintf(req, 512, "FRAMECOMPILE '%s' %d", pathOut.data(), version);
m_parent->_writeStr(req); m_parent->_writeStr(req);
char readBuf[1024]; char readBuf[1024];
@ -1588,13 +1590,13 @@ void BlenderConnection::DataStream::compileGuiFrame(const std::string& pathOut,
break; break;
std::string readStr(readBuf); std::string readStr(readBuf);
SystemStringView absolute(readStr); SystemStringConv absolute(readStr);
auto& proj = m_parent->m_loadedBlend.getProject(); auto& proj = m_parent->m_loadedBlend.getProject();
SystemString relative; SystemString relative;
if (PathRelative(absolute.c_str())) if (PathRelative(absolute.c_str()))
relative = absolute.sys_str(); relative = absolute.sys_str();
else else
relative = proj.getProjectRootPath().getProjectRelativeFromAbsolute(absolute); relative = proj.getProjectRootPath().getProjectRelativeFromAbsolute(absolute.sys_str());
hecl::ProjectPath path(proj.getProjectWorkingPath(), relative); hecl::ProjectPath path(proj.getProjectWorkingPath(), relative);
snprintf(req, 512, "%016" PRIX64 , path.hash().val64()); snprintf(req, 512, "%016" PRIX64 , path.hash().val64());
@ -1621,10 +1623,10 @@ std::vector<ProjectPath> BlenderConnection::DataStream::getTextures()
m_parent->_readBuf(&bufSz, 4); m_parent->_readBuf(&bufSz, 4);
std::string readStr(bufSz, ' '); std::string readStr(bufSz, ' ');
m_parent->_readBuf(&readStr[0], bufSz); m_parent->_readBuf(&readStr[0], bufSz);
SystemStringView absolute(readStr); SystemStringConv absolute(readStr);
SystemString relative = SystemString relative =
m_parent->m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(absolute); m_parent->m_loadedBlend.getProject().getProjectRootPath().getProjectRelativeFromAbsolute(absolute.sys_str());
texs.emplace_back(m_parent->m_loadedBlend.getProject().getProjectWorkingPath(), relative); texs.emplace_back(m_parent->m_loadedBlend.getProject().getProjectWorkingPath(), relative);
} }
@ -1635,7 +1637,7 @@ BlenderConnection::DataStream::Actor BlenderConnection::DataStream::compileActor
{ {
if (m_parent->m_loadedType != BlendType::Actor) if (m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("ACTORCOMPILE"); m_parent->_writeStr("ACTORCOMPILE");
@ -1652,7 +1654,7 @@ BlenderConnection::DataStream::compileActorCharacterOnly()
{ {
if (m_parent->m_loadedType != BlendType::Actor) if (m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("ACTORCOMPILECHARACTERONLY"); m_parent->_writeStr("ACTORCOMPILECHARACTERONLY");
@ -1665,14 +1667,14 @@ BlenderConnection::DataStream::compileActorCharacterOnly()
} }
BlenderConnection::DataStream::Actor::Action BlenderConnection::DataStream::Actor::Action
BlenderConnection::DataStream::compileActionChannelsOnly(const std::string& name) BlenderConnection::DataStream::compileActionChannelsOnly(std::string_view name)
{ {
if (m_parent->m_loadedType != BlendType::Actor) if (m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[128]; char req[128];
snprintf(req, 128, "ACTIONCOMPILECHANNELSONLY %s", name.c_str()); snprintf(req, 128, "ACTIONCOMPILECHANNELSONLY %s", name.data());
m_parent->_writeStr(req); m_parent->_writeStr(req);
char readBuf[256]; char readBuf[256];
@ -1688,7 +1690,7 @@ BlenderConnection::DataStream::compileWorld()
{ {
if (m_parent->m_loadedType != BlendType::World) if (m_parent->m_loadedType != BlendType::World)
BlenderLog.report(logvisor::Fatal, _S("%s is not an WORLD blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an WORLD blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("WORLDCOMPILE"); m_parent->_writeStr("WORLDCOMPILE");
@ -1704,7 +1706,7 @@ std::vector<std::string> BlenderConnection::DataStream::getArmatureNames()
{ {
if (m_parent->m_loadedType != BlendType::Actor) if (m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("GETARMATURENAMES"); m_parent->_writeStr("GETARMATURENAMES");
@ -1735,7 +1737,7 @@ std::vector<std::string> BlenderConnection::DataStream::getSubtypeNames()
{ {
if (m_parent->m_loadedType != BlendType::Actor) if (m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("GETSUBTYPENAMES"); m_parent->_writeStr("GETSUBTYPENAMES");
@ -1766,7 +1768,7 @@ std::vector<std::string> BlenderConnection::DataStream::getActionNames()
{ {
if (m_parent->m_loadedType != BlendType::Actor) if (m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("GETACTIONNAMES"); m_parent->_writeStr("GETACTIONNAMES");
@ -1793,14 +1795,14 @@ std::vector<std::string> BlenderConnection::DataStream::getActionNames()
return ret; return ret;
} }
std::vector<std::string> BlenderConnection::DataStream::getSubtypeOverlayNames(const std::string& name) std::vector<std::string> BlenderConnection::DataStream::getSubtypeOverlayNames(std::string_view name)
{ {
if (m_parent->m_loadedType != BlendType::Actor) if (m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[128]; char req[128];
snprintf(req, 128, "GETSUBTYPEOVERLAYNAMES %s", name.c_str()); snprintf(req, 128, "GETSUBTYPEOVERLAYNAMES %s", name.data());
m_parent->_writeStr(req); m_parent->_writeStr(req);
char readBuf[256]; char readBuf[256];
@ -1827,17 +1829,17 @@ std::vector<std::string> BlenderConnection::DataStream::getSubtypeOverlayNames(c
} }
std::unordered_map<std::string, BlenderConnection::DataStream::Matrix3f> std::unordered_map<std::string, BlenderConnection::DataStream::Matrix3f>
BlenderConnection::DataStream::getBoneMatrices(const std::string& name) BlenderConnection::DataStream::getBoneMatrices(std::string_view name)
{ {
if (name.empty()) if (name.empty())
return {}; return {};
if (m_parent->m_loadedType != BlendType::Actor) if (m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[128]; char req[128];
snprintf(req, 128, "GETBONEMATRICES %s", name.c_str()); snprintf(req, 128, "GETBONEMATRICES %s", name.data());
m_parent->_writeStr(req); m_parent->_writeStr(req);
char readBuf[256]; char readBuf[256];
@ -1877,17 +1879,17 @@ BlenderConnection::DataStream::getBoneMatrices(const std::string& name)
} }
bool BlenderConnection::DataStream::renderPvs(const std::string& path, const atVec3f& location) bool BlenderConnection::DataStream::renderPvs(std::string_view path, const atVec3f& location)
{ {
if (path.empty()) if (path.empty())
return false; return false;
if (m_parent->m_loadedType != BlendType::Area) if (m_parent->m_loadedType != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[256]; char req[256];
snprintf(req, 256, "RENDERPVS %s %f %f %f", path.c_str(), snprintf(req, 256, "RENDERPVS %s %f %f %f", path.data(),
location.vec[0], location.vec[1], location.vec[2]); location.vec[0], location.vec[1], location.vec[2]);
m_parent->_writeStr(req); m_parent->_writeStr(req);
@ -1895,29 +1897,29 @@ bool BlenderConnection::DataStream::renderPvs(const std::string& path, const atV
m_parent->_readStr(readBuf, 256); m_parent->_readStr(readBuf, 256);
if (strcmp(readBuf, "OK")) if (strcmp(readBuf, "OK"))
BlenderLog.report(logvisor::Fatal, "unable to render PVS for: %s; %s", BlenderLog.report(logvisor::Fatal, "unable to render PVS for: %s; %s",
m_parent->m_loadedBlend.getAbsolutePathUTF8().c_str(), readBuf); m_parent->m_loadedBlend.getAbsolutePathUTF8().data(), readBuf);
return true; return true;
} }
bool BlenderConnection::DataStream::renderPvsLight(const std::string& path, const std::string& lightName) bool BlenderConnection::DataStream::renderPvsLight(std::string_view path, std::string_view lightName)
{ {
if (path.empty()) if (path.empty())
return false; return false;
if (m_parent->m_loadedType != BlendType::Area) if (m_parent->m_loadedType != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
char req[256]; char req[256];
snprintf(req, 256, "RENDERPVSLIGHT %s %s", path.c_str(), lightName.c_str()); snprintf(req, 256, "RENDERPVSLIGHT %s %s", path.data(), lightName.data());
m_parent->_writeStr(req); m_parent->_writeStr(req);
char readBuf[256]; char readBuf[256];
m_parent->_readStr(readBuf, 256); m_parent->_readStr(readBuf, 256);
if (strcmp(readBuf, "OK")) if (strcmp(readBuf, "OK"))
BlenderLog.report(logvisor::Fatal, "unable to render PVS light %s for: %s; %s", lightName.c_str(), BlenderLog.report(logvisor::Fatal, "unable to render PVS light %s for: %s; %s", lightName.data(),
m_parent->m_loadedBlend.getAbsolutePathUTF8().c_str(), readBuf); m_parent->m_loadedBlend.getAbsolutePathUTF8().data(), readBuf);
return true; return true;
} }
@ -1926,7 +1928,7 @@ BlenderConnection::DataStream::MapArea BlenderConnection::DataStream::compileMap
{ {
if (m_parent->m_loadedType != BlendType::MapArea) if (m_parent->m_loadedType != BlendType::MapArea)
BlenderLog.report(logvisor::Fatal, _S("%s is not a MAPAREA blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not a MAPAREA blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("MAPAREACOMPILE"); m_parent->_writeStr("MAPAREACOMPILE");
@ -1934,7 +1936,7 @@ BlenderConnection::DataStream::MapArea BlenderConnection::DataStream::compileMap
m_parent->_readStr(readBuf, 256); m_parent->_readStr(readBuf, 256);
if (strcmp(readBuf, "OK")) if (strcmp(readBuf, "OK"))
BlenderLog.report(logvisor::Fatal, "unable to compile map area: %s; %s", BlenderLog.report(logvisor::Fatal, "unable to compile map area: %s; %s",
m_parent->m_loadedBlend.getAbsolutePathUTF8().c_str(), readBuf); m_parent->m_loadedBlend.getAbsolutePathUTF8().data(), readBuf);
return {*m_parent}; return {*m_parent};
} }
@ -1943,7 +1945,7 @@ BlenderConnection::DataStream::MapUniverse BlenderConnection::DataStream::compil
{ {
if (m_parent->m_loadedType != BlendType::MapUniverse) if (m_parent->m_loadedType != BlendType::MapUniverse)
BlenderLog.report(logvisor::Fatal, _S("%s is not a MAPUNIVERSE blend"), BlenderLog.report(logvisor::Fatal, _S("%s is not a MAPUNIVERSE blend"),
m_parent->m_loadedBlend.getAbsolutePath().c_str()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("MAPUNIVERSECOMPILE"); m_parent->_writeStr("MAPUNIVERSECOMPILE");
@ -1951,7 +1953,7 @@ BlenderConnection::DataStream::MapUniverse BlenderConnection::DataStream::compil
m_parent->_readStr(readBuf, 256); m_parent->_readStr(readBuf, 256);
if (strcmp(readBuf, "OK")) if (strcmp(readBuf, "OK"))
BlenderLog.report(logvisor::Fatal, "unable to compile map universe: %s; %s", BlenderLog.report(logvisor::Fatal, "unable to compile map universe: %s; %s",
m_parent->m_loadedBlend.getAbsolutePathUTF8().c_str(), readBuf); m_parent->m_loadedBlend.getAbsolutePathUTF8().data(), readBuf);
return {*m_parent}; return {*m_parent};
} }

View File

@ -10,24 +10,26 @@ namespace hecl
extern CVar* com_developer; extern CVar* com_developer;
extern CVar* com_enableCheats; extern CVar* com_enableCheats;
CVar::CVar(const std::string& name, const std::string &value, const std::string &help, EType type, EFlags flags, CVarManager& parent) using namespace std::literals;
CVar::CVar(std::string_view name, std::string_view value, std::string_view help, EType type, EFlags flags, CVarManager& parent)
: m_mgr(parent) : m_mgr(parent)
{ {
m_name= name; m_name = std::string(name);
m_value = value; m_value = std::string(value);
m_defaultValue = value; m_defaultValue = std::string(value);
m_help = help; m_help = help;
m_type = type; m_type = type;
m_flags = flags; m_flags = flags;
m_allowedWrite = false; m_allowedWrite = false;
} }
CVar::CVar(const std::string& name, const std::string& value, const std::string& help, CVar::EFlags flags, CVarManager& parent) CVar::CVar(std::string_view name, std::string_view value, std::string_view help, CVar::EFlags flags, CVarManager& parent)
: m_mgr(parent) : m_mgr(parent)
{ {
m_flags = flags; m_flags = flags;
m_allowedWrite = false; m_allowedWrite = false;
m_name = name; m_name = std::string(name);
m_help = help; m_help = help;
m_type = EType::Literal; m_type = EType::Literal;
@ -43,10 +45,10 @@ CVar::CVar(const std::string& name, const std::string& value, const std::string&
m_flags = flags; m_flags = flags;
} }
CVar::CVar(const std::string& name, const atVec4f& value, const std::string& help, EFlags flags, CVarManager& parent) CVar::CVar(std::string_view name, const atVec4f& value, std::string_view help, EFlags flags, CVarManager& parent)
: m_mgr(parent) : m_mgr(parent)
{ {
m_name= name; m_name = std::string(name);
m_help = help; m_help = help;
m_type = EType::Vec4f; m_type = EType::Vec4f;
m_flags = flags; m_flags = flags;
@ -64,10 +66,10 @@ CVar::CVar(const std::string& name, const atVec4f& value, const std::string& hel
m_flags = flags; m_flags = flags;
} }
CVar::CVar(const std::string& name, float value, const std::string& help, EFlags flags, CVarManager& parent) CVar::CVar(std::string_view name, float value, std::string_view help, EFlags flags, CVarManager& parent)
: m_mgr(parent) : m_mgr(parent)
{ {
m_name= name; m_name = std::string(name);
m_help = help; m_help = help;
m_type = EType::Float; m_type = EType::Float;
m_flags = flags; m_flags = flags;
@ -85,10 +87,10 @@ CVar::CVar(const std::string& name, float value, const std::string& help, EFlags
m_flags = flags; m_flags = flags;
} }
CVar::CVar(const std::string& name, bool value, const std::string& help, CVar::EFlags flags, CVarManager& parent) CVar::CVar(std::string_view name, bool value, std::string_view help, CVar::EFlags flags, CVarManager& parent)
: m_mgr(parent) : m_mgr(parent)
{ {
m_name= name; m_name = std::string(name);
m_help = help; m_help = help;
m_type = EType::Boolean; m_type = EType::Boolean;
m_flags = flags; m_flags = flags;
@ -106,10 +108,10 @@ CVar::CVar(const std::string& name, bool value, const std::string& help, CVar::E
m_flags = flags; m_flags = flags;
} }
CVar::CVar(const std::string& name, int value, const std::string& help, CVar::EFlags flags, CVarManager& parent) CVar::CVar(std::string_view name, int value, std::string_view help, CVar::EFlags flags, CVarManager& parent)
: m_mgr(parent) : m_mgr(parent)
{ {
m_name= name; m_name = std::string(name);
m_help = help; m_help = help;
m_type = EType::Integer; m_type = EType::Integer;
m_flags = flags; m_flags = flags;
@ -287,9 +289,9 @@ bool CVar::fromBoolean(bool val)
return false; return false;
if (val) if (val)
m_value = "true"; m_value = "true"sv;
else else
m_value = "false"; m_value = "false"sv;
setModified(); setModified();
return true; return true;
@ -313,7 +315,7 @@ bool CVar::fromInteger(int val)
return true; return true;
} }
bool CVar::fromLiteral(const std::string& val) bool CVar::fromLiteral(std::string_view val)
{ {
if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean())) if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean()))
return false; return false;
@ -331,7 +333,7 @@ bool CVar::fromLiteral(const std::string& val)
return true; return true;
} }
bool CVar::fromLiteral(const std::wstring& val) bool CVar::fromLiteral(std::wstring_view val)
{ {
if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean())) if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean()))
return false; return false;

View File

@ -41,7 +41,7 @@ void CVarManager::update()
bool CVarManager::registerCVar(CVar* cvar) bool CVarManager::registerCVar(CVar* cvar)
{ {
std::string tmp = cvar->name(); std::string tmp(cvar->name());
athena::utility::tolower(tmp); athena::utility::tolower(tmp);
if (m_cvars.find(tmp) != m_cvars.end()) if (m_cvars.find(tmp) != m_cvars.end())
return false; return false;
@ -50,13 +50,15 @@ bool CVarManager::registerCVar(CVar* cvar)
return true; return true;
} }
CVar* CVarManager::findCVar(std::string name) CVar* CVarManager::findCVar(std::string_view name)
{ {
athena::utility::tolower(name); std::string lower(name);
if (m_cvars.find(name) == m_cvars.end()) athena::utility::tolower(lower);
auto search = m_cvars.find(lower);
if (search == m_cvars.end())
return nullptr; return nullptr;
return m_cvars[name]; return search->second;
} }
std::vector<CVar*> CVarManager::archivedCVars() const std::vector<CVar*> CVarManager::archivedCVars() const
@ -87,7 +89,7 @@ void CVarManager::deserialize(CVar* cvar)
#if _WIN32 #if _WIN32
hecl::SystemString filename = m_store.getStoreRoot() + _S('/') + com_configfile->toWideLiteral(); hecl::SystemString filename = m_store.getStoreRoot() + _S('/') + com_configfile->toWideLiteral();
#else #else
hecl::SystemString filename = m_store.getStoreRoot() + _S('/') + com_configfile->toLiteral(); hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _S('/') + com_configfile->toLiteral();
#endif #endif
hecl::Sstat st; hecl::Sstat st;
@ -147,9 +149,9 @@ void CVarManager::serialize()
container.cvarCount = container.cvars.size(); container.cvarCount = container.cvars.size();
#if _WIN32 #if _WIN32
hecl::SystemString filename = m_store.getStoreRoot() + _S('/') + com_configfile->toWideLiteral(); hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _S('/') + com_configfile->toWideLiteral();
#else #else
hecl::SystemString filename = m_store.getStoreRoot() + _S('/') + com_configfile->toLiteral(); hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _S('/') + com_configfile->toLiteral();
#endif #endif
if (m_useBinary) if (m_useBinary)

View File

@ -35,7 +35,7 @@ void ClientProcess::BufferTransaction::run(BlenderToken& btok)
if (r.hasError()) if (r.hasError())
{ {
Log.report(logvisor::Fatal, _S("unable to background-buffer '%s'"), Log.report(logvisor::Fatal, _S("unable to background-buffer '%s'"),
m_path.getAbsolutePath().c_str()); m_path.getAbsolutePath().data());
return; return;
} }
if (m_offset) if (m_offset)
@ -162,11 +162,11 @@ bool ClientProcess::syncCook(const hecl::ProjectPath& path, Database::IDataSpec*
{ {
if (path.getAuxInfo().empty()) if (path.getAuxInfo().empty())
LogModule.report(logvisor::Info, _S("Cooking %s"), LogModule.report(logvisor::Info, _S("Cooking %s"),
path.getRelativePath().c_str()); path.getRelativePath().data());
else else
LogModule.report(logvisor::Info, _S("Cooking %s|%s"), LogModule.report(logvisor::Info, _S("Cooking %s|%s"),
path.getRelativePath().c_str(), path.getRelativePath().data(),
path.getAuxInfo().c_str()); path.getAuxInfo().data());
spec->doCook(path, cooked, false, btok, [](const SystemChar*) {}); spec->doCook(path, cooked, false, btok, [](const SystemChar*) {});
} }
return true; return true;

View File

@ -345,7 +345,7 @@ void Lexer::consumeAllTokens(Parser& parser)
if (hecl::VerbosityLevel > 1) if (hecl::VerbosityLevel > 1)
{ {
printf("%s\n", m_diag.getSource().c_str()); printf("%s\n", m_diag.getSource().data());
PrintTree(firstNode); PrintTree(firstNode);
printf("\n"); printf("\n");
} }

View File

@ -8,19 +8,19 @@ namespace hecl
namespace Frontend namespace Frontend
{ {
void Parser::skipWhitespace(std::string::const_iterator& it) void Parser::skipWhitespace(std::string_view::const_iterator& it)
{ {
while (it != m_source->cend()) while (it != m_source.cend())
{ {
while (it != m_source->cend() && isspace(*it)) while (it != m_source.cend() && isspace(*it))
++it; ++it;
/* Skip comment line */ /* Skip comment line */
if (it != m_source->cend() && *it == '#') if (it != m_source.cend() && *it == '#')
{ {
while (it != m_source->cend() && *it != '\n') while (it != m_source.cend() && *it != '\n')
++it; ++it;
if (it != m_source->cend() && *it == '\n') if (it != m_source.cend() && *it == '\n')
++it; ++it;
continue; continue;
} }
@ -28,17 +28,17 @@ void Parser::skipWhitespace(std::string::const_iterator& it)
} }
} }
void Parser::reset(const std::string& source) void Parser::reset(std::string_view source)
{ {
m_source = &source; m_source = source;
m_sourceIt = m_source->cbegin(); m_sourceIt = m_source.cbegin();
m_parenStack.clear(); m_parenStack.clear();
m_reset = true; m_reset = true;
} }
Parser::Token Parser::consumeToken() Parser::Token Parser::consumeToken()
{ {
if (!m_source) if (m_source.empty())
return Parser::Token(TokenType::None, SourceLocation()); return Parser::Token(TokenType::None, SourceLocation());
/* If parser has just been reset, emit begin token */ /* If parser has just been reset, emit begin token */
@ -52,7 +52,7 @@ Parser::Token Parser::consumeToken()
skipWhitespace(m_sourceIt); skipWhitespace(m_sourceIt);
/* Check for source end */ /* Check for source end */
if (m_sourceIt == m_source->cend()) if (m_sourceIt == m_source.cend())
return Parser::Token(TokenType::SourceEnd, getLocation()); return Parser::Token(TokenType::SourceEnd, getLocation());
/* Check for numeric literal */ /* Check for numeric literal */
@ -72,13 +72,13 @@ Parser::Token Parser::consumeToken()
if (*m_sourceIt == '.') if (*m_sourceIt == '.')
{ {
int count = 0; int count = 0;
std::string::const_iterator tmp = m_sourceIt + 1; std::string_view::const_iterator tmp = m_sourceIt + 1;
if (tmp != m_source->cend()) if (tmp != m_source.cend())
{ {
for (int i=0 ; i<4 ; ++i) for (int i=0 ; i<4 ; ++i)
{ {
std::string::const_iterator tmp2 = tmp + i; std::string_view::const_iterator tmp2 = tmp + i;
if (tmp2 == m_source->cend()) if (tmp2 == m_source.cend())
break; break;
char ch = tolower(*tmp2); char ch = tolower(*tmp2);
if (ch >= 'w' && ch <= 'z') if (ch >= 'w' && ch <= 'z')
@ -94,7 +94,7 @@ Parser::Token Parser::consumeToken()
Parser::Token tok(TokenType::VectorSwizzle, getLocation()); Parser::Token tok(TokenType::VectorSwizzle, getLocation());
for (int i=0 ; i<count ; ++i) for (int i=0 ; i<count ; ++i)
{ {
std::string::const_iterator tmp2 = tmp + i; std::string_view::const_iterator tmp2 = tmp + i;
tok.m_tokenString += tolower(*tmp2); tok.m_tokenString += tolower(*tmp2);
} }
m_sourceIt = tmp + count; m_sourceIt = tmp + count;
@ -137,10 +137,10 @@ Parser::Token Parser::consumeToken()
/* Check for function start */ /* Check for function start */
if (isalpha(*m_sourceIt) || *m_sourceIt == '_') if (isalpha(*m_sourceIt) || *m_sourceIt == '_')
{ {
std::string::const_iterator tmp = m_sourceIt + 1; std::string_view::const_iterator tmp = m_sourceIt + 1;
while (tmp != m_source->cend() && (isalnum(*tmp) || *tmp == '_') && *tmp != '(') while (tmp != m_source.cend() && (isalnum(*tmp) || *tmp == '_') && *tmp != '(')
++tmp; ++tmp;
std::string::const_iterator nameEnd = tmp; std::string_view::const_iterator nameEnd = tmp;
skipWhitespace(tmp); skipWhitespace(tmp);
if (*tmp == '(') if (*tmp == '(')
{ {
@ -172,9 +172,9 @@ Parser::Token Parser::consumeToken()
SourceLocation Parser::getLocation() const SourceLocation Parser::getLocation() const
{ {
if (!m_source) if (m_source.empty())
return SourceLocation(); return SourceLocation();
std::string::const_iterator it = m_source->cbegin(); std::string_view::const_iterator it = m_source.cbegin();
int line = 0; int line = 0;
int col = 0; int col = 0;
for (; it != m_sourceIt ; ++it) for (; it != m_sourceIt ; ++it)

View File

@ -45,10 +45,10 @@ static inline bool CheckNewLineAdvance(std::string::const_iterator& it)
return false; return false;
} }
Project::ConfigFile::ConfigFile(const Project& project, const SystemString& name, Project::ConfigFile::ConfigFile(const Project& project, SystemStringView name,
const SystemString& subdir) SystemStringView subdir)
{ {
m_filepath = project.m_rootPath.getAbsolutePath() + subdir + name; m_filepath = SystemString(project.m_rootPath.getAbsolutePath()) + subdir.data() + name.data();
} }
std::vector<std::string>& Project::ConfigFile::lockAndRead() std::vector<std::string>& Project::ConfigFile::lockAndRead()
@ -89,13 +89,13 @@ std::vector<std::string>& Project::ConfigFile::lockAndRead()
return m_lines; return m_lines;
} }
void Project::ConfigFile::addLine(const std::string& line) void Project::ConfigFile::addLine(std::string_view line)
{ {
if (!checkForLine(line)) if (!checkForLine(line))
m_lines.push_back(line); m_lines.emplace_back(line);
} }
void Project::ConfigFile::removeLine(const std::string& refLine) void Project::ConfigFile::removeLine(std::string_view refLine)
{ {
if (!m_lockedFile) if (!m_lockedFile)
{ {
@ -116,7 +116,7 @@ void Project::ConfigFile::removeLine(const std::string& refLine)
} }
} }
bool Project::ConfigFile::checkForLine(const std::string& refLine) bool Project::ConfigFile::checkForLine(std::string_view refLine)
{ {
if (!m_lockedFile) if (!m_lockedFile)
{ {
@ -210,15 +210,16 @@ Project::Project(const ProjectRootPath& rootPath)
{ {
/* Stat for existing project directory (must already exist) */ /* Stat for existing project directory (must already exist) */
Sstat myStat; Sstat myStat;
if (hecl::Stat(m_rootPath.getAbsolutePath().c_str(), &myStat)) if (hecl::Stat(m_rootPath.getAbsolutePath().data(), &myStat))
{ {
LogModule.report(logvisor::Error, _S("unable to stat %s"), m_rootPath.getAbsolutePath().c_str()); LogModule.report(logvisor::Error, _S("unable to stat %s"), m_rootPath.getAbsolutePath().data());
return; return;
} }
if (!S_ISDIR(myStat.st_mode)) if (!S_ISDIR(myStat.st_mode))
{ {
LogModule.report(logvisor::Error, _S("provided path must be a directory; '%s' isn't"), m_rootPath.getAbsolutePath().c_str()); LogModule.report(logvisor::Error, _S("provided path must be a directory; '%s' isn't"),
m_rootPath.getAbsolutePath().data());
return; return;
} }
@ -228,7 +229,7 @@ Project::Project(const ProjectRootPath& rootPath)
/* Ensure beacon is valid or created */ /* Ensure beacon is valid or created */
ProjectPath beaconPath(m_dotPath, _S("beacon")); ProjectPath beaconPath(m_dotPath, _S("beacon"));
FILE* bf = hecl::Fopen(beaconPath.getAbsolutePath().c_str(), _S("a+b")); FILE* bf = hecl::Fopen(beaconPath.getAbsolutePath().data(), _S("a+b"));
struct BeaconStruct struct BeaconStruct
{ {
hecl::FourCC magic; hecl::FourCC magic;
@ -279,7 +280,7 @@ bool Project::removePaths(const std::vector<ProjectPath>& paths, bool recursive)
{ {
for (const ProjectPath& path : paths) for (const ProjectPath& path : paths)
{ {
std::string recursiveBase = path.getRelativePathUTF8(); auto recursiveBase = path.getRelativePathUTF8();
for (auto it = existingPaths.begin(); for (auto it = existingPaths.begin();
it != existingPaths.end();) it != existingPaths.end();)
{ {
@ -319,9 +320,9 @@ void Project::rescanDataSpecs()
for (const DataSpecEntry* spec : DATA_SPEC_REGISTRY) for (const DataSpecEntry* spec : DATA_SPEC_REGISTRY)
{ {
hecl::SystemString specStr(spec->m_name); hecl::SystemString specStr(spec->m_name);
SystemUTF8View specUTF8(specStr); SystemUTF8Conv specUTF8(specStr);
m_compiledSpecs.push_back({*spec, ProjectPath(m_cookedRoot, hecl::SystemString(spec->m_name) + _S(".spec")), m_compiledSpecs.push_back({*spec, ProjectPath(m_cookedRoot, hecl::SystemString(spec->m_name) + _S(".spec")),
m_specs.checkForLine(specUTF8) ? true : false}); m_specs.checkForLine(specUTF8.str())});
} }
m_specs.unlockAndDiscard(); m_specs.unlockAndDiscard();
} }
@ -331,8 +332,8 @@ bool Project::enableDataSpecs(const std::vector<SystemString>& specs)
m_specs.lockAndRead(); m_specs.lockAndRead();
for (const SystemString& spec : specs) for (const SystemString& spec : specs)
{ {
SystemUTF8View specView(spec); SystemUTF8Conv specView(spec);
m_specs.addLine(specView); m_specs.addLine(specView.str());
} }
bool result = m_specs.unlockAndCommit(); bool result = m_specs.unlockAndCommit();
rescanDataSpecs(); rescanDataSpecs();
@ -344,8 +345,8 @@ bool Project::disableDataSpecs(const std::vector<SystemString>& specs)
m_specs.lockAndRead(); m_specs.lockAndRead();
for (const SystemString& spec : specs) for (const SystemString& spec : specs)
{ {
SystemUTF8View specView(spec); SystemUTF8Conv specView(spec);
m_specs.removeLine(specView); m_specs.removeLine(specView.str());
} }
bool result = m_specs.unlockAndCommit(); bool result = m_specs.unlockAndCommit();
rescanDataSpecs(); rescanDataSpecs();
@ -446,7 +447,7 @@ static void VisitDirectory(const ProjectPath& dir,
/* Pass 2: child files */ /* Pass 2: child files */
int progNum = 0; int progNum = 0;
float progDenom = childFileCount; float progDenom = childFileCount;
progress.changeDir(dir.getLastComponent()); progress.changeDir(dir.getLastComponent().data());
for (auto& child : children) for (auto& child : children)
{ {
if (child.second.getPathType() == ProjectPath::Type::File) if (child.second.getPathType() == ProjectPath::Type::File)
@ -494,7 +495,7 @@ bool Project::cookPath(const ProjectPath& path, FProgress progress,
case ProjectPath::Type::File: case ProjectPath::Type::File:
case ProjectPath::Type::Glob: case ProjectPath::Type::Glob:
{ {
cookProg.changeFile(path.getLastComponent(), 0.0); cookProg.changeFile(path.getLastComponent().data(), 0.0);
VisitFile(path, force, fast, m_cookSpecs, cookProg, cp); VisitFile(path, force, fast, m_cookSpecs, cookProg, cp);
break; break;
} }

View File

@ -7,12 +7,12 @@ namespace hecl
static const SystemRegex regPATHCOMP(_S("[/\\\\]*([^/\\\\]+)"), SystemRegex::ECMAScript|SystemRegex::optimize); static const SystemRegex regPATHCOMP(_S("[/\\\\]*([^/\\\\]+)"), SystemRegex::ECMAScript|SystemRegex::optimize);
static const SystemRegex regDRIVELETTER(_S("^([^/]*)/"), SystemRegex::ECMAScript|SystemRegex::optimize); static const SystemRegex regDRIVELETTER(_S("^([^/]*)/"), SystemRegex::ECMAScript|SystemRegex::optimize);
static SystemString CanonRelPath(const SystemString& path) static SystemString CanonRelPath(SystemStringView path)
{ {
/* Tokenize Path */ /* Tokenize Path */
std::vector<SystemString> comps; std::vector<SystemString> comps;
hecl::SystemRegexMatch matches; hecl::SystemRegexMatch matches;
SystemString in = path; SystemString in(path);
SanitizePath(in); SanitizePath(in);
for (; std::regex_search(in, matches, regPATHCOMP) ; in = matches.suffix()) for (; std::regex_search(in, matches, regPATHCOMP) ; in = matches.suffix())
{ {
@ -24,7 +24,7 @@ static SystemString CanonRelPath(const SystemString& path)
if (comps.empty()) if (comps.empty())
{ {
/* Unable to resolve outside project */ /* Unable to resolve outside project */
LogModule.report(logvisor::Fatal, _S("Unable to resolve outside project root in %s"), path.c_str()); LogModule.report(logvisor::Fatal, _S("Unable to resolve outside project root in %s"), path.data());
return _S("."); return _S(".");
} }
comps.pop_back(); comps.pop_back();
@ -51,7 +51,7 @@ static SystemString CanonRelPath(const SystemString& path)
return _S("."); return _S(".");
} }
static SystemString CanonRelPath(const SystemString& path, const ProjectRootPath& projectRoot) static SystemString CanonRelPath(SystemStringView path, const ProjectRootPath& projectRoot)
{ {
/* Absolute paths not allowed; attempt to make project-relative */ /* Absolute paths not allowed; attempt to make project-relative */
if (IsAbsolute(path)) if (IsAbsolute(path))
@ -59,7 +59,7 @@ static SystemString CanonRelPath(const SystemString& path, const ProjectRootPath
return CanonRelPath(path); return CanonRelPath(path);
} }
void ProjectPath::assign(Database::Project& project, const SystemString& path) void ProjectPath::assign(Database::Project& project, SystemStringView path)
{ {
m_proj = &project; m_proj = &project;
@ -74,7 +74,7 @@ void ProjectPath::assign(Database::Project& project, const SystemString& path)
usePath = path; usePath = path;
m_relPath = CanonRelPath(usePath, project.getProjectRootPath()); m_relPath = CanonRelPath(usePath, project.getProjectRootPath());
m_absPath = project.getProjectRootPath().getAbsolutePath() + _S('/') + m_relPath; m_absPath = SystemString(project.getProjectRootPath().getAbsolutePath()) + _S('/') + m_relPath;
SanitizePath(m_relPath); SanitizePath(m_relPath);
SanitizePath(m_absPath); SanitizePath(m_absPath);
@ -82,14 +82,14 @@ void ProjectPath::assign(Database::Project& project, const SystemString& path)
} }
#if HECL_UCS2 #if HECL_UCS2
void ProjectPath::assign(Database::Project& project, const std::string& path) void ProjectPath::assign(Database::Project& project, std::string_view path)
{ {
std::wstring wpath = UTF8ToWide(path); std::wstring wpath = UTF8ToWide(path);
assign(project, wpath); assign(project, wpath);
} }
#endif #endif
void ProjectPath::assign(const ProjectPath& parentPath, const SystemString& path) void ProjectPath::assign(const ProjectPath& parentPath, SystemStringView path)
{ {
m_proj = parentPath.m_proj; m_proj = parentPath.m_proj;
@ -104,7 +104,7 @@ void ProjectPath::assign(const ProjectPath& parentPath, const SystemString& path
usePath = path; usePath = path;
m_relPath = CanonRelPath(parentPath.m_relPath + _S('/') + usePath); m_relPath = CanonRelPath(parentPath.m_relPath + _S('/') + usePath);
m_absPath = m_proj->getProjectRootPath().getAbsolutePath() + _S('/') + m_relPath; m_absPath = SystemString(m_proj->getProjectRootPath().getAbsolutePath()) + _S('/') + m_relPath;
SanitizePath(m_relPath); SanitizePath(m_relPath);
SanitizePath(m_absPath); SanitizePath(m_absPath);
@ -112,7 +112,7 @@ void ProjectPath::assign(const ProjectPath& parentPath, const SystemString& path
} }
#if HECL_UCS2 #if HECL_UCS2
void ProjectPath::assign(const ProjectPath& parentPath, const std::string& path) void ProjectPath::assign(const ProjectPath& parentPath, std::string_view path)
{ {
std::wstring wpath = UTF8ToWide(path); std::wstring wpath = UTF8ToWide(path);
assign(parentPath, wpath); assign(parentPath, wpath);
@ -125,7 +125,7 @@ ProjectPath ProjectPath::getCookedPath(const Database::DataSpecEntry& spec) cons
ProjectPath ret(m_proj->getProjectCookedPath(spec), woExt.getRelativePath()); ProjectPath ret(m_proj->getProjectCookedPath(spec), woExt.getRelativePath());
if (getAuxInfo().size()) if (getAuxInfo().size())
return ret.getWithExtension((_S('.') + getAuxInfo()).c_str()); return ret.getWithExtension((SystemString(_S(".")) + getAuxInfo().data()).c_str());
else else
return ret; return ret;
} }
@ -154,7 +154,7 @@ Time ProjectPath::getModtime() const
getGlobResults(globResults); getGlobResults(globResults);
for (ProjectPath& path : globResults) for (ProjectPath& path : globResults)
{ {
if (!hecl::Stat(path.getAbsolutePath().c_str(), &theStat)) if (!hecl::Stat(path.getAbsolutePath().data(), &theStat))
{ {
if (S_ISREG(theStat.st_mode) && theStat.st_mtime > latestTime) if (S_ISREG(theStat.st_mode) && theStat.st_mtime > latestTime)
latestTime = theStat.st_mtime; latestTime = theStat.st_mtime;
@ -254,15 +254,15 @@ hecl::DirectoryEnumerator ProjectPath::enumerateDir() const
void ProjectPath::getGlobResults(std::vector<ProjectPath>& outPaths) const void ProjectPath::getGlobResults(std::vector<ProjectPath>& outPaths) const
{ {
const SystemString& rootPath = m_proj->getProjectRootPath().getAbsolutePath(); auto rootPath = m_proj->getProjectRootPath().getAbsolutePath();
_recursiveGlob(*m_proj, outPaths, m_relPath, rootPath, rootPath.back() != _S('/')); _recursiveGlob(*m_proj, outPaths, m_relPath, rootPath.data(), rootPath.back() != _S('/'));
} }
ProjectRootPath SearchForProject(const SystemString& path) ProjectRootPath SearchForProject(SystemStringView path)
{ {
ProjectRootPath testRoot(path); ProjectRootPath testRoot(path);
SystemString::const_iterator begin = testRoot.getAbsolutePath().begin(); auto begin = testRoot.getAbsolutePath().begin();
SystemString::const_iterator end = testRoot.getAbsolutePath().end(); auto end = testRoot.getAbsolutePath().end();
while (begin != end) while (begin != end)
{ {
SystemString testPath(begin, end); SystemString testPath(begin, end);
@ -295,11 +295,11 @@ ProjectRootPath SearchForProject(const SystemString& path)
return ProjectRootPath(); return ProjectRootPath();
} }
ProjectRootPath SearchForProject(const SystemString& path, SystemString& subpathOut) ProjectRootPath SearchForProject(SystemStringView path, SystemString& subpathOut)
{ {
ProjectRootPath testRoot(path); ProjectRootPath testRoot(path);
SystemString::const_iterator begin = testRoot.getAbsolutePath().begin(); auto begin = testRoot.getAbsolutePath().begin();
SystemString::const_iterator end = testRoot.getAbsolutePath().end(); auto end = testRoot.getAbsolutePath().end();
while (begin != end) while (begin != end)
{ {
SystemString testPath(begin, end); SystemString testPath(begin, end);
@ -320,7 +320,7 @@ ProjectRootPath SearchForProject(const SystemString& path, SystemString& subpath
if (hecl::FourCC(magic) != FOURCC('HECL')) if (hecl::FourCC(magic) != FOURCC('HECL'))
continue; continue;
ProjectRootPath newRootPath = ProjectRootPath(testPath); ProjectRootPath newRootPath = ProjectRootPath(testPath);
SystemString::const_iterator origEnd = testRoot.getAbsolutePath().end(); auto origEnd = testRoot.getAbsolutePath().end();
while (end != origEnd && *end != _S('/') && *end != _S('\\')) while (end != origEnd && *end != _S('/') && *end != _S('\\'))
++end; ++end;
if (end != origEnd && (*end == _S('/') || *end == _S('\\'))) if (end != origEnd && (*end == _S('/') || *end == _S('\\')))

View File

@ -10,7 +10,7 @@ namespace Runtime
{ {
static logvisor::Module Log("FileStoreManager"); static logvisor::Module Log("FileStoreManager");
FileStoreManager::FileStoreManager(const SystemString& domain) FileStoreManager::FileStoreManager(SystemStringView domain)
: m_domain(domain) : m_domain(domain)
{ {
#if _WIN32 #if _WIN32
@ -35,7 +35,8 @@ FileStoreManager::FileStoreManager(const SystemString& domain)
path += "/.heclrun"; path += "/.heclrun";
if (mkdir(path.c_str(), 0755) && errno != EEXIST) if (mkdir(path.c_str(), 0755) && errno != EEXIST)
Log.report(logvisor::Fatal, "unable to mkdir at %s", path.c_str()); Log.report(logvisor::Fatal, "unable to mkdir at %s", path.c_str());
path += '/' + domain; path += '/';
path += domain.data();
if (mkdir(path.c_str(), 0755) && errno != EEXIST) if (mkdir(path.c_str(), 0755) && errno != EEXIST)
Log.report(logvisor::Fatal, "unable to mkdir at %s", path.c_str()); Log.report(logvisor::Fatal, "unable to mkdir at %s", path.c_str());
m_storeRoot = path; m_storeRoot = path;

View File

@ -116,8 +116,10 @@ ShaderCacheManager::ShaderCacheManager(const FileStoreManager& storeMgr,
ShaderCacheExtensions&& extension) ShaderCacheExtensions&& extension)
: m_storeMgr(storeMgr), : m_storeMgr(storeMgr),
m_extensions(std::move(extension)), m_extensions(std::move(extension)),
m_idxFr(storeMgr.getStoreRoot() + _S("/shadercache") + gfxFactory->platformName() + _S(".idx"), 32*1024, false), m_idxFr(SystemString(storeMgr.getStoreRoot()) + _S("/shadercache") +
m_datFr(storeMgr.getStoreRoot() + _S("/shadercache") + gfxFactory->platformName() + _S(".dat"), 32*1024, false) gfxFactory->platformName() + _S(".idx"), 32*1024, false),
m_datFr(SystemString(storeMgr.getStoreRoot()) + _S("/shadercache") +
gfxFactory->platformName() + _S(".dat"), 32*1024, false)
{ {
boo::IGraphicsDataFactory::Platform plat = gfxFactory->platform(); boo::IGraphicsDataFactory::Platform plat = gfxFactory->platform();
if (m_extensions && m_extensions.m_plat != plat) if (m_extensions && m_extensions.m_plat != plat)
@ -378,8 +380,8 @@ ShaderCacheManager::buildFromCache(const ShaderCachedData& foundData,
} }
std::shared_ptr<ShaderPipelines> std::shared_ptr<ShaderPipelines>
ShaderCacheManager::buildShader(const ShaderTag& tag, const std::string& source, ShaderCacheManager::buildShader(const ShaderTag& tag, std::string_view source,
const std::string& diagName, std::string_view diagName,
boo::IGraphicsDataFactory& factory) boo::IGraphicsDataFactory& factory)
{ {
auto search = m_pipelineLookup.find(tag); auto search = m_pipelineLookup.find(tag);
@ -392,7 +394,7 @@ ShaderCacheManager::buildShader(const ShaderTag& tag, const std::string& source,
{ {
factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
{ {
Log.report(logvisor::Info, "building cached shader '%s' %016llX", diagName.c_str(), tag.val64()); Log.report(logvisor::Info, "building cached shader '%s' %016llX", diagName.data(), tag.val64());
boo::ObjToken<boo::IShaderPipeline> build = buildFromCache(foundData, ctx); boo::ObjToken<boo::IShaderPipeline> build = buildFromCache(foundData, ctx);
if (build) if (build)
{ {
@ -407,13 +409,13 @@ ShaderCacheManager::buildShader(const ShaderTag& tag, const std::string& source,
m_pipelineLookup[tag] = ret; m_pipelineLookup[tag] = ret;
return ret; return ret;
} }
Log.report(logvisor::Warning, "invalid cache read, rebuilding shader '%s'", diagName.c_str()); Log.report(logvisor::Warning, "invalid cache read, rebuilding shader '%s'", diagName.data());
} }
factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
{ {
hecl::Frontend::IR ir = FE.compileSource(source, diagName); hecl::Frontend::IR ir = FE.compileSource(source, diagName);
Log.report(logvisor::Info, "building shader '%s' %016llX", diagName.c_str(), tag.val64()); Log.report(logvisor::Info, "building shader '%s' %016llX", diagName.data(), tag.val64());
FE.getDiagnostics().reset(diagName); FE.getDiagnostics().reset(diagName);
boo::ObjToken<boo::IShaderPipeline> build; boo::ObjToken<boo::IShaderPipeline> build;
addData(m_factory->buildShaderFromIR(tag, ir, FE.getDiagnostics(), ctx, build)); addData(m_factory->buildShaderFromIR(tag, ir, FE.getDiagnostics(), ctx, build));
@ -426,7 +428,7 @@ ShaderCacheManager::buildShader(const ShaderTag& tag, const std::string& source,
std::shared_ptr<ShaderPipelines> std::shared_ptr<ShaderPipelines>
ShaderCacheManager::buildShader(const ShaderTag& tag, const hecl::Frontend::IR& ir, ShaderCacheManager::buildShader(const ShaderTag& tag, const hecl::Frontend::IR& ir,
const std::string& diagName, std::string_view diagName,
boo::IGraphicsDataFactory& factory) boo::IGraphicsDataFactory& factory)
{ {
auto search = m_pipelineLookup.find(tag); auto search = m_pipelineLookup.find(tag);
@ -439,7 +441,7 @@ ShaderCacheManager::buildShader(const ShaderTag& tag, const hecl::Frontend::IR&
{ {
factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
{ {
Log.report(logvisor::Info, "building cached shader '%s' %016llX", diagName.c_str(), tag.val64()); Log.report(logvisor::Info, "building cached shader '%s' %016llX", diagName.data(), tag.val64());
boo::ObjToken<boo::IShaderPipeline> build = buildFromCache(foundData, ctx); boo::ObjToken<boo::IShaderPipeline> build = buildFromCache(foundData, ctx);
if (build) if (build)
{ {
@ -454,12 +456,12 @@ ShaderCacheManager::buildShader(const ShaderTag& tag, const hecl::Frontend::IR&
m_pipelineLookup[tag] = ret; m_pipelineLookup[tag] = ret;
return ret; return ret;
} }
Log.report(logvisor::Warning, "invalid cache read, rebuilding shader '%s'", diagName.c_str()); Log.report(logvisor::Warning, "invalid cache read, rebuilding shader '%s'", diagName.data());
} }
factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
{ {
Log.report(logvisor::Info, "building shader '%s' %016llX", diagName.c_str(), tag.val64()); Log.report(logvisor::Info, "building shader '%s' %016llX", diagName.data(), tag.val64());
FE.getDiagnostics().reset(diagName); FE.getDiagnostics().reset(diagName);
boo::ObjToken<boo::IShaderPipeline> build; boo::ObjToken<boo::IShaderPipeline> build;
addData(m_factory->buildShaderFromIR(tag, ir, FE.getDiagnostics(), ctx, build)); addData(m_factory->buildShaderFromIR(tag, ir, FE.getDiagnostics(), ctx, build));
@ -486,8 +488,8 @@ ShaderCacheManager::buildExtendedFromCache(const ShaderCachedData& foundData,
} }
std::shared_ptr<ShaderPipelines> std::shared_ptr<ShaderPipelines>
ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, const std::string& source, ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, std::string_view source,
const std::string& diagName, std::string_view diagName,
boo::IGraphicsDataFactory& factory) boo::IGraphicsDataFactory& factory)
{ {
auto search = m_pipelineLookup.find(tag); auto search = m_pipelineLookup.find(tag);
@ -500,7 +502,7 @@ ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, const std::string&
{ {
factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
{ {
Log.report(logvisor::Info, "building cached shader '%s' %016llX", diagName.c_str(), tag.val64()); Log.report(logvisor::Info, "building cached shader '%s' %016llX", diagName.data(), tag.val64());
ret->m_pipelines = buildExtendedFromCache(foundData, ctx); ret->m_pipelines = buildExtendedFromCache(foundData, ctx);
return ret->m_pipelines.size() != 0; return ret->m_pipelines.size() != 0;
}); });
@ -510,7 +512,7 @@ ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, const std::string&
m_pipelineLookup[tag] = ret; m_pipelineLookup[tag] = ret;
return ret; return ret;
} }
Log.report(logvisor::Warning, "invalid cache read, rebuilding shader '%s'", diagName.c_str()); Log.report(logvisor::Warning, "invalid cache read, rebuilding shader '%s'", diagName.data());
} }
hecl::Frontend::IR ir = FE.compileSource(source, diagName); hecl::Frontend::IR ir = FE.compileSource(source, diagName);
@ -519,7 +521,7 @@ ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, const std::string&
{ {
ret->m_pipelines.reserve(m_extensions.m_extensionSlots.size()); ret->m_pipelines.reserve(m_extensions.m_extensionSlots.size());
FE.getDiagnostics().reset(diagName); FE.getDiagnostics().reset(diagName);
Log.report(logvisor::Info, "building shader '%s' %016llX", diagName.c_str(), tag.val64()); Log.report(logvisor::Info, "building shader '%s' %016llX", diagName.data(), tag.val64());
ShaderCachedData data = ShaderCachedData data =
m_factory->buildExtendedShaderFromIR(tag, ir, FE.getDiagnostics(), m_extensions.m_extensionSlots, ctx, m_factory->buildExtendedShaderFromIR(tag, ir, FE.getDiagnostics(), m_extensions.m_extensionSlots, ctx,
[&](const boo::ObjToken<boo::IShaderPipeline>& shader){ret->m_pipelines.push_back(shader);}); [&](const boo::ObjToken<boo::IShaderPipeline>& shader){ret->m_pipelines.push_back(shader);});
@ -535,7 +537,7 @@ ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, const std::string&
std::shared_ptr<ShaderPipelines> std::shared_ptr<ShaderPipelines>
ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, const hecl::Frontend::IR& ir, ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, const hecl::Frontend::IR& ir,
const std::string& diagName, std::string_view diagName,
boo::IGraphicsDataFactory& factory) boo::IGraphicsDataFactory& factory)
{ {
auto search = m_pipelineLookup.find(tag); auto search = m_pipelineLookup.find(tag);
@ -548,7 +550,7 @@ ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, const hecl::Fronte
{ {
factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
{ {
Log.report(logvisor::Info, "building cached shader '%s' %016llX", diagName.c_str(), tag.val64()); Log.report(logvisor::Info, "building cached shader '%s' %016llX", diagName.data(), tag.val64());
ret->m_pipelines = buildExtendedFromCache(foundData, ctx); ret->m_pipelines = buildExtendedFromCache(foundData, ctx);
return ret->m_pipelines.size() != 0; return ret->m_pipelines.size() != 0;
}); });
@ -558,14 +560,14 @@ ShaderCacheManager::buildExtendedShader(const ShaderTag& tag, const hecl::Fronte
m_pipelineLookup[tag] = ret; m_pipelineLookup[tag] = ret;
return ret; return ret;
} }
Log.report(logvisor::Warning, "invalid cache read, rebuilding shader '%s'", diagName.c_str()); Log.report(logvisor::Warning, "invalid cache read, rebuilding shader '%s'", diagName.data());
} }
factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool factory.commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
{ {
ret->m_pipelines.reserve(m_extensions.m_extensionSlots.size()); ret->m_pipelines.reserve(m_extensions.m_extensionSlots.size());
FE.getDiagnostics().reset(diagName); FE.getDiagnostics().reset(diagName);
Log.report(logvisor::Info, "building shader '%s' %016llX", diagName.c_str(), tag.val64()); Log.report(logvisor::Info, "building shader '%s' %016llX", diagName.data(), tag.val64());
ShaderCachedData data = ShaderCachedData data =
m_factory->buildExtendedShaderFromIR(tag, ir, FE.getDiagnostics(), m_extensions.m_extensionSlots, ctx, m_factory->buildExtendedShaderFromIR(tag, ir, FE.getDiagnostics(), m_extensions.m_extensionSlots, ctx,
[&](const boo::ObjToken<boo::IShaderPipeline>& shader){ret->m_pipelines.push_back(shader);}); [&](const boo::ObjToken<boo::IShaderPipeline>& shader){ret->m_pipelines.push_back(shader);});

View File

@ -94,8 +94,8 @@ hecl::SystemString FindCommonSteamApp(const hecl::SystemChar* name)
while (std::regex_search(begin, end, dirMatch, regSteamPath)) while (std::regex_search(begin, end, dirMatch, regSteamPath))
{ {
std::string match = dirMatch[1].str(); std::string match = dirMatch[1].str();
hecl::SystemStringView otherInstallDir(match); hecl::SystemStringConv otherInstallDir(match);
hecl::SystemString otherAppPath = otherInstallDir.sys_str() + PATH_SEP + hecl::SystemString otherAppPath = hecl::SystemString(otherInstallDir.sys_str()) + PATH_SEP +
_S("steamapps") + PATH_SEP + appPath; _S("steamapps") + PATH_SEP + appPath;
if (!hecl::Stat(otherAppPath.c_str(), &theStat) && S_ISDIR(theStat.st_mode)) if (!hecl::Stat(otherAppPath.c_str(), &theStat) && S_ISDIR(theStat.st_mode))
return otherAppPath; return otherAppPath;

View File

@ -4,7 +4,7 @@
namespace hecl namespace hecl
{ {
std::string WideToUTF8(const std::wstring& src) std::string WideToUTF8(std::wstring_view src)
{ {
std::string retval; std::string retval;
retval.reserve(src.length()); retval.reserve(src.length());
@ -22,7 +22,7 @@ std::string WideToUTF8(const std::wstring& src)
return retval; return retval;
} }
std::string Char16ToUTF8(const std::u16string& src) std::string Char16ToUTF8(std::u16string_view src)
{ {
std::string retval; std::string retval;
retval.reserve(src.length()); retval.reserve(src.length());
@ -40,11 +40,11 @@ std::string Char16ToUTF8(const std::u16string& src)
return retval; return retval;
} }
std::wstring UTF8ToWide(const std::string& src) std::wstring UTF8ToWide(std::string_view src)
{ {
std::wstring retval; std::wstring retval;
retval.reserve(src.length()); retval.reserve(src.length());
const utf8proc_uint8_t* buf = reinterpret_cast<const utf8proc_uint8_t*>(src.c_str()); const utf8proc_uint8_t* buf = reinterpret_cast<const utf8proc_uint8_t*>(src.data());
while (*buf) while (*buf)
{ {
utf8proc_int32_t wc; utf8proc_int32_t wc;
@ -60,11 +60,11 @@ std::wstring UTF8ToWide(const std::string& src)
return retval; return retval;
} }
std::u16string UTF8ToChar16(const std::string& src) std::u16string UTF8ToChar16(std::string_view src)
{ {
std::u16string retval; std::u16string retval;
retval.reserve(src.length()); retval.reserve(src.length());
const utf8proc_uint8_t* buf = reinterpret_cast<const utf8proc_uint8_t*>(src.c_str()); const utf8proc_uint8_t* buf = reinterpret_cast<const utf8proc_uint8_t*>(src.data());
while (*buf) while (*buf)
{ {
utf8proc_int32_t wc; utf8proc_int32_t wc;

View File

@ -180,7 +180,7 @@ void ResourceLock::ClearThreadRes()
bool IsPathPNG(const hecl::ProjectPath& path) bool IsPathPNG(const hecl::ProjectPath& path)
{ {
FILE* fp = hecl::Fopen(path.getAbsolutePath().c_str(), _S("rb")); FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _S("rb"));
if (!fp) if (!fp)
return false; return false;
uint32_t buf = 0; uint32_t buf = 0;
@ -198,10 +198,10 @@ bool IsPathPNG(const hecl::ProjectPath& path)
bool IsPathBlend(const hecl::ProjectPath& path) bool IsPathBlend(const hecl::ProjectPath& path)
{ {
const SystemChar* lastCompExt = path.getLastComponentExt(); auto lastCompExt = path.getLastComponentExt();
if (!lastCompExt || hecl::StrCmp(lastCompExt, _S("blend"))) if (lastCompExt.empty() || hecl::StrCmp(lastCompExt.data(), _S("blend")))
return false; return false;
FILE* fp = hecl::Fopen(path.getAbsolutePath().c_str(), _S("rb")); FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _S("rb"));
if (!fp) if (!fp)
return false; return false;
uint32_t buf = 0; uint32_t buf = 0;
@ -219,22 +219,22 @@ bool IsPathBlend(const hecl::ProjectPath& path)
bool IsPathYAML(const hecl::ProjectPath& path) bool IsPathYAML(const hecl::ProjectPath& path)
{ {
if (!hecl::StrCmp(path.getLastComponent(), _S("!catalog.yaml"))) if (!hecl::StrCmp(path.getLastComponent().data(), _S("!catalog.yaml")))
return false; /* !catalog.yaml is exempt from general use */ return false; /* !catalog.yaml is exempt from general use */
const SystemChar* lastCompExt = path.getLastComponentExt(); auto lastCompExt = path.getLastComponentExt();
if (!lastCompExt) if (lastCompExt.empty())
return false; return false;
if (!hecl::StrCmp(lastCompExt, _S("yaml")) || if (!hecl::StrCmp(lastCompExt.data(), _S("yaml")) ||
!hecl::StrCmp(lastCompExt, _S("yml"))) !hecl::StrCmp(lastCompExt.data(), _S("yml")))
return true; return true;
return false; return false;
} }
hecl::DirectoryEnumerator::DirectoryEnumerator(const hecl::SystemChar* path, Mode mode, hecl::DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode,
bool sizeSort, bool reverse, bool noHidden) bool sizeSort, bool reverse, bool noHidden)
{ {
hecl::Sstat theStat; hecl::Sstat theStat;
if (hecl::Stat(path, &theStat) || !S_ISDIR(theStat.st_mode)) if (hecl::Stat(path.data(), &theStat) || !S_ISDIR(theStat.st_mode))
return; return;
#if _WIN32 #if _WIN32
@ -366,7 +366,7 @@ hecl::DirectoryEnumerator::DirectoryEnumerator(const hecl::SystemChar* path, Mod
#else #else
DIR* dir = opendir(path); DIR* dir = opendir(path.data());
if (!dir) if (!dir)
return; return;
const dirent* d; const dirent* d;
@ -495,16 +495,16 @@ hecl::DirectoryEnumerator::DirectoryEnumerator(const hecl::SystemChar* path, Mod
#define FILE_MAXDIR 768 #define FILE_MAXDIR 768
static std::pair<hecl::SystemString, std::string> static std::pair<hecl::SystemString, std::string>
NameFromPath(const hecl::SystemString& path) NameFromPath(hecl::SystemStringView path)
{ {
hecl::SystemUTF8View utf8(path); hecl::SystemUTF8Conv utf8(path);
if (utf8.str().size() == 1 && utf8.str()[0] == '/') if (utf8.str().size() == 1 && utf8.str()[0] == '/')
return {path, "/"}; return {hecl::SystemString(path), "/"};
size_t lastSlash = utf8.str().rfind('/'); size_t lastSlash = utf8.str().rfind('/');
if (lastSlash != std::string::npos) if (lastSlash != std::string::npos)
return {path, std::string(utf8.str().cbegin() + lastSlash + 1, utf8.str().cend())}; return {hecl::SystemString(path), std::string(utf8.str().cbegin() + lastSlash + 1, utf8.str().cend())};
else else
return {path, utf8.str()}; return {hecl::SystemString(path), std::string(utf8.str())};
} }
std::vector<std::pair<hecl::SystemString, std::string>> GetSystemLocations() std::vector<std::pair<hecl::SystemString, std::string>> GetSystemLocations()
@ -647,7 +647,7 @@ std::vector<std::pair<hecl::SystemString, std::string>> GetSystemLocations()
return ret; return ret;
} }
std::wstring Char16ToWide(const std::u16string& src) std::wstring Char16ToWide(std::u16string_view src)
{ {
return std::wstring(src.begin(), src.end()); return std::wstring(src.begin(), src.end());
} }