Ejemplo n.º 1
0
/**
 * Load or generate the case handling tables.
 *
 * The case tables are defined in UCS2 and don't depend on any
 * configured parameters, so they never need to be reloaded.
 **/
void load_case_tables(void)
{
	static int initialised;
	int i;

	if (initialised) return;
	initialised = 1;

	upcase_table = map_file(lib_path("upcase.dat"), 0x20000);
	lowcase_table = map_file(lib_path("lowcase.dat"), 0x20000);

	/* we would like Samba to limp along even if these tables are
	   not available */
	if (!upcase_table) {
		DEBUG(1,("creating lame upcase table\n"));
		upcase_table = malloc(0x20000);
		for (i=0;i<0x10000;i++) {
			smb_ucs2_t v;
			SSVAL(&v, 0, i);
			upcase_table[v] = i;
		}
		for (i=0;i<256;i++) {
			smb_ucs2_t v;
			SSVAL(&v, 0, UCS2_CHAR(i));
			upcase_table[v] = UCS2_CHAR(islower(i)?toupper(i):i);
		}
	}

	if (!lowcase_table) {
		DEBUG(1,("creating lame lowcase table\n"));
		lowcase_table = malloc(0x20000);
		for (i=0;i<0x10000;i++) {
			smb_ucs2_t v;
			SSVAL(&v, 0, i);
			lowcase_table[v] = i;
		}
		for (i=0;i<256;i++) {
			smb_ucs2_t v;
			SSVAL(&v, 0, UCS2_CHAR(i));
			lowcase_table[v] = UCS2_CHAR(isupper(i)?tolower(i):i);
		}
	}
}
Ejemplo n.º 2
0
int main(int argc, char *argv[]) {

	std::string lib_path("../../../lib");
	std::string grammar_path("./grammar");

	if (argc >= 2 && argv[1]) {
		std::cout << "Using user specified search path for jars." << std::endl;
		lib_path = argv[1];
	} else {
		std::cout << "Using default search path for jars." << std::endl;
		std::cout << "If this doesn't work, try passing a jar search path as the first argument." << std::endl;
	}
	std::cout << "Looking for jars in " << lib_path << std::endl;

	if (argc >= 3 && argv[2]) {
		std::cout << "Using user specified grammar search path." << std::endl;
		grammar_path = argv[2];
	} else {
		std::cout << "Using default grammar search path." << std::endl;
		std::cout << "If this doesn't work, try passing a grammar search path as the second argument." << std::endl;
	}
	std::cout << "Looking for .gram grammar files in " << grammar_path << std::endl;

	voce::init(lib_path, false, true, grammar_path, "digits");

	std::cout << "This is a speech recognition test. "
	          << "Speak digits from 0-9 into the microphone. "
	          << "Speak 'quit' to quit." << std::endl;

	bool quit = false;
	while (!quit) {
		// Normally, applications would do application-specific things
		// here.  For this sample, we'll just sleep for a little bit.
#ifdef WIN32
		::Sleep(200);
#else
		usleep(200);
#endif

		while (voce::getRecognizerQueueSize() > 0) {
			std::string s = voce::popRecognizedString();

			// Check if the string contains 'quit'.
			if (std::string::npos != s.rfind("quit")) {
				quit = true;
			}

			std::cout << "You said: " << s << std::endl;
			//voce::synthesize(s);
		}
	}

	voce::destroy();
	return 0;
}
Ejemplo n.º 3
0
HMODULE LoadLibrarySystem(const std::wstring& library_name, std::wstring* out_path)
{
	std::unique_ptr<wchar_t[]> system_directory(new wchar_t[MAX_PATH]);
	GetSystemDirectoryW(system_directory.get(), MAX_PATH);

	std::wstring lib_path(system_directory.get());
	StringPathAppend(&lib_path, library_name);

	if (out_path)
		*out_path = lib_path;

	return LoadLibraryW(lib_path.c_str());
}
Ejemplo n.º 4
0
static
void shim_load_libGL()
{
    if(!libGL) {
	libGL = dlopen(lib_path("libGL.so"), RTLD_LAZY);

	fprintf(stderr, "%s\n", lib_path("libGL.so"));
	
	if(!libGL) {
	    fputs(dlerror(), stderr);
	    exit(1);
	}

	_glXSwapBuffers = (void (*)(Display*, GLXDrawable))real_dlsym(libGL, "glXSwapBuffers");
	_glXGetProcAddress = (void (*(*)(const GLubyte *procName))())real_dlsym(libGL, "glXGetProcAddressARB");

	const char *error;
	if((error = dlerror())) {
	    fputs(error, stderr);
	    exit(1);
	}
    }
}
Ejemplo n.º 5
0
int main(int argc, char* argv[]) {
    /*<-*/ b2_workarounds::argv_to_path_guard guard(argc, argv); /*->*/
    boost::filesystem::path lib_path(argv[1]);          // argv[1] contains path to directory with our plugin library
    boost::shared_ptr<my_plugin_api> plugin;            // variable to hold a pointer to plugin variable
    std::cout << "Loading the plugin" << std::endl;
     
    plugin = dll::import<my_plugin_api>(          // type of imported symbol is located between `<` and `>`
        lib_path / "my_plugin_sum",                     // path to the library and library name
        "plugin",                                       // name of the symbol to import
        dll::load_mode::append_decorations              // makes `libmy_plugin_sum.so` or `my_plugin_sum.dll` from `my_plugin_sum`
    );

    std::cout << "plugin->calculate(1.5, 1.5) call:  " << plugin->calculate(1.5, 1.5) << std::endl;
}
Ejemplo n.º 6
0
int main(int argc, char* argv[]) { 
    std::cout << "Application started" << std::endl;
    /*<-*/ BOOST_ASSERT(argc >= 2);    /*->*/
    // argv[1] contains path to our plugin library
    boost::filesystem::path lib_path(argv[1]);
    boost::shared_ptr<my_plugin_api> plugin;            // variable to hold a pointer to plugin variable
    std::cout << "Loading the plugin" << std::endl;
     
    plugin = dll::import_alias<my_plugin_api>( // type of imported symbol is located between `<` and `>`
        lib_path / "my_plugin_sum"/*<-*/ BOOST_B2_LIBRARY_DECORATIONS /*->*/,                     // path to the library and library name
        "plugin",                                       // name of the symbol to import
        dll::load_mode::append_decorations              // makes `libmy_plugin_sum.so` or `my_plugin_sum.dll` from `my_plugin_sum`
    );

    std::cout << "Plugin Version: " << plugin->version() << std::endl;
    std::cout << "Plugin Method:  " << plugin->calculate(1.5, 1.5) << std::endl;
}
Ejemplo n.º 7
0
static
void shim_load_libEGL()
{
    if(!libEGL) {
	libEGL = dlopen(lib_path("libEGL.so"), RTLD_LAZY);
	if(!libEGL) {
	    fputs(dlerror(), stderr);
	    exit(1);
	}

	_eglSwapBuffers = (EGLBoolean (*)(EGLDisplay, EGLSurface))dlsym(libEGL, "eglSwapBuffers");

	const char *error;
	if((error = dlerror())) {
	    fputs(error, stderr);
	    exit(1);
	}
    }
}
Ejemplo n.º 8
0
void init_valid_table(void)
{
	static int mapped_file;
	int i;
	const char *allowed = ".!#$%&'()_-@^`~";
	uint8 *valid_file;

	if (mapped_file) {
		/* Can't unmap files, so stick with what we have */
		return;
	}

	valid_file = map_file(lib_path("valid.dat"), 0x10000);
	if (valid_file) {
		valid_table = valid_file;
		mapped_file = 1;
		valid_table_use_unmap = True;
		return;
	}

	/* Otherwise, we're using a dynamically created valid_table.
	 * It might need to be regenerated if the code page changed.
	 * We know that we're not using a mapped file, so we can
	 * free() the old one. */
	if (valid_table) 
		SAFE_FREE(valid_table);

	/* use free rather than unmap */
	valid_table_use_unmap = False;

	DEBUG(2,("creating default valid table\n"));
	valid_table = SMB_MALLOC(0x10000);
	for (i=0;i<128;i++) {
		valid_table[i] = isalnum(i) || strchr(allowed,i);
	}
	
	for (;i<0x10000;i++) {
		smb_ucs2_t c;
		SSVAL(&c, 0, i);
		valid_table[i] = check_dos_char(c);
	}
}
Ejemplo n.º 9
0
void *dlsym(void *handle, const char *name)
{
    if(!real_dlsym) {
	fprintf(stderr, "with_smaa: Getting real dlsym...\n");
	void *libdl = dlopen(lib_path("libdl.so"), RTLD_NOW);
	real_dlsym = __libc_dlsym(libdl, "dlsym");	
	fprintf(stderr, "with_smaa: real_dlsym=%p\n", real_dlsym);
    }
    
    if (!strcmp(name, "dlsym")) {
	return (void*) dlsym;
    } else if(!strcmp(name, "glXGetProcAddressARB")) {
	fprintf(stderr, "with_smaa: dlsym: redirecting glXGetProcAddressARB\n");
	return (void*) glXGetProcAddress;
    } else if(!strcmp(name, "glXGetProcAddress")) {
	fprintf(stderr, "with_smaa: dlsym: redirecting glXGetProcAddress\n");
	return (void*) glXGetProcAddress;
    } else if(!strcmp(name, "glXSwapBuffers")) {
	fprintf(stderr, "with_smaa: dlsym: redirecting glXSwapBuffers\n");
	return (void*) glXSwapBuffers;
    }

    return real_dlsym(handle, name);
}
Ejemplo n.º 10
0
void load_case_tables(void)
{
	static int initialised;
	char *old_locale = NULL, *saved_locale = NULL;
	int i;

	if (initialised) {
		return;
	}
	initialised = 1;

	upcase_table = map_file(lib_path("upcase.dat"), 0x20000);
	upcase_table_use_unmap = ( upcase_table != NULL );

	lowcase_table = map_file(lib_path("lowcase.dat"), 0x20000);
	lowcase_table_use_unmap = ( lowcase_table != NULL );

#ifdef HAVE_SETLOCALE
	/* Get the name of the current locale.  */
	old_locale = setlocale(LC_ALL, NULL);

	if (old_locale) {
		/* Save it as it is in static storage. */
		saved_locale = SMB_STRDUP(old_locale);
	}

	/* We set back the locale to C to get ASCII-compatible toupper/lower functions. */
	setlocale(LC_ALL, "C");
#endif

	/* we would like Samba to limp along even if these tables are
	   not available */
	if (!upcase_table) {
		DEBUG(1,("creating lame upcase table\n"));
		upcase_table = SMB_MALLOC(0x20000);
		for (i=0;i<0x10000;i++) {
			smb_ucs2_t v;
			SSVAL(&v, 0, i);
			upcase_table[v] = i;
		}
		for (i=0;i<256;i++) {
			smb_ucs2_t v;
			SSVAL(&v, 0, UCS2_CHAR(i));
			upcase_table[v] = UCS2_CHAR(islower(i)?toupper(i):i);
		}
	}

	if (!lowcase_table) {
		DEBUG(1,("creating lame lowcase table\n"));
		lowcase_table = SMB_MALLOC(0x20000);
		for (i=0;i<0x10000;i++) {
			smb_ucs2_t v;
			SSVAL(&v, 0, i);
			lowcase_table[v] = i;
		}
		for (i=0;i<256;i++) {
			smb_ucs2_t v;
			SSVAL(&v, 0, UCS2_CHAR(i));
			lowcase_table[v] = UCS2_CHAR(isupper(i)?tolower(i):i);
		}
	}

#ifdef HAVE_SETLOCALE
	/* Restore the old locale. */
	if (saved_locale) {
		setlocale (LC_ALL, saved_locale);
		SAFE_FREE(saved_locale);
	}
#endif
}
Ejemplo n.º 11
0
/* initialise the message translation subsystem. If the "lang" argument
   is NULL then get the language from the normal environment variables */
BOOL lang_tdb_init(const char *lang)
{
	char *path = NULL;
	char *msg_path = NULL;
	struct stat st;
	static int initialised;
	time_t loadtime;
	BOOL result = False;

	/* we only want to init once per process, unless given
	   an override */
	if (initialised && !lang) 
		return True;

	if (initialised) {
		/* we are re-initialising, free up any old init */
		if (tdb) {
			tdb_close(tdb);
			tdb = NULL;
		}
		SAFE_FREE(current_lang);
	}

	initialised = 1;

	if (!lang) {
		/* no lang given, use environment */
		lang = get_lang();
	}

	/* if no lang then we don't translate */
	if (!lang) 
		return True;

	asprintf(&msg_path, "%s.msg", lib_path((const char *)lang));
	if (stat(msg_path, &st) != 0) {
		/* the msg file isn't available */
		DEBUG(10, ("lang_tdb_init: %s: %s\n", msg_path, 
			   strerror(errno)));
		goto done;
	}
	
	asprintf(&path, "%s%s.tdb", lock_path("lang_"), lang);

	DEBUG(10, ("lang_tdb_init: loading %s\n", path));

	tdb = tdb_open_log(path, 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0644);
	if (!tdb) {
		tdb = tdb_open_log(path, 0, TDB_DEFAULT, O_RDONLY, 0);
		if (!tdb) {
			DEBUG(10, ("lang_tdb_init: %s: %s\n", path,
				   strerror(errno)));
			goto done;
		}
		current_lang = SMB_STRDUP(lang);
		result = True;
		goto done;
	}

	loadtime = tdb_fetch_int32(tdb, "/LOADTIME/");

	if (loadtime == -1 || loadtime < st.st_mtime) {
		load_msg(msg_path);
		tdb_store_int32(tdb, "/LOADTIME/", (int)time(NULL));
	}

	current_lang = SMB_STRDUP(lang);
	result = True;

 done:
	SAFE_FREE(msg_path);
	SAFE_FREE(path);

	return result;
}