strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/sal/rtl/source/bootstrap.cxx
Rüdiger Timm 392fb06810 CWS-TOOLING: integrate CWS sb101 
2008-12-08 16:52:06 +0100 sb  r265009 : #i95330# python23.dll needs to be copied to brand layer, not just moved there
2008-11-24 18:15:54 +0100 sb  r264259 : #i95022# tools::extendApplicationEnvironment gets URE_BOOTSTRAP value from outside bootstrap.cxx, so needs to operate in LOOKUP_MODE_URE_BOOTSTRAP, too
2008-11-20 21:12:31 +0100 jbu  r264103 : deactivated debug log
2008-11-20 21:09:03 +0100 jbu  r264102 : #i95331# ld_library_path now contains ure/lib directory
2008-11-20 21:05:37 +0100 jbu  r264101 : #i95330# python.dll is now installed in the brand-program directory (unix remains unchanged)
2008-11-20 20:46:57 +0100 jbu  r264099 : #i95118# + #i93994# Python scripts in share and user uno packages now work again
2008-11-20 20:38:23 +0100 jbu  r264098 : #i95037# python wrapper now waits for completion of python executable and currectly returns the exit state
2008-11-20 10:46:28 +0100 sb  r264034 : #i95028# import socket, since on Windows sal3.dll no longer calls WSAStartup (and import socket does)
2008-11-18 17:01:09 +0100 sb  r263784 : #i96314# fixed encode()
2008-11-18 15:59:17 +0100 sb  r263779 : #i95024# missing vnd.sun.star.pathname: in URE_BOOTSTRAP
2008-11-18 13:51:36 +0100 sb  r263765 : #i95022# treat \ and $ verbatim in URE_BOOTSTRAP=vnd.sun.star.pathname values
2008-12-11 12:57:12 +00:00

1070 lines
34 KiB
C++
Raw Blame History

/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: bootstrap.cxx,v $
* $Revision: 1.43.20.1 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sal.hxx"
#include "rtl/bootstrap.h"
#include "rtl/bootstrap.hxx"
#include <osl/diagnose.h>
#include <osl/module.h>
#include <osl/process.h>
#include <osl/file.hxx>
#include <osl/mutex.hxx>
#include <osl/profile.hxx>
#include <osl/security.hxx>
#include <rtl/alloc.h>
#include <rtl/string.hxx>
#include <rtl/ustrbuf.hxx>
#include <rtl/ustring.hxx>
#include <rtl/byteseq.hxx>
#include <rtl/instance.hxx>
#include <rtl/malformeduriexception.hxx>
#include <rtl/uri.hxx>
#include "rtl/allocator.hxx"
#include "macro.hxx"
#include <hash_map>
#include <list>
#define MY_STRING_(x) # x
#define MY_STRING(x) MY_STRING_(x)
//----------------------------------------------------------------------------
using osl::DirectoryItem;
using osl::FileStatus;
using rtl::OString;
using rtl::OUString;
using rtl::OUStringToOString;
struct Bootstrap_Impl;
namespace {
static char const VND_SUN_STAR_PATHNAME[] = "vnd.sun.star.pathname:";
bool isPathnameUrl(rtl::OUString const & url) {
return url.matchIgnoreAsciiCaseAsciiL(
RTL_CONSTASCII_STRINGPARAM(VND_SUN_STAR_PATHNAME));
}
bool resolvePathnameUrl(rtl::OUString * url) {
OSL_ASSERT(url != NULL);
if (!isPathnameUrl(*url) ||
(osl::FileBase::getFileURLFromSystemPath(
url->copy(RTL_CONSTASCII_LENGTH(VND_SUN_STAR_PATHNAME)), *url) ==
osl::FileBase::E_None))
{
return true;
} else {
*url = rtl::OUString();
return false;
}
}
enum LookupMode {
LOOKUP_MODE_NORMAL, LOOKUP_MODE_URE_BOOTSTRAP,
LOOKUP_MODE_URE_BOOTSTRAP_EXPANSION };
struct ExpandRequestLink {
ExpandRequestLink const * next;
Bootstrap_Impl const * file;
rtl::OUString key;
};
rtl::OUString expandMacros(
Bootstrap_Impl const * file, rtl::OUString const & text, LookupMode mode,
ExpandRequestLink const * requestStack);
rtl::OUString recursivelyExpandMacros(
Bootstrap_Impl const * file, rtl::OUString const & text, LookupMode mode,
Bootstrap_Impl const * requestFile, rtl::OUString const & requestKey,
ExpandRequestLink const * requestStack)
{
for (; requestStack != NULL; requestStack = requestStack->next) {
if (requestStack->file == requestFile &&
requestStack->key == requestKey)
{
return rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("***RECURSION DETECTED***"));
}
}
ExpandRequestLink link = { requestStack, requestFile, requestKey };
return expandMacros(file, text, mode, &link);
}
}
//----------------------------------------------------------------------------
struct rtl_bootstrap_NameValue
{
OUString sName;
OUString sValue;
inline rtl_bootstrap_NameValue() SAL_THROW( () )
{}
inline rtl_bootstrap_NameValue(
OUString const & name, OUString const & value ) SAL_THROW( () )
: sName( name ),
sValue( value )
{}
};
typedef std::list<
rtl_bootstrap_NameValue,
rtl::Allocator< rtl_bootstrap_NameValue >
> NameValueList;
bool find(
NameValueList const & list, rtl::OUString const & key,
rtl::OUString * value)
{
OSL_ASSERT(value != NULL);
for (NameValueList::const_iterator i(list.begin()); i != list.end(); ++i) {
if (i->sName == key) {
*value = i->sValue;
return true;
}
}
return false;
}
namespace {
struct rtl_bootstrap_set_list :
public rtl::Static< NameValueList, rtl_bootstrap_set_list > {};
}
//----------------------------------------------------------------------------
static sal_Bool getFromCommandLineArgs(
rtl::OUString const & key, rtl::OUString * value )
{
OSL_ASSERT(value != NULL);
static NameValueList *pNameValueList = 0;
if( ! pNameValueList )
{
static NameValueList nameValueList;
sal_Int32 nArgCount = osl_getCommandArgCount();
for(sal_Int32 i = 0; i < nArgCount; ++ i)
{
rtl_uString *pArg = 0;
osl_getCommandArg( i, &pArg );
if( ('-' == pArg->buffer[0] || '/' == pArg->buffer[0] ) &&
'e' == pArg->buffer[1] &&
'n' == pArg->buffer[2] &&
'v' == pArg->buffer[3] &&
':' == pArg->buffer[4] )
{
sal_Int32 nIndex = rtl_ustr_indexOfChar( pArg->buffer, '=' );
if( nIndex >= 0 )
{
rtl_bootstrap_NameValue nameValue;
nameValue.sName = OUString( &(pArg->buffer[5]), nIndex - 5 );
nameValue.sValue = OUString( &(pArg->buffer[nIndex+1]) );
if( i == nArgCount-1 &&
nameValue.sValue.getLength() &&
nameValue.sValue[nameValue.sValue.getLength()-1] == 13 )
{
// avoid the 13 linefeed for the last argument,
// when the executable is started from a script,
// that was edited on windows
nameValue.sValue = nameValue.sValue.copy(0,nameValue.sValue.getLength()-1);
}
nameValueList.push_back( nameValue );
}
}
rtl_uString_release( pArg );
}
pNameValueList = &nameValueList;
}
sal_Bool found = sal_False;
for( NameValueList::iterator ii = pNameValueList->begin() ;
ii != pNameValueList->end() ;
++ii )
{
if( (*ii).sName.equals(key) )
{
*value = (*ii).sValue;
found = sal_True;
break;
}
}
return found;
}
//----------------------------------------------------------------------------
extern "C" oslProcessError SAL_CALL osl_bootstrap_getExecutableFile_Impl (
rtl_uString ** ppFileURL) SAL_THROW_EXTERN_C();
inline void getExecutableFile_Impl (rtl_uString ** ppFileURL)
{
osl_bootstrap_getExecutableFile_Impl (ppFileURL);
}
//----------------------------------------------------------------------------
static void getExecutableDirectory_Impl (rtl_uString ** ppDirURL)
{
OUString fileName;
getExecutableFile_Impl (&(fileName.pData));
sal_Int32 nDirEnd = fileName.lastIndexOf('/');
OSL_ENSURE(nDirEnd >= 0, "Cannot locate executable directory");
rtl_uString_newFromStr_WithLength(ppDirURL,fileName.getStr(),nDirEnd);
}
//----------------------------------------------------------------------------
static OUString & getIniFileName_Impl()
{
static OUString *pStaticName = 0;
if( ! pStaticName )
{
OUString fileName;
if(getFromCommandLineArgs(
OUString(RTL_CONSTASCII_USTRINGPARAM("INIFILENAME")), &fileName))
{
resolvePathnameUrl(&fileName);
}
else
{
getExecutableFile_Impl (&(fileName.pData));
// get rid of a potential executable extension
OUString progExt (RTL_CONSTASCII_USTRINGPARAM(".bin"));
if(fileName.getLength() > progExt.getLength()
&& fileName.copy(fileName.getLength() - progExt.getLength()).equalsIgnoreAsciiCase(progExt))
fileName = fileName.copy(0, fileName.getLength() - progExt.getLength());
progExt = OUString::createFromAscii(".exe");
if(fileName.getLength() > progExt.getLength()
&& fileName.copy(fileName.getLength() - progExt.getLength()).equalsIgnoreAsciiCase(progExt))
fileName = fileName.copy(0, fileName.getLength() - progExt.getLength());
// append config file suffix
fileName += OUString(RTL_CONSTASCII_USTRINGPARAM(SAL_CONFIGFILE("")));
}
OUString workDir;
osl_getProcessWorkingDir(&workDir.pData);
osl::FileBase::getAbsoluteFileURL(workDir, fileName, fileName);
static OUString theFileName;
if(fileName.getLength())
theFileName = fileName;
pStaticName = &theFileName;
}
return *pStaticName;
}
//----------------------------------------------------------------------------
static inline bool path_exists( OUString const & path )
{
DirectoryItem dirItem;
return (DirectoryItem::E_None == DirectoryItem::get( path, dirItem ));
}
//----------------------------------------------------------------------------
// #111772#
// ensure the given file url has no final slash
inline void EnsureNoFinalSlash (rtl::OUString & url)
{
sal_Int32 i = url.getLength();
if (i > 0 && url[i - 1] == '/') {
url = url.copy(0, i - 1);
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
struct Bootstrap_Impl
{
sal_Int32 _nRefCount;
Bootstrap_Impl * _base_ini;
NameValueList _nameValueList;
OUString _iniName;
explicit Bootstrap_Impl (OUString const & rIniName);
~Bootstrap_Impl();
static void * operator new (std::size_t n) SAL_THROW(())
{ return rtl_allocateMemory (sal_uInt32(n)); }
static void operator delete (void * p , std::size_t) SAL_THROW(())
{ rtl_freeMemory (p); }
bool getValue(
rtl::OUString const & key, rtl_uString ** value,
rtl_uString * defaultValue, LookupMode mode, bool override,
ExpandRequestLink const * requestStack) const;
bool getDirectValue(
rtl::OUString const & key, rtl_uString ** value, LookupMode mode,
ExpandRequestLink const * requestStack) const;
bool getAmbienceValue(
rtl::OUString const & key, rtl_uString ** value, LookupMode mode,
ExpandRequestLink const * requestStack) const;
void expandValue(
rtl_uString ** value, rtl::OUString const & text, LookupMode mode,
Bootstrap_Impl const * requestFile, rtl::OUString const & requestKey,
ExpandRequestLink const * requestStack) const;
};
//----------------------------------------------------------------------------
Bootstrap_Impl::Bootstrap_Impl( OUString const & rIniName )
: _nRefCount( 0 ),
_base_ini( 0 ),
_iniName (rIniName)
{
OUString base_ini( getIniFileName_Impl() );
// normalize path
FileStatus status( FileStatusMask_FileURL );
DirectoryItem dirItem;
if (DirectoryItem::E_None == DirectoryItem::get( base_ini, dirItem ) &&
DirectoryItem::E_None == dirItem.getFileStatus( status ))
{
base_ini = status.getFileURL();
if (! rIniName.equals( base_ini ))
{
_base_ini = static_cast< Bootstrap_Impl * >(
rtl_bootstrap_args_open( base_ini.pData ) );
}
}
#if OSL_DEBUG_LEVEL > 1
OString sFile = OUStringToOString(_iniName, RTL_TEXTENCODING_ASCII_US);
OSL_TRACE(__FILE__" -- Bootstrap_Impl() - %s\n", sFile.getStr());
#endif /* OSL_DEBUG_LEVEL > 1 */
oslFileHandle handle;
if (_iniName.getLength() &&
osl_File_E_None == osl_openFile(_iniName.pData, &handle, osl_File_OpenFlag_Read))
{
rtl::ByteSequence seq;
while (osl_File_E_None == osl_readLine(handle , (sal_Sequence **)&seq))
{
OString line( (const sal_Char *) seq.getConstArray(), seq.getLength() );
sal_Int32 nIndex = line.indexOf('=');
if (nIndex >= 1)
{
struct rtl_bootstrap_NameValue nameValue;
nameValue.sName = OStringToOUString(
line.copy(0,nIndex).trim(), RTL_TEXTENCODING_ASCII_US );
nameValue.sValue = OStringToOUString(
line.copy(nIndex+1).trim(), RTL_TEXTENCODING_UTF8 );
#if OSL_DEBUG_LEVEL > 1
OString name_tmp = OUStringToOString(nameValue.sName, RTL_TEXTENCODING_ASCII_US);
OString value_tmp = OUStringToOString(nameValue.sValue, RTL_TEXTENCODING_UTF8);
OSL_TRACE(
__FILE__" -- pushing: name=%s value=%s\n",
name_tmp.getStr(), value_tmp.getStr() );
#endif /* OSL_DEBUG_LEVEL > 1 */
_nameValueList.push_back(nameValue);
}
}
osl_closeFile(handle);
}
#if OSL_DEBUG_LEVEL > 1
else
{
OString file_tmp = OUStringToOString(_iniName, RTL_TEXTENCODING_ASCII_US);
OSL_TRACE( __FILE__" -- couldn't open file: %s", file_tmp.getStr() );
}
#endif /* OSL_DEBUG_LEVEL > 1 */
}
//----------------------------------------------------------------------------
Bootstrap_Impl::~Bootstrap_Impl()
{
if (_base_ini != 0)
rtl_bootstrap_args_close( _base_ini );
}
//----------------------------------------------------------------------------
namespace {
Bootstrap_Impl * get_static_bootstrap_handle() SAL_THROW(())
{
osl::MutexGuard guard( osl::Mutex::getGlobalMutex() );
static Bootstrap_Impl * s_handle = 0;
if (s_handle == 0)
{
OUString iniName (getIniFileName_Impl());
s_handle = static_cast< Bootstrap_Impl * >(
rtl_bootstrap_args_open( iniName.pData ) );
if (s_handle == 0)
{
Bootstrap_Impl * that = new Bootstrap_Impl( iniName );
++that->_nRefCount;
s_handle = that;
}
}
return s_handle;
}
struct FundamentalIniData {
rtlBootstrapHandle ini;
FundamentalIniData() {
OUString uri;
ini =
((static_cast< Bootstrap_Impl * >(get_static_bootstrap_handle())->
getValue(
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("URE_BOOTSTRAP")),
&uri.pData, 0, LOOKUP_MODE_NORMAL, false, 0)) &&
resolvePathnameUrl(&uri))
? rtl_bootstrap_args_open(uri.pData) : NULL;
}
~FundamentalIniData() { rtl_bootstrap_args_close(ini); }
private:
FundamentalIniData(FundamentalIniData &); // not defined
void operator =(FundamentalIniData &); // not defined
};
struct FundamentalIni: public rtl::Static< FundamentalIniData, FundamentalIni >
{};
}
bool Bootstrap_Impl::getValue(
rtl::OUString const & key, rtl_uString ** value, rtl_uString * defaultValue,
LookupMode mode, bool override, ExpandRequestLink const * requestStack)
const
{
if (mode == LOOKUP_MODE_NORMAL &&
key.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("URE_BOOTSTRAP")))
{
mode = LOOKUP_MODE_URE_BOOTSTRAP;
}
if (override && getDirectValue(key, value, mode, requestStack)) {
return true;
}
if (key.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("_OS"))) {
rtl_uString_assign(
value, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(THIS_OS)).pData);
return true;
}
if (key.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("_ARCH"))) {
rtl_uString_assign(
value, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(THIS_ARCH)).pData);
return true;
}
if (key.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("_CPPU_ENV"))) {
rtl_uString_assign(
value,
(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(MY_STRING(CPPU_ENV))).
pData));
return true;
}
if (key.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("ORIGIN"))) {
rtl_uString_assign(
value,
_iniName.copy(
0, std::max<sal_Int32>(0, _iniName.lastIndexOf('/'))).pData);
return true;
}
if (getAmbienceValue(key, value, mode, requestStack)) {
return true;
}
if (key.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("SYSUSERCONFIG"))) {
rtl::OUString v;
bool b = osl::Security().getConfigDir(v);
EnsureNoFinalSlash(v);
rtl_uString_assign(value, v.pData);
return b;
}
if (key.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("SYSUSERHOME"))) {
rtl::OUString v;
bool b = osl::Security().getHomeDir(v);
EnsureNoFinalSlash(v);
rtl_uString_assign(value, v.pData);
return b;
}
if (key.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("SYSBINDIR"))) {
getExecutableDirectory_Impl(value);
return true;
}
if (_base_ini != NULL &&
_base_ini->getDirectValue(key, value, mode, requestStack))
{
return true;
}
if (!override && getDirectValue(key, value, mode, requestStack)) {
return true;
}
if (mode == LOOKUP_MODE_NORMAL) {
FundamentalIniData const & d = FundamentalIni::get();
Bootstrap_Impl const * b = static_cast<Bootstrap_Impl const *>(d.ini);
if (b != NULL && b != this &&
b->getDirectValue(key, value, mode, requestStack))
{
return true;
}
}
if (defaultValue != NULL) {
rtl_uString_assign(value, defaultValue);
return true;
}
rtl_uString_new(value);
return false;
}
bool Bootstrap_Impl::getDirectValue(
rtl::OUString const & key, rtl_uString ** value, LookupMode mode,
ExpandRequestLink const * requestStack) const
{
rtl::OUString v;
if (find(_nameValueList, key, &v)) {
expandValue(value, v, mode, this, key, requestStack);
return true;
} else {
return false;
}
}
bool Bootstrap_Impl::getAmbienceValue(
rtl::OUString const & key, rtl_uString ** value, LookupMode mode,
ExpandRequestLink const * requestStack) const
{
rtl::OUString v;
bool f;
{
osl::MutexGuard g(osl::Mutex::getGlobalMutex());
f = find(rtl_bootstrap_set_list::get(), key, &v);
}
if (f || getFromCommandLineArgs(key, &v) ||
osl_getEnvironment(key.pData, &v.pData) == osl_Process_E_None)
{
expandValue(value, v, mode, NULL, key, requestStack);
return true;
} else {
return false;
}
}
void Bootstrap_Impl::expandValue(
rtl_uString ** value, rtl::OUString const & text, LookupMode mode,
Bootstrap_Impl const * requestFile, rtl::OUString const & requestKey,
ExpandRequestLink const * requestStack) const
{
rtl_uString_assign(
value,
(mode == LOOKUP_MODE_URE_BOOTSTRAP && isPathnameUrl(text) ?
text :
recursivelyExpandMacros(
this, text,
(mode == LOOKUP_MODE_URE_BOOTSTRAP ?
LOOKUP_MODE_URE_BOOTSTRAP_EXPANSION : mode),
requestFile, requestKey, requestStack)).pData);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
namespace {
struct bootstrap_map {
// map<> may be preferred here, but hash_map<> is implemented fully inline,
// thus there is no need to link against the stlport:
typedef std::hash_map<
rtl::OUString, Bootstrap_Impl *,
rtl::OUStringHash, std::equal_to< rtl::OUString >,
rtl::Allocator< OUString > > t;
// get and release must only be called properly synchronized via some mutex
// (e.g., osl::Mutex::getGlobalMutex()):
static t * get() {
if (m_map == NULL) {
m_map = new t;
}
return m_map;
}
static void release() {
if (m_map != NULL && m_map->empty()) {
delete m_map;
m_map = NULL;
}
}
private:
bootstrap_map(); // not defined
static t * m_map;
};
bootstrap_map::t * bootstrap_map::m_map = NULL;
}
//----------------------------------------------------------------------------
rtlBootstrapHandle SAL_CALL rtl_bootstrap_args_open (
rtl_uString * pIniName
) SAL_THROW_EXTERN_C()
{
OUString workDir;
OUString iniName( pIniName );
osl_getProcessWorkingDir( &workDir.pData );
osl::FileBase::getAbsoluteFileURL( workDir, iniName, iniName );
// normalize path
FileStatus status( FileStatusMask_FileURL );
DirectoryItem dirItem;
if (DirectoryItem::E_None != DirectoryItem::get( iniName, dirItem ) ||
DirectoryItem::E_None != dirItem.getFileStatus( status ))
{
return 0;
}
iniName = status.getFileURL();
Bootstrap_Impl * that;
osl::ResettableMutexGuard guard( osl::Mutex::getGlobalMutex() );
bootstrap_map::t* p_bootstrap_map = bootstrap_map::get();
bootstrap_map::t::const_iterator iFind( p_bootstrap_map->find( iniName ) );
if (iFind == p_bootstrap_map->end())
{
bootstrap_map::release();
guard.clear();
that = new Bootstrap_Impl( iniName );
guard.reset();
p_bootstrap_map = bootstrap_map::get();
iFind = p_bootstrap_map->find( iniName );
if (iFind == p_bootstrap_map->end())
{
++that->_nRefCount;
::std::pair< bootstrap_map::t::iterator, bool > insertion(
p_bootstrap_map->insert(
bootstrap_map::t::value_type( iniName, that ) ) );
OSL_ASSERT( insertion.second );
}
else
{
Bootstrap_Impl * obsolete = that;
that = iFind->second;
++that->_nRefCount;
guard.clear();
delete obsolete;
}
}
else
{
that = iFind->second;
++that->_nRefCount;
}
return static_cast< rtlBootstrapHandle >( that );
}
//----------------------------------------------------------------------------
void SAL_CALL rtl_bootstrap_args_close (
rtlBootstrapHandle handle
) SAL_THROW_EXTERN_C()
{
if (handle == 0)
return;
Bootstrap_Impl * that = static_cast< Bootstrap_Impl * >( handle );
osl::MutexGuard guard( osl::Mutex::getGlobalMutex() );
bootstrap_map::t* p_bootstrap_map = bootstrap_map::get();
OSL_ASSERT(
p_bootstrap_map->find( that->_iniName )->second == that );
--that->_nRefCount;
if (that->_nRefCount == 0)
{
::std::size_t nLeaking = 8; // only hold up to 8 files statically
#if OSL_DEBUG_LEVEL == 1 // nonpro
nLeaking = 0;
#elif OSL_DEBUG_LEVEL > 1 // debug
nLeaking = 1;
#endif /* OSL_DEBUG_LEVEL */
if (p_bootstrap_map->size() > nLeaking)
{
::std::size_t erased = p_bootstrap_map->erase( that->_iniName );
if (erased != 1) {
OSL_ASSERT( false );
}
delete that;
}
bootstrap_map::release();
}
}
//----------------------------------------------------------------------------
sal_Bool SAL_CALL rtl_bootstrap_get_from_handle(
rtlBootstrapHandle handle,
rtl_uString * pName,
rtl_uString ** ppValue,
rtl_uString * pDefault
) SAL_THROW_EXTERN_C()
{
osl::MutexGuard guard( osl::Mutex::getGlobalMutex() );
sal_Bool found = sal_False;
if(ppValue && pName)
{
if (handle == 0)
handle = get_static_bootstrap_handle();
found = static_cast< Bootstrap_Impl * >( handle )->getValue(
pName, ppValue, pDefault, LOOKUP_MODE_NORMAL, false, NULL );
}
return found;
}
//----------------------------------------------------------------------------
void SAL_CALL rtl_bootstrap_get_iniName_from_handle (
rtlBootstrapHandle handle,
rtl_uString ** ppIniName
) SAL_THROW_EXTERN_C()
{
if(ppIniName)
{
if(handle)
{
Bootstrap_Impl * pImpl = static_cast<Bootstrap_Impl*>(handle);
rtl_uString_assign(ppIniName, pImpl->_iniName.pData);
}
else
{
const OUString & iniName = getIniFileName_Impl();
rtl_uString_assign(ppIniName, iniName.pData);
}
}
}
//----------------------------------------------------------------------------
void SAL_CALL rtl_bootstrap_setIniFileName (
rtl_uString * pName
) SAL_THROW_EXTERN_C()
{
osl::MutexGuard guard( osl::Mutex::getGlobalMutex() );
OUString & file = getIniFileName_Impl();
file = pName;
}
//----------------------------------------------------------------------------
sal_Bool SAL_CALL rtl_bootstrap_get (
rtl_uString * pName,
rtl_uString ** ppValue,
rtl_uString * pDefault
) SAL_THROW_EXTERN_C()
{
return rtl_bootstrap_get_from_handle(0, pName, ppValue, pDefault);
}
//----------------------------------------------------------------------------
void SAL_CALL rtl_bootstrap_set (
rtl_uString * pName,
rtl_uString * pValue
) SAL_THROW_EXTERN_C()
{
OUString const & name = *reinterpret_cast< OUString const * >( &pName );
OUString const & value = *reinterpret_cast< OUString const * >( &pValue );
osl::MutexGuard guard( osl::Mutex::getGlobalMutex() );
NameValueList& r_rtl_bootstrap_set_list = rtl_bootstrap_set_list::get();
NameValueList::iterator iPos( r_rtl_bootstrap_set_list.begin() );
NameValueList::iterator iEnd( r_rtl_bootstrap_set_list.end() );
for ( ; iPos != iEnd; ++iPos )
{
if (iPos->sName.equals( name ))
{
iPos->sValue = value;
return;
}
}
#if OSL_DEBUG_LEVEL > 1
OString cstr_name( OUStringToOString( name, RTL_TEXTENCODING_ASCII_US ) );
OString cstr_value( OUStringToOString( value, RTL_TEXTENCODING_ASCII_US ) );
OSL_TRACE(
"bootstrap.cxx: explicitly setting: name=%s value=%s\n",
cstr_name.getStr(), cstr_value.getStr() );
#endif /* OSL_DEBUG_LEVEL > 1 */
r_rtl_bootstrap_set_list.push_back( rtl_bootstrap_NameValue( name, value ) );
}
//----------------------------------------------------------------------------
void SAL_CALL rtl_bootstrap_expandMacros_from_handle (
rtlBootstrapHandle handle,
rtl_uString ** macro
) SAL_THROW_EXTERN_C()
{
if (handle == NULL) {
handle = get_static_bootstrap_handle();
}
OUString expanded( expandMacros( static_cast< Bootstrap_Impl * >( handle ),
* reinterpret_cast< OUString const * >( macro ),
LOOKUP_MODE_NORMAL, NULL ) );
rtl_uString_assign( macro, expanded.pData );
}
//----------------------------------------------------------------------------
void SAL_CALL rtl_bootstrap_expandMacros(
rtl_uString ** macro )
SAL_THROW_EXTERN_C()
{
rtl_bootstrap_expandMacros_from_handle(NULL, macro);
}
void rtl_bootstrap_encode( rtl_uString const * value, rtl_uString ** encoded )
SAL_THROW_EXTERN_C()
{
OSL_ASSERT(value != NULL);
rtl::OUStringBuffer b;
for (sal_Int32 i = 0; i < value->length; ++i) {
sal_Unicode c = value->buffer[i];
if (c == '$' || c == '\\') {
b.append(sal_Unicode('\\'));
}
b.append(c);
}
rtl_uString_assign(encoded, b.makeStringAndClear().pData);
}
namespace {
int hex(sal_Unicode c) {
return
c >= '0' && c <= '9' ? c - '0' :
c >= 'A' && c <= 'F' ? c - 'A' + 10 :
c >= 'a' && c <= 'f' ? c - 'a' + 10 : -1;
}
sal_Unicode read(rtl::OUString const & text, sal_Int32 * pos, bool * escaped) {
OSL_ASSERT(
pos != NULL && *pos >= 0 && *pos < text.getLength() && escaped != NULL);
sal_Unicode c = text[(*pos)++];
if (c == '\\') {
int n1, n2, n3, n4;
if (*pos < text.getLength() - 4 && text[*pos] == 'u' &&
((n1 = hex(text[*pos + 1])) >= 0) &&
((n2 = hex(text[*pos + 2])) >= 0) &&
((n3 = hex(text[*pos + 3])) >= 0) &&
((n4 = hex(text[*pos + 4])) >= 0))
{
*pos += 5;
*escaped = true;
return static_cast< sal_Unicode >(
(n1 << 12) | (n2 << 8) | (n3 << 4) | n4);
} else if (*pos < text.getLength()) {
*escaped = true;
return text[(*pos)++];
}
}
*escaped = false;
return c;
}
rtl::OUString lookup(
Bootstrap_Impl const * file, LookupMode mode, bool override,
rtl::OUString const & key, ExpandRequestLink const * requestStack)
{
rtl::OUString v;
(file == NULL ? get_static_bootstrap_handle() : file)->getValue(
key, &v.pData, NULL, mode, override, requestStack);
return v;
}
rtl::OUString expandMacros(
Bootstrap_Impl const * file, rtl::OUString const & text, LookupMode mode,
ExpandRequestLink const * requestStack)
{
rtl::OUStringBuffer buf;
for (sal_Int32 i = 0; i < text.getLength();) {
bool escaped;
sal_Unicode c = read(text, &i, &escaped);
if (escaped || c != '$') {
buf.append(c);
} else {
if (i < text.getLength() && text[i] == '{') {
++i;
sal_Int32 p = i;
sal_Int32 nesting = 0;
rtl::OUString seg[3];
int n = 0;
while (i < text.getLength()) {
sal_Int32 j = i;
c = read(text, &i, &escaped);
if (!escaped) {
switch (c) {
case '{':
++nesting;
break;
case '}':
if (nesting == 0) {
seg[n++] = text.copy(p, j - p);
goto done;
} else {
--nesting;
}
break;
case ':':
if (nesting == 0 && n < 2) {
seg[n++] = text.copy(p, j - p);
p = i;
}
break;
}
}
}
done:
for (int j = 0; j < n; ++j) {
seg[j] = expandMacros(file, seg[j], mode, requestStack);
}
if (n == 3 && seg[1].getLength() == 0) {
// For backward compatibility, treat ${file::key} the same
// as just ${file:key}:
seg[1] = seg[2];
n = 2;
}
if (n == 1) {
buf.append(lookup(file, mode, false, seg[0], requestStack));
} else if (n == 2) {
if (seg[0].equalsAsciiL(
RTL_CONSTASCII_STRINGPARAM(".link")))
{
osl::File f(seg[1]);
rtl::ByteSequence seq;
rtl::OUString line;
rtl::OUString url;
// Silently ignore any errors (is that good?):
if (f.open(OpenFlag_Read) == osl::FileBase::E_None &&
f.readLine(seq) == osl::FileBase::E_None &&
rtl_convertStringToUString(
&line.pData,
reinterpret_cast< char const * >(
seq.getConstArray()),
seq.getLength(), RTL_TEXTENCODING_UTF8,
(RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR |
RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR |
RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)) &&
(osl::File::getFileURLFromSystemPath(line, url) ==
osl::FileBase::E_None))
{
try {
buf.append(
rtl::Uri::convertRelToAbs(seg[1], url));
} catch (rtl::MalformedUriException &) {}
}
} else {
buf.append(
lookup(
static_cast< Bootstrap_Impl * >(
rtl::Bootstrap(seg[0]).getHandle()),
mode, false, seg[1], requestStack));
}
} else if (seg[0].equalsAsciiL(
RTL_CONSTASCII_STRINGPARAM(".override")))
{
rtl::Bootstrap b(seg[1]);
Bootstrap_Impl * f = static_cast< Bootstrap_Impl * >(
b.getHandle());
buf.append(
lookup(f, mode, f != NULL, seg[2], requestStack));
} else {
// Going through osl::Profile, this code erroneously does
// not recursively expand macros in the resulting
// replacement text (and if it did, it would fail to detect
// cycles that pass through here):
buf.append(
rtl::OStringToOUString(
osl::Profile(seg[0]).readString(
rtl::OUStringToOString(
seg[1], RTL_TEXTENCODING_UTF8),
rtl::OUStringToOString(
seg[2], RTL_TEXTENCODING_UTF8),
rtl::OString()),
RTL_TEXTENCODING_UTF8));
}
} else {
rtl::OUStringBuffer kbuf;
for (; i < text.getLength();) {
sal_Int32 j = i;
c = read(text, &j, &escaped);
if (!escaped &&
(c == ' ' || c == '$' || c == '-' || c == '/' ||
c == ';' || c == '\\'))
{
break;
}
kbuf.append(c);
i = j;
}
buf.append(
lookup(
file, mode, false, kbuf.makeStringAndClear(),
requestStack));
}
}
}
return buf.makeStringAndClear();
}
}
Reference in a new issue View git blame Copy permalink