sal_Int32 SAL_CALL rtl_str_valueOfDouble(sal_Char * pStr, double d) { rtl_String * pResult = NULL; sal_Int32 nLen; rtl_math_doubleToString( &pResult, 0, 0, d, rtl_math_StringFormat_G, RTL_STR_MAX_VALUEOFDOUBLE - RTL_CONSTASCII_LENGTH("-x.E-xxx"), '.', 0, 0, sal_True); nLen = pResult->length; OSL_ASSERT(nLen < RTL_STR_MAX_VALUEOFDOUBLE); rtl_copyMemory(pStr, pResult->buffer, (nLen + 1) * sizeof(sal_Char)); rtl_string_release(pResult); return nLen; }
static void * load(void * address, char const * symbol) { Dl_info dl_info; char * slash; size_t len; char * libname; void * h; void * func; if (dladdr(address, &dl_info) == 0) { abort(); } slash = strrchr(dl_info.dli_fname, '/'); if (slash == NULL) { abort(); } len = slash - dl_info.dli_fname + 1; libname = malloc( len + RTL_CONSTASCII_LENGTH(SAL_DLLPREFIX "pyuno" SAL_DLLEXTENSION) + 1); if (libname == NULL) { abort(); } strncpy(libname, dl_info.dli_fname, len); strcpy(libname + len, SAL_DLLPREFIX "pyuno" SAL_DLLEXTENSION); h = dlopen(libname, RTLD_LAZY | RTLD_GLOBAL); free(libname); if (h == NULL) { fprintf(stderr, "failed to load pyuno: '%s'\n", dlerror()); abort(); } func = dlsym(h, symbol); if (func == NULL) { dlclose(h); abort(); } return func; }
/* * The main function implements a loader for applications which use UNO. * * <p>This code runs on the Unix/Linux platforms only.</p> * * <p>The main function detects a UNO installation on the system and adds the * relevant directories of the installation to the LD_LIBRARY_PATH environment * variable. After that, the application process is loaded and started, whereby * the new process inherits the environment of the calling process, including * the modified LD_LIBRARY_PATH environment variable. The application's * executable name must be the same as the name of this executable, prefixed * by '_'.</p> * <p>On MACOSX DYLD_LIBRARY_PATH is used instead of LD_LIBRARY_PATH!<p> * * <p>A UNO installation can be specified by the user by setting the UNO_PATH * environment variable to the program directory of the UNO installation. * If no installation is specified by the user, the default installation on * the system will be taken. The default installation is found from the * PATH environment variable. This requires that the 'soffice' executable or * a symbolic link is in one of the directories listed in the PATH environment * variable.</p> */ int main( int argc, char *argv[] ) { char const* path; char* cmdname; (void) argc; /* avoid warning about unused parameter */ /* get the path of the UNO installation */ path = getPath(); if ( path != NULL ) { #if defined(MACOSX) static const char* ENVVARNAME = "DYLD_LIBRARY_PATH"; #elif defined(AIX) static const char* ENVVARNAME = "LIBPATH"; #else static const char* ENVVARNAME = "LD_LIBRARY_PATH"; #endif char * libpath; int freeLibpath; char* value; char* envstr; int size; size_t pathlen = strlen(path); struct stat stats; int ret; static char const unoinfoSuffix[] = "/unoinfo"; char * unoinfo = malloc( pathlen + RTL_CONSTASCII_LENGTH(unoinfoSuffix) + 1); /*TODO: overflow */ if (unoinfo == NULL) { fprintf(stderr, "Error: out of memory!\n"); exit(EXIT_FAILURE); } strcpy(unoinfo, path); strcpy( unoinfo + pathlen, unoinfoSuffix + (pathlen == 0 || path[pathlen - 1] != '/' ? 0 : 1)); ret = lstat(unoinfo, &stats); free(unoinfo); if (ret == 0) { char * cmd = malloc( 2 * pathlen + RTL_CONSTASCII_LENGTH("/unoinfo c++") + 1); /*TODO: overflow */ char const * p; char * q; FILE * f; size_t n = 1000; size_t old = 0; if (cmd == NULL) { fprintf(stderr, "Error: out of memory!\n"); exit(EXIT_FAILURE); } p = path; q = cmd; while (*p != '\0') { *q++ = '\\'; *q++ = *p++; } if (p == path || p[-1] != '/') { *q++ = '/'; } strcpy(q, "unoinfo c++"); f = popen(cmd, "r"); free(cmd); if (f == NULL) { fprintf(stderr, "Error: calling unoinfo failed!\n"); exit(EXIT_FAILURE); } libpath = NULL; for (;;) { size_t m; libpath = realloc(libpath, n); if (libpath == NULL) { fprintf( stderr, "Error: out of memory reading unoinfo output!\n"); exit(EXIT_FAILURE); } m = fread(libpath + old, 1, n - old - 1, f); if (m != n - old - 1) { if (ferror(f)) { fprintf(stderr, "Error: cannot read unoinfo output!\n"); exit(EXIT_FAILURE); } libpath[old + m] = '\0'; break; } if (n >= SAL_MAX_SIZE / 2) { fprintf( stderr, "Error: out of memory reading unoinfo output!\n"); exit(EXIT_FAILURE); } old = n - 1; n *= 2; } if (pclose(f) != 0) { fprintf(stderr, "Error: executing unoinfo failed!\n"); exit(EXIT_FAILURE); } freeLibpath = 1; } else { /* Assume an old OOo 2.x installation without unoinfo: */ libpath = (char *) path; freeLibpath = 0; } value = getenv( ENVVARNAME ); // workaround for finding wrong libsqlite3.dylib in the office installation // For MacOS > 10.6 nss uses the system lib -> unresolved symbol _sqlite3_wal_checkpoint #ifdef MACOSX size = strlen( ENVVARNAME ) + strlen( "=/usr/lib:" ) + strlen( libpath ) + 1; #else size = strlen( ENVVARNAME ) + strlen( "=" ) + strlen( libpath ) + 1; #endif if ( value != NULL ) size += strlen( PATHSEPARATOR ) + strlen( value ); envstr = (char*) malloc( size ); strcpy( envstr, ENVVARNAME ); #ifdef MACOSX strcat( envstr, "=/usr/lib:" ); #else strcat( envstr, "=" ); #endif strcat( envstr, libpath ); if ( freeLibpath != 0 ) { free( libpath ); } if ( value != NULL ) { strcat( envstr, PATHSEPARATOR ); strcat( envstr, value ); } putenv( envstr ); } else { fprintf( stderr, "Warning: no office installation found!\n" ); fflush( stderr ); } /* set the executable name for the application process */ cmdname = createCommandName( argv[0] ); argv[0] = cmdname; /* * create the application process; * if successful, execvp doesn't return to the calling process */ execvp( cmdname, argv ); fprintf( stderr, "Error: execvp failed!\n" ); fflush( stderr ); return 0; }