void GuiTerminal::update(const ServerMessage &message)
{
sf::Lock Lock(mutex);
std::vector<std::string> ret;
switch(message.type)
{
case ServerMessage::server_fun:
term->add_server_exe("/bin", message.msg, message.msg);
break;
case ServerMessage::register_mons:
ret = message.get_parsed_msg();
if(ret.size() > 1) term->add_readable("/mon", ret[0], ret[1]);
break;
case ServerMessage::reply:
frozen=false;
textbox->remove_last_line_if( std::bind1st( std::equal_to<std::string>(), GuiTerminal::waiting_message ) );
if(!message.msg.empty()) {
ret = string_explode(message.msg, "\n");
for(size_t i=0; i<ret.size(); ++i) if(i != ret.size() -1 || !ret[i].empty()) textbox->add(ret[i]);
}
break;
default:
break;
}
}
void LevelData::parseUserData() {
char app_dir[255];
int ret = PDL_GetDataFilePath("my_data.mja", app_dir, 256);
string file_path(app_dir);
ifstream config_file(file_path.c_str());
string line;
string state="none"; // none, level_data, inprocess
while (getline(config_file, line)) {
if (line == "(inp)") state = "inprocess";
if (line == "(endinp)") state = "none";
if (line == "(lvl)") state = "level_data";
if (line == "(endlvl)") state = "none";
if (state == "inprocess" && line != "(inp)") {
// list,id
vector<string> parsed_level;
string_explode(line, ":", &parsed_level);
current_level = parsed_level[1];
}
if (state == "level_data" && line != "(lvl)") {
// id,score,completed,unlocked,stars
vector<string> parsed_level;
string_explode(line, ":", &parsed_level);
vector<LevelDetails>::iterator iter;
for (iter = core_levels.begin(); iter != core_levels.end(); iter++) {
if (iter->id == parsed_level[0]) {
iter->score = parsed_level[1];
iter->completed = parsed_level[2];
iter->unlocked = parsed_level[3];
if (parsed_level.size() >= 5)
iter->stars = parsed_level[4];
}
}
}
}
config_file.close();
}
void GuiTerminal::handleTermReply(const std::string& repl) {
std::vector<std::string> ret = string_explode(repl, '\n');
if(stringutils::trim(ret.back()).empty()) ret.pop_back();
if(!ret.empty() && ret.back() == Terminal::freezing_return) {
ret.pop_back();
frozen=true;
}
for(size_t i=0; i<ret.size(); ++i) if(ret[i]!=Terminal::freezing_return) textbox->add(ret[i]);
if(frozen) textbox->add(GuiTerminal::waiting_message);
}
std::string DylibSearch::resolveInLdPath(std::string name)
{
std::string ldpath = MachOMgr::instance()->libraryPath();
std::vector<std::string> elems;
if (ldpath.empty())
return std::string();
elems = string_explode(name, ':');
return resolveInPathList(name, elems);
}
int
hashify_read_hashes(stream_t* file, hashify_string_t** hashes) {
//Read in hashes in file
char line_buffer[HASHIFY_LINEBUFFER_LENGTH];
string_const_t tokens[32];
memset(line_buffer, 0, sizeof(line_buffer));
do {
string_t line = stream_read_line_buffer(file, line_buffer, sizeof(line_buffer), '\n');
string_const_t stripped_line = string_strip(STRING_ARGS(line), STRING_CONST("\n\r"));
if ((string_find_string(STRING_ARGS(stripped_line), STRING_CONST("define"), 0) != STRING_NPOS) &&
(string_find_string(STRING_ARGS(stripped_line), STRING_CONST("static_hash"), 0) != STRING_NPOS)) {
//Format is: #define HASH_<hashstring> static_hash_string( "<string>", 0x<hashvalue>ULL )
size_t num_tokens = string_explode(STRING_ARGS(stripped_line), STRING_CONST(" \t"), tokens, 32,
false);
if (num_tokens >= 6) {
hashify_string_t hash_string;
string_const_t stripped = string_strip(STRING_ARGS(tokens[3]), STRING_CONST(","));
stripped = string_strip(STRING_ARGS(stripped), STRING_CONST("\""));
hash_string.string = string_copy(hash_string.buffer, HASHIFY_STRING_LENGTH, STRING_ARGS(stripped));
hash_string.hash = string_to_uint64(STRING_ARGS(tokens[4]), true);
if (hash(STRING_ARGS(hash_string.string)) != hash_string.hash) {
log_errorf(0, ERROR_INVALID_VALUE,
STRING_CONST(" hash output file is out of date, %.*s is set to 0x%" PRIx64 " but should be 0x%"
PRIx64),
STRING_FORMAT(hash_string.string), hash_string.hash, hash(STRING_ARGS(hash_string.string)));
return HASHIFY_RESULT_OUTPUT_FILE_OUT_OF_DATE;
}
array_push_memcpy(*hashes, &hash_string);
}
}
}
while (!stream_eos(file));
return 0;
}
static void initTranslation()
{
std::istringstream istr(g_directmap);
std::string line;
while (std::getline(istr, line))
{
if (line.empty() || line[0] == '#')
continue;
std::vector<std::string> segs = string_explode(line, ';');
if (segs.size() < 2)
continue;
if (segs[0].compare(0, 3, "32!") == 0)
{
#ifdef __x86_64__
continue;
#else
segs[0] = segs[0].substr(3);
#endif
}
if (segs[0].compare(0, 3, "64!") == 0)
{
#ifdef __i386__
continue;
#else
segs[0] = segs[0].substr(3);
#endif
}
// std::cout << segs[0] << " -> " << segs[1] << std::endl;
g_nameMap[segs[0]] = segs[1];
}
Darling::registerDlsymHook(NameTranslator);
}
int hashify_read_hashes( stream_t* file, hashify_string_t** hashes )
{
//Read in hashes in file
char* line;
char line_buffer[HASHIFY_LINEBUFFER_LENGTH];
do
{
stream_read_line_buffer( file, line_buffer, HASHIFY_LINEBUFFER_LENGTH-1, '\n' );
line = string_strip( line_buffer, "\n\r" );
if( ( string_find_string( line, "define", 0 ) != STRING_NPOS ) && ( string_find_string( line, "static_hash", 0 ) != STRING_NPOS ) )
{
//Format is: #define HASH_<hashstring> static_hash_string( "<string>", 0x<hashvalue>ULL )
char** tokens = string_explode( line, " \t", false );
if( array_size( tokens ) >= 6 )
{
hashify_string_t hash_string;
string_copy( hash_string.string, string_strip( string_strip( tokens[3], "," ), "\"" ), HASHIFY_STRING_LENGTH );
hash_string.hash = string_to_uint64( tokens[4], true );
if( hash( hash_string.string, string_length( hash_string.string ) ) != hash_string.hash )
{
log_errorf( ERROR_INVALID_VALUE, " hash output file is out of date, %s is set to 0x%llx but should be 0x%llx ", hash_string.string, hash_string.hash, hash( hash_string.string, string_length( hash_string.string ) ) );
string_array_deallocate( tokens );
return HASHIFY_RESULT_OUTPUT_FILE_OUT_OF_DATE;
}
array_push_memcpy( *hashes, &hash_string );
}
string_array_deallocate( tokens );
}
} while( !stream_eos( file ) );
return 0;
}
std::string DylibSearch::resolve(std::string dylib, MachOObject* requester)
{
if (dylib.empty())
return std::string();
// expand @rpath, @executable_path and @loader_path
if (requester != nullptr && dylib[0] == '@')
{
if (dylib.compare(0, 16, "@executable_path") == 0)
{
MachOObject* mainModule = MachOMgr::instance()->mainModule();
if (!mainModule)
throw std::runtime_error("Cannot resolve @executable_path without a main module");
dylib.replace(0, 16, mainModule->directory());
}
else if (dylib.compare(0, 12, "@loader_path") == 0)
{
dylib.replace(0, 12, requester->directory());
}
else if (dylib.compare(0, 6, "@rpath") == 0)
{
return resolveViaRpath(dylib, requester);
}
}
// Search in configuration
if (const char* aliasTarget = resolveAlias(dylib))
{
std::string p;
if (!strchr(aliasTarget, '/'))
{
p = LIB_PATH;
p += '/';
p += aliasTarget;
// std::cout << p << std::endl;
}
return p;
}
// Search in extra paths
std::string epath;
epath = resolveInPathList(dylib, m_extraPaths);
if (!epath.empty())
return epath;
// Search in DYLD_LIBRARY_PATH
epath = resolveInLdPath(dylib);
if (!epath.empty())
return epath;
// Try the path as is
epath = checkPresence(dylib);
if (!epath.empty())
return epath;
// If absolute, search in sysroot
if (dylib[0] == '/')
{
const char* prefix = __prefix_get();
if (!MachOMgr::instance()->sysRoot().empty())
{
std::vector<std::string> roots = string_explode(MachOMgr::instance()->sysRoot(), ':');
for (const std::string& in_path : roots)
{
std::string path;
if (prefix != nullptr)
path = prefix;
path += in_path;
path += '/';
path += dylib;
epath = checkPresence(path);
if (!epath.empty())
return epath;
}
}
if (prefix != nullptr)
{
std::string path = prefix;
path += dylib;
epath = checkPresence(path);
if (!epath.empty())
return epath;
}
}
/*if (MachOMgr::instance()->ignoreMissingDependencies())
{
}*/
return std::string();
}
void DylibSearch::setAdditionalPaths(const std::string& paths)
{
m_extraPaths = string_explode(paths, ':', false);
}
static int
render_import_glsl_shader(stream_t* stream, const uuid_t uuid, const char* type,
size_t type_length) {
resource_source_t source;
void* blob = 0;
size_t size;
size_t read;
size_t begin;
size_t next;
hash_t checksum;
tick_t timestamp;
uint64_t platform;
size_t maxtokens;
size_t parameter;
string_const_t* token = 0;
string_const_t valstr;
char buffer[128];
int ret = 0;
resource_platform_t platformdecl = { -1, -1, RENDERAPIGROUP_OPENGL, -1, -1, -1};
resource_source_initialize(&source);
resource_source_read(&source, uuid);
read = 0;
size = stream_size(stream);
blob = memory_allocate(HASH_RESOURCE, size, 0, MEMORY_PERSISTENT);
size = stream_read(stream, blob, size);
platform = resource_platform(platformdecl);
timestamp = time_system();
checksum = hash(blob, size);
if (resource_source_write_blob(uuid, timestamp, HASH_SOURCE,
platform, checksum, blob, size)) {
resource_source_set_blob(&source, timestamp, HASH_SOURCE,
platform, checksum, size);
}
else {
ret = -1;
goto finalize;
}
//Parse source and set parameters
maxtokens = 256;
token = memory_allocate(HASH_RESOURCE, sizeof(string_const_t) * maxtokens, 0, MEMORY_PERSISTENT);
begin = 0;
parameter = 0;
do {
string_const_t tokens[64], line;
size_t itok, ntokens;
next = string_find_first_of(blob, size, STRING_CONST("\n\r"), begin);
line = string_substr(blob, size, begin, next - begin);
ntokens = string_explode(STRING_ARGS(line), STRING_CONST(GLSL_TOKEN_DELIM),
tokens, maxtokens, false);
for (itok = 0; itok < ntokens; ++itok) {
if ((string_equal(STRING_ARGS(tokens[itok]), STRING_CONST("attribute")) ||
string_equal(STRING_ARGS(tokens[itok]), STRING_CONST("uniform"))) &&
(itok + 2 < ntokens)) {
char typebuf[16], dimbuf[16];
string_const_t typestr = tokens[itok + 1];
string_const_t namestr = tokens[itok + 2];
string_const_t dimstr;
int parameter_type = glsl_type_to_parameter_type(typestr);
if (parameter_type < 0)
continue;
int parameter_dim = glsl_dim_from_token(typestr);
if (parameter_dim == 1)
parameter_dim = glsl_dim_from_token(namestr);
namestr = glsl_name_from_token(namestr);
typestr = string_to_const(string_from_uint(typebuf, sizeof(typebuf), (unsigned int)parameter_type, false, 0, 0));
dimstr = string_to_const(string_from_uint(dimbuf, sizeof(dimbuf), (unsigned int)parameter_dim, false, 0, 0));
log_debugf(HASH_RESOURCE, STRING_CONST("parameter: %.*s type %.*s dim %.*s"),
STRING_FORMAT(namestr), STRING_FORMAT(typestr), STRING_FORMAT(dimstr));
string_t param = string_format(buffer, sizeof(buffer), STRING_CONST("parameter_type_%" PRIsize),
parameter);
resource_source_set(&source, timestamp, hash(STRING_ARGS(param)),
platform, STRING_ARGS(typestr));
param = string_format(buffer, sizeof(buffer), STRING_CONST("parameter_name_%" PRIsize),
parameter);
resource_source_set(&source, timestamp, hash(STRING_ARGS(param)),
platform, STRING_ARGS(namestr));
param = string_format(buffer, sizeof(buffer), STRING_CONST("parameter_dim_%" PRIsize),
parameter);
resource_source_set(&source, timestamp, hash(STRING_ARGS(param)),
platform, STRING_ARGS(dimstr));
++parameter;
}
}
begin = string_find_first_not_of(blob, size, STRING_CONST(STRING_WHITESPACE), next);
}
while (next != STRING_NPOS);
valstr = string_from_uint_static(parameter, false, 0, 0);
resource_source_set(&source, timestamp, HASH_PARAMETER_COUNT,
platform, STRING_ARGS(valstr));
resource_source_set(&source, timestamp, HASH_RESOURCE_TYPE,
0, type, type_length);
if (!resource_source_write(&source, uuid, false)) {
string_const_t uuidstr = string_from_uuid_static(uuid);
log_warnf(HASH_RESOURCE, WARNING_SUSPICIOUS, STRING_CONST("Failed writing imported GLSL shader: %.*s"),
STRING_FORMAT(uuidstr));
ret = -1;
goto finalize;
}
else {
string_const_t uuidstr = string_from_uuid_static(uuid);
log_infof(HASH_RESOURCE, STRING_CONST("Wrote imported GLSL shader: %.*s"),
STRING_FORMAT(uuidstr));
}
finalize:
memory_deallocate(blob);
memory_deallocate(token);
resource_source_finalize(&source);
return ret;
}
DECLARE_TEST( string, utility )
{
{
char* path1 = string_clone( "" );
char* path2 = string_clone( "/" );
char* path3 = string_clone( "/." );
char* path4 = string_clone( "./" );
char* path5 = string_clone( "./." );
char* path6 = string_clone( "././" );
char* path7 = string_clone( "././//" );
char* path8 = string_clone( "././//./////././////.//////.//." );
char* path9 = string_clone( "http://././//./////././////.//////.//." );
char* path10 = string_clone( "" );
char* path11 = string_clone( "\\" );
char* path12 = string_clone( "/\\." );
char* path13 = string_clone( ".\\/" );
char* path14 = string_clone( "./\\." );
char* path15 = string_clone( ".\\.//\\" );
char* path16 = string_clone( ".\\.\\\\\\" );
char* path17 = string_clone( ".\\.\\\\\\.\\\\////\\///\\\\.\\.\\\\\\\\\\.\\\\\\\\\\\\.\\\\." );
char* path18 = string_clone( "http://\\.\\.\\\\\\.\\\\\\\\//\\.\\.\\\\\\\\//\\.\\\\\\\\\\\\.\\\\." );
char* path19 = string_clone( "testing/path/ext" );
char* path20 = string_clone( "testing/path/extend" );
char* path21 = string_clone( "testing/path/extend/dyn" );
char* path22 = string_clone( "testing/./\\\\/\\/./path/././//./extend/\\\\" );
path1 = path_clean( path1, true );
path2 = path_clean( path2, true );
path3 = path_clean( path3, true );
path4 = path_clean( path4, true );
path5 = path_clean( path5, true );
path6 = path_clean( path6, true );
path7 = path_clean( path7, true );
path8 = path_clean( path8, true );
path9 = path_clean( path9, true );
path10 = path_clean( path10, true );
path11 = path_clean( path11, true );
path12 = path_clean( path12, true );
path13 = path_clean( path13, true );
path14 = path_clean( path14, true );
path15 = path_clean( path15, true );
path16 = path_clean( path16, true );
path17 = path_clean( path17, true );
path18 = path_clean( path18, true );
path19 = path_clean( path19, true );
path20 = path_clean( path20, true );
path21 = path_clean( path21, true );
path22 = path_clean( path22, true );
EXPECT_TRUE( string_equal( path1, "/" ) );
EXPECT_TRUE( string_equal( path2, "/" ) );
EXPECT_TRUE( string_equal( path3, "/" ) );
EXPECT_TRUE( string_equal( path4, "/" ) );
EXPECT_TRUE( string_equal( path5, "/" ) );
EXPECT_TRUE( string_equal( path6, "/" ) );
EXPECT_TRUE( string_equal( path7, "/" ) );
EXPECT_TRUE( string_equal( path8, "/" ) );
EXPECT_TRUE( string_equal( path9, "http://" ) );
EXPECT_TRUE( string_equal( path10, "/" ) );
EXPECT_TRUE( string_equal( path11, "/" ) );
EXPECT_TRUE( string_equal( path12, "/" ) );
EXPECT_TRUE( string_equal( path13, "/" ) );
EXPECT_TRUE( string_equal( path14, "/" ) );
EXPECT_TRUE( string_equal( path15, "/" ) );
EXPECT_TRUE( string_equal( path16, "/" ) );
EXPECT_TRUE( string_equal( path17, "/" ) );
EXPECT_TRUE( string_equal( path18, "http://" ) );
EXPECT_TRUE( string_equal( path19, "/testing/path/ext" ) );
EXPECT_TRUE( string_equal( path20, "/testing/path/extend" ) );
EXPECT_TRUE( string_equal( path21, "/testing/path/extend/dyn" ) );
EXPECT_TRUE( string_equal( path22, "/testing/path/extend" ) );
string_deallocate( path1 );
string_deallocate( path2 );
string_deallocate( path3 );
string_deallocate( path4 );
string_deallocate( path5 );
string_deallocate( path6 );
string_deallocate( path7 );
string_deallocate( path8 );
string_deallocate( path9 );
string_deallocate( path10 );
string_deallocate( path11 );
string_deallocate( path12 );
string_deallocate( path13 );
string_deallocate( path14 );
string_deallocate( path15 );
string_deallocate( path16 );
string_deallocate( path17 );
string_deallocate( path18 );
string_deallocate( path19 );
string_deallocate( path20 );
string_deallocate( path21 );
string_deallocate( path22 );
}
{
char** explodearr = 0;
char* explodestr = string_clone( " .,testing, .,utility.,string methods ..., like,,,finds split..merge .,.explode.and. .., ., similar .,,,. " );
char* mergestr = string_clone( " testing merge string " );
char* mergestr2 = string_clone( " ., testing, .merge.string,. " );
char* merged = 0;
char** mergearr, **mergearr2, **mergearr3;
char* splitstr = string_clone( " testing split" );
char* splitright = 0, *splitleft = 0;
char* splitright2 = 0, *splitleft2 = 0;
char* substrtest = string_clone( "testing substr" );
char* substr = 0;
explodearr = string_explode( explodestr, " ,.", false );
mergearr = string_explode( mergestr, " .,", true );
mergearr2 = string_explode( mergestr, " .,", false );
mergearr3 = string_explode( mergestr, " .,", true );
merged = string_merge( (const char* const*)mergearr, array_size( mergearr ), " " );
string_split( splitstr, " ", &splitleft, &splitright, false );
string_split( splitstr, " ", &splitleft2, &splitright2, true );
EXPECT_EQ( array_size( explodearr ), 11 );
EXPECT_TRUE( string_equal( explodearr[0], "testing" ) );
EXPECT_TRUE( string_equal( explodearr[1], "utility" ) );
EXPECT_TRUE( string_equal( explodearr[2], "string" ) );
EXPECT_TRUE( string_equal( explodearr[3], "methods" ) );
EXPECT_TRUE( string_equal( explodearr[4], "like" ) );
EXPECT_TRUE( string_equal( explodearr[5], "finds" ) );
EXPECT_TRUE( string_equal( explodearr[6], "split" ) );
EXPECT_TRUE( string_equal( explodearr[7], "merge" ) );
EXPECT_TRUE( string_equal( explodearr[8], "explode" ) );
EXPECT_TRUE( string_equal( explodearr[9], "and" ) );
EXPECT_TRUE( string_equal( explodearr[10], "similar" ) );
EXPECT_EQ( array_size( mergearr ), 12 );
EXPECT_TRUE( string_equal( mergearr[0], "" ) );
EXPECT_TRUE( string_equal( mergearr[1], "" ) );
EXPECT_TRUE( string_equal( mergearr[2], "" ) );
EXPECT_TRUE( string_equal( mergearr[3], "" ) );
EXPECT_TRUE( string_equal( mergearr[4], "testing" ) );
EXPECT_TRUE( string_equal( mergearr[5], "" ) );
EXPECT_TRUE( string_equal( mergearr[6], "" ) );
EXPECT_TRUE( string_equal( mergearr[7], "merge" ) );
EXPECT_TRUE( string_equal( mergearr[8], "string" ) );
EXPECT_TRUE( string_equal( mergearr[9], "" ) );
EXPECT_TRUE( string_equal( mergearr[10], "" ) );
EXPECT_TRUE( string_equal( mergearr[11], "" ) );
EXPECT_EQ( array_size( mergearr2 ), 3 );
EXPECT_TRUE( string_equal( mergearr2[0], "testing" ) );
EXPECT_TRUE( string_equal( mergearr2[1], "merge" ) );
EXPECT_TRUE( string_equal( mergearr2[2], "string" ) );
EXPECT_TRUE( string_equal( merged, mergestr ) );
EXPECT_EQ( array_size( mergearr3 ), 12 );
EXPECT_TRUE( string_equal( mergearr3[0], "" ) );
EXPECT_TRUE( string_equal( mergearr3[1], "" ) );
EXPECT_TRUE( string_equal( mergearr3[2], "" ) );
EXPECT_TRUE( string_equal( mergearr3[3], "" ) );
EXPECT_TRUE( string_equal( mergearr3[4], "testing" ) );
EXPECT_TRUE( string_equal( mergearr3[5], "" ) );
EXPECT_TRUE( string_equal( mergearr3[6], "" ) );
EXPECT_TRUE( string_equal( mergearr3[7], "merge" ) );
EXPECT_TRUE( string_equal( mergearr3[8], "string" ) );
EXPECT_TRUE( string_equal( mergearr3[9], "" ) );
EXPECT_TRUE( string_equal( mergearr3[10], "" ) );
EXPECT_TRUE( string_equal( mergearr3[11], "" ) );
EXPECT_TRUE( string_equal( substr = string_substr( substrtest, 0, 4 ), "test" ) ); string_deallocate( substr );
EXPECT_TRUE( string_equal( substr = string_substr( substrtest, 0, 14 ), "testing substr" ) ); string_deallocate( substr );
EXPECT_TRUE( string_equal( substr = string_substr( substrtest, 0, 20 ), "testing substr" ) ); string_deallocate( substr );
EXPECT_TRUE( string_equal( substr = string_substr( substrtest, 3, 20 ), "ting substr" ) ); string_deallocate( substr );
EXPECT_TRUE( string_equal( substr = string_substr( substrtest, 3, 11 ), "ting substr" ) ); string_deallocate( substr );
EXPECT_TRUE( string_equal( substr = string_substr( substrtest, 3, 1 ), "t" ) ); string_deallocate( substr );
EXPECT_TRUE( string_equal( substr = string_substr( substrtest, 3, 0 ), "" ) ); string_deallocate( substr );
EXPECT_TRUE( string_equal( substr = string_substr( substrtest, 20, 0 ), "" ) ); string_deallocate( substr );
EXPECT_TRUE( string_equal( substr = string_substr( substrtest, 20, 20 ), "" ) ); string_deallocate( substr );
EXPECT_TRUE( string_equal( splitleft, "testing" ) );
EXPECT_TRUE( string_equal( splitright, "split" ) );
EXPECT_TRUE( string_equal( splitleft2, "" ) );
EXPECT_TRUE( string_equal( splitright2, "testing split" ) );
{
char* replacestr = string_clone( "testing replace" );
char* replacestr2 = string_clone( "testing replace" );
char* replacestr3 = string_clone( "testing replacelace" );
char* replacestr4 = string_clone( "" );
char* replacestr5 = string_clone( "repppppppppp" );
replacestr = string_replace( replacestr, "rep", "testrep", false );
replacestr2 = string_replace( replacestr2, "rep", "testrep", true );
replacestr3 = string_replace( replacestr3, "replace", "testrep", true );
replacestr4 = string_replace( replacestr4, "foo", "bar", true );
replacestr5 = string_replace( replacestr5, "rep", "re", true );
EXPECT_TRUE( string_equal( replacestr, "testing testreplace" ) );
EXPECT_TRUE( string_equal( replacestr2, "testing testreplace" ) );
EXPECT_TRUE( string_equal( replacestr3, "testing testtestrep" ) );
EXPECT_TRUE( string_equal( replacestr4, "" ) );
EXPECT_TRUE( string_equal( replacestr5, "re" ) );
string_deallocate( replacestr );
string_deallocate( replacestr2 );
string_deallocate( replacestr3 );
string_deallocate( replacestr4 );
string_deallocate( replacestr5 );
}
{
char* stripstr = string_clone( " testing strip : " );
char* stripstr2 = string_clone( " testing strip : " );
char* stripstr3 = string_clone( " testing strip : " );
stripstr = string_strip( stripstr, " tp: " );
stripstr2 = string_strip( stripstr2, "" );
stripstr3 = string_strip( stripstr3, " tesingrp:" );
EXPECT_TRUE( string_equal( stripstr, "esting stri" ) );
EXPECT_TRUE( string_equal( stripstr2, " testing strip : " ) );
EXPECT_TRUE( string_equal( stripstr3, "" ) );
string_deallocate( stripstr );
string_deallocate( stripstr2 );
string_deallocate( stripstr3 );
}
string_array_deallocate( explodearr );
string_deallocate( explodestr );
string_deallocate( mergestr );
string_deallocate( mergestr2 );
string_deallocate( merged );
string_array_deallocate( mergearr );
string_array_deallocate( mergearr2 );
string_array_deallocate( mergearr3 );
string_deallocate( splitstr );
string_deallocate( splitright );
string_deallocate( splitleft );
string_deallocate( splitright2 );
string_deallocate( splitleft2 );
string_deallocate( substrtest );
}
{
#define SHORTSTRING "short"
#define LONGSTRING "long string with dynamic buffer storage but with no real useful data"
char* clonestr = string_clone( "" );
char* clonestr2 = string_clone( SHORTSTRING );
char* clonestr3 = string_clone( LONGSTRING );
char* teststr = string_clone( clonestr );
char* teststr2 = string_clone( clonestr2 );
char* teststr3 = string_clone( clonestr3 );
char* concatstr = string_concat( clonestr, teststr );
char* concatstr2 = string_concat( clonestr, teststr2 );
char* concatstr3 = string_concat( teststr2, clonestr );
char* concatstr4 = string_concat( clonestr2, teststr2 );
char* concatstr5 = string_concat( clonestr, teststr3 );
char* concatstr6 = string_concat( teststr3, clonestr );
char* concatstr7 = string_concat( clonestr2, teststr3 );
char* concatstr8 = string_concat( teststr3, clonestr2 );
char* concatstr9 = string_concat( clonestr3, teststr3 );
char* concatstr10 = string_concat( teststr3, clonestr3 );
EXPECT_NE( teststr, clonestr );
EXPECT_TRUE( string_equal( teststr, clonestr ) );
EXPECT_NE( teststr2, clonestr2 );
EXPECT_TRUE( string_equal( teststr2, clonestr2 ) );
EXPECT_NE( teststr3, clonestr3 );
EXPECT_TRUE( string_equal( teststr3, clonestr3 ) );
EXPECT_TRUE( string_equal( concatstr, "" ) );
EXPECT_TRUE( string_equal( concatstr2, SHORTSTRING ) );
EXPECT_TRUE( string_equal( concatstr3, SHORTSTRING ) );
EXPECT_TRUE( string_equal( concatstr4, SHORTSTRING SHORTSTRING ) );
EXPECT_TRUE( string_equal( concatstr5, LONGSTRING ) );
EXPECT_TRUE( string_equal( concatstr6, LONGSTRING ) );
EXPECT_TRUE( string_equal( concatstr7, SHORTSTRING LONGSTRING ) );
EXPECT_TRUE( string_equal( concatstr8, LONGSTRING SHORTSTRING ) );
EXPECT_TRUE( string_equal( concatstr9, LONGSTRING LONGSTRING ) );
EXPECT_TRUE( string_equal( concatstr10, LONGSTRING LONGSTRING ) );
string_deallocate( teststr );
string_deallocate( clonestr );
string_deallocate( teststr2 );
string_deallocate( clonestr2 );
string_deallocate( teststr3 );
string_deallocate( clonestr3 );
string_deallocate( concatstr );
string_deallocate( concatstr2 );
string_deallocate( concatstr3 );
string_deallocate( concatstr4 );
string_deallocate( concatstr5 );
string_deallocate( concatstr6 );
string_deallocate( concatstr7 );
string_deallocate( concatstr8 );
string_deallocate( concatstr9 );
string_deallocate( concatstr10 );
#undef SHORTSTRING
#undef LONGSTRING
}
return 0;
}
OSStatus FSPathMakeRefWithOptions(const uint8_t* path, long options, FSRef* fsref, Boolean* isDirectory)
{
if (!path || !fsref)
return paramErr;
std::string fullPath;
char* rpath;
if (options & kFSPathMakeRefDoNotFollowLeafSymlink)
rpath = realpath_ns(reinterpret_cast<const char*>(path));
else
rpath = realpath(reinterpret_cast<const char*>(path), nullptr);
if (!rpath)
return fnfErr;
if (std::count(rpath, rpath+strlen(rpath), '/') > FSRef_MAX_DEPTH)
{
free(rpath);
return unimpErr;
}
fullPath = rpath;
free(rpath);
memset(fsref, 0, sizeof(*fsref));
if (fullPath == "/")
{
if (isDirectory)
*isDirectory = true;
return noErr;
}
std::vector<std::string> components = string_explode(fullPath, '/', false);
std::string position = "/";
size_t pos;
for (size_t pos = 0; pos < components.size(); pos++)
{
bool found = false;
struct dirent* ent;
DIR* dir = opendir(position.c_str());
if (!dir)
return makeOSStatus(errno);
while ((ent = readdir(dir)))
{
if (components[pos] == ent->d_name)
{
found = true;
fsref->inodes[pos] = ent->d_ino;
if (pos+1 == components.size() && isDirectory != nullptr)
*isDirectory = ent->d_type == DT_DIR;
break;
}
}
closedir(dir);
if (!found)
return fnfErr;
if (!string_endsWith(position, "/"))
position += '/';
position += components[pos];
pos++;
}
return noErr;
}
std::vector<std::string> sum::ServerMessage::get_parsed_msg() const {
return string_explode(msg, SEP);
}
