Java

/*
 * Copyright (c) 1987, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int    opterr = 1,        /* if error message should be printed */
       optind = 1,        /* index into parent argv vector */
       optopt,            /* character checked for validity */
       optreset;          /* reset getopt */
char    *optarg;          /* argument associated with option */

#define    BADCH    (int)'?'
#define    BADARG    (int)':'
#define    EMSG    ""

/*
 * getopt --
 *    Parse argc/argv argument vector.
 */
int
getopt(nargc, nargv, ostr)
    int nargc;
    char * const nargv[];
    const char *ostr;
{
    static char *place = EMSG;            /* option letter processing */
    char *oli;                            /* option letter list index */

    if (optreset || *place == 0) {        /* update scanning pointer */
        optreset = 0;
        place = nargv[optind];
        if (optind >= nargc || *place++ != '-') {
            /* Argument is absent or is not an option */
            place = EMSG;
            return (-1);
        }
        optopt = *place++;
        if (optopt == '-' && *place == 0) {
            /* "--" => end of options */
            ++optind;
            place = EMSG;
            return (-1);
        }
        if (optopt == 0) {
            /* Solitary '-', treat as a '-' option
               if the program (eg su) is looking for it. */
            place = EMSG;
            if (strchr(ostr, '-') == NULL)
                return (-1);
            optopt = '-';
        }
    } else
        optopt = *place++;

    /* See if option letter is one the caller wanted... */
    if (optopt == ':' || (oli = strchr(ostr, optopt)) == NULL) {
        if (*place == 0)
            ++optind;
        if (opterr && *ostr != ':')
            (void)fprintf(stderr,
                "%s: illegal option -- %c\n", _getprogname(),
                optopt);
        return (BADCH);
    }

    /* Does this option need an argument? */
    if (oli[1] != ':') {
        /* don't need argument */
        optarg = NULL;
        if (*place == 0)
            ++optind;
    } else {
        /* Option-argument is either the rest of this argument or the
           entire next argument. */
        if (*place)
            optarg = place;
        else if (nargc > ++optind)
            optarg = nargv[optind];
        else {
            /* option-argument absent */
            place = EMSG;
            if (*ostr == ':')
                return (BADARG);
            if (opterr)
                (void)fprintf(stderr,
                    "%s: option requires an argument -- %c\n",
                    _getprogname(), optopt);
            return (BADCH);
        }
        place = EMSG;
        ++optind;
    }
    return (optopt);            /* return option letter */
}

//
//  getopt.js    Finnbarr P. Murphy March 2010
//
//  Based on BSD getopt.c  Use subject to BSD license.
//
//  For details of how to use this function refer to
//  the BSD man page for getopt(3). GNU-style long
//  options are not supported.
//

var opterr = 1;                          // print error message
var optind = 0;                          // index into parent argv array
var optopt = "";                         // character checked for validity
var optreset = 0;                        // reset getopt
var optarg = "";                         // option argument

function getopt(nargv, ostr)
{
    if ( typeof getopt.place == 'undefined' ) {
        getopt.place =  "";              // static string, option letter processing
        getopt.iplace = 0;               // index into string
    }

    var oli;                             // option letter list index

    if (optreset > 0 || getopt.iplace == getopt.place.length) {
        optreset = 0;
        getopt.place = nargv[optind]; getopt.iplace = 0;
        if (optind >= nargv.length || getopt.place.charAt(getopt.iplace++) != "-") {
            // argument is absent or is not an option
            getopt.place = ""; getopt.iplace = 0;
            return("");
        }
        optopt = getopt.place.charAt(getopt.iplace++);
        if (optopt == '-' && getopt.iplace == getopt.place.length) {
            // "--" => end of options
            ++optind;
            getopt.getopt.place = ""; getopt.getopt.iplace = 0;
            return("");
        }
        if (optopt == 0) {
            // Solitary '-', treat as a '-' option
            getopt.place = ""; getopt.iplace = 0;
            if (ostr.indexOf('-') == -1)
                return("");
            optopt = '-';
        }
    } else
         optopt = getopt.place.charAt(getopt.iplace++);

    // see if option letter is what is wanted
    if (optopt == ':' || (oli = ostr.indexOf(optopt)) == -1) {
        if (getopt.iplace == getopt.place.length)
            ++optind;
        if (opterr && ostr.charAt(0) != ':')
            print("illegal option -- " + optopt);
        return ('?');
    }

    // does this option require an argument?
    if (ostr.charAt(oli + 1) != ':') {
         // does not need argument
         optarg = null;
         if (getopt.iplace == getopt.place.length)
             ++optind;
    } else {
       //  Option-argument is either the rest of this argument or the entire next argument.
       if (getopt.iplace < getopt.place.length) {
            optarg = getopt.place.substr(getopt.iplace);
       } else if (nargv.length > ++optind) {
            optarg = nargv[optind];
       } else {
            // option argument absent
            getopt.place = ""; getopt.iplace = 0;
            if (ostr.charAt(0) == ':') {
                 return (':');
           }
            if (opterr)
                 print("option requires an argument -- " + optopt);
            return('?');
        }
        getopt.place = ""; getopt.iplace = 0;
        ++optind;
    }

    return (optopt);
}

$ cat test.js
#!/bin/js

load("getopt.js");

var opt;

while ((opt = getopt(arguments, "ghf:v")) != '') {
    switch (opt) {
       case 'f':
           print("f option found. Argument is: " + optarg);
           break;
       case 'g':
           print("g option found");
           break;
       case 'h':
           print("usage: " + environment["_"] + " [-f filename] [-g] [-v]");
           quit(0);
       case 'v':
           print("v option found");
           break;
       case ':':
           print("Error - Option needs a value: " + optopt);
           quit(1);
       case '?':
           print("Error - No such option: " + optopt);
           quit(1);
     }
}

quit(0);

$
$ ./test.js
$ ./test.js -h
usage: ./test.js [-f filename] [-g] [-v]
$ ./test.js -j
illegal option -- j
Error - No such option: j
$ ./test.js -gvf finn
g option found
v option found
f option found. Argument is: finn
$ ./test.js -g -v -f finn
g option found
v option found
f option found. Argument is: finn
$

#!/bin/js

var key;

for ( key in environment ) {
   if (typeof environment[key] == 'string') {
      print(key + ' ---> ' + environment[key]);
   }
}

USERNAME ---> fpm
GDM_KEYBOARD_LAYOUT ---> us
LANG ---> en_US.UTF-8
SHLVL ---> 3
HOME ---> /home/fpm
LOGNAME ---> fpm
COLORTERM ---> gnome-terminal
PWD --> /work/js/tmp
_ ---> ./env.js
OLDPWD ---> /work/js