Main Page | Namespace List | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals | Related Pages

argv.c

Go to the documentation of this file.
00001 /*!
00002  * @file argv.c
00003  *
00004  * @brief Process command line arguments passed in to JVM program.
00005  *
00006  * Read @link #jvm() command line parameters@endlink from,
00007  * @code main(int argc, char **argv, char **envp) @endcode
00008  *
00009  * These parameters typically are passed from the
00010  * @link #main() actual 'C' program entry point@endlink.
00011  * Process these parameters and use a subset to construct the Java
00012  * command line parameters to pass in to the main Java entry point,
00013  * @code public static void main(String[] args) @endcode
00014  *
00015  * Part of this process is to read environment settings for
00016  * @b JAVA_HOME, @b CLASSPATH, and @b BOOTCLASSPATH, which may be
00017  * overridden from the command line.
00018  *
00019  * The HEAP_INIT() function must have been called before using
00020  * these functions so the environment variables can be stored
00021  * into it and not depend on the argument or environment pointers
00022  * to always be unchanged.
00023  *
00024  * The tmparea_init() function must have been called before these
00025  * functions so the internal @b CLASSPATH can be set up properly.
00026  *
00027  *
00028  * @section Control
00029  *
00030  * \$URL: https://svn.apache.org/path/name/argv.c $ \$Id: argv.c 0 09/28/2005 dlydick $
00031  *
00032  * Copyright 2005 The Apache Software Foundation
00033  * or its licensors, as applicable.
00034  *
00035  * Licensed under the Apache License, Version 2.0 ("the License");
00036  * you may not use this file except in compliance with the License.
00037  * You may obtain a copy of the License at
00038  *
00039  *     http://www.apache.org/licenses/LICENSE-2.0
00040  *
00041  * Unless required by applicable law or agreed to in writing,
00042  * software distributed under the License is distributed on an
00043  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
00044  * either express or implied.
00045  *
00046  * See the License for the specific language governing permissions
00047  * and limitations under the License.
00048  *
00049  * @version \$LastChangedRevision: 0 $
00050  *
00051  * @date \$LastChangedDate: 09/28/2005 $
00052  *
00053  * @author \$LastChangedBy: dlydick $
00054  *         Original code contributed by Daniel Lydick on 09/28/2005.
00055  *
00056  * @section Reference
00057  *
00058  */
00059 
00060 #include "arch.h"
00061 ARCH_COPYRIGHT_APACHE(argv, c ,"$URL: https://svn.apache.org/path/name/argv.c $ $Id: argv.c 0 09/28/2005 dlydick $");
00062 
00063 
00064 #include <stdlib.h>
00065 #include <string.h>
00066 
00067 #include "jvmcfg.h" 
00068 #include "classfile.h" 
00069 #include "classpath.h" 
00070 #include "exit.h" 
00071 #include "heap.h" 
00072 #include "jvm.h" 
00073 #include "util.h" 
00074 
00075 
00076 /*!
00077  * @brief Parse command line
00078  *
00079  * Retrieve parameters from the program entry point
00080  * @code main(int argc, char **argv, char **envp) @endcode
00081  * and parse them into internal form.  Since this program
00082  * is delivered primarily as a library, these will have
00083  * to be reported as parameters to
00084  * @link jvm(int argc, char **argv, char **envp)@endlink
00085  * from the invoking program.
00086  *
00087  * The syntax for the command line is:
00088  *
00089  * @code
00090  * main_pgm_name [{-Xjh    | -Xjavahome | -Xjava_home}  dir_name]
00091  *               [{-cp     | -classpath}                dir_name]
00092  *               [{-Xbcp   | -Xbootclasspath}           dir_name]
00093  *               [{-Xdebug | -Xdebuglevel | -Xdebug_level} level]
00094  *
00095  *               [-jar any/path/name/jarfilename]
00096  *               start.class.name
00097  *
00098  *               [java_arg1 [java_arg2 [...]]]
00099  *
00100  *
00101  * main_pgm_name -show
00102  *               -version
00103  *               -copyright
00104  *               -help
00105  * @endcode
00106  *
00107  * If more than one '-<token>' or '-X<token>' option entry is
00108  * found on the command line for a given token type, the last one
00109  * wins If one of these tokens is the last parameter on a command
00110  * line, it is ignored.  After the option entries are reviewed, the
00111  * starting class name is specified, preceded by an optional '-jar'
00112  * modifier which, if present, indicates that the specified jar file
00113  * should be read to locate the starting class.  Any parameters after
00114  * the starting class name are passed to the JVM as '(String) args[]'.
00115  *
00116  *
00117  * @param argc    Number of arguments on command line
00118  * @param argv    Argument vector from the command line
00119  * @param envp    Environment pointer from command line environ
00120  *
00121  * @returns @link #rvoid rvoid@endlink
00122  */
00123 rvoid argv_init(int argc, char **argv, char **envp)
00124 {
00125     rchar *chkjh;  chkjh =  (rchar *) rnull;
00126     rchar *chkcp;  chkcp =  (rchar *) rnull;
00127     rchar *chkbcp; chkbcp = (rchar *) rnull;
00128 
00129     pjvm->startjar   = (rchar *) rnull;
00130     pjvm->startclass = (rchar *) rnull;
00131 
00132     /* Save off startup parameters, incl. pgm name (argv0) */
00133     pjvm->argc = argc;
00134     pjvm->argv = argv;
00135     pjvm->envp = envp;
00136 
00137     /* Extract program name from path, defaulting to whole invocation */
00138     pjvm->argv0 = argv[0];
00139     pjvm->argv0name = strrchr(pjvm->argv0,
00140                               JVMCFG_PATHNAME_DELIMITER_CHAR);
00141     if (rnull != pjvm->argv0name)
00142     {
00143         pjvm->argv0name++;
00144     }
00145     else
00146     {
00147         pjvm->argv0name = pjvm->argv0;
00148     }
00149 
00150     /*
00151      * Initially extract @b JAVA_HOME, @b CLASSPATH, and
00152      * @p @b BOOTCLASSPATH from environment (could do this with
00153      * @b envp, but @c @b getenv(3) is easier).
00154      */
00155     chkjh  = getenv(JVMCFG_ENVIRONMENT_VARIABLE_JAVA_HOME);
00156     chkcp  = getenv(JVMCFG_ENVIRONMENT_VARIABLE_CLASSPATH);
00157     chkbcp = getenv(JVMCFG_ENVIRONMENT_VARIABLE_BOOTCLASSPATH);
00158 
00159     /*
00160      * Look in command line, scan WHOLE command line for
00161      * '-X<clspthtoken> classpath', last entry wins.
00162      * Ignore trailing token without a following parameter.
00163      */
00164     rint  i;
00165     rint show_flag = rfalse;
00166 
00167     for (i = 1; i < argc; i++)
00168     {
00169         /*
00170          * Options that terminate program execution
00171          */
00172         if (0 == strcmp(JVMCFG_COMMAND_LINE_HELP_PARM, argv[i]))
00173         {
00174             argv_helpmsg();
00175             exit_jvm(EXIT_ARGV_HELP);
00176 /*NOTREACHED*/
00177         }
00178         else
00179         if (0 == strcmp(JVMCFG_COMMAND_LINE_LICENSE_PARM, argv[i]))
00180         {
00181             argv_licensemsg();
00182             exit_jvm(EXIT_ARGV_LICENSE);
00183 /*NOTREACHED*/
00184         }
00185         else
00186         if (0 == strcmp(JVMCFG_COMMAND_LINE_VERSION_PARM, argv[i]))
00187         {
00188             argv_versionmsg();
00189             exit_jvm(EXIT_ARGV_VERSION);
00190 /*NOTREACHED*/
00191         }
00192         else
00193         if (0 == strcmp(JVMCFG_COMMAND_LINE_COPYRIGHT_PARM, argv[i]))
00194         {
00195             argv_copyrightmsg();
00196             exit_jvm(EXIT_ARGV_COPYRIGHT);
00197 /*NOTREACHED*/
00198         }
00199         else
00200         /*
00201          * Reporting options
00202          */
00203         if (0 == strcmp(JVMCFG_COMMAND_LINE_SHOW_PARM, argv[i]))
00204         {
00205             /* Display command line parms after parsing */
00206             show_flag = rtrue;
00207             continue;
00208         }
00209         else
00210         /*
00211          * Options that affect program execution,
00212          * not including JVM arguments (below).
00213          */
00214         if ((0 == strcmp(JVMCFG_JAVA_HOME_ABBREV_PARM, argv[i])) ||
00215             (0 == strcmp(JVMCFG_JAVA_HOME_MID_PARM,    argv[i])) ||
00216             (0 == strcmp(JVMCFG_JAVA_HOME_FULL_PARM,   argv[i])))
00217         {
00218             if (argc - 1 > i)
00219             {
00220                 chkjh = argv[i + 1];
00221                 i++;
00222             }
00223         }
00224         else
00225         if ((0 == strcmp(JVMCFG_CLASSPATH_ABBREV_PARM, argv[i])) ||
00226             (0 == strcmp(JVMCFG_CLASSPATH_FULL_PARM, argv[i])))
00227         {
00228             if (argc - 1 > i)
00229             {
00230                 chkcp = argv[i + 1];
00231                 i++;
00232             }
00233         }
00234         else
00235         if ((0 == strcmp(JVMCFG_BOOTCLASSPATH_ABBREV_PARM, argv[i])) ||
00236             (0 == strcmp(JVMCFG_BOOTCLASSPATH_FULL_PARM, argv[i])))
00237         {
00238             if (argc - 1 > i)
00239             {
00240                 chkbcp = argv[i + 1];
00241                 i++;
00242             }
00243         }
00244         else
00245         if ((0 == strcmp(JVMCFG_DEBUGMSGLEVEL_ABBREV_PARM, argv[i])) ||
00246             (0 == strcmp(JVMCFG_DEBUGMSGLEVEL_MID_PARM,    argv[i])) ||
00247             (0 == strcmp(JVMCFG_DEBUGMSGLEVEL_FULL_PARM,   argv[i])))
00248         {
00249             if (argc - 1 > i)
00250             {
00251                 rint chkdml = atol(argv[i + 1]);
00252 
00253                 if ((DMLOFF == chkdml) ||
00254                     ((DMLMIN <= chkdml) && (DMLMAX >= chkdml)))
00255                 {
00256                     jvmutil_set_dml(chkdml);
00257 
00258                  /* sysDbgMsg(DMLMIN, */
00259                     sysErrMsg("argv_init",
00260                               "debug message level %d",
00261                               chkdml);
00262                 }
00263                 else
00264                 {
00265                     sysErrMsg("argv_init",
00266                            "invalid debug message level %d.  Ignored",
00267                               chkdml);
00268                 }
00269 
00270                 i++;
00271             }
00272         }
00273         else
00274         /*
00275          * Java class to run (terminates option scanning),
00276          * either JAR or class file.
00277          */
00278         if (0 == strcmp(JVMCFG_JARFILE_STARTCLASS_PARM, argv[i]))
00279         {
00280             if (argc - 1 > i)
00281             {
00282                 pjvm->startjar = argv[i + 1];
00283                 i++;
00284                 i++;
00285             }
00286 
00287             break; /* End of token parsing.  Quit for() loop */
00288         }
00289         else
00290         {
00291             /* If not a -xxxxx token, it must be the startup class */
00292             pjvm->startclass = argv[i];
00293             i++;
00294 
00295             break; /* End of token parsing.  Quit for() loop */
00296         }
00297 
00298     } /* for i */
00299 
00300     /*
00301      * Now get JVM Java @c @b args[] list from rest
00302      * of @b argv parms
00303      */
00304 
00305     /* Add 1 NUL byte at the end, initialize to zeroes (NUL) */
00306     pjvm->argcj = 0;
00307     pjvm->argvj = HEAP_GET_DATA(sizeof(rchar *) * ( 1 + argc - i),
00308                                 rtrue);
00309 
00310     /*
00311      * If any @b argv parms left, load them into
00312      * @c @b pjvm->argvj
00313      */
00314     if (i < argc)
00315     {
00316         /*
00317          * Keep scanning @c @b argv[] , only initialization
00318          * for @c @b pjvm->argvj
00319          */
00320 
00321         /* @warning  NON-STANDARD TERMINATION CONDITION <= VERSUS < */
00322         rint j;
00323         for (j = 0; i <= argc; i++, j++)
00324         {
00325             /* Done when all @b argv is scanned and NUL byte added */
00326             if (i == argc)
00327             {
00328                 pjvm->argvj[j] = (rchar *) rnull;
00329                 break;
00330             }
00331 
00332             pjvm->argcj++;
00333             pjvm->argvj[j] = argv[i];
00334         }
00335     }
00336 
00337     /* Try to get a valid @b JAVA_HOME even if not found elsewhere */
00338     chkjh = (rchar *) ((rnull == chkjh)
00339                        ? JVMCFG_JAVA_HOME_DEFAULT
00340                        : chkjh);
00341 
00342     pjvm->java_home = (rchar *) rnull;
00343     if (rnull != chkjh)
00344     {
00345         /* Copy '\0' byte also*/
00346         pjvm->java_home = HEAP_GET_DATA(sizeof(rchar) + strlen(chkjh),
00347                                         rfalse);
00348 
00349         memcpy(pjvm->java_home, chkjh, sizeof(rchar) + strlen(chkjh));
00350     }
00351 
00352     /* Try to get a valid @b CLASSPATH even if not found elsewhere */
00353     chkcp = (rchar *) ((rnull == chkcp)
00354                          ? JVMCFG_CLASSPATH_DEFAULT
00355                          : (const rchar *) chkcp);
00356 
00357     pjvm->classpath = (rchar *) rnull;
00358     if (rnull != chkcp)
00359     {
00360         /* Copy '\0' byte also */
00361         pjvm->classpath = HEAP_GET_DATA(sizeof(rchar) + strlen(chkcp),
00362                                         rfalse);
00363 
00364         memcpy(pjvm->classpath, chkcp, sizeof(rchar) + strlen(chkcp));
00365     }
00366 #ifdef JVMCFG_HARDCODED_TEST_CLASSPATH
00367     pjvm->classpath = JVMCFG_HARDCODED_TEST_CLASSPATH;
00368 #endif
00369 
00370     /* Try to get a valid @b BOOTCLASSPATH even if not found elsewhere*/
00371     chkbcp = (rchar *) ((rnull == chkbcp)
00372                           ?
00373 #ifdef CONFIG_HACKED_BOOTCLASSPATH
00374                             JVMCFG_CLASSPATH_DEFAULT
00375 #else
00376                             JVMCFG_BOOTCLASSPATH_DEFAULT
00377 #endif
00378                           : (const rchar *) chkbcp);
00379 
00380     pjvm->bootclasspath = (rchar *) rnull;
00381     if (rnull != chkbcp)
00382     {
00383         /* Copy '\0' byte also */
00384         pjvm->bootclasspath = HEAP_GET_DATA(sizeof(rchar) +
00385                                                 strlen(chkbcp),
00386                                             rfalse);
00387 
00388         memcpy(pjvm->bootclasspath,
00389                chkbcp,
00390                sizeof(rchar) + strlen(chkbcp));
00391     }
00392 
00393     /* Show summary of what command line resoved into */
00394     if (rtrue == show_flag)
00395     {
00396         argv_showmsg();
00397     }
00398 
00399     /* Display copyright msg and finish */
00400     argv_copyrightmsg();
00401 
00402     /* Declare this module initialized */
00403     jvm_argv_initialized = rtrue;
00404 
00405     return;
00406 
00407 } /* END of argv_init() */
00408 
00409 
00410 /*!
00411  * @brief Show program version message to standard output.
00412  *
00413  *
00414  * @b Parameters: @link #rvoid rvoid@endlink
00415  *
00416  *
00417  *       @returns @link #rvoid rvoid@endlink
00418  *
00419  */
00420 rvoid argv_versionmsg(rvoid)
00421 {
00422     fprintfLocalStdout("%s\n", CONFIG_RELEASE_LEVEL);
00423 
00424     return;
00425 
00426 } /* END of argv_versionmsg() */
00427 
00428 
00429 /*!
00430  * @brief Show program copyright message to standard output.
00431  *
00432  *
00433  * @b Parameters: @link #rvoid rvoid@endlink
00434  *
00435  *
00436  *       @returns @link #rvoid rvoid@endlink
00437  *
00438  */
00439 rvoid argv_copyrightmsg(rvoid)
00440 {
00441     fprintfLocalStdout("\n%s:  %s, version %s\n%s\n\n",
00442                        CONFIG_PROGRAM_NAME,
00443                        CONFIG_PROGRAM_DESCRIPTION,
00444                        CONFIG_RELEASE_LEVEL,
00445                        ARCH_COPYRIGHT_TEXT_APACHE);
00446 
00447     return;
00448 
00449 } /* END of argv_copyrightmsg() */
00450 
00451 
00452 /*!
00453  * @brief Show program software license message to standard output.
00454  *
00455  *
00456  * @b Parameters: @link #rvoid rvoid@endlink
00457  *
00458  *
00459  *       @returns @link #rvoid rvoid@endlink
00460  *
00461  */
00462 rvoid argv_licensemsg(rvoid)
00463 {
00464     argv_copyrightmsg();
00465     fprintfLocalStdout("%s\n\n", ARCH_LICENSE_TEXT_APACHE);
00466 
00467     return;
00468 
00469 } /* END of argv_licensemsg() */
00470 
00471 
00472 #define LEADING_SPACES "                  "
00473 
00474 /*!
00475  * @brief Show program syntax and usage message to standard output.
00476  *
00477  *
00478  * @b Parameters: @link #rvoid rvoid@endlink
00479  *
00480  *
00481  *       @returns @link #rvoid rvoid@endlink
00482  *
00483  */
00484 rvoid argv_helpmsg(rvoid)
00485 {
00486     argv_copyrightmsg();
00487 
00488     fprintfLocalStdout(
00489 "%s:  version %s\n\n",
00490                        pjvm->argv0name,
00491                        CONFIG_RELEASE_LEVEL);
00492     fprintfLocalStdout(
00493 "Invoke a class: %s: [options] start.class.name [args]\n",
00494                        pjvm->argv0name);
00495     fprintfLocalStdout(
00496 "Invoke a jar:   %s: [options] -jar filename    [args]\n\n",
00497                        pjvm->argv0name);
00498 
00499     fprintfLocalStdout(
00500 "Where:\n");
00501 
00502     fprintfLocalStdout(
00503 "    %s filename %s",
00504                        JVMCFG_JARFILE_STARTCLASS_PARM,
00505             "Invoke class from JAR file whose main() appears in the\n");
00506     fprintfLocalStdout(
00507 "%senclosed '%s' file on the '%s'\n",
00508                        LEADING_SPACES,
00509                        JVMCFG_JARFILE_MANIFEST_FILENAME,
00510                        JVMCFG_JARFILE_MANIFEST_MAIN_CLASS);
00511     fprintfLocalStdout(
00512 "%sattribute line.  This name may not cause the line to be\n",
00513                        LEADING_SPACES);
00514     fprintfLocalStdout(
00515 "%smore than %d characters wide.  Line continuations are\n",
00516                        LEADING_SPACES,
00517                        JVMCFG_JARFILE_MANIFEST_LINE_MAX);
00518     fprintfLocalStdout(
00519 "%snot supported for locating this class name.\n\n",
00520                        LEADING_SPACES);
00521 
00522     fprintfLocalStdout("    %s         %s",
00523                        JVMCFG_COMMAND_LINE_SHOW_PARM,
00524    "Show how command line and environment resolves after parsing.\n");
00525     fprintfLocalStdout("    %s      %s",
00526                        JVMCFG_COMMAND_LINE_VERSION_PARM,
00527    "Display the program release level.\n");
00528 
00529     fprintfLocalStdout("    %s    %s",
00530                        JVMCFG_COMMAND_LINE_COPYRIGHT_PARM,
00531    "Display the program copyright.\n");
00532 
00533     fprintfLocalStdout("    %s      %s",
00534                        JVMCFG_COMMAND_LINE_LICENSE_PARM,
00535    "Display the program software license.\n");
00536 
00537     fprintfLocalStdout("    %s         %s",
00538                        JVMCFG_COMMAND_LINE_HELP_PARM,
00539    "Display this help message.\n\n");
00540 
00541 
00542     fprintfLocalStdout("    %s pathname\n", JVMCFG_JAVA_HOME_FULL_PARM);
00543     fprintfLocalStdout("    %s  pathname\n", JVMCFG_JAVA_HOME_MID_PARM);
00544     fprintfLocalStdout(
00545 "    %s        pathname\n",
00546                        JVMCFG_JAVA_HOME_ABBREV_PARM);
00547     fprintfLocalStdout(
00548 "%sOverride JAVA_HOME environment variable, if any.\n",
00549                        LEADING_SPACES);
00550     fprintfLocalStdout(
00551 "%sIf none found, this option @e must be present.\n",
00552                        LEADING_SPACES);
00553     fprintfLocalStdout(
00554 "%sIt points to the Java home directory for this invocation.\n\n",
00555                        LEADING_SPACES);
00556 
00557     fprintfLocalStdout(
00558 "    %s path1%cpath2%c...pathN\n",
00559                        JVMCFG_CLASSPATH_FULL_PARM,
00560                        CLASSPATH_ITEM_DELIMITER_CHAR,
00561                        CLASSPATH_ITEM_DELIMITER_CHAR);
00562     fprintfLocalStdout(
00563 "    %s        path1%cpath2%c...pathN\n",
00564                        JVMCFG_CLASSPATH_ABBREV_PARM,
00565                        CLASSPATH_ITEM_DELIMITER_CHAR,
00566                        CLASSPATH_ITEM_DELIMITER_CHAR);
00567     fprintfLocalStdout(
00568 "%sOverride CLASSPATH environment variable, if any.\n",
00569                        LEADING_SPACES);
00570     fprintfLocalStdout(
00571 "%sIf none found, this option @e must be present.\n",
00572                        LEADING_SPACES);
00573     fprintfLocalStdout(
00574 "%sContains a search paths of directories and/or jar files.\n",
00575                        LEADING_SPACES);
00576     fprintfLocalStdout(
00577 "%sto use for locating classfiles.  Each entry is\n",
00578                        LEADING_SPACES);
00579     fprintfLocalStdout(
00580 "%san /absolute/path/name and is separated by a '%c' character.\n\n",
00581                        LEADING_SPACES,
00582                        CLASSPATH_ITEM_DELIMITER_CHAR);
00583 
00584     fprintfLocalStdout(
00585 "    %s path1%cpath2%c...pathN\n",
00586                        JVMCFG_BOOTCLASSPATH_FULL_PARM,
00587                        CLASSPATH_ITEM_DELIMITER_CHAR,
00588                        CLASSPATH_ITEM_DELIMITER_CHAR);
00589     fprintfLocalStdout(
00590 "    %s           path1%cpath2%c...pathN\n",
00591                        JVMCFG_BOOTCLASSPATH_ABBREV_PARM,
00592                        CLASSPATH_ITEM_DELIMITER_CHAR,
00593                        CLASSPATH_ITEM_DELIMITER_CHAR);
00594     fprintfLocalStdout(
00595 "%sOverride BOOTCLASSPATH environment variable, if any.\n",
00596                        LEADING_SPACES);
00597     fprintfLocalStdout(
00598 "%sPerforms similar function to CLASSPATH, but used for\n",
00599                        LEADING_SPACES);
00600     fprintfLocalStdout("%ssystem startup purposes.\n\n",
00601                        LEADING_SPACES);
00602     fprintfLocalStdout(
00603 "    args          Optional arguments to pass to JVM, if any.\n\n");
00604 
00605 
00606     return;
00607 
00608 } /* END of argv_helpmsg() */
00609 
00610 
00611 /*!
00612  * @brief Show resolution of command line to standard output.
00613  *
00614  *
00615  * @b Parameters: @link #rvoid rvoid@endlink
00616  *
00617  *
00618  *       @returns @link #rvoid rvoid@endlink
00619  *
00620  */
00621 rvoid argv_showmsg(rvoid)
00622 {
00623     fprintfLocalStdout("JAVA_HOME=%s\n", pjvm->java_home);
00624 
00625     fprintfLocalStdout("CLASSPATH=%s\n", pjvm->classpath);
00626 
00627     fprintfLocalStdout("BOOTCLASSPATH=%s\n", pjvm->bootclasspath);
00628 
00629     if (rnull != pjvm->startjar)
00630     {
00631         fprintfLocalStdout("entry=%s\n", pjvm->startjar);
00632     }
00633     else
00634     if (rnull != pjvm->startclass)
00635     {
00636         fprintfLocalStdout("entry=%s\n", pjvm->startclass);
00637     }
00638     else
00639     {
00640         fprintfLocalStdout("entry=UNKNOWN\n");
00641     }
00642 
00643     rint argc;
00644     for (argc = 0; rnull != pjvm->argvj[argc]; argc++)
00645     {
00646         ; /* Simply count number of args, terminated by rnull slot */
00647     }
00648 
00649     fprintfLocalStdout("argc=%d\n", argc);
00650 
00651     fprintfLocalStdout("args=");
00652 
00653     rint i;
00654     for (i = 0; i < argc; i++)
00655     {
00656         fprintfLocalStdout("%s ", pjvm->argvj[i]);
00657 
00658     }
00659     
00660     fprintfLocalStdout("\n\n");
00661 
00662 
00663     return;
00664 
00665 } /* END of argv_showmsg() */
00666 
00667 
00668 /*!
00669  * @brief Clean up from argv[] setup after JVM execution.
00670  *
00671  *
00672  * @b Parameters: @link #rvoid rvoid@endlink
00673  *
00674  *
00675  *       @returns @link #rvoid rvoid@endlink
00676  *
00677  */
00678 rvoid argv_shutdown(rvoid)
00679 {
00680     HEAP_FREE_DATA(pjvm->bootclasspath);
00681     pjvm->bootclasspath = (rchar *) rnull;
00682 
00683     HEAP_FREE_DATA(pjvm->classpath);
00684     pjvm->classpath = (rchar *) rnull;
00685 
00686     HEAP_FREE_DATA(pjvm->java_home);
00687     pjvm->java_home = (rchar *) rnull;
00688 
00689     rint argidx;
00690     for (argidx = 0; argidx < pjvm->argcj; argidx++)
00691     {
00692         HEAP_FREE_DATA(pjvm->argvj[argidx]);
00693     }
00694     HEAP_FREE_DATA(pjvm->argvj);
00695     pjvm->argvj = (char **) rnull;
00696 
00697     /* Declare this module uninitialized */
00698     jvm_argv_initialized = rfalse;
00699 
00700     return;
00701 
00702 } /* END of argv_shutdown() */
00703 
00704 
00705 /* EOF */
00706 

Generated on Fri Sep 30 18:48:58 2005 by  doxygen 1.4.4