/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <vector>

#include "sal/main.h"
#include <rtl/strbuf.hxx>
#include <rtl/ustrbuf.hxx>

#include <cppuhelper/servicefactory.hxx>
#include <cppuhelper/shlib.hxx>

#include <com/sun/star/container/XSet.hpp>
#include <com/sun/star/container/XContentEnumerationAccess.hpp>
#include <com/sun/star/registry/XImplementationRegistration2.hpp>
#include <com/sun/star/registry/XSimpleRegistry.hpp>
#include <com/sun/star/lang/XComponent.hpp>

#include <algorithm>
#include <osl/process.h>
#include <osl/diagnose.h>
#include <osl/thread.h>
#include <osl/file.hxx>

#ifdef SAL_UNX
#define SEPARATOR '/'
#else
#define SEPARATOR '\\'
#endif

using namespace ::rtl;
using namespace ::osl;
using namespace ::cppu;
using namespace ::std;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::registry;
using com::sun::star::container::XSet;
using com::sun::star::container::XContentEnumerationAccess;
using com::sun::star::container::XEnumeration;

namespace {

OUString replacePrefix(OUString const & url, OUString const & prefix) {
    sal_Int32 i = url.lastIndexOf('/');
    // Backward compatibility with stoc/source/implementationregistration/
    // implreg.cxx:1.27 l. 1892:
    if (i == -1) {
        i = url.lastIndexOf('\\');
    }
    return prefix + url.copy(i + 1);
}

}

sal_Bool isFileUrl(const OUString& fileName)
{
    if (fileName.indexOf(OUString::createFromAscii("file://")) == 0 )
        return sal_True;
    return sal_False;
}

OUString convertToFileUrl(const OUString& fileName)
{
    if ( isFileUrl(fileName) )
    {
        return fileName;
    }

    OUString uUrlFileName;
    if ( fileName.indexOf('.') == 0 || fileName.indexOf(SEPARATOR) < 0 )
    {
        OUString uWorkingDir;
        if (osl_getProcessWorkingDir(&uWorkingDir.pData) != osl_Process_E_None) {
            OSL_ASSERT(false);
        }
        if (FileBase::getAbsoluteFileURL(uWorkingDir, fileName, uUrlFileName)
            != FileBase::E_None)
        {
            OSL_ASSERT(false);
        }
    } else
    {
        if (FileBase::getFileURLFromSystemPath(fileName, uUrlFileName)
            != FileBase::E_None)
        {
            OSL_ASSERT(false);
        }
    }

    return uUrlFileName;
}
static void usingRegisterImpl()
{
	fprintf(stderr, "usage: regcomp -register|revoke -r registryfile -c locationUrl [-br registryfile] [-l componentLoaderUrl] [-s] [-classpath path]\n");
	fprintf(stderr, " Parameters:\n");
	fprintf(stderr, "  -register\n"
                    "        register a new component.\n");
	fprintf(stderr, "  -revoke\n"
                    "        revoke a component.\n");
	fprintf(stderr, "  -br registryfile\n"
                    "        the name of the registry used for bootstrapping\n"
                    "        regcomp. The option can be given twice, each\n"
                    "        one followed by exactly one registry file.\n"
                    "        The registries are used to access both types and\n"
                    "        registered components.\n");
	fprintf(stderr, "  -r registryfile\n"
                    "        the name of the target registry (will be created\n"
                    "        if it does not exists). The file name may match\n"
                    "        with one of the filenames given with the -br option.\n");
	fprintf(stderr, "  -c locationUrls\n"
                    "        the location of a component (a url to a shared\n"
                    "        library or a absolute url to a .jar file) or a\n"
                    "        list of urls separated by ';' or ' '. Note if a\n"
                    "        list of urls is specified, the components must\n"
                    "        all need the same loader (quoting is possible with\n"
                    "        \\ or \"\").\n");
	fprintf(stderr, "  -l componentLoaderUrl\n"
                    "        the name of the needed loader. If no loader is\n"
                    "        specified and the components have a .jar suffix,\n"
                    "        the default is com.sun.star.loader.Java2.\n"
					"        Otherwise, the default is\n"
                    "        com.sun.star.loader.SharedLibrary\n"
                    "  -s\n"
                    "        silent, regcomp prints messages only on error.\n"
                    "  -wop\n"
                    "        register the component name only without path\n"
                    "  -wop=prefix\n"
                    "        register the component name with path replaced\n"
                    "        by given prefix\n"
                    "  -classpath path\n"
                    "        sets the java classpath to path (overwriting the\n"
                    "        current classpath environment variable). Note that\n"
                    "        in case you start regcomp e.g. within an office\n"
                    "        environment, the classpath entries in the\n"
                    "        configuration still have precedence over this\n"
                    "        option.\n");
}

class IllegalArgument
{
public:
	IllegalArgument(const OString& rMessage)
		: m_message(rMessage)
		{}

	OString m_message;
};

struct Options
{
	Options()
		: bRegister(sal_False)
		, bRevoke(sal_False)
        , bSilent( sal_False )
        , bPrefix( sal_False )
		{}

	sal_Bool bRegister;
	sal_Bool bRevoke;
    sal_Bool bSilent;
	sal_Bool bPrefix;
    OUString sPrefix;
	OUString sProgramName;
	OUString sBootRegName;
    OUString sBootRegName2;
	OUString sRegName;
	OUString sComponentUrls;
	OUString sLoaderName;
};

sal_Bool parseOptions(int ac, char* av[], Options& rOptions, sal_Bool bCmdFile)
	throw( IllegalArgument )
{
	sal_Bool 	ret = sal_True;
	sal_uInt16	i=0;
    sal_Bool bLoaderExplicitlyGiven = sal_False;

	rOptions.sProgramName = OUString::createFromAscii(av[i++]);

	if (!bCmdFile)
	{
		bCmdFile = sal_True;

		if (ac < 2)
		{
			usingRegisterImpl();
			ret = sal_False;
		}
	}

	for (; i < ac; i++)
	{
		if (av[i][0] == '-')
		{
			switch (av[i][1])
			{
				case 'r':
					if (strcmp(av[i], "-register") == 0)
					{
						rOptions.bRegister = sal_True;
					} else
					if (strcmp(av[i], "-revoke") == 0)
					{
						rOptions.bRevoke = sal_True;
					} else
					if (av[i][2] == '\0')
					{
						if (i < ac - 1 && av[i+1][0] != '-')
						{
							i++;
							rOptions.sRegName = OStringToOUString(av[i], osl_getThreadTextEncoding());
						} else
						{
							OString tmp("'-r', please check");
							if (i <= ac - 1)
							{
								tmp += " your input '" + OString(av[i+1]) + "'";
							}
							throw IllegalArgument(tmp);
						}
					} else
					{
						rOptions.sRegName = OStringToOUString(av[i]+2, osl_getThreadTextEncoding());
					}
					break;
				case 'b':
					if (av[i][2] != 'r')
					{
						OString tmp("'-b', invalid option!");
						throw IllegalArgument(tmp);
					}
					if (av[i][3] == '\0')
					{
						if (i < ac - 1 && av[i+1][0] != '-')
						{
							i++;
                            OUString regName = OStringToOUString(av[i], osl_getThreadTextEncoding());
                            if( ! rOptions.sBootRegName.getLength() )
                            {
                                rOptions.sBootRegName = regName;
                            }
                            else
                            {
                                rOptions.sBootRegName2 = regName;
                            }
						} else
						{
							OString tmp("'-br', please check");
							if (i <= ac - 1)
							{
								tmp += " your input '" + OString(av[i+1]) + "'";
							}
							throw IllegalArgument(tmp);
						}
					} else
					{
						rOptions.sBootRegName = OStringToOUString(av[i]+3, osl_getThreadTextEncoding());
					}
					break;
				case 'c':
				{
					OUString sUrls;
					if (av[i][2] == '\0')
					{
						if (i < ac - 1 && av[i+1][0] != '-')
						{
							i++;
							sUrls = OStringToOUString(av[i], osl_getThreadTextEncoding());
						} else
						{
							OString tmp("'-c', please check");
							if (i <= ac - 1)
							{
								tmp += " your input '" + OString(av[i+1]) + "'";
							}
							throw IllegalArgument(tmp);
						}
					}
                    else if( 0 == strncmp( av[i] , "-classpath" ,10 ) )
                    {
                        i++;
                        if( i < ac )
                        {
                            rtl::OUString envVar(RTL_CONSTASCII_USTRINGPARAM("CLASSPATH"));
                            rtl::OUString envValue(av[i], strlen(av[i]), osl_getThreadTextEncoding());
                            osl_setEnvironment(envVar.pData, envValue.pData);
                        }
                        break;
                    }
                    else
					{
						sUrls = OStringToOUString(av[i]+2, osl_getThreadTextEncoding());
					}

                    if (rOptions.sComponentUrls.getLength())
					{
						OUString tmp(rOptions.sComponentUrls + OUString(";", 1, osl_getThreadTextEncoding()) + sUrls);
						rOptions.sComponentUrls = tmp;
					} else
					{
						rOptions.sComponentUrls = sUrls;
					}
					break;
				}
				case 'l':
				{
					if (av[i][2] == '\0')
					{
						if (i < ac - 1 && av[i+1][0] != '-')
						{
							i++;
							rOptions.sLoaderName = OUString::createFromAscii(av[i]);
                            bLoaderExplicitlyGiven = sal_True;
						} else
						{
							OString tmp("'-l', please check");
							if (i <= ac - 1)
							{
								tmp += " your input '" + OString(av[i+1]) + "'";
							}
							throw IllegalArgument(tmp);
						}
					} else
					{
                        bLoaderExplicitlyGiven = sal_True;
						rOptions.sLoaderName = OUString::createFromAscii(av[i]+2);
					}
					break;
				}
                case 's':
                {
                    if( av[i][2] == 0 )
                    {
                        rOptions.bSilent = sal_True;
                    }
                    else
                    {
                        rtl::OStringBuffer buf;
                        buf.append( "Unknown error " );
                        buf.append( av[i] );
                        throw IllegalArgument( av[i] );
                    }
                    break;
                }
                case 'e':
                {
                    if( av[i][2] == 'n' && av[i][3] == 'v' && av[i][4] == ':' )
                    {
                        // bootstrap variable, ignore it
                        break;
                    }
                }
                case 'w':
                {
                    if (strcmp(av[i], "-wop") == 0)
					{
						rOptions.bPrefix = sal_True;
                        rOptions.sPrefix = OUString();
                            // in case there are multiple -wops
                        break;
					}
                    else if (
                        strncmp(av[i], "-wop=", RTL_CONSTASCII_LENGTH("-wop="))
                        == 0)
                    {
                        rOptions.bPrefix = sal_True;
                        rOptions.sPrefix = OStringToOUString(
                            av[i] + RTL_CONSTASCII_LENGTH("-wop="),
                            osl_getThreadTextEncoding());
                        break;
                    }
                }
                default:
                {
                    OString tmp( "unknown option " );
                    tmp += av[i];
                    throw IllegalArgument( tmp );
                }
			}
		} else
		{
			if (av[i][0] == '@')
			{
				FILE* cmdFile = fopen(av[i]+1, "r");
		  		if( cmdFile == NULL )
      			{
					usingRegisterImpl();
					ret = sal_False;
				} else
				{
                    fseek( cmdFile , 0 , SEEK_END );
                    sal_Int32 nLen = ftell( cmdFile);
                    fseek( cmdFile, 0, SEEK_SET );

                    // 2 chars per string is a upper limit for the number of
                    // substrings ( at least one separator char needed for fscanf).
					char ** rargv = (char **)rtl_allocateMemory( nLen * sizeof( char* ) /2);
                    if( ! rargv )
                    {
                        OStringBuffer buf;
                        buf.append( "Not enough memory for reading command file " );
                        buf.append( av[i] +1 );
                        buf.append( " with length " );
                        buf.append( nLen );
                        buf.append( "." );
                        throw IllegalArgument( buf.makeStringAndClear() );
                    }
					char *buffer = ( char * )rtl_allocateMemory( nLen +1 );
                    if( ! buffer )
                    {
                        OStringBuffer buf;
                        buf.append( "Not enough memory for reading command file " );
                        buf.append( av[i] +1 );
                        buf.append( " with length " );
                        buf.append( nLen );
                        buf.append( "." );
                        throw IllegalArgument( buf.makeStringAndClear() );
                    }

                    // we start at one to omit argv[0]
                    sal_Int32 rargc = 1;
                    rargv[0] = av[0];
					while ( fscanf(cmdFile, "%s", buffer) != EOF )
					{
						rargv[rargc]= (char * )rtl_allocateMemory( strlen( buffer ) +1 );
                        if( ! rargv[rargc] )
                        {
                            OStringBuffer buf;
                            buf.append( "Not enough memory for reading command file " );
                            buf.append( av[i] +1 );
                            buf.append( " with length " );
                            buf.append( nLen );
                            buf.append( "." );
                            throw IllegalArgument( buf.makeStringAndClear() );
                        }
                        strcpy( rargv[rargc] , buffer ); // #100211# - checked
						rargc++;
					}
					fclose(cmdFile);

					parseOptions(rargc, rargv, rOptions, bCmdFile);

					for (long j=1; j < rargc; j++)
					{
						rtl_freeMemory(rargv[j]);
					}
                    rtl_freeMemory( buffer );
                    rtl_freeMemory( rargv );
				}
			} else
			{
				usingRegisterImpl();
				ret = sal_False;
			}
		}
	}

    if( ! bLoaderExplicitlyGiven )
    {
        if ( rOptions.sComponentUrls.getLength() > 4 &&
             rOptions.sComponentUrls.matchAsciiL(
                 ".jar" , 4 , rOptions.sComponentUrls.getLength() - 4 ) )
        {
            if( ! rOptions.bSilent )
            {
                printf( "using loader com.sun.star.loader.Java2\n" );
            }
            rOptions.sLoaderName = OUString(
                RTL_CONSTASCII_USTRINGPARAM("com.sun.star.loader.Java2"));
        }
        else
        {
            rOptions.sLoaderName = OUString(
                RTL_CONSTASCII_USTRINGPARAM("com.sun.star.loader.SharedLibrary") );
        }
    }

	return ret;
}


struct DoIt
{
	sal_Bool                                _bRegister;
	sal_Bool                                _bRevoke;
    sal_Bool                                _bSilent;
    sal_Bool                                _bPrefix;
    OUString                                _sPrefix;
	OString 	                            _sRegName;
	OUString                                _sLoaderName;
	Reference<XImplementationRegistration2> _xImplRegistration;
	Reference<XSimpleRegistry> 		        _xReg;
	sal_uInt32                            * _exitCode;

	DoIt(sal_Bool bRegister,
		 sal_Bool bRevoke,
         sal_Bool bSilent,
         sal_Bool bPrefix,
         const OUString & sPrefix,
		 const Reference<XSimpleRegistry> & xReg,
		 const OString & sRegName,
		 const Reference<XImplementationRegistration2> & xImplRegistration,
		 const OUString & sLoaderName,
		 sal_uInt32 * exitCode)
		throw();

	void operator()(const OUString & url) throw();
};

DoIt::DoIt(sal_Bool bRegister,
		   sal_Bool bRevoke,
           sal_Bool bSilent,
           sal_Bool bPrefix,
           const OUString & sPrefix,
		   const Reference<XSimpleRegistry> & xReg,
		   const OString & sRegName,
		   const Reference<XImplementationRegistration2> & xImplRegistration,
		   const OUString & sLoaderName,
		   sal_uInt32 * exitCode) throw()
	: _bRegister(bRegister),
	  _bRevoke(bRevoke),
      _bSilent( bSilent ),
      _bPrefix( bPrefix ),
      _sPrefix( sPrefix ),
	  _sRegName(sRegName),
	  _sLoaderName(sLoaderName),
	  _xImplRegistration(xImplRegistration),
	  _xReg(xReg),
	  _exitCode(exitCode)
{}

void DoIt::operator() (const OUString & url) throw()
{
	OString sUrl = OUStringToOString(url, osl_getThreadTextEncoding());

	if (_bRegister)
	{
		try
		{
            Reference<XImplementationRegistration2> _xImplRegistration2(_xImplRegistration, UNO_QUERY);
            if ( _bPrefix ) {
                _xImplRegistration->registerImplementationWithLocation(
                    _sLoaderName, url, replacePrefix(url, _sPrefix), _xReg);
            } else {
                _xImplRegistration->registerImplementation(_sLoaderName, url, _xReg);
            }
                    
            if ( ! _bSilent )
            {
                fprintf(stderr, "register component '%s' in registry '%s' successful!\n", sUrl.getStr(), _sRegName.getStr());
            }

		}
		catch(CannotRegisterImplementationException & cannotRegisterImplementationException) {
			OString aMessage(OUStringToOString(cannotRegisterImplementationException.Message, RTL_TEXTENCODING_ASCII_US));
			fprintf(stderr, "register component '%s' in registry '%s' failed!\n", sUrl.getStr(), _sRegName.getStr());
			fprintf(stderr, "error (CannotRegisterImplementationException): %s\n", aMessage.getStr());

			++ (*_exitCode);
		}
        catch( RuntimeException & e )
        {
			OString aMessage(OUStringToOString(e.Message, RTL_TEXTENCODING_ASCII_US));
			fprintf(stderr, "register component '%s' in registry '%s' failed!\n", sUrl.getStr(), _sRegName.getStr());
			fprintf(stderr, "error (RuntimeException): %s\n", aMessage.getStr());

			++ (*_exitCode);
        }
	}
	else if(_bRevoke)
	{
        try
        {
            sal_Bool bRet = _xImplRegistration->revokeImplementation(url, _xReg);

            if (bRet)
            {
                if ( ! _bSilent )
                    fprintf(stderr, "revoke component '%s' from registry '%s' successful!\n", sUrl.getStr(), _sRegName.getStr());
            }
            else
            {
                fprintf(stderr, "revoke component '%s' from registry '%s' failed!\n", sUrl.getStr(), _sRegName.getStr());
                ++ (*_exitCode);
            }
        }
        catch( RuntimeException & e )
        {
			OString aMessage(OUStringToOString(e.Message, RTL_TEXTENCODING_ASCII_US));
            fprintf( stderr,
                     "revoke component '%s' from registry '%s' failed!\n",
                     sUrl.getStr(),
                     _sRegName.getStr() );
            fprintf( stderr, "RuntimeException: %s\n" , aMessage.getStr());
            ++ (*_exitCode);
        }
	}
}

static bool hasService(
    const Reference< XMultiServiceFactory > &xSMgr,
    const sal_Char * service )
{
    bool ret = false;

    Reference< XContentEnumerationAccess > access( xSMgr, UNO_QUERY );
    if( access.is( ))
    {
        Reference< XEnumeration > enumeration = access->createContentEnumeration(
            OUString::createFromAscii( service ) );

        if( enumeration.is() && enumeration->hasMoreElements() )
        {
            ret = true;
        }
    }
    return ret;
}

static void bootstrap(
    Options & opt ,
    Reference< XMultiServiceFactory > &xSMgr,
    Reference< XSimpleRegistry > & reg ) throw ( Exception )
{
    if( opt.sRegName.equals( opt.sBootRegName2 ) )
    {
        OUString tmp2 = opt.sBootRegName;
        opt.sBootRegName = opt.sBootRegName2;
        opt.sBootRegName2 = tmp2;
    }

	if ( opt.sRegName.equals(opt.sBootRegName) )
    {
        if( opt.sBootRegName2.getLength() )
        {
            xSMgr = createRegistryServiceFactory(
                convertToFileUrl(opt.sRegName),
                convertToFileUrl(opt.sBootRegName2),
                sal_False );
        }
        else
        {
            xSMgr = createRegistryServiceFactory(
                convertToFileUrl(opt.sRegName) , sal_False );
        }
    }
    else
	{
        if( opt.sBootRegName2.getLength() )
        {
            xSMgr = createRegistryServiceFactory(
                convertToFileUrl( opt.sBootRegName2 ),
                convertToFileUrl( opt.sBootRegName ),
                sal_True );
        }
        else if ( opt.sBootRegName.getLength() )
        {
            xSMgr = createRegistryServiceFactory(
                convertToFileUrl( opt.sBootRegName ),
                sal_True );
        }
        else
        {
			xSMgr = createServiceFactory();
        }
		reg = Reference< XSimpleRegistry >(
            xSMgr->createInstance(
                rtl::OUString::createFromAscii("com.sun.star.registry.SimpleRegistry")), UNO_QUERY);

		if (reg.is())
		{
			try
			{
				reg->open( convertToFileUrl(opt.sRegName), sal_False, sal_True);
				if (!reg->isValid())
				{
					fprintf(stderr, "ERROR: open|create registry '%s' failed!\n",
                            OUStringToOString(opt.sRegName, osl_getThreadTextEncoding() ).getStr());
					exit(1);
				}
			}
			catch( InvalidRegistryException & e)
			{
                OString o = OUStringToOString( e.Message , RTL_TEXTENCODING_ASCII_US );
				fprintf(stderr,
                        "ERROR: create registry '%s' failed!\n"
                        "InvalidRegistryException: %s\n",
                         OUStringToOString( opt.sRegName, osl_getThreadTextEncoding()).getStr(),
                        o.getStr() );
				exit(1);
			}
		}
	}

    if( ! opt.sLoaderName.compareToAscii( "com.sun.star.loader.Java2" ) &&
        ! hasService( xSMgr, "com.sun.star.loader.Java2" ) )
    {
        // we know our java loader, so we check, whether a java-loader is
        // registered
        Reference< XInterface > r = loadSharedLibComponentFactory(
            OUString::createFromAscii( "javavm.uno" SAL_DLLEXTENSION ),
            OUString(),
            OUString::createFromAscii( "com.sun.star.comp.stoc.JavaVirtualMachine" ),
            xSMgr,
            Reference< XRegistryKey > () );
        Reference< XInterface > r2 = loadSharedLibComponentFactory(
            OUString::createFromAscii( "javaloader.uno" SAL_DLLEXTENSION ),
            OUString(),
            OUString::createFromAscii(( "com.sun.star.comp.stoc.JavaComponentLoader" ) ),
            xSMgr,
            Reference< XRegistryKey > () );
        Reference <XSet> xSet( xSMgr, UNO_QUERY );
        if( r.is() && r2.is() && xSet.is() )
        {
            xSet->insert( makeAny( r ) );
            xSet->insert( makeAny( r2 ) );
        }
    }
}

SAL_IMPLEMENT_MAIN_WITH_ARGS(argc, argv)
{
	sal_Bool 	bRet = sal_False;
	sal_uInt32 	exitCode = 0;
	Options	 	aOptions;

	try
	{
		if ( !parseOptions(argc, argv, aOptions, sal_False) )
		{
			exit(1);
		}
	}
	catch ( IllegalArgument& e)
	{
		fprintf(stderr, "ERROR: %s\n", e.m_message.getStr());
		exit(1);
	}

    if( ! aOptions.sRegName.getLength() )
    {
        fprintf( stderr, "ERROR: target registry missing (-r option)\n" );
        exit( 1 );
    }
	if ( aOptions.sComponentUrls.getLength() == 0 )
	{
		fprintf(stderr, "ERROR: no component url is specified!\n");
		exit(1);
	}

	Reference< XMultiServiceFactory >	xSMgr;
	Reference< XSimpleRegistry > 		xReg;
	try
	{
        bootstrap( aOptions, xSMgr ,xReg );
	}
	catch( Exception& e )
	{
		fprintf(stderr, "ERROR: create ServiceManager failed!\n");
		if ( e.Message.getLength() )
		{
			fprintf(stderr, "ERROR description: %s\n",
                    OUStringToOString(e.Message, osl_getThreadTextEncoding()).getStr());
		}
		exit(1);
	}

	Reference<XImplementationRegistration2> xImplRegistration(
        xSMgr->createInstance(
            OUString(RTL_CONSTASCII_USTRINGPARAM(
                         "com.sun.star.registry.ImplementationRegistration"))),
        UNO_QUERY);

	if (xImplRegistration.is())
	{
		sal_Int32 index = 0;
		vector<OUString> urls;

		OUString urlListWithSemikolon = aOptions.sComponentUrls;
        do {
            OUString aToken = urlListWithSemikolon.getToken( 0, ';', index);
            fprintf(stderr, "%s\n", OUStringToOString(aToken, osl_getThreadTextEncoding()).getStr());
            urls.push_back(aToken);
        } while ( index >= 0 );

        
        OString sRegName = OUStringToOString( aOptions.sRegName, osl_getThreadTextEncoding() );
		if(aOptions.bRegister || aOptions.bRevoke)
        {
			for_each(urls.begin(), urls.end(),
                     DoIt(aOptions.bRegister, aOptions.bRevoke, aOptions.bSilent,
                          aOptions.bPrefix, aOptions.sPrefix,
                          xReg, sRegName, xImplRegistration,
                          aOptions.sLoaderName, &exitCode));
		}
		else
		{
			++ exitCode;
			 usingRegisterImpl();
		}
	}
	else
	{
		fprintf(stderr, "Component registration service could not be loaded!\n");
		exitCode++;
	}

	if (!bRet && xReg.is() && xReg->isValid())
		xReg->close();

	Reference< XComponent > xComponent( xSMgr, UNO_QUERY );
	if ( xComponent.is() )
		xComponent->dispose();

	return exitCode;
}