From 6838142c9fa7c1ae6b0f8dc11ea636813509b6d3 Mon Sep 17 00:00:00 2001 From: Morten Delenk Date: Sat, 9 Jul 2016 09:51:02 +0200 Subject: [PATCH] Update to nall v100r1 --- atoi.hpp | 62 ++++++------ beat/archive.hpp | 6 +- beat/multi.hpp | 8 +- bit-field.hpp | 151 ++++++++++++++++++++---------- bit.hpp | 32 +++---- config.hpp | 6 +- directory.hpp | 87 ++++++++++------- emulation/21fx.hpp | 4 +- emulation/super-famicom-usart.hpp | 95 ------------------- file.hpp | 18 ++-- http/request.hpp | 6 +- http/response.hpp | 8 +- http/role.hpp | 2 +- string/path.hpp => location.hpp | 16 ++-- main.hpp | 14 ++- mosaic/context.hpp | 12 +-- nall.hpp | 1 + path.hpp | 2 +- posix/service.hpp | 16 ++-- primitives.hpp | 40 ++++---- run.hpp | 8 +- serializer.hpp | 4 +- stdint.hpp | 11 +-- string.hpp | 85 ++++++++--------- string/atoi.hpp | 14 ++- string/cast.hpp | 32 +++---- string/core.hpp | 2 +- string/datetime.hpp | 12 +-- string/eval/evaluator.hpp | 4 +- string/format.hpp | 46 +++++---- string/list.hpp | 22 ++--- string/markup/bml.hpp | 4 +- string/markup/find.hpp | 4 +- string/markup/node.hpp | 4 +- string/match.hpp | 2 +- string/split.hpp | 10 +- string/transform/cml.hpp | 10 +- string/transform/dml.hpp | 6 +- string/utility.hpp | 6 +- thread.hpp | 16 ++-- varint.hpp | 12 +-- vfs/fs/file.hpp | 6 +- vfs/memory/file.hpp | 18 ++-- vfs/vfs.hpp | 24 ++--- windows/registry.hpp | 13 +-- 45 files changed, 475 insertions(+), 486 deletions(-) delete mode 100644 emulation/super-famicom-usart.hpp rename string/path.hpp => location.hpp (86%) diff --git a/atoi.hpp b/atoi.hpp index 4fc639e..46921f7 100644 --- a/atoi.hpp +++ b/atoi.hpp @@ -4,83 +4,83 @@ namespace nall { -constexpr inline auto binary_(const char* s, uintmax sum = 0) -> uintmax { +constexpr inline auto toBinary_(const char* s, uintmax_t sum = 0) -> uintmax_t { return ( - *s == '0' || *s == '1' ? binary_(s + 1, (sum << 1) | *s - '0') : - *s == '\'' ? binary_(s + 1, sum) : + *s == '0' || *s == '1' ? toBinary_(s + 1, (sum << 1) | *s - '0') : + *s == '\'' ? toBinary_(s + 1, sum) : sum ); } -constexpr inline auto octal_(const char* s, uintmax sum = 0) -> uintmax { +constexpr inline auto toOctal_(const char* s, uintmax_t sum = 0) -> uintmax_t { return ( - *s >= '0' && *s <= '7' ? octal_(s + 1, (sum << 3) | *s - '0') : - *s == '\'' ? octal_(s + 1, sum) : + *s >= '0' && *s <= '7' ? toOctal_(s + 1, (sum << 3) | *s - '0') : + *s == '\'' ? toOctal_(s + 1, sum) : sum ); } -constexpr inline auto decimal_(const char* s, uintmax sum = 0) -> uintmax { +constexpr inline auto toDecimal_(const char* s, uintmax_t sum = 0) -> uintmax_t { return ( - *s >= '0' && *s <= '9' ? decimal_(s + 1, (sum * 10) + *s - '0') : - *s == '\'' ? decimal_(s + 1, sum) : + *s >= '0' && *s <= '9' ? toDecimal_(s + 1, (sum * 10) + *s - '0') : + *s == '\'' ? toDecimal_(s + 1, sum) : sum ); } -constexpr inline auto hex_(const char* s, uintmax sum = 0) -> uintmax { +constexpr inline auto toHex_(const char* s, uintmax_t sum = 0) -> uintmax_t { return ( - *s >= 'A' && *s <= 'F' ? hex_(s + 1, (sum << 4) | *s - 'A' + 10) : - *s >= 'a' && *s <= 'f' ? hex_(s + 1, (sum << 4) | *s - 'a' + 10) : - *s >= '0' && *s <= '9' ? hex_(s + 1, (sum << 4) | *s - '0') : - *s == '\'' ? hex_(s + 1, sum) : + *s >= 'A' && *s <= 'F' ? toHex_(s + 1, (sum << 4) | *s - 'A' + 10) : + *s >= 'a' && *s <= 'f' ? toHex_(s + 1, (sum << 4) | *s - 'a' + 10) : + *s >= '0' && *s <= '9' ? toHex_(s + 1, (sum << 4) | *s - '0') : + *s == '\'' ? toHex_(s + 1, sum) : sum ); } // -constexpr inline auto binary(const char* s) -> uintmax { +constexpr inline auto toBinary(const char* s) -> uintmax_t { return ( - *s == '0' && (*(s + 1) == 'B' || *(s + 1) == 'b') ? binary_(s + 2) : - *s == '%' ? binary_(s + 1) : binary_(s) + *s == '0' && (*(s + 1) == 'B' || *(s + 1) == 'b') ? toBinary_(s + 2) : + *s == '%' ? toBinary_(s + 1) : toBinary_(s) ); } -constexpr inline auto octal(const char* s) -> uintmax { +constexpr inline auto toOctal(const char* s) -> uintmax_t { return ( - *s == '0' && (*(s + 1) == 'O' || *(s + 1) == 'o') ? octal_(s + 2) : - octal_(s) + *s == '0' && (*(s + 1) == 'O' || *(s + 1) == 'o') ? toOctal_(s + 2) : + toOctal_(s) ); } -constexpr inline auto hex(const char* s) -> uintmax { +constexpr inline auto toHex(const char* s) -> uintmax_t { return ( - *s == '0' && (*(s + 1) == 'X' || *(s + 1) == 'x') ? hex_(s + 2) : - *s == '$' ? hex_(s + 1) : hex_(s) + *s == '0' && (*(s + 1) == 'X' || *(s + 1) == 'x') ? toHex_(s + 2) : + *s == '$' ? toHex_(s + 1) : toHex_(s) ); } // -constexpr inline auto natural(const char* s) -> uintmax { +constexpr inline auto toNatural(const char* s) -> uintmax_t { return ( - *s == '0' && (*(s + 1) == 'B' || *(s + 1) == 'b') ? binary_(s + 2) : - *s == '0' && (*(s + 1) == 'O' || *(s + 1) == 'o') ? octal_(s + 2) : - *s == '0' && (*(s + 1) == 'X' || *(s + 1) == 'x') ? hex_(s + 2) : - *s == '%' ? binary_(s + 1) : *s == '$' ? hex_(s + 1) : decimal_(s) + *s == '0' && (*(s + 1) == 'B' || *(s + 1) == 'b') ? toBinary_(s + 2) : + *s == '0' && (*(s + 1) == 'O' || *(s + 1) == 'o') ? toOctal_(s + 2) : + *s == '0' && (*(s + 1) == 'X' || *(s + 1) == 'x') ? toHex_(s + 2) : + *s == '%' ? toBinary_(s + 1) : *s == '$' ? toHex_(s + 1) : toDecimal_(s) ); } -constexpr inline auto integer(const char* s) -> intmax { +constexpr inline auto toInteger(const char* s) -> intmax_t { return ( - *s == '+' ? +natural(s + 1) : *s == '-' ? -natural(s + 1) : natural(s) + *s == '+' ? +toNatural(s + 1) : *s == '-' ? -toNatural(s + 1) : toNatural(s) ); } // -inline auto real(const char* s) -> double { +inline auto toReal(const char* s) -> double { return atof(s); } diff --git a/beat/archive.hpp b/beat/archive.hpp index df3d3c4..1209d03 100644 --- a/beat/archive.hpp +++ b/beat/archive.hpp @@ -10,7 +10,7 @@ struct Archive { static auto extract(const string& beatname, const string& pathname) -> vector; private: - static auto scan(lstring& result, const string& basename, const string& pathname) -> void; + static auto scan(string_vector& result, const string& basename, const string& pathname) -> void; }; auto Archive::create(const string& beatname, const string& pathname, const string& metadata) -> bool { @@ -23,7 +23,7 @@ auto Archive::create(const string& beatname, const string& pathname, const strin beat.writevu(metadata.size()); beat.writes(metadata); - lstring contents; + string_vector contents; scan(contents, pathname, pathname); for(auto& name : contents) { @@ -121,7 +121,7 @@ auto Archive::extract(const string& beatname, const string& filename) -> vector< return {}; } -auto Archive::scan(lstring& result, const string& basename, const string& pathname) -> void { +auto Archive::scan(string_vector& result, const string& basename, const string& pathname) -> void { for(auto& name : directory::contents(pathname)) { result.append(string{pathname, name}.trimLeft(basename, 1L)); if(name.endsWith("/")) scan(result, basename, {pathname, name}); diff --git a/beat/multi.hpp b/beat/multi.hpp index 342bfcb..1f0b595 100644 --- a/beat/multi.hpp +++ b/beat/multi.hpp @@ -28,7 +28,7 @@ struct bpsmulti { writeNumber(metadata.length()); writeString(metadata); - lstring sourceList, targetList; + string_vector sourceList, targetList; ls(sourceList, sourcePath, sourcePath); ls(targetList, targetPath, targetPath); @@ -156,14 +156,14 @@ protected: Hash::CRC32 checksum; //create() functions - auto ls(lstring& list, const string& path, const string& basepath) -> void { - lstring paths = directory::folders(path); + auto ls(string_vector& list, const string& path, const string& basepath) -> void { + auto paths = directory::folders(path); for(auto& pathname : paths) { list.append(string{path, pathname}.trimLeft(basepath, 1L)); ls(list, {path, pathname}, basepath); } - lstring files = directory::files(path); + auto files = directory::files(path); for(auto& filename : files) { list.append(string{path, filename}.trimLeft(basepath, 1L)); } diff --git a/bit-field.hpp b/bit-field.hpp index 85ac5a6..50d0e05 100644 --- a/bit-field.hpp +++ b/bit-field.hpp @@ -2,55 +2,11 @@ namespace nall { -template struct NaturalBitField { - enum : uint { lo = Lo <= Hi ? Lo : Hi }; - enum : uint { hi = Hi >= Lo ? Hi : Lo }; - enum : uint { bits = hi - lo + 1 }; - enum : uint { mask = (~0ull >> (64 - bits)) << lo }; - static_assert(hi < sizeof(type) * 8, ""); - - inline NaturalBitField() = default; - inline NaturalBitField(const NaturalBitField& value) { set(value.data); } - template inline NaturalBitField(const T& value) { set(value << lo); } - - inline explicit operator bool() const { return data & mask; } - inline operator type() const { return get(); } - - inline auto& operator=(const NaturalBitField& value) { return set(value.data); } - template inline auto& operator=(const T& value) { return set(value << lo); } - - inline auto operator++(int) { type value = get(); set(data + (1 << lo)); return value; } - inline auto operator--(int) { type value = get(); set(data - (1 << lo)); return value; } - - inline auto& operator++() { return set(data + (1 << lo)); } - inline auto& operator--() { return set(data - (1 << lo)); } - - inline auto& operator &=(const type value) { return set(data & (value << lo)); } - inline auto& operator |=(const type value) { return set(data | (value << lo)); } - inline auto& operator ^=(const type value) { return set(data ^ (value << lo)); } - inline auto& operator<<=(const type value) { return set((data & mask) << value); } - inline auto& operator>>=(const type value) { return set((data & mask) >> value); } - inline auto& operator +=(const type value) { return set(data + (value << lo)); } - inline auto& operator -=(const type value) { return set(data - (value << lo)); } - inline auto& operator *=(const type value) { return set((get() * value) << lo); } - inline auto& operator /=(const type value) { return set((get() / value) << lo); } - inline auto& operator %=(const type value) { return set((get() % value) << lo); } - -private: - type data; - - inline auto get() const -> type { - return (data & mask) >> lo; - } - - inline auto set(type value) -> NaturalBitField& { - return data = (data & ~mask) | (value & mask), *this; - } -}; - -template struct BooleanBitField { +template struct BooleanBitField { enum : uint { bit = Bit }; enum : uint { mask = 1ull << bit }; + using type = Type; + using utype = typename std::make_unsigned::type; static_assert(bit < sizeof(type) * 8, ""); inline BooleanBitField() = default; @@ -71,7 +27,7 @@ template struct BooleanBitField { inline auto& invert() { return set(get() ^ 1); } private: - type data; + utype data; inline auto get() const -> bool { return data & mask; @@ -82,4 +38,103 @@ private: } }; +template struct NaturalBitField { + enum : uint { lo = Lo <= Hi ? Lo : Hi }; + enum : uint { hi = Hi >= Lo ? Hi : Lo }; + enum : uint { bits = hi - lo + 1 }; + enum : uint { mask = (~0ull >> (64 - bits)) << lo }; + using type = Type; + using utype = typename std::make_unsigned::type; + static_assert(hi < sizeof(type) * 8, ""); + + inline NaturalBitField() = default; + inline NaturalBitField(const NaturalBitField& value) { set(value.data); } + template inline NaturalBitField(const T& value) { set(value << lo); } + + inline explicit operator bool() const { return data & mask; } + inline operator utype() const { return get(); } + + inline auto& operator=(const NaturalBitField& value) { return set(value.data); } + template inline auto& operator=(const T& value) { return set(value << lo); } + + inline auto operator++(int) { utype value = get(); set(data + (1 << lo)); return value; } + inline auto operator--(int) { utype value = get(); set(data - (1 << lo)); return value; } + + inline auto& operator++() { return set(data + (1 << lo)); } + inline auto& operator--() { return set(data - (1 << lo)); } + + inline auto& operator &=(const utype value) { return set(data & (value << lo)); } + inline auto& operator |=(const utype value) { return set(data | (value << lo)); } + inline auto& operator ^=(const utype value) { return set(data ^ (value << lo)); } + inline auto& operator<<=(const utype value) { return set((data & mask) << value); } + inline auto& operator>>=(const utype value) { return set((data & mask) >> value); } + inline auto& operator +=(const utype value) { return set(data + (value << lo)); } + inline auto& operator -=(const utype value) { return set(data - (value << lo)); } + inline auto& operator *=(const utype value) { return set((get() * value) << lo); } + inline auto& operator /=(const utype value) { return set((get() / value) << lo); } + inline auto& operator %=(const utype value) { return set((get() % value) << lo); } + +private: + utype data; + + inline auto get() const -> utype { + return (data & mask) >> lo; + } + + inline auto set(utype value) -> NaturalBitField& { + return data = (data & ~mask) | (value & mask), *this; + } +}; + +template struct IntegerBitField { + enum : uint { lo = Lo <= Hi ? Lo : Hi }; + enum : uint { hi = Hi >= Lo ? Hi : Lo }; + enum : uint { bits = hi - lo + 1 }; + enum : uint { mask = (~0ull >> (64 - bits)) << lo }; + using type = Type; + using stype = typename std::make_signed::type; + using utype = typename std::make_unsigned::type; + static_assert(hi < sizeof(type) * 8, ""); + + inline IntegerBitField() = default; + inline IntegerBitField(const IntegerBitField& value) { set(value.get()); } + template inline IntegerBitField(const T& value) { set(value); } + + inline explicit operator bool() const { return data & mask; } + inline operator stype() const { return get(); } + + inline auto& operator=(const IntegerBitField& value) { return set(value.get()); } + template inline auto& operator=(const T& value) { return set(value); } + + inline auto operator++(int) { stype value = get(); set(value + 1); return value; } + inline auto operator--(int) { stype value = get(); set(value - 1); return value; } + + inline auto& operator++() { return set(get() + 1); } + inline auto& operator--() { return set(get() - 1); } + + inline auto& operator &=(const stype value) { return set(get() & value); } + inline auto& operator |=(const stype value) { return set(get() | value); } + inline auto& operator ^=(const stype value) { return set(get() ^ value); } + inline auto& operator<<=(const stype value) { return set(get() << value); } + inline auto& operator>>=(const stype value) { return set(get() >> value); } + inline auto& operator +=(const stype value) { return set(get() + value); } + inline auto& operator -=(const stype value) { return set(get() - value); } + inline auto& operator *=(const stype value) { return set(get() * value); } + inline auto& operator /=(const stype value) { return set(get() / value); } + inline auto& operator %=(const stype value) { return set(get() % value); } + +private: + utype data; + + inline auto get() const -> stype { + enum : utype { b = 1ull << (bits - 1) }; + enum : utype { m = b * 2 - 1 }; + return ((((data & mask) >> lo) & m) ^ b) - b; + } + + inline auto set(utype value) -> IntegerBitField& { + return data = (data & ~mask) | ((value << lo) & mask), *this; + } +}; + } diff --git a/bit.hpp b/bit.hpp index f2a54b6..f935c86 100644 --- a/bit.hpp +++ b/bit.hpp @@ -4,28 +4,28 @@ namespace nall { -template inline auto uclamp(const uintmax x) -> uintmax { - enum : uintmax { b = 1ull << (bits - 1), y = b * 2 - 1 }; +template inline auto uclamp(const uintmax_t x) -> uintmax_t { + enum : uintmax_t { b = 1ull << (bits - 1), y = b * 2 - 1 }; return y + ((x - y) & -(x < y)); //min(x, y); } -template inline auto uclip(const uintmax x) -> uintmax { - enum : uintmax { b = 1ull << (bits - 1), m = b * 2 - 1 }; +template inline auto uclip(const uintmax_t x) -> uintmax_t { + enum : uintmax_t { b = 1ull << (bits - 1), m = b * 2 - 1 }; return (x & m); } -template inline auto sclamp(const intmax x) -> intmax { - enum : intmax { b = 1ull << (bits - 1), m = b - 1 }; +template inline auto sclamp(const intmax_t x) -> intmax_t { + enum : intmax_t { b = 1ull << (bits - 1), m = b - 1 }; return (x > m) ? m : (x < -b) ? -b : x; } -template inline auto sclip(const intmax x) -> intmax { - enum : uintmax { b = 1ull << (bits - 1), m = b * 2 - 1 }; +template inline auto sclip(const intmax_t x) -> intmax_t { + enum : uintmax_t { b = 1ull << (bits - 1), m = b * 2 - 1 }; return ((x & m) ^ b) - b; } namespace bit { - constexpr inline auto mask(const char* s, uintmax sum = 0) -> uintmax { + constexpr inline auto mask(const char* s, uintmax_t sum = 0) -> uintmax_t { return ( *s == '0' || *s == '1' ? mask(s + 1, (sum << 1) | 1) : *s == ' ' || *s == '_' ? mask(s + 1, sum) : @@ -34,7 +34,7 @@ namespace bit { ); } - constexpr inline auto test(const char* s, uintmax sum = 0) -> uintmax { + constexpr inline auto test(const char* s, uintmax_t sum = 0) -> uintmax_t { return ( *s == '0' || *s == '1' ? test(s + 1, (sum << 1) | (*s - '0')) : *s == ' ' || *s == '_' ? test(s + 1, sum) : @@ -44,22 +44,22 @@ namespace bit { } //lowest(0b1110) == 0b0010 - constexpr inline auto lowest(const uintmax x) -> uintmax { + constexpr inline auto lowest(const uintmax_t x) -> uintmax_t { return x & -x; } //clear_lowest(0b1110) == 0b1100 - constexpr inline auto clearLowest(const uintmax x) -> uintmax { + constexpr inline auto clearLowest(const uintmax_t x) -> uintmax_t { return x & (x - 1); } //set_lowest(0b0101) == 0b0111 - constexpr inline auto setLowest(const uintmax x) -> uintmax { + constexpr inline auto setLowest(const uintmax_t x) -> uintmax_t { return x | (x + 1); } //count number of bits set in a byte - inline auto count(uintmax x) -> uint { + inline auto count(uintmax_t x) -> uint { uint count = 0; do count += x & 1; while(x >>= 1); return count; @@ -67,7 +67,7 @@ namespace bit { //return index of the first bit set (or zero of no bits are set) //first(0b1000) == 3 - inline auto first(uintmax x) -> uint { + inline auto first(uintmax_t x) -> uint { uint first = 0; while(x) { if(x & 1) break; x >>= 1; first++; } return first; @@ -75,7 +75,7 @@ namespace bit { //round up to next highest single bit: //round(15) == 16, round(16) == 16, round(17) == 32 - inline auto round(uintmax x) -> uintmax { + inline auto round(uintmax_t x) -> uintmax_t { if((x & (x - 1)) == 0) return x; while(x & (x - 1)) x &= x - 1; return x << 1; diff --git a/config.hpp b/config.hpp index 2efb538..83912d6 100644 --- a/config.hpp +++ b/config.hpp @@ -30,9 +30,9 @@ struct Node { auto set(const string& value) -> void { switch(type) { case Type::Boolean: *(bool*)data = (value != "false"); break; - case Type::Integer: *(int*)data = integer(value); break; - case Type::Natural: *(uint*)data = natural(value); break; - case Type::Double: *(double*)data = real(value); break; + case Type::Integer: *(int*)data = toInteger(value); break; + case Type::Natural: *(uint*)data = toNatural(value); break; + case Type::Double: *(double*)data = toReal(value); break; case Type::String: *(string*)data = value; break; } } diff --git a/directory.hpp b/directory.hpp index 52c9a5e..04eaf4b 100644 --- a/directory.hpp +++ b/directory.hpp @@ -18,46 +18,46 @@ namespace nall { struct directory : inode { - static auto create(const string& pathname, unsigned permissions = 0755) -> bool; //recursive + static auto create(const string& pathname, uint permissions = 0755) -> bool; //recursive static auto remove(const string& pathname) -> bool; //recursive static auto exists(const string& pathname) -> bool; - static auto folders(const string& pathname, const string& pattern = "*") -> lstring { - lstring folders = directory::ufolders(pathname, pattern); + static auto folders(const string& pathname, const string& pattern = "*") -> string_vector { + auto folders = directory::ufolders(pathname, pattern); folders.sort(); return folders; } - static auto files(const string& pathname, const string& pattern = "*") -> lstring { - lstring files = directory::ufiles(pathname, pattern); + static auto files(const string& pathname, const string& pattern = "*") -> string_vector { + auto files = directory::ufiles(pathname, pattern); files.sort(); return files; } - static auto contents(const string& pathname, const string& pattern = "*") -> lstring { - lstring folders = directory::ufolders(pathname); //pattern search of contents should only filter files - lstring files = directory::ufiles(pathname, pattern); + static auto contents(const string& pathname, const string& pattern = "*") -> string_vector { + auto folders = directory::ufolders(pathname); //pattern search of contents should only filter files + auto files = directory::ufiles(pathname, pattern); folders.sort(); files.sort(); for(auto& file : files) folders.append(file); return folders; } - static auto ifolders(const string& pathname, const string& pattern = "*") -> lstring { - lstring folders = ufolders(pathname, pattern); + static auto ifolders(const string& pathname, const string& pattern = "*") -> string_vector { + auto folders = ufolders(pathname, pattern); folders.isort(); return folders; } - static auto ifiles(const string& pathname, const string& pattern = "*") -> lstring { - lstring files = ufiles(pathname, pattern); + static auto ifiles(const string& pathname, const string& pattern = "*") -> string_vector { + auto files = ufiles(pathname, pattern); files.isort(); return files; } - static auto icontents(const string& pathname, const string& pattern = "*") -> lstring { - lstring folders = directory::ufolders(pathname); //pattern search of contents should only filter files - lstring files = directory::ufiles(pathname, pattern); + static auto icontents(const string& pathname, const string& pattern = "*") -> string_vector { + auto folders = directory::ufolders(pathname); //pattern search of contents should only filter files + auto files = directory::ufiles(pathname, pattern); folders.isort(); files.isort(); for(auto& file : files) folders.append(file); @@ -66,14 +66,14 @@ struct directory : inode { private: //internal functions; these return unsorted lists - static auto ufolders(const string& pathname, const string& pattern = "*") -> lstring; - static auto ufiles(const string& pathname, const string& pattern = "*") -> lstring; + static auto ufolders(const string& pathname, const string& pattern = "*") -> string_vector; + static auto ufiles(const string& pathname, const string& pattern = "*") -> string_vector; }; #if defined(PLATFORM_WINDOWS) - inline auto directory::create(const string& pathname, unsigned permissions) -> bool { + inline auto directory::create(const string& pathname, uint permissions) -> bool { string path; - lstring list = string{pathname}.transform("\\", "/").trimRight("/").split("/"); + auto list = string{pathname}.transform("\\", "/").trimRight("/").split("/"); bool result = true; for(auto& part : list) { path.append(part, "/"); @@ -84,7 +84,7 @@ private: } inline auto directory::remove(const string& pathname) -> bool { - lstring list = directory::contents(pathname); + auto list = directory::contents(pathname); for(auto& name : list) { if(name.endsWith("/")) directory::remove({pathname, name}); else file::remove({pathname, name}); @@ -100,8 +100,20 @@ private: return (result & FILE_ATTRIBUTE_DIRECTORY); } - inline auto directory::ufolders(const string& pathname, const string& pattern) -> lstring { - lstring list; + inline auto directory::ufolders(const string& pathname, const string& pattern) -> string_vector { + if(!pathname) { + //special root pseudo-folder (return list of drives) + wchar_t drives[PATH_MAX] = {0}; + GetLogicalDriveStrings(PATH_MAX, drives); + wchar_t* p = drives; + while(*p || *(p + 1)) { + if(!*p) *p = ';'; + *p++; + } + return string{(const char*)utf8_t(drives)}.replace("\\", "/").split(";"); + } + + string_vector list; string path = pathname; path.transform("/", "\\"); if(!path.endsWith("\\")) path.append("\\"); @@ -130,8 +142,10 @@ private: return list; } - inline auto directory::ufiles(const string& pathname, const string& pattern) -> lstring { - lstring list; + inline auto directory::ufiles(const string& pathname, const string& pattern) -> string_vector { + if(!pathname) return {}; + + string_vector list; string path = pathname; path.transform("/", "\\"); if(!path.endsWith("\\")) path.append("\\"); @@ -166,9 +180,9 @@ private: return false; } - inline auto directory::create(const string& pathname, unsigned permissions) -> bool { + inline auto directory::create(const string& pathname, uint permissions) -> bool { string path; - lstring list = string{pathname}.trimRight("/").split("/"); + auto list = string{pathname}.trimRight("/").split("/"); bool result = true; for(auto& part : list) { path.append(part, "/"); @@ -179,7 +193,7 @@ private: } inline auto directory::remove(const string& pathname) -> bool { - lstring list = directory::contents(pathname); + auto list = directory::contents(pathname); for(auto& name : list) { if(name.endsWith("/")) directory::remove({pathname, name}); else file::remove({pathname, name}); @@ -188,14 +202,15 @@ private: } inline auto directory::exists(const string& pathname) -> bool { - DIR* dp = opendir(pathname); - if(!dp) return false; - closedir(dp); - return true; + struct stat data; + if(stat(pathname, &data) != 0) return false; + return S_ISDIR(data.st_mode); } - inline auto directory::ufolders(const string& pathname, const string& pattern) -> lstring { - lstring list; + inline auto directory::ufolders(const string& pathname, const string& pattern) -> string_vector { + if(!pathname) return string_vector{"/"}; + + string_vector list; DIR* dp; struct dirent* ep; dp = opendir(pathname); @@ -213,8 +228,10 @@ private: return list; } - inline auto directory::ufiles(const string& pathname, const string& pattern) -> lstring { - lstring list; + inline auto directory::ufiles(const string& pathname, const string& pattern) -> string_vector { + if(!pathname) return {}; + + string_vector list; DIR* dp; struct dirent* ep; dp = opendir(pathname); diff --git a/emulation/21fx.hpp b/emulation/21fx.hpp index c6613f3..a1396e2 100644 --- a/emulation/21fx.hpp +++ b/emulation/21fx.hpp @@ -5,7 +5,7 @@ using namespace nall; struct FX { - auto open(lstring& args) -> bool; + auto open(string_vector& args) -> bool; auto close() -> void; auto readable() -> bool; auto read() -> uint8_t; @@ -23,7 +23,7 @@ struct FX { serial device; }; -auto FX::open(lstring& args) -> bool { +auto FX::open(string_vector& args) -> bool { //device name override support string name; for(uint n : range(args)) { diff --git a/emulation/super-famicom-usart.hpp b/emulation/super-famicom-usart.hpp deleted file mode 100644 index c8a1650..0000000 --- a/emulation/super-famicom-usart.hpp +++ /dev/null @@ -1,95 +0,0 @@ -#pragma once - -#include -#include -using namespace nall; - -#include -#include -#include - -static function bool> usart_quit; -static function void> usart_usleep; -static function bool> usart_readable; -static function uint8> usart_read; -static function bool> usart_writable; -static function void> usart_write; - -extern "C" auto usart_init( - function bool> quit, - function void> usleep, - function bool> readable, - function uint8> read, - function bool> writable, - function void> write -) -> void { - usart_quit = quit; - usart_usleep = usleep; - usart_readable = readable; - usart_read = read; - usart_writable = writable; - usart_write = write; -} - -extern "C" auto usart_main(nall::lstring) -> void; - -// - -static serial usart; -static bool usart_is_virtual = true; -static bool usart_sigint = false; - -static auto usart_virtual() -> bool { - return usart_is_virtual; -} - -// - -static auto usarthw_quit() -> bool { - return usart_sigint; -} - -static auto usarthw_usleep(uint microseconds) -> void { - usleep(microseconds); -} - -static auto usarthw_readable() -> bool { - return usart.readable(); -} - -static auto usarthw_read() -> uint8 { - while(true) { - uint8 buffer[1]; - int length = usart.read((uint8_t*)&buffer, 1); - if(length > 0) return buffer[0]; - } -} - -static auto usarthw_writable() -> bool { - return usart.writable(); -} - -static auto usarthw_write(uint8 data) -> void { - uint8 buffer[1] = {data}; - usart.write((uint8*)&buffer, 1); -} - -static auto sigint(int) -> void { - signal(SIGINT, SIG_DFL); - usart_sigint = true; -} - -#include -auto nall::main(lstring args) -> void { - setpriority(PRIO_PROCESS, 0, -20); //requires superuser privileges; otherwise priority = +0 - signal(SIGINT, sigint); - - if(!usart.open("/dev/ttyACM0", 57600, true)) { - return print("error: unable to open USART hardware device\n"); - } - - usart_is_virtual = false; - usart_init(usarthw_quit, usarthw_usleep, usarthw_readable, usarthw_read, usarthw_writable, usarthw_write); - usart_main(args); - usart.close(); -} diff --git a/file.hpp b/file.hpp index cc5228f..9301489 100644 --- a/file.hpp +++ b/file.hpp @@ -61,7 +61,7 @@ struct file : inode, varint { return !(data.st_mode & S_IFDIR); } - static auto size(const string& filename) -> uintmax { + static auto size(const string& filename) -> uintmax_t { #if defined(API_POSIX) struct stat data; stat(filename, &data); @@ -127,16 +127,16 @@ struct file : inode, varint { return buffer[(file_offset++) & buffer_mask]; } - auto readl(uint length = 1) -> uintmax { - uintmax data = 0; + auto readl(uint length = 1) -> uintmax_t { + uintmax_t data = 0; for(int i = 0; i < length; i++) { - data |= (uintmax)read() << (i << 3); + data |= (uintmax_t)read() << (i << 3); } return data; } - auto readm(uint length = 1) -> uintmax { - uintmax data = 0; + auto readm(uint length = 1) -> uintmax_t { + uintmax_t data = 0; while(length--) { data <<= 8; data |= read(); @@ -164,14 +164,14 @@ struct file : inode, varint { if(file_offset > file_size) file_size = file_offset; } - auto writel(uintmax data, uint length = 1) -> void { + auto writel(uintmax_t data, uint length = 1) -> void { while(length--) { write(data); data >>= 8; } } - auto writem(uintmax data, uint length = 1) -> void { + auto writem(uintmax_t data, uint length = 1) -> void { for(int i = length - 1; i >= 0; i--) { write(data >> (i << 3)); } @@ -200,7 +200,7 @@ struct file : inode, varint { if(!fp) return; //file not open buffer_flush(); - intmax req_offset = file_offset; + intmax_t req_offset = file_offset; switch(index_) { case index::absolute: req_offset = offset; break; case index::relative: req_offset += offset; break; diff --git a/http/request.hpp b/http/request.hpp index da81dd7..eba7217 100644 --- a/http/request.hpp +++ b/http/request.hpp @@ -69,7 +69,7 @@ auto Request::head(const function& callback) co } auto Request::setHead() -> bool { - lstring headers = _head.split("\n"); + auto headers = _head.split("\n"); string request = headers.takeLeft().trimRight("\r", 1L); string requestHost; @@ -85,12 +85,12 @@ auto Request::setHead() -> bool { //decode absolute URIs request.strip().itrimLeft("http://", 1L); if(!request.beginsWith("/")) { - lstring components = request.split("/", 1L); + auto components = request.split("/", 1L); requestHost = components(0); request = {"/", components(1)}; } - lstring components = request.split("?", 1L); + auto components = request.split("?", 1L); setPath(components(0)); if(auto queryString = components(1)) { diff --git a/http/response.hpp b/http/response.hpp index 3e4b315..2e2c12e 100644 --- a/http/response.hpp +++ b/http/response.hpp @@ -87,18 +87,18 @@ auto Response::head(const function& callback) c } auto Response::setHead() -> bool { - lstring headers = _head.split("\n"); + auto headers = _head.split("\n"); string response = headers.takeLeft().trimRight("\r"); if(response.ibeginsWith("HTTP/1.0 ")) response.itrimLeft("HTTP/1.0 ", 1L); else if(response.ibeginsWith("HTTP/1.1 ")) response.itrimLeft("HTTP/1.1 ", 1L); else return false; - setResponseType(natural(response)); + setResponseType(response.natural()); for(auto& header : headers) { if(header.beginsWith(" ") || header.beginsWith("\t")) continue; - lstring variable = header.split(":", 1L).strip(); + auto variable = header.split(":", 1L).strip(); if(variable.size() != 2) continue; this->header.append(variable[0], variable[1]); } @@ -166,7 +166,7 @@ auto Response::findContentLength() const -> unsigned { auto Response::findContentType() const -> string { if(auto contentType = header["Content-Type"]) return contentType.value(); if(hasData()) return "application/octet-stream"; - if(hasFile()) return findContentType(suffixname(file())); + if(hasFile()) return findContentType(Location::suffix(file())); return "text/html; charset=utf-8"; } diff --git a/http/role.hpp b/http/role.hpp index 29eaea8..57c083e 100644 --- a/http/role.hpp +++ b/http/role.hpp @@ -101,7 +101,7 @@ auto Role::download(signed fd, Message& message) -> bool { if(chunk.endsWith("\r\n") || chunk.endsWith("\n")) { chunkReceived = true; - chunkLength = hex(chunk); + chunkLength = chunk.hex(); if(chunkLength == 0) break; chunk.reset(); } diff --git a/string/path.hpp b/location.hpp similarity index 86% rename from string/path.hpp rename to location.hpp index eac881b..7d89d29 100644 --- a/string/path.hpp +++ b/location.hpp @@ -1,10 +1,10 @@ #pragma once -namespace nall { +namespace nall { namespace Location { // (/parent/child.type/) // (/parent/child.type/)name.type -auto pathname(string_view self) -> string { +inline auto path(string_view self) -> string { const char* p = self.data() + self.size() - 1; for(int offset = self.size() - 1; offset >= 0; offset--, p--) { if(*p == '/') return slice(self, 0, offset + 1); @@ -14,7 +14,7 @@ auto pathname(string_view self) -> string { // /parent/child.type/() // /parent/child.type/(name.type) -auto filename(string_view self) -> string { +inline auto file(string_view self) -> string { const char* p = self.data() + self.size() - 1; for(int offset = self.size() - 1; offset >= 0; offset--, p--) { if(*p == '/') return slice(self, offset + 1); @@ -24,7 +24,7 @@ auto filename(string_view self) -> string { // (/parent/)child.type/ // (/parent/child.type/)name.type -auto dirname(string_view self) -> string { +inline auto dir(string_view self) -> string { const char* p = self.data() + self.size() - 1, *last = p; for(int offset = self.size() - 1; offset >= 0; offset--, p--) { if(*p == '/' && p == last) continue; @@ -35,7 +35,7 @@ auto dirname(string_view self) -> string { // /parent/(child.type/) // /parent/child.type/(name.type) -auto basename(string_view self) -> string { +inline auto base(string_view self) -> string { const char* p = self.data() + self.size() - 1, *last = p; for(int offset = self.size() - 1; offset >= 0; offset--, p--) { if(*p == '/' && p == last) continue; @@ -46,7 +46,7 @@ auto basename(string_view self) -> string { // /parent/(child).type/ // /parent/child.type/(name).type -auto prefixname(string_view self) -> string { +inline auto prefix(string_view self) -> string { const char* p = self.data() + self.size() - 1, *last = p; for(int offset = self.size() - 1, suffix = -1; offset >= 0; offset--, p--) { if(*p == '/' && p == last) continue; @@ -59,7 +59,7 @@ auto prefixname(string_view self) -> string { // /parent/child(.type)/ // /parent/child.type/name(.type) -auto suffixname(string_view self) -> string { +inline auto suffix(string_view self) -> string { const char* p = self.data() + self.size() - 1, *last = p; for(int offset = self.size() - 1; offset >= 0; offset--, p--) { if(*p == '/' && p == last) continue; @@ -69,4 +69,4 @@ auto suffixname(string_view self) -> string { return ""; //no suffix found } -} +}} diff --git a/main.hpp b/main.hpp index eecc005..81042f9 100644 --- a/main.hpp +++ b/main.hpp @@ -4,7 +4,7 @@ #include namespace nall { - auto main(lstring arguments) -> void; + auto main(string_vector arguments) -> void; auto main(int argc, char** argv) -> int { #if defined(PLATFORM_WINDOWS) @@ -17,8 +17,16 @@ namespace nall { utf8_args(argc, argv); #endif - lstring arguments; - for(auto n : range(argc)) arguments.append(argv[n]); + string_vector arguments; + for(auto n : range(argc)) { + string argument = argv[n]; + + //normalize directory and file path arguments + if(directory::exists(argument)) argument.transform("\\", "/").trimRight("/").append("/"); + else if(file::exists(argument)) argument.transform("\\", "/").trimRight("/"); + + arguments.append(argument); + } return main(move(arguments)), EXIT_SUCCESS; } diff --git a/mosaic/context.hpp b/mosaic/context.hpp index 256d926..ceb1342 100644 --- a/mosaic/context.hpp +++ b/mosaic/context.hpp @@ -65,13 +65,13 @@ struct context { if(c == ',' && function == true) c = ';'; } - lstring list = expression.split(","); + auto list = expression.split(","); for(auto& item : list) { item.strip(); if(item.match("f(?*) ?*")) { item.trimLeft("f(", 1L); - lstring part = item.split(") ", 1L); - lstring args = part[0].split(";", 3L).strip(); + auto part = item.split(") ", 1L); + auto args = part[0].split(";", 3L).strip(); uint length = eval(args(0, "0")); uint offset = eval(args(1, "0")); @@ -93,7 +93,7 @@ struct context { item.trimLeft("base64", 1L); if(item.match("(?*) *")) { item.trimLeft("(", 1L); - lstring part = item.split(") ", 1L); + auto part = item.split(") ", 1L); offset = eval(part[0]); item = part(1, ""); } @@ -118,9 +118,9 @@ struct context { auto parse(const string& data) -> void { reset(); - lstring lines = data.split("\n"); + auto lines = data.split("\n"); for(auto& line : lines) { - lstring part = line.split(":", 1L).strip(); + auto part = line.split(":", 1L).strip(); if(part.size() != 2) continue; if(part[0] == "offset") offset = eval(part[1]); diff --git a/nall.hpp b/nall.hpp index 24389e0..fa40e83 100644 --- a/nall.hpp +++ b/nall.hpp @@ -32,6 +32,7 @@ #include #include #include +#include #include #include #include diff --git a/path.hpp b/path.hpp index 945a144..360c8d3 100644 --- a/path.hpp +++ b/path.hpp @@ -17,7 +17,7 @@ inline auto active() -> string { inline auto real(string_view name) -> string { string result; char path[PATH_MAX] = ""; - if(::realpath(name, path)) result = pathname(string{path}.transform("\\", "/")); + if(::realpath(name, path)) result = Location::path(string{path}.transform("\\", "/")); if(!result) return active(); result.transform("\\", "/"); if(!result.endsWith("/")) result.append("/"); diff --git a/posix/service.hpp b/posix/service.hpp index a8e1ed4..0ce155b 100644 --- a/posix/service.hpp +++ b/posix/service.hpp @@ -31,29 +31,29 @@ auto service::command(const string& name, const string& command) -> bool { " stop : stop service if it is running\n" " remove : remove semaphore lock if service crashed\n" " {value} : send custom command to service\n" - "", format{name}), false; + "", string_format{name}), false; if(shared.open(name, 4096)) { if(command == "start") { - print("[{0}] already started\n", format{name}); + print("[{0}] already started\n", string_format{name}); } else if(command == "status") { - print("[{0}] running\n", format{name}); + print("[{0}] running\n", string_format{name}); } if(auto data = shared.acquire()) { - if(command == "stop") print("[{0}] stopped\n", format{name}); + if(command == "stop") print("[{0}] stopped\n", string_format{name}); memory::copy(data, command.data(), min(command.size(), 4096)); shared.release(); } if(command == "remove") { shared.remove(); - print("[{0}] removed\n", format{name}); + print("[{0}] removed\n", string_format{name}); } return false; } if(command == "start") { if(shared.create(name, 4096)) { - print("[{0}] started\n", format{name}); + print("[{0}] started\n", string_format{name}); auto pid = fork(); if(pid == 0) { signal(SIGHUP, SIG_IGN); @@ -63,13 +63,13 @@ auto service::command(const string& name, const string& command) -> bool { } shared.close(); } else { - print("[{0}] start failed ({1})\n", format{name, strerror(errno)}); + print("[{0}] start failed ({1})\n", string_format{name, strerror(errno)}); } return false; } if(command == "status") { - print("[{0}] stopped\n", format{name}); + print("[{0}] stopped\n", string_format{name}); return false; } diff --git a/primitives.hpp b/primitives.hpp index 5c08e44..f44734f 100644 --- a/primitives.hpp +++ b/primitives.hpp @@ -79,15 +79,15 @@ template struct Natural { inline auto bit(uint index) -> Reference { return {*this, index, index}; } inline auto byte(uint index) -> Reference { return {*this, index * 8 + 0, index * 8 + 7}; } - inline auto clamp(uint bits) -> uintmax { - const uintmax b = 1ull << (bits - 1); - const uintmax m = b * 2 - 1; + inline auto clamp(uint bits) -> uintmax_t { + const uintmax_t b = 1ull << (bits - 1); + const uintmax_t m = b * 2 - 1; return data < m ? data : m; } - inline auto clip(uint bits) -> uintmax { - const uintmax b = 1ull << (bits - 1); - const uintmax m = b * 2 - 1; + inline auto clip(uint bits) -> uintmax_t { + const uintmax_t b = 1ull << (bits - 1); + const uintmax_t m = b * 2 - 1; return data & m; } @@ -161,15 +161,15 @@ template struct Integer { inline auto bit(uint index) -> Reference { return {*this, index, index}; } inline auto byte(uint index) -> Reference { return {*this, index * 8 + 0, index * 8 + 7}; } - inline auto clamp(uint bits) -> intmax { - const intmax b = 1ull << (bits - 1); - const intmax m = b - 1; + inline auto clamp(uint bits) -> intmax_t { + const intmax_t b = 1ull << (bits - 1); + const intmax_t m = b - 1; return data > m ? m : data < -b ? -b : data; } - inline auto clip(uint bits) -> intmax { - const uintmax b = 1ull << (bits - 1); - const uintmax m = b * 2 - 1; + inline auto clip(uint bits) -> intmax_t { + const uintmax_t b = 1ull << (bits - 1); + const uintmax_t m = b * 2 - 1; return ((data & m) ^ b) - b; } @@ -185,8 +185,8 @@ template struct Real { using type = type_if, float32_t, type_if, float64_t, - type_if, float80_t, - void>>>; + //type_if, float80_t, + void>>; inline Real() : data(0.0) {} template inline Real(const T& value) : data((type)value) {} @@ -215,9 +215,9 @@ private: } using boolean = nall::Boolean; -//note: these conflict with nall/atoi.hpp functions -//using integer = nall::Integer; -//using natural = nall::Natural; +using integer = nall::Integer; +using natural = nall::Natural; +using real = nall::Real; using int1 = nall::Integer< 1>; using int2 = nall::Integer< 2>; @@ -349,6 +349,6 @@ using uint62 = nall::Natural<62>; using uint63 = nall::Natural<63>; using uint64 = nall::Natural<64>; -using float32 = nall::Real<32>; -using float64 = nall::Real<64>; -using float80 = nall::Real<80>; +using real32 = nall::Real<32>; +using real64 = nall::Real<64>; +//using real80 = nall::Real<80>; diff --git a/run.hpp b/run.hpp index 7fcc224..7ab5ac1 100644 --- a/run.hpp +++ b/run.hpp @@ -36,7 +36,7 @@ template inline auto execute(const string& name, P&&... p) -> exe if(pid == 0) { const char* argv[1 + sizeof...(p) + 1]; const char** argp = argv; - lstring argl(forward

(p)...); + string_vector argl(forward

(p)...); *argp++ = (const char*)name; for(auto& arg : argl) *argp++ = (const char*)arg; *argp++ = nullptr; @@ -92,7 +92,7 @@ template inline auto invoke(const string& name, P&&... p) -> void if(pid == 0) { const char* argv[1 + sizeof...(p) + 1]; const char** argp = argv; - lstring argl(forward

(p)...); + string_vector argl(forward

(p)...); *argp++ = (const char*)name; for(auto& arg : argl) *argp++ = (const char*)arg; *argp++ = nullptr; @@ -107,7 +107,7 @@ template inline auto invoke(const string& name, P&&... p) -> void #elif defined(PLATFORM_WINDOWS) template inline auto execute(const string& name, P&&... p) -> execute_result_t { - lstring argl(name, forward

(p)...); + string_vector argl(name, forward

(p)...); for(auto& arg : argl) if(arg.find(" ")) arg = {"\"", arg, "\""}; string arguments = argl.merge(" "); @@ -189,7 +189,7 @@ template inline auto execute(const string& name, P&&... p) -> exe } template inline auto invoke(const string& name, P&&... p) -> void { - lstring argl(forward

(p)...); + string_vector argl(forward

(p)...); for(auto& arg : argl) if(arg.find(" ")) arg = {"\"", arg, "\""}; string arguments = argl.merge(" "); ShellExecute(nullptr, nullptr, utf16_t(name), utf16_t(arguments), nullptr, SW_SHOWNORMAL); diff --git a/serializer.hpp b/serializer.hpp index bb7d862..e883647 100644 --- a/serializer.hpp +++ b/serializer.hpp @@ -63,10 +63,10 @@ struct serializer { template auto integer(T& value) -> serializer& { enum { size = std::is_same::value ? 1 : sizeof(T) }; if(_mode == Save) { - for(uint n = 0; n < size; n++) _data[_size++] = (uintmax)value >> (n << 3); + for(uint n = 0; n < size; n++) _data[_size++] = (uintmax_t)value >> (n << 3); } else if(_mode == Load) { value = 0; - for(uint n = 0; n < size; n++) value |= (uintmax)_data[_size++] << (n << 3); + for(uint n = 0; n < size; n++) value |= (uintmax_t)_data[_size++] << (n << 3); } else if(_mode == Size) { _size += size; } diff --git a/stdint.hpp b/stdint.hpp index 250b72c..67408f3 100644 --- a/stdint.hpp +++ b/stdint.hpp @@ -33,7 +33,8 @@ using float32_t = float; using float64_t = double; -using float80_t = long double; +//note: long double size is not reliable across platforms +//using float80_t = long double; static_assert(sizeof(int8_t) == 1, "int8_t is not of the correct size" ); static_assert(sizeof(int16_t) == 2, "int16_t is not of the correct size"); @@ -47,12 +48,6 @@ static_assert(sizeof(uint64_t) == 8, "int64_t is not of the correct size"); static_assert(sizeof(float) >= 4, "float32_t is not of the correct size"); static_assert(sizeof(double) >= 8, "float64_t is not of the correct size"); -static_assert(sizeof(long double) >= 10, "float80_t is not of the correct size"); - -using intmax = intmax_t; -using intptr = intptr_t; - -using uintmax = uintmax_t; -using uintptr = uintptr_t; +//static_assert(sizeof(long double) >= 10, "float80_t is not of the correct size"); using uint = unsigned int; diff --git a/string.hpp b/string.hpp index 63e7112..2d190d6 100644 --- a/string.hpp +++ b/string.hpp @@ -24,8 +24,9 @@ namespace nall { struct string; -struct format; -struct lstring; +struct string_view; +struct string_vector; +struct string_format; struct string_view { inline string_view(); @@ -61,34 +62,22 @@ template struct stringify; //format.hpp template inline auto print(P&&...) -> void; template inline auto print(FILE*, P&&...) -> void; -inline auto integer(intmax value, long precision = 0, char padchar = '0') -> string; -inline auto natural(uintmax value, long precision = 0, char padchar = '0') -> string; -inline auto hex(uintmax value, long precision = 0, char padchar = '0') -> string; -inline auto octal(uintmax value, long precision = 0, char padchar = '0') -> string; -inline auto binary(uintmax value, long precision = 0, char padchar = '0') -> string; +template inline auto numeral(T value, long precision = 0, char padchar = '0') -> string; +inline auto hex(uintmax_t value, long precision = 0, char padchar = '0') -> string; +inline auto octal(uintmax_t value, long precision = 0, char padchar = '0') -> string; +inline auto binary(uintmax_t value, long precision = 0, char padchar = '0') -> string; template inline auto pointer(const T* value, long precision = 0) -> string; -inline auto pointer(uintptr value, long precision = 0) -> string; -inline auto real(long double value) -> string; +inline auto pointer(uintptr_t value, long precision = 0) -> string; //match.hpp inline auto tokenize(const char* s, const char* p) -> bool; -inline auto tokenize(lstring& list, const char* s, const char* p) -> bool; - -//path.hpp -inline auto pathname(string_view self) -> string; -inline auto filename(string_view self) -> string; - -inline auto dirname(string_view self) -> string; -inline auto basename(string_view self) -> string; -inline auto prefixname(string_view self) -> string; -inline auto suffixname(string_view self) -> string; +inline auto tokenize(string_vector& list, const char* s, const char* p) -> bool; //utility.hpp inline auto slice(string_view self, int offset = 0, int length = -1) -> string; - -inline auto integer(char* result, intmax value) -> char*; -inline auto natural(char* result, uintmax value) -> char*; -inline auto real(char* str, long double value) -> uint; +inline auto fromInteger(char* result, intmax_t value) -> char*; +inline auto fromNatural(char* result, uintmax_t value) -> char*; +inline auto fromReal(char* str, long double value) -> uint; struct string { using type = string; @@ -179,15 +168,16 @@ public: auto end() const -> const char* { return &data()[size()]; } //atoi.hpp - inline auto integer() const -> intmax; - inline auto natural() const -> uintmax; + inline auto integer() const -> intmax_t; + inline auto natural() const -> uintmax_t; + inline auto hex() const -> uintmax_t; inline auto real() const -> double; //core.hpp inline auto operator[](int) const -> const char&; template inline auto assign(P&&...) -> type&; template inline auto append(const T&, P&&...) -> type&; - template inline auto append(const nall::format&, P&&...) -> type&; + template inline auto append(const nall::string_format&, P&&...) -> type&; inline auto append() -> type&; template inline auto _append(const stringify&) -> string&; inline auto length() const -> uint; @@ -209,7 +199,7 @@ public: inline auto ifindFrom(int offset, string_view source) const -> maybe; //format.hpp - inline auto format(const nall::format& params) -> type&; + inline auto format(const nall::string_format& params) -> type&; //compare.hpp template inline static auto _compare(const char*, uint, const char*, uint) -> int; @@ -250,10 +240,10 @@ public: inline auto iqreplace(string_view from, string_view to, long limit = LONG_MAX) -> type&; //split.hpp - inline auto split(string_view key, long limit = LONG_MAX) const -> lstring; - inline auto isplit(string_view key, long limit = LONG_MAX) const -> lstring; - inline auto qsplit(string_view key, long limit = LONG_MAX) const -> lstring; - inline auto iqsplit(string_view key, long limit = LONG_MAX) const -> lstring; + inline auto split(string_view key, long limit = LONG_MAX) const -> string_vector; + inline auto isplit(string_view key, long limit = LONG_MAX) const -> string_vector; + inline auto qsplit(string_view key, long limit = LONG_MAX) const -> string_vector; + inline auto iqsplit(string_view key, long limit = LONG_MAX) const -> string_vector; //trim.hpp inline auto trim(string_view lhs, string_view rhs, long limit = LONG_MAX) -> type&; @@ -278,21 +268,21 @@ public: inline auto size(int length, char fill = ' ') -> type&; }; -struct lstring : vector { - using type = lstring; +struct string_vector : vector { + using type = string_vector; - lstring(const lstring& source) { vector::operator=(source); } - lstring(lstring& source) { vector::operator=(source); } - lstring(lstring&& source) { vector::operator=(move(source)); } - template lstring(P&&... p) { append(forward

(p)...); } + string_vector(const string_vector& source) { vector::operator=(source); } + string_vector(string_vector& source) { vector::operator=(source); } + string_vector(string_vector&& source) { vector::operator=(move(source)); } + template string_vector(P&&... p) { append(forward

(p)...); } //list.hpp - inline auto operator==(const lstring&) const -> bool; - inline auto operator!=(const lstring&) const -> bool; + inline auto operator==(const string_vector&) const -> bool; + inline auto operator!=(const string_vector&) const -> bool; - inline auto operator=(const lstring& source) -> type& { return vector::operator=(source), *this; } - inline auto operator=(lstring& source) -> type& { return vector::operator=(source), *this; } - inline auto operator=(lstring&& source) -> type& { return vector::operator=(move(source)), *this; } + inline auto operator=(const string_vector& source) -> type& { return vector::operator=(source), *this; } + inline auto operator=(string_vector& source) -> type& { return vector::operator=(source), *this; } + inline auto operator=(string_vector&& source) -> type& { return vector::operator=(move(source)), *this; } inline auto isort() -> type&; @@ -301,18 +291,18 @@ struct lstring : vector { inline auto find(string_view source) const -> maybe; inline auto ifind(string_view source) const -> maybe; - inline auto match(string_view pattern) const -> lstring; + inline auto match(string_view pattern) const -> string_vector; inline auto merge(string_view separator) const -> string; inline auto strip() -> type&; //split.hpp - template inline auto _split(string_view, string_view, long) -> lstring&; + template inline auto _split(string_view, string_view, long) -> type&; }; -struct format : vector { - using type = format; +struct string_format : vector { + using type = string_format; - template format(P&&... p) { reserve(sizeof...(p)); append(forward

(p)...); } + template string_format(P&&... p) { reserve(sizeof...(p)); append(forward

(p)...); } template inline auto append(const T&, P&&... p) -> type&; inline auto append() -> type&; }; @@ -330,7 +320,6 @@ struct format : vector { #include #include #include -#include #include #include #include diff --git a/string/atoi.hpp b/string/atoi.hpp index 7ee5de5..3dd1f77 100644 --- a/string/atoi.hpp +++ b/string/atoi.hpp @@ -2,16 +2,20 @@ namespace nall { -auto string::integer() const -> intmax { - return nall::integer(data()); +auto string::integer() const -> intmax_t { + return toInteger(data()); } -auto string::natural() const -> uintmax { - return nall::natural(data()); +auto string::natural() const -> uintmax_t { + return toNatural(data()); +} + +auto string::hex() const -> uintmax_t { + return toHex(data()); } auto string::real() const -> double { - return nall::real(data()); + return toReal(data()); } } diff --git a/string/cast.hpp b/string/cast.hpp index 2c68071..88f0482 100644 --- a/string/cast.hpp +++ b/string/cast.hpp @@ -33,42 +33,42 @@ template<> struct stringify { //signed integers template<> struct stringify { - stringify(signed char source) { integer(_data, source); } + stringify(signed char source) { fromInteger(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[2 + sizeof(signed char) * 3]; }; template<> struct stringify { - stringify(signed short source) { integer(_data, source); } + stringify(signed short source) { fromInteger(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[2 + sizeof(signed short) * 3]; }; template<> struct stringify { - stringify(signed int source) { integer(_data, source); } + stringify(signed int source) { fromInteger(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[2 + sizeof(signed int) * 3]; }; template<> struct stringify { - stringify(signed long source) { integer(_data, source); } + stringify(signed long source) { fromInteger(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[2 + sizeof(signed long) * 3]; }; template<> struct stringify { - stringify(signed long long source) { integer(_data, source); } + stringify(signed long long source) { fromInteger(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[2 + sizeof(signed long long) * 3]; }; template struct stringify> { - stringify(Integer source) { integer(_data, source); } + stringify(Integer source) { fromInteger(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[2 + sizeof(int64_t) * 3]; @@ -77,42 +77,42 @@ template struct stringify> { //unsigned integers template<> struct stringify { - stringify(unsigned char source) { natural(_data, source); } + stringify(unsigned char source) { fromNatural(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[1 + sizeof(unsigned char) * 3]; }; template<> struct stringify { - stringify(unsigned short source) { natural(_data, source); } + stringify(unsigned short source) { fromNatural(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[1 + sizeof(unsigned short) * 3]; }; template<> struct stringify { - stringify(unsigned int source) { natural(_data, source); } + stringify(unsigned int source) { fromNatural(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[1 + sizeof(unsigned int) * 3]; }; template<> struct stringify { - stringify(unsigned long source) { natural(_data, source); } + stringify(unsigned long source) { fromNatural(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[1 + sizeof(unsigned long) * 3]; }; template<> struct stringify { - stringify(unsigned long long source) { natural(_data, source); } + stringify(unsigned long long source) { fromNatural(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[1 + sizeof(unsigned long long) * 3]; }; template struct stringify> { - stringify(Natural source) { natural(_data, source); } + stringify(Natural source) { fromNatural(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[1 + sizeof(uint64_t) * 3]; @@ -121,28 +121,28 @@ template struct stringify> { //floating-point template<> struct stringify { - stringify(float source) { real(_data, source); } + stringify(float source) { fromReal(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[256]; }; template<> struct stringify { - stringify(double source) { real(_data, source); } + stringify(double source) { fromReal(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[256]; }; template<> struct stringify { - stringify(long double source) { real(_data, source); } + stringify(long double source) { fromReal(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[256]; }; template struct stringify> { - stringify(Real source) { real(_data, source); } + stringify(Real source) { fromReal(_data, source); } auto data() const -> const char* { return _data; } auto size() const -> uint { return strlen(_data); } char _data[256]; diff --git a/string/core.hpp b/string/core.hpp index 7122c5f..c0a2f85 100644 --- a/string/core.hpp +++ b/string/core.hpp @@ -30,7 +30,7 @@ template auto string::append(const T& value, P&&... p return append(forward

(p)...); } -template auto string::append(const nall::format& value, P&&... p) -> string& { +template auto string::append(const nall::string_format& value, P&&... p) -> string& { format(value); return append(forward

(p)...); } diff --git a/string/datetime.hpp b/string/datetime.hpp index 8469699..9d24230 100644 --- a/string/datetime.hpp +++ b/string/datetime.hpp @@ -6,9 +6,9 @@ auto string::date(time_t timestamp) -> string { if(timestamp == 0) timestamp = ::time(nullptr); tm* info = localtime(×tamp); return { - nall::natural(1900 + info->tm_year, 4L), "-", - nall::natural(1 + info->tm_mon, 2L), "-", - nall::natural(info->tm_mday, 2L) + numeral(1900 + info->tm_year, 4L), "-", + numeral(1 + info->tm_mon, 2L), "-", + numeral(info->tm_mday, 2L) }; } @@ -16,9 +16,9 @@ auto string::time(time_t timestamp) -> string { if(timestamp == 0) timestamp = ::time(nullptr); tm* info = localtime(×tamp); return { - nall::natural(info->tm_hour, 2L), ":", - nall::natural(info->tm_min, 2L), ":", - nall::natural(info->tm_sec, 2L) + numeral(info->tm_hour, 2L), ":", + numeral(info->tm_min, 2L), ":", + numeral(info->tm_sec, 2L) }; } diff --git a/string/eval/evaluator.hpp b/string/eval/evaluator.hpp index 184f8eb..5ed01f1 100644 --- a/string/eval/evaluator.hpp +++ b/string/eval/evaluator.hpp @@ -37,7 +37,7 @@ inline auto evaluateExpression(Node* node) -> string { } inline auto evaluateInteger(Node* node) -> int64_t { - if(node->type == Node::Type::Literal) return nall::integer(node->literal); + if(node->type == Node::Type::Literal) return toInteger(node->literal); #define p(n) evaluateInteger(node->link[n]) switch(node->type) { @@ -99,7 +99,7 @@ inline auto integer(const string& expression) -> maybe { } inline auto evaluateReal(Node* node) -> long double { - if(node->type == Node::Type::Literal) return nall::real(node->literal); + if(node->type == Node::Type::Literal) return toReal(node->literal); #define p(n) evaluateReal(node->link[n]) switch(node->type) { diff --git a/string/format.hpp b/string/format.hpp index 71c8a1a..78a61ee 100644 --- a/string/format.hpp +++ b/string/format.hpp @@ -5,7 +5,7 @@ namespace nall { //nall::format is a vector of parameters that can be applied to a string //each {#} token will be replaced with its appropriate format parameter -auto string::format(const nall::format& params) -> type& { +auto string::format(const nall::string_format& params) -> type& { auto size = (int)this->size(); auto data = (char*)memory::allocate(size); memory::copy(data, this->data(), size); @@ -32,7 +32,7 @@ auto string::format(const nall::format& params) -> type& { }; if(!isNumeric(&data[x + 1], &data[y - 1])) { x++; continue; } - uint index = nall::natural(&data[x + 1]); + uint index = toNatural(&data[x + 1]); if(index >= params.size()) { x++; continue; } uint sourceSize = y - x; @@ -59,12 +59,12 @@ auto string::format(const nall::format& params) -> type& { return *this; } -template auto format::append(const T& value, P&&... p) -> format& { +template auto string_format::append(const T& value, P&&... p) -> string_format& { vector::append(value); return append(forward

(p)...); } -auto format::append() -> format& { +auto string_format::append() -> string_format& { return *this; } @@ -78,9 +78,10 @@ template auto print(FILE* fp, P&&... p) -> void { fwrite(s.data(), 1, s.size(), fp); } -auto integer(intmax value, long precision, char padchar) -> string { +/* +auto integer(intmax_t value, long precision, char padchar) -> string { string buffer; - buffer.resize(1 + sizeof(intmax) * 3); + buffer.resize(1 + sizeof(intmax_t) * 3); char* p = buffer.get(); bool negative = value < 0; @@ -97,9 +98,9 @@ auto integer(intmax value, long precision, char padchar) -> string { return buffer; } -auto natural(uintmax value, long precision, char padchar) -> string { +auto natural(uintmax_t value, long precision, char padchar) -> string { string buffer; - buffer.resize(sizeof(uintmax) * 3); + buffer.resize(sizeof(uintmax_t) * 3); char* p = buffer.get(); uint size = 0; @@ -112,10 +113,17 @@ auto natural(uintmax value, long precision, char padchar) -> string { if(precision) buffer.size(precision, padchar); return buffer; } +*/ -auto hex(uintmax value, long precision, char padchar) -> string { +template auto numeral(T value, long precision, char padchar) -> string { + string buffer{value}; + if(precision) buffer.size(precision, padchar); + return buffer; +} + +auto hex(uintmax_t value, long precision, char padchar) -> string { string buffer; - buffer.resize(sizeof(uintmax) * 2); + buffer.resize(sizeof(uintmax_t) * 2); char* p = buffer.get(); uint size = 0; @@ -130,9 +138,9 @@ auto hex(uintmax value, long precision, char padchar) -> string { return buffer; } -auto octal(uintmax value, long precision, char padchar) -> string { +auto octal(uintmax_t value, long precision, char padchar) -> string { string buffer; - buffer.resize(sizeof(uintmax) * 3); + buffer.resize(sizeof(uintmax_t) * 3); char* p = buffer.get(); uint size = 0; @@ -146,9 +154,9 @@ auto octal(uintmax value, long precision, char padchar) -> string { return buffer; } -auto binary(uintmax value, long precision, char padchar) -> string { +auto binary(uintmax_t value, long precision, char padchar) -> string { string buffer; - buffer.resize(sizeof(uintmax) * 8); + buffer.resize(sizeof(uintmax_t) * 8); char* p = buffer.get(); uint size = 0; @@ -164,19 +172,21 @@ auto binary(uintmax value, long precision, char padchar) -> string { template auto pointer(const T* value, long precision) -> string { if(value == nullptr) return "(nullptr)"; - return {"0x", hex((uintptr)value, precision)}; + return {"0x", hex((uintptr_t)value, precision)}; } -auto pointer(uintptr value, long precision) -> string { +auto pointer(uintptr_t value, long precision) -> string { if(value == 0) return "(nullptr)"; return {"0x", hex(value, precision)}; } +/* auto real(long double value) -> string { string temp; - temp.resize(real(nullptr, value)); - real(temp.get(), value); + temp.resize(fromReal(nullptr, value)); + fromReal(temp.get(), value); return temp; } +*/ } diff --git a/string/list.hpp b/string/list.hpp index ae74172..72cace5 100644 --- a/string/list.hpp +++ b/string/list.hpp @@ -2,7 +2,7 @@ namespace nall { -auto lstring::operator==(const lstring& source) const -> bool { +auto string_vector::operator==(const string_vector& source) const -> bool { if(this == &source) return true; if(size() != source.size()) return false; for(uint n = 0; n < size(); n++) { @@ -11,50 +11,50 @@ auto lstring::operator==(const lstring& source) const -> bool { return true; } -auto lstring::operator!=(const lstring& source) const -> bool { +auto string_vector::operator!=(const string_vector& source) const -> bool { return !operator==(source); } -auto lstring::isort() -> lstring& { +auto string_vector::isort() -> type& { sort([](const string& x, const string& y) { return memory::icompare(x.data(), x.size(), y.data(), y.size()) < 0; }); return *this; } -template auto lstring::append(const string& data, P&&... p) -> lstring& { +template auto string_vector::append(const string& data, P&&... p) -> type& { vector::append(data); append(forward

(p)...); return *this; } -auto lstring::append() -> lstring& { +auto string_vector::append() -> type& { return *this; } -auto lstring::find(string_view source) const -> maybe { +auto string_vector::find(string_view source) const -> maybe { for(uint n = 0; n < size(); n++) { if(operator[](n).equals(source)) return n; } return nothing; } -auto lstring::ifind(string_view source) const -> maybe { +auto string_vector::ifind(string_view source) const -> maybe { for(uint n = 0; n < size(); n++) { if(operator[](n).iequals(source)) return n; } return nothing; } -auto lstring::match(string_view pattern) const -> lstring { - lstring result; +auto string_vector::match(string_view pattern) const -> type { + string_vector result; for(uint n = 0; n < size(); n++) { if(operator[](n).match(pattern)) result.append(operator[](n)); } return result; } -auto lstring::merge(string_view separator) const -> string { +auto string_vector::merge(string_view separator) const -> string { string output; for(uint n = 0; n < size(); n++) { output.append(operator[](n)); @@ -63,7 +63,7 @@ auto lstring::merge(string_view separator) const -> string { return output; } -auto lstring::strip() -> lstring& { +auto string_vector::strip() -> type& { for(uint n = 0; n < size(); n++) { operator[](n).strip(); } diff --git a/string/markup/bml.hpp b/string/markup/bml.hpp index 550f3e0..631a612 100644 --- a/string/markup/bml.hpp +++ b/string/markup/bml.hpp @@ -80,7 +80,7 @@ protected: } //read a node and all of its child nodes - auto parseNode(const lstring& text, uint& y) -> void { + auto parseNode(const string_vector& text, uint& y) -> void { const char* p = text[y++]; _metadata = parseDepth(p); parseName(p); @@ -166,7 +166,7 @@ inline auto serialize(const Markup::Node& node, uint depth = 0) -> string { padding.resize(depth * 2); for(auto& byte : padding) byte = ' '; - lstring lines; + string_vector lines; if(auto value = node.value()) lines = value.split("\n"); string result; diff --git a/string/markup/find.hpp b/string/markup/find.hpp index f4016ba..8a2ef8e 100644 --- a/string/markup/find.hpp +++ b/string/markup/find.hpp @@ -20,7 +20,7 @@ auto ManagedNode::_evaluate(string query) const -> bool { return false; } - lstring side; + string_vector side; switch(comparator) { case Comparator::EQ: side = rule.split ("=", 1L); break; case Comparator::NE: side = rule.split("!=", 1L); break; @@ -55,7 +55,7 @@ auto ManagedNode::_evaluate(string query) const -> bool { auto ManagedNode::_find(const string& query) const -> vector { vector result; - lstring path = query.split("/"); + auto path = query.split("/"); string name = path.take(0), rule; uint lo = 0u, hi = ~0u; diff --git a/string/markup/node.hpp b/string/markup/node.hpp index 875e576..f1a3a2a 100644 --- a/string/markup/node.hpp +++ b/string/markup/node.hpp @@ -59,8 +59,8 @@ struct Node { auto text() const -> string { return value().strip(); } auto boolean() const -> bool { return text() == "true"; } - auto integer() const -> intmax { return text().integer(); } - auto natural() const -> uintmax { return text().natural(); } + auto integer() const -> intmax_t { return text().integer(); } + auto natural() const -> uintmax_t { return text().natural(); } auto real() const -> double { return text().real(); } auto setName(const string& name = "") -> Node& { shared->_name = name; return *this; } diff --git a/string/match.hpp b/string/match.hpp index 3d1bebb..ecd9fb4 100644 --- a/string/match.hpp +++ b/string/match.hpp @@ -68,7 +68,7 @@ auto tokenize(const char* s, const char* p) -> bool { return !*p; } -auto tokenize(lstring& list, const char* s, const char* p) -> bool { +auto tokenize(string_vector& list, const char* s, const char* p) -> bool { while(*s) { if(*p == '*') { const char* b = s; diff --git a/string/split.hpp b/string/split.hpp index ef5b8f3..a852011 100644 --- a/string/split.hpp +++ b/string/split.hpp @@ -3,7 +3,7 @@ namespace nall { template -auto lstring::_split(string_view source, string_view find, long limit) -> lstring& { +auto string_vector::_split(string_view source, string_view find, long limit) -> string_vector& { reset(); if(limit <= 0 || find.size() == 0) return *this; @@ -33,9 +33,9 @@ auto lstring::_split(string_view source, string_view find, long limit) -> lstrin return *this; } -auto string::split(string_view on, long limit) const -> lstring { return lstring()._split<0, 0>(*this, on, limit); } -auto string::isplit(string_view on, long limit) const -> lstring { return lstring()._split<1, 0>(*this, on, limit); } -auto string::qsplit(string_view on, long limit) const -> lstring { return lstring()._split<0, 1>(*this, on, limit); } -auto string::iqsplit(string_view on, long limit) const -> lstring { return lstring()._split<1, 1>(*this, on, limit); } +auto string::split(string_view on, long limit) const -> string_vector { return string_vector()._split<0, 0>(*this, on, limit); } +auto string::isplit(string_view on, long limit) const -> string_vector { return string_vector()._split<1, 0>(*this, on, limit); } +auto string::qsplit(string_view on, long limit) const -> string_vector { return string_vector()._split<0, 1>(*this, on, limit); } +auto string::iqsplit(string_view on, long limit) const -> string_vector { return string_vector()._split<1, 1>(*this, on, limit); } } diff --git a/string/transform/cml.hpp b/string/transform/cml.hpp index c0e9733..0d1935b 100644 --- a/string/transform/cml.hpp +++ b/string/transform/cml.hpp @@ -4,6 +4,8 @@ * revision 0.02 */ +#include + namespace nall { namespace { struct CML { @@ -33,7 +35,7 @@ private: }; auto CML::parse(const string& filename) -> string { - if(!settings.path) settings.path = pathname(filename); + if(!settings.path) settings.path = Location::path(filename); string document = settings.reader ? settings.reader(filename) : string::read(filename); parseDocument(document, settings.path, 0); return state.output; @@ -54,14 +56,14 @@ auto CML::parseDocument(const string& filedata, const string& pathname, uint dep }; for(auto& block : filedata.split("\n\n")) { - lstring lines = block.stripRight().split("\n"); - string name = lines.takeLeft(); + auto lines = block.stripRight().split("\n"); + auto name = lines.takeLeft(); if(name.beginsWith("include ")) { name.trimLeft("include ", 1L); string filename{pathname, name}; string document = settings.reader ? settings.reader(filename) : string::read(filename); - parseDocument(document, nall::pathname(filename), depth + 1); + parseDocument(document, Location::path(filename), depth + 1); continue; } diff --git a/string/transform/dml.hpp b/string/transform/dml.hpp index 32dcf1d..4e7bda4 100644 --- a/string/transform/dml.hpp +++ b/string/transform/dml.hpp @@ -4,6 +4,8 @@ * revision 0.03 */ +#include + namespace nall { namespace { struct DML { @@ -45,7 +47,7 @@ auto DML::parse(const string& filedata, const string& pathname) -> string { } auto DML::parse(const string& filename) -> string { - if(!settings.path) settings.path = pathname(filename); + if(!settings.path) settings.path = Location::path(filename); string document = settings.reader ? settings.reader(filename) : string::read(filename); parseDocument(document, settings.path, 0); return state.output; @@ -68,7 +70,7 @@ auto DML::parseBlock(string& block, const string& pathname, uint depth) -> bool if(block.beginsWith("")) { string filename{pathname, block.trim("", 1L).strip()}; string document = settings.reader ? settings.reader(filename) : string::read(filename); - parseDocument(document, nall::pathname(filename), depth + 1); + parseDocument(document, Location::path(filename), depth + 1); } //html diff --git a/string/utility.hpp b/string/utility.hpp index 00a5296..983d259 100644 --- a/string/utility.hpp +++ b/string/utility.hpp @@ -92,7 +92,7 @@ auto slice(string_view self, int offset, int length) -> string { return result; } -auto integer(char* result, intmax value) -> char* { +auto fromInteger(char* result, intmax_t value) -> char* { bool negative = value < 0; if(negative) value = -value; @@ -111,7 +111,7 @@ auto integer(char* result, intmax value) -> char* { return result; } -auto natural(char* result, uintmax value) -> char* { +auto fromNatural(char* result, uintmax_t value) -> char* { char buffer[64]; uint size = 0; @@ -129,7 +129,7 @@ auto natural(char* result, uintmax value) -> char* { //using sprintf is certainly not the most ideal method to convert //a double to a string ... but attempting to parse a double by //hand, digit-by-digit, results in subtle rounding errors. -auto real(char* result, long double value) -> uint { +auto fromReal(char* result, long double value) -> uint { char buffer[256]; #ifdef _WIN32 //Windows C-runtime does not support long double via sprintf() diff --git a/thread.hpp b/thread.hpp index fd33e2d..3a76e43 100644 --- a/thread.hpp +++ b/thread.hpp @@ -19,13 +19,13 @@ namespace nall { struct thread { inline auto join() -> void; - static inline auto create(const function& callback, uintptr parameter = 0, uint stacksize = 0) -> thread; + static inline auto create(const function& callback, uintptr_t parameter = 0, uint stacksize = 0) -> thread; static inline auto detach() -> void; static inline auto exit() -> void; struct context { - function void> callback; - uintptr parameter = 0; + function void> callback; + uintptr_t parameter = 0; }; private: @@ -43,7 +43,7 @@ auto thread::join() -> void { pthread_join(handle, nullptr); } -auto thread::create(const function& callback, uintptr parameter, uint stacksize) -> thread { +auto thread::create(const function& callback, uintptr_t parameter, uint stacksize) -> thread { thread instance; auto context = new thread::context; @@ -76,13 +76,13 @@ struct thread { inline ~thread(); inline auto join() -> void; - static inline auto create(const function& callback, uintptr parameter = 0, uint stacksize = 0) -> thread; + static inline auto create(const function& callback, uintptr_t parameter = 0, uint stacksize = 0) -> thread; static inline auto detach() -> void; static inline auto exit() -> void; struct context { - function void> callback; - uintptr parameter = 0; + function void> callback; + uintptr_t parameter = 0; }; private: @@ -111,7 +111,7 @@ auto thread::join() -> void { } } -auto thread::create(const function& callback, uintptr parameter, uint stacksize) -> thread { +auto thread::create(const function& callback, uintptr_t parameter, uint stacksize) -> thread { thread instance; auto context = new thread::context; diff --git a/varint.hpp b/varint.hpp index ee18a03..f684bf4 100644 --- a/varint.hpp +++ b/varint.hpp @@ -10,8 +10,8 @@ struct varint { virtual auto read() -> uint8_t = 0; virtual auto write(uint8_t) -> void = 0; - auto readvu() -> uintmax { - uintmax data = 0, shift = 1; + auto readvu() -> uintmax_t { + uintmax_t data = 0, shift = 1; while(true) { uint8_t x = read(); data += (x & 0x7f) * shift; @@ -22,15 +22,15 @@ struct varint { return data; } - auto readvs() -> intmax { - uintmax data = readvu(); + auto readvs() -> intmax_t { + uintmax_t data = readvu(); bool negate = data & 1; data >>= 1; if(negate) data = ~data; return data; } - auto writevu(uintmax data) -> void { + auto writevu(uintmax_t data) -> void { while(true) { uint8_t x = data & 0x7f; data >>= 7; @@ -40,7 +40,7 @@ struct varint { } } - auto writevs(intmax data) -> void { + auto writevs(intmax_t data) -> void { bool negate = data < 0; if(negate) data = ~data; data = (data << 1) | negate; diff --git a/vfs/fs/file.hpp b/vfs/fs/file.hpp index d899a43..d52d387 100644 --- a/vfs/fs/file.hpp +++ b/vfs/fs/file.hpp @@ -11,15 +11,15 @@ struct file : vfs::file { return instance; } - auto size() const -> uintmax override { + auto size() const -> uintmax_t override { return _fp.size(); } - auto offset() const -> uintmax override { + auto offset() const -> uintmax_t override { return _fp.offset(); } - auto seek(intmax offset_, index index_) -> void override { + auto seek(intmax_t offset_, index index_) -> void override { _fp.seek(offset_, (nall::file::index)index_); } diff --git a/vfs/memory/file.hpp b/vfs/memory/file.hpp index 4f9afa2..02bdcbb 100644 --- a/vfs/memory/file.hpp +++ b/vfs/memory/file.hpp @@ -5,18 +5,18 @@ namespace nall { namespace vfs { namespace memory { struct file : vfs::file { ~file() { delete[] _data; } - static auto open(const uint8_t* data, uintmax size) -> vfs::shared::file { + static auto open(const uint8_t* data, uintmax_t size) -> vfs::shared::file { auto instance = shared_pointer{new file}; instance->_open(data, size); return instance; } - auto size() const -> uintmax override { return _size; } - auto offset() const -> uintmax override { return _offset; } + auto size() const -> uintmax_t override { return _size; } + auto offset() const -> uintmax_t override { return _offset; } - auto seek(intmax offset, index mode) -> void override { - if(mode == index::absolute) _offset = (uintmax)offset; - if(mode == index::relative) _offset += (intmax)offset; + auto seek(intmax_t offset, index mode) -> void override { + if(mode == index::absolute) _offset = (uintmax_t)offset; + if(mode == index::relative) _offset += (intmax_t)offset; } auto read() -> uint8_t override { @@ -34,15 +34,15 @@ private: file(const file&) = delete; auto operator=(const file&) -> file& = delete; - auto _open(const uint8_t* data, uintmax size) -> void { + auto _open(const uint8_t* data, uintmax_t size) -> void { _size = size; _data = new uint8_t[size]; nall::memory::copy(_data, data, size); } uint8_t* _data = nullptr; - uintmax _size = 0; - uintmax _offset = 0; + uintmax_t _size = 0; + uintmax_t _offset = 0; }; }}} diff --git a/vfs/vfs.hpp b/vfs/vfs.hpp index b1589bb..6944921 100644 --- a/vfs/vfs.hpp +++ b/vfs/vfs.hpp @@ -11,10 +11,10 @@ struct file { virtual ~file() = default; - virtual auto size() const -> uintmax = 0; - virtual auto offset() const -> uintmax = 0; + virtual auto size() const -> uintmax_t = 0; + virtual auto offset() const -> uintmax_t = 0; - virtual auto seek(intmax offset, index = index::absolute) -> void = 0; + virtual auto seek(intmax_t offset, index = index::absolute) -> void = 0; virtual auto read() -> uint8_t = 0; virtual auto write(uint8_t data) -> void = 0; virtual auto flush() -> void {} @@ -23,19 +23,19 @@ struct file { return offset() >= size(); } - auto read(void* vdata, uintmax bytes) -> void { + auto read(void* vdata, uintmax_t bytes) -> void { auto data = (uint8_t*)vdata; while(bytes--) *data++ = read(); } - auto readl(uint bytes) -> uintmax { - uintmax data = 0; - for(auto n : range(bytes)) data |= (uintmax)read() << n * 8; + auto readl(uint bytes) -> uintmax_t { + uintmax_t data = 0; + for(auto n : range(bytes)) data |= (uintmax_t)read() << n * 8; return data; } - auto readm(uint bytes) -> uintmax { - uintmax data = 0; + auto readm(uint bytes) -> uintmax_t { + uintmax_t data = 0; for(auto n : range(bytes)) data = data << 8 | read(); return data; } @@ -47,16 +47,16 @@ struct file { return s; } - auto write(const void* vdata, uintmax bytes) -> void { + auto write(const void* vdata, uintmax_t bytes) -> void { auto data = (const uint8_t*)vdata; while(bytes--) write(*data++); } - auto writel(uintmax data, uint bytes) -> void { + auto writel(uintmax_t data, uint bytes) -> void { for(auto n : range(bytes)) write(data), data >>= 8; } - auto writem(uintmax data, uint bytes) -> void { + auto writem(uintmax_t data, uint bytes) -> void { for(auto n : rrange(bytes)) write(data >> n * 8); } diff --git a/windows/registry.hpp b/windows/registry.hpp index 97f3f35..d58ff18 100644 --- a/windows/registry.hpp +++ b/windows/registry.hpp @@ -24,7 +24,7 @@ namespace nall { struct registry { static auto exists(const string& name) -> bool { - lstring part = name.split("/"); + auto part = name.split("/"); HKEY handle, rootKey = root(part.takeLeft()); string node = part.takeRight(); string path = part.merge("\\"); @@ -39,7 +39,7 @@ struct registry { } static auto read(const string& name) -> string { - lstring part = name.split("/"); + auto part = name.split("/"); HKEY handle, rootKey = root(part.takeLeft()); string node = part.takeRight(); string path = part.merge("\\"); @@ -54,7 +54,7 @@ struct registry { } static auto write(const string& name, const string& data = "") -> void { - lstring part = name.split("/"); + auto part = name.split("/"); HKEY handle, rootKey = root(part.takeLeft()); string node = part.takeRight(), path; DWORD disposition; @@ -71,7 +71,7 @@ struct registry { } static auto remove(const string& name) -> bool { - lstring part = name.split("/"); + auto part = name.split("/"); HKEY rootKey = root(part.takeLeft()); string node = part.takeRight(); string path = part.merge("\\"); @@ -79,8 +79,9 @@ struct registry { return SHDeleteValueW(rootKey, utf16_t(path), utf16_t(node)) == ERROR_SUCCESS; } - static auto contents(const string& name) -> lstring { - lstring part = name.split("/"), result; + static auto contents(const string& name) -> string_vector { + string_vector result; + auto part = name.split("/"); HKEY handle, rootKey = root(part.takeLeft()); part.removeRight(); string path = part.merge("\\");