Copyright 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Please report bugs at http://www.gnu.org/software/classpath/bugs.html

GNU Classpath GIOP persitent naming service.
  usage: NameServicePersistent <options>

 where <options> includes:
* -org.omg.CORBA.ORBInitialPort NNN
 or -ORBInitialPort NNN          - specifies the port, on that the 
                                   service must be started. If this key
                                   is not specified, the service starts
                                   at the port 900.
   
* -ior FILE_NAME                - store the IOR reference to this naming 
                                  service to the specified file. The
                                  IOR reference contains enough 
                                  information to locate the service
                                  on the web.
* - folder FOLDER               - store the persistent information
                                  to the given folder
* - reset                       - discard any previously stored
                                  persistent information (cold start)                                          



