コード例 #1
0
ファイル: main.c プロジェクト: apprisi/foundation_lib
DECLARE_TEST( environment, builtin )
{
	char const* const* cmdline = environment_command_line();

	EXPECT_GE( array_size( cmdline ), 1 );
#if !FOUNDATION_PLATFORM_ANDROID && !FOUNDATION_PLATFORM_IOS
	EXPECT_NE( string_find_string( cmdline[0], "test-environment", 0 ), STRING_NPOS );

	EXPECT_STREQ( environment_executable_name(), "test-environment" );
#endif
	EXPECT_NE( environment_initial_working_directory(), 0 );
	EXPECT_NE( string_length( environment_initial_working_directory() ), 0 );
	EXPECT_STREQ( environment_initial_working_directory(), environment_current_working_directory() );
	
	EXPECT_NE( environment_home_directory(), 0 );
	EXPECT_NE( string_length( environment_home_directory() ), 0 );

	EXPECT_NE( environment_temporary_directory(), 0 );
	EXPECT_NE( string_length( environment_temporary_directory() ), 0 );

	EXPECT_NE( environment_variable( "PATH" ), 0 );
	EXPECT_NE( string_length( environment_variable( "PATH" ) ), 0 );
	
	return 0;
}
コード例 #2
0
ファイル: main.c プロジェクト: haifenghuang/foundation_lib
DECLARE_TEST(environment, builtin) {
	const string_const_t* cmdline = environment_command_line();

	EXPECT_GE(array_size(cmdline), 1);
#if !BUILD_MONOLITHIC
	EXPECT_NE_MSGFORMAT(string_find_string(STRING_ARGS(cmdline[0]), STRING_CONST("test-environment"),
	                                       0), STRING_NPOS, "Commandline: %.*s", (int)cmdline[0].length, cmdline[0].str);
	EXPECT_CONSTSTRINGEQ(environment_executable_name(), string_const(STRING_CONST("test-environment")));
#elif FOUNDATION_PLATFORM_ANDROID
	EXPECT_NE_MSGFORMAT(string_find_string(STRING_ARGS(cmdline[0]),
	                                       STRING_CONST("com.rampantpixels.foundation.test"), 0), STRING_NPOS, "Commandline: %.*s",
	                    (int)cmdline[0].length, cmdline[0].str);
#elif !FOUNDATION_PLATFORM_PNACL
	EXPECT_NE_MSGFORMAT(string_find_string(STRING_ARGS(cmdline[0]), STRING_CONST("test-all"), 0),
	                    STRING_NPOS, "Commandline: %.*s", (int)cmdline[0].length, cmdline[0].str);
	EXPECT_CONSTSTRINGEQ(environment_executable_name(), string_const(STRING_CONST("test-all")));
#endif
	EXPECT_NE(environment_initial_working_directory().str, 0);
	EXPECT_NE(environment_initial_working_directory().length, 0);
	EXPECT_CONSTSTRINGEQ(environment_initial_working_directory(),
	                     environment_current_working_directory());

	EXPECT_NE(environment_home_directory().str, 0);
	EXPECT_NE(environment_home_directory().length, 0);

	EXPECT_NE(environment_temporary_directory().str, 0);
	EXPECT_NE(environment_temporary_directory().length, 0);

#if !FOUNDATION_PLATFORM_PNACL
	EXPECT_NE(environment_variable(STRING_CONST("PATH")).str, 0);
	EXPECT_NE(environment_variable(STRING_CONST("PATH")).length, 0);
#endif

	return 0;
}
コード例 #3
0
ファイル: main.c プロジェクト: milzod/foundation_lib
DECLARE_TEST( environment, builtin )
{
	char const* const* cmdline = environment_command_line();

	EXPECT_GE( array_size( cmdline ), 1 );
#if !BUILD_MONOLITHIC
	EXPECT_NE_MSGFORMAT( string_find_string( cmdline[0], "test-environment", 0 ), STRING_NPOS, "Commandline: %s", cmdline[0] );
	EXPECT_STREQ( environment_executable_name(), "test-environment" );
#elif FOUNDATION_PLATFORM_ANDROID
	EXPECT_NE_MSGFORMAT( string_find_string( cmdline[0], "com.rampantpixels.foundation.test", 0 ), STRING_NPOS, "Commandline: %s", cmdline[0] );
#elif !FOUNDATION_PLATFORM_PNACL
	EXPECT_NE_MSGFORMAT( string_find_string( cmdline[0], "test-all", 0 ), STRING_NPOS, "Commandline: %s", cmdline[0] );
	EXPECT_STREQ( environment_executable_name(), "test-all" );
#endif
	EXPECT_NE( environment_initial_working_directory(), 0 );
	EXPECT_NE( string_length( environment_initial_working_directory() ), 0 );
	EXPECT_STREQ( environment_initial_working_directory(), environment_current_working_directory() );

	EXPECT_NE( environment_home_directory(), 0 );
	EXPECT_NE( string_length( environment_home_directory() ), 0 );

	EXPECT_NE( environment_temporary_directory(), 0 );
	EXPECT_NE( string_length( environment_temporary_directory() ), 0 );

#if !FOUNDATION_PLATFORM_PNACL
	EXPECT_NE( environment_variable( "PATH" ), 0 );
	EXPECT_NE( string_length( environment_variable( "PATH" ) ), 0 );
#endif

	return 0;
}
コード例 #4
0
ファイル: main.c プロジェクト: rampantpixels/task_lib
int
main_initialize(void) {
	foundation_config_t config;
	application_t application;
	int ret;
	size_t iarg, asize;
	const string_const_t* cmdline = environment_command_line();

	_test_memory_tracker = true;
	for (iarg = 0, asize = array_size(cmdline); iarg < asize; ++iarg) {
		if (string_equal(STRING_ARGS(cmdline[iarg]), STRING_CONST("--no-memory-tracker")))
			_test_memory_tracker = false;
	}

	if (_test_memory_tracker)
		memory_set_tracker(memory_tracker_local());

	memset(&config, 0, sizeof(config));

	memset(&application, 0, sizeof(application));
	application.name = string_const(STRING_CONST("Task library test suite"));
	application.short_name = string_const(STRING_CONST("test_all"));
	application.company = string_const(STRING_CONST("Rampant Pixels"));
	application.version = task_module_version();
	application.flags = APPLICATION_UTILITY;
	application.exception_handler = test_exception_handler;

	log_set_suppress(0, ERRORLEVEL_INFO);

#if ( FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID ) && BUILD_ENABLE_LOG
	log_set_handler(test_log_handler);
#endif

#if !FOUNDATION_PLATFORM_IOS && !FOUNDATION_PLATFORM_ANDROID && !FOUNDATION_PLATFORM_PNACL

	_test_should_start = true;

#endif

	ret = foundation_initialize(memory_system_malloc(), application, config);

#if BUILD_MONOLITHIC
	if (ret == 0) {
		task_config_t task_config;
		memset(&task_config, 0, sizeof(task_config));
		ret = task_module_initialize(task_config);

		test_set_suitable_working_directory();
	}
#endif
	return ret;
}
コード例 #5
0
ファイル: main.c プロジェクト: ifzz/render_lib
int
main_run(void* main_arg) {
	int result = RENDERCOMPILE_RESULT_OK;
	rendercompile_input_t input = rendercompile_parse_command_line(environment_command_line());

	FOUNDATION_UNUSED(main_arg);

	if (input.display_help) {
		rendercompile_print_usage();
		goto exit;
	}

	resource_source_set_path(STRING_ARGS(input.source_path));
	resource_compile_register(render_compile);

	size_t ifile, fsize;
	for (ifile = 0, fsize = array_size(input.input_files); ifile < fsize; ++ifile) {
		uuid_t uuid = string_to_uuid(STRING_ARGS(input.input_files[ifile]));
		if (uuid_is_null(uuid)) {
			char buffer[BUILD_MAX_PATHLEN];
			string_t pathstr = string_copy(buffer, sizeof(buffer), STRING_ARGS(input.input_files[ifile]));
			pathstr = path_clean(STRING_ARGS(pathstr), sizeof(buffer));
			pathstr = path_absolute(STRING_ARGS(pathstr), sizeof(buffer));
			uuid = resource_import_map_lookup(STRING_ARGS(pathstr));
		}
		if (uuid_is_null(uuid)) {
			log_warnf(HASH_RESOURCE, WARNING_INVALID_VALUE, STRING_CONST("Failed to lookup: %.*s"), STRING_FORMAT(input.input_files[ifile]));
			result = RENDERCOMPILE_RESULT_INVALID_INPUT;
			break;
		}

		if (resource_compile(uuid, RESOURCE_PLATFORM_ALL)) {
			string_const_t uuidstr = string_from_uuid_static(uuid);
			log_infof(HASH_RESOURCE, STRING_CONST("Successfully compiled: %.*s (%.*s)"),
			          STRING_FORMAT(uuidstr), STRING_FORMAT(input.input_files[ifile]));
		}
		else {
			string_const_t uuidstr = string_from_uuid_static(uuid);
			log_warnf(HASH_RESOURCE, WARNING_UNSUPPORTED, STRING_CONST("Failed to compile: %.*s (%.*s)"),
			          STRING_FORMAT(uuidstr), STRING_FORMAT(input.input_files[ifile]));
		}
	}

exit:

	array_deallocate(input.input_files);

	return result;
}
コード例 #6
0
ファイル: main.c プロジェクト: NocturnDragon/foundation_lib
int main_run( void* main_arg )
{
	int result = 0;
	hashify_input_t input = hashify_parse_command_line( environment_command_line() );
	
	result = hashify_process_strings( (char const* const*)input.strings );
	if( result < 0 )
		goto exit;

	result = hashify_process_files( (char const* const*)input.files, input.check_only );
	if( result < 0 )
		goto exit;

exit:

	string_array_deallocate( input.strings );
	string_array_deallocate( input.files );

	return result;
}
コード例 #7
0
ファイル: main.c プロジェクト: apprisi/foundation_lib
int main_run( void* main_arg )
{
    int result = BIN2HEX_RESULT_OK;

    bin2hex_input_t input = bin2hex_parse_command_line( environment_command_line() );

    if( !array_size( input.input_files ) )
        bin2hex_print_usage();
    else
    {
        result = bin2hex_process_files( (char const* const*)input.input_files, (char const* const*)input.output_files, input.columns );
        if( result < 0 )
            goto exit;
    }

exit:

    string_array_deallocate( input.input_files );
    string_array_deallocate( input.output_files );

    return result;
}
コード例 #8
0
int
foundation_initialize(const memory_system_t memory, const application_t application,
                      const foundation_config_t config) {
	int ret = 0;

	if (_initialized)
		return 0;

	process_set_exit_code(PROCESS_EXIT_SUCCESS);

	foundation_initialize_config(config);

	/*lint -e774 */
	SUBSYSTEM_INIT(atomic);
	SUBSYSTEM_INIT_ARGS(memory, memory);
	SUBSYSTEM_INIT(static_hash);
	SUBSYSTEM_INIT(log);
	SUBSYSTEM_INIT(time);
	SUBSYSTEM_INIT(thread);
	SUBSYSTEM_INIT(random);
	SUBSYSTEM_INIT(stream);
	SUBSYSTEM_INIT(fs);
	SUBSYSTEM_INIT(stacktrace);
	SUBSYSTEM_INIT(exception);
	SUBSYSTEM_INIT_ARGS(environment, application);
	SUBSYSTEM_INIT(library);
	SUBSYSTEM_INIT(system);

	if (ret)
		return ret;

	//Parse built-in command line options
	{
		/*lint --e{613} */
		const string_const_t* cmdline = environment_command_line();
		size_t iarg, argsize;
		for (iarg = 0, argsize = array_size(cmdline); iarg < argsize; ++iarg) {
			string_const_t arg = cmdline[iarg];
			if (string_equal(arg.str, arg.length, STRING_CONST("--log-debug")))
				log_set_suppress(0, ERRORLEVEL_NONE);
			else if (string_equal(arg.str, arg.length, STRING_CONST("--log-info")))
				log_set_suppress(0, ERRORLEVEL_DEBUG);
			else if (string_equal(arg.str, arg.length, STRING_CONST("--log-warning")))
				log_set_suppress(0, ERRORLEVEL_WARNING);
			else if (string_equal(arg.str, arg.length, STRING_CONST("--log-error")))
				log_set_suppress(0, ERRORLEVEL_ERROR);
		}
	}

#if !BUILD_DYNAMIC_LINK
	//Artificial references
	/*lint -e506 */
#if FOUNDATION_PLATFORM_ANDROID
	android_main(0);
#elif FOUNDATION_PLATFORM_PNACL
	if (((uintptr_t)PPP_InitializeModule < 1) || ((uintptr_t)PPP_GetInterface < 1) ||
	        ((uintptr_t)PPP_ShutdownModule < 1))
		return -1;
#else
	if ((uintptr_t)main < 1)
		return -1;
#endif
#endif

	_initialized = true;

	return 0;
}
コード例 #9
0
ファイル: config.c プロジェクト: apprisi/foundation_lib
void config_load( const char* name, hash_t filter_section, bool built_in, bool overwrite )
{
	/*lint --e{838} Safety null assign all pointers for all preprocessor paths */
	/*lint --e{750} Unused macros in some paths */
#define NUM_SEARCH_PATHS 10
#define ANDROID_ASSET_PATH_INDEX 5
	char* sub_exe_path = 0;
	char* exe_parent_path = 0;
	char* exe_processed_path = 0;
	char* abs_exe_parent_path = 0;
	char* abs_exe_processed_path = 0;
	char* bundle_path = 0;
	char* home_dir = 0;
	char* cmdline_path = 0;
	char* cwd_config_path = 0;
	const char* paths[NUM_SEARCH_PATHS];
#if !FOUNDATION_PLATFORM_FAMILY_MOBILE
	const char* const* cmd_line;
	int icl, clsize;
#endif
	int start_path, i, j;

	const char buildsuffix[4][9] = { "/debug", "/release", "/profile", "/deploy" };
	const char platformsuffix[7][14] = { "/win32", "/win64", "/osx", "/ios", "/android", "/raspberrypi", "/unknown" };
	const char binsuffix[1][5] = { "/bin" };

	FOUNDATION_ASSERT( name );

	sub_exe_path = path_merge( environment_executable_directory(), "config" );
	exe_parent_path = path_merge( environment_executable_directory(), "../config" );
	abs_exe_parent_path = path_make_absolute( exe_parent_path );

	exe_processed_path = string_clone( environment_executable_directory() );
	for( i = 0; i < 4; ++i )
	{
		if( string_ends_with( exe_processed_path, buildsuffix[i] ) )
		{
			exe_processed_path[ string_length( exe_processed_path ) - string_length( buildsuffix[i] ) ] = 0;
			break;
		}
	}
	for( i = 0; i < 7; ++i )
	{
		if( string_ends_with( exe_processed_path, platformsuffix[i] ) )
		{
			exe_processed_path[ string_length( exe_processed_path ) - string_length( platformsuffix[i] ) ] = 0;
			break;
		}
	}
	for( i = 0; i < 1; ++i )
	{
		if( string_ends_with( exe_processed_path, binsuffix[i] ) )
		{
			exe_processed_path[ string_length( exe_processed_path ) - string_length( binsuffix[i] ) ] = 0;
			break;
		}
	}
	exe_processed_path = path_append( exe_processed_path, "config" );
	abs_exe_processed_path = path_make_absolute( exe_processed_path );
	
	paths[0] = environment_executable_directory();
	paths[1] = sub_exe_path;
	paths[2] = abs_exe_parent_path;
	paths[3] = abs_exe_processed_path;

#if FOUNDATION_PLATFORM_FAMILY_DESKTOP && !BUILD_DEPLOY
	paths[4] = environment_initial_working_directory();
#else
	paths[4] = 0;
#endif

#if FOUNDATION_PLATFORM_APPLE
	bundle_path = path_merge( environment_executable_directory(), "../Resources/config" );
	paths[5] = bundle_path;
#elif FOUNDATION_PLATFORM_ANDROID
	paths[5] = "/config";
#else
	paths[5] = 0;
#endif

#if FOUNDATION_PLATFORM_FAMILY_DESKTOP
	paths[6] = environment_current_working_directory();
#else
	paths[6] = 0;
#endif

	paths[7] = 0;
	paths[8] = 0;

	string_deallocate( exe_parent_path );
	string_deallocate( exe_processed_path );

#if FOUNDATION_PLATFORM_FAMILY_DESKTOP
	cwd_config_path = path_merge( environment_current_working_directory(), "config" );
	paths[7] = cwd_config_path;

	cmd_line = environment_command_line();
	/*lint -e{850} We modify loop var to skip extra arg */
	for( icl = 0, clsize = array_size( cmd_line ); icl < clsize; ++icl )
	{
		/*lint -e{613} array_size( cmd_line ) in loop condition does the null pointer guard */
		if( string_equal_substr( cmd_line[icl], "--configdir", 11 ) )
		{
			if( string_equal_substr( cmd_line[icl], "--configdir=", 12 ) )
			{
				paths[8] = cmdline_path = string_substr( cmd_line[icl], 12, STRING_NPOS );
			}
			else if( icl < ( clsize - 1 ) )
			{
				paths[8] = cmdline_path = string_clone( cmd_line[++icl] );
			}
		}
	}
#endif
	
	start_path = 0;
	if( !built_in )
	{
#if FOUNDATION_PLATFORM_WINDOWS
		home_dir = path_merge( environment_home_directory(), environment_application()->config_dir );
#elif FOUNDATION_PLATFORM_LINUX || FOUNDATION_PLATFORM_MACOSX
		home_dir = path_prepend( string_concat( ".", environment_application()->config_dir ), environment_home_directory() );
#endif
		if( home_dir )
			paths[9] = home_dir;
		start_path = 9;
	}
	else
	{
		paths[9] = 0;
	}

	for( i = start_path; i < NUM_SEARCH_PATHS; ++i )
	{
		char* filename;
		stream_t* istream;
		bool path_already_searched = false;

		if( !paths[i] )
			continue;

		for( j = start_path; j < i; ++j )
		{
			if( paths[j] && string_equal( paths[j], paths[i] ) )
			{
				path_already_searched = true;
				break;
			}
		}
		if( path_already_searched )
			continue;
		
		//TODO: Support loading configs from virtual file system (i.e in zip/other packages)
		filename = string_append( path_merge( paths[i], name ), ".ini" );
		istream = 0;
#if FOUNDATION_PLATFORM_ANDROID
		if( i == ANDROID_ASSET_PATH_INDEX )
			istream = asset_stream_open( filename, STREAM_IN );
		else
#endif
		istream = stream_open( filename, STREAM_IN );
		if( istream )
		{
			config_parse( istream, filter_section, overwrite );
			stream_deallocate( istream );
		}
		string_deallocate( filename );

		if( built_in )
		{
			const char* FOUNDATION_PLATFORM_name =
#if FOUNDATION_PLATFORM_WINDOWS
				"windows";
#elif FOUNDATION_PLATFORM_LINUX_RASPBERRYPI
				"raspberrypi";
#elif FOUNDATION_PLATFORM_LINUX
				"linux";
#elif FOUNDATION_PLATFORM_MACOSX
				"osx";
#elif FOUNDATION_PLATFORM_IOS
				"ios";
#elif FOUNDATION_PLATFORM_ANDROID
				"android";
#else
#  error Insert platform name
				"unknown";
#endif
			filename = string_append( path_append( path_merge( paths[i], FOUNDATION_PLATFORM_name ), name ), ".ini" );
#if FOUNDATION_PLATFORM_ANDROID
			if( i == ANDROID_ASSET_PATH_INDEX )
				istream = asset_stream_open( filename, STREAM_IN );
			else
#endif
			istream = stream_open( filename, STREAM_IN );
			if( istream )
			{
				config_parse( istream, filter_section, overwrite );
				stream_deallocate( istream );
			}
			string_deallocate( filename );
		}
	}

	string_deallocate( home_dir );
	string_deallocate( cmdline_path );
	string_deallocate( sub_exe_path );
	string_deallocate( abs_exe_processed_path );
	string_deallocate( abs_exe_parent_path );
	string_deallocate( bundle_path );
	string_deallocate( cwd_config_path );
}
コード例 #10
0
ファイル: main.c プロジェクト: rampantpixels/foundation_lib
int
main_initialize(void) {
	foundation_config_t config;
	application_t application;
	int ret;
	size_t iarg, asize;
	const string_const_t* cmdline = environment_command_line();

	_test_memory_tracker = true;
	for (iarg = 0, asize = array_size(cmdline); iarg < asize; ++iarg) {
		if (string_equal(STRING_ARGS(cmdline[iarg]), STRING_CONST("--no-memory-tracker")))
			_test_memory_tracker = false;
	}

	if (_test_memory_tracker)
		memory_set_tracker(memory_tracker_local());

	memset(&config, 0, sizeof(config));
#if BUILD_MONOLITHIC
	//For fs monitor test
	config.fs_monitor_max = 1;
	//For temporary allocator test, 256KiB
	config.temporary_memory = 256 * 1024;
	//For testing static hash store
	config.hash_store_size = 32 * 1024;
	//Test preallocation of random state buffers
	config.random_state_prealloc = 4;
#endif

	memset(&application, 0, sizeof(application));
	application.name = string_const(STRING_CONST("Foundation library test suite"));
	application.short_name = string_const(STRING_CONST("test_all"));
	application.company = string_const(STRING_CONST("Rampant Pixels"));
	application.version = foundation_version();
	application.flags = APPLICATION_UTILITY;
	application.exception_handler = test_exception_handler;

	log_set_suppress(0, ERRORLEVEL_INFO);

#if (FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID) && BUILD_ENABLE_LOG
	log_set_handler(test_log_handler);
#endif

#if !FOUNDATION_PLATFORM_IOS && !FOUNDATION_PLATFORM_ANDROID && !FOUNDATION_PLATFORM_PNACL

	_test_should_start = true;

#endif

	ret = foundation_initialize(memory_system_malloc(), application, config);

#if BUILD_MONOLITHIC
	//For monolithic process test
	if (string_array_find(cmdline, array_size(cmdline), STRING_CONST("wait for kill")) >= 0) {
		while (true)
			thread_sleep(100);
	}

	test_set_suitable_working_directory();
#endif
	return ret;
}