/* parser for pxgraph command line arguments and binary files.

 @Author: Edward A. Lee and Christopher Hylands

 @Version: $Id$

 @Copyright (c) 1997-2014 The Regents of the University of California.
 All rights reserved.

 Permission is hereby granted, without written agreement and without
 license or royalty fees, to use, copy, modify, and distribute this
 software and its documentation for any purpose, provided that the
 above copyright notice and the following two paragraphs appear in all
 copies of this software.

 IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.

 THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 ENHANCEMENTS, OR MODIFICATIONS.

 PT_COPYRIGHT_VERSION_2
 COPYRIGHTENDKEY
 */
package ptolemy.plot.compat;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Vector;

import ptolemy.plot.CmdLineArgException;
import ptolemy.plot.Plot;
import ptolemy.plot.PlotBox;

///////////////////////////////////////////////////////////////////
//// PxgraphParser

/**
This class provides backwards compatibility with an older plotting
program, pxgraph.  It provides two methods, one for parsing command-line
arguments, and one for reading binary data from a file. In pxgraph,
the binary files have no format information; all format information
is provided by command line arguments.

<p>Below we describe the <code>pxgraph</code> arguments.  The text is
  based on the <code>xgraph</code> Unix man page written by David
  Harrison (University of California).  To see the command line
  options, you can type
  <code>pxgraph -help</code>.</p>

<p>The <code>pxgraph</code> program draws a graph on a display given
  data read from either data files or from standard input if one of
  the arguments is a dash. It can display up to 64 independent data
  sets using different colors and/or line styles for each set. It
  annotates the graph with a title, axis labels, grid lines or tick
  marks, grid labels, and a legend. There are options to control the
  appearance of most components of the graph.</p>

<p>The input format is similar to <code>graph(<i>1G</i>)</code> but differs
  slightly. The data consists of a number of <I>data</I> <I>sets</I>. Data
  sets are separated by a blank line. A new data set is also
  assumed at the start of each input file. A data set consists
  of an ordered list of points of the form <code><i>directive</i>
    X Y</code>.</p>

<p>The directive is either <code>draw</code> or <code>move</code> and can
  be omitted (Note that with binary data files, you must have a directive,
  the above statement only applies to ascii format data files). If the
  directive is <code>draw</code>, a line will be drawn
  between the previous point and the current point (if a line
  graph is chosen). Specifying a <code>move</code> directive tells
  xgraph not to draw a line between the points. If the directive
  is omitted, <code>draw</code> is assumed for all points in a data
  set except the first point where <code>move</code> is assumed. The
  <code>move</code> directive is used most often to allow discontinuous
  data in a data set.</p>

<p>After <code>pxgraph</code> has read the data, it will create a new window
  to graphically display the data.</p>

<p> Once the window has been opened, all of the data sets will
  be displayed graphically (subject to the options explained
  below) with a legend in the upper right corner of the
  screen. To zoom in on a portion of the graph, depress a
  mouse button in the window and sweep out a region. <code>pxgraph</code>
  will then the window will be redrawn with just that portion of
  the graph. <code>pxgraph</code> also presents four control buttons in
  the lower left corner of each window: <code>Exit</code>,
  <code>Print</code>, <code>HTML</code> and <code>About</code>.</p>

<p>The <code>Exit</code> button will exit the process.  You can also
  type <code>Control-D</code>, <code>Control-C</code> or <code>q</code>
  to exit.</p>

<p>The <code>Print</code> button brings up a print dialog window.</p>

<p>The <code>About</code> button brings up a message about
<code>pxgraph</code>.</p>

<p>The <code>HTML</code> button prints an HTML file to stdout that
  can be used to display the file with applet <code>Plot</code> classes
  (Experimental).</p>

<p><code>pxgraph</code> accepts a large number of command line options.
  A list of these options is given below.</p>

<dl>
  <dt><code>=<i>W</i>x<i>H</i>+<i>X</i>+<i>Y</i></code></dt>
  <dd>Specifies the initial size and location of the pxgraph
    window.</dd>

  <dt> <code>-<i>&lt;digit&gt; &lt;name&gt;</i></code></dt>
  <dd> These options specify the data
    set name for the corresponding data set. The digit
    should be in the range 0 to 63. This name will be
    used in the legend.</dd>

  <dt><code>-bar</code></dt>
  <dd>Specifies that vertical bars should be drawn from the
    data points to a base point which can be specified with
    <code>-brb</code>.
    Usually, the <code>-nl</code> flag is used with this option.
    The point itself is located at the center of the bar.</dd>

  <dt><code>-bb</code></dt>
  <dd>Draw a bounding box around the data region. This is
    very useful if you prefer to see tick marks rather than
    grid lines (see <code>-tk</code>).
    <b>Ignored in the Java version because the plotting area is a different
      color than the border where the axes are labeled.</b></dd>

  <dt><code>-bd</code> <code><i>&lt;color&gt;</i></code></dt>
  <dd>This specifies the border color of the <code>pxgraph</code> window.
    <b>Unsupported in the Java version.</b></dd>

  <dt><code>-bg</code> <code><i>&lt;color&gt;</i></code></dt>
  <dd>Background color of the area where the labels and legend are rendered.
    <b>In the Java version, this argument takes hexadecimal color values
      (<code>fffff</code>), not color names.</b>  Note that the background
    of the data plotting region is always white because the dataset colors
    were designed for a white background.</dd>

  <dt><a name="bigendianFlag"><code>-bigendian</code></a></dt>
  <dd>Data files are in big-endian, or network binary format.
    See the <code>-binary</code> command line argument documentation
    below for details about the format.
    If you are on a little-endian machine, such as a machine
    with an Intel x86 chip, and you would like to read a binary
    format file, created on a big-endian machine, such as a Sun SPARC,
    use the <code>-bigendian</code> flag.</dd>

  <dt><a name="binaryFlag"><code>-binary</code></a></dt>
  <dd>Data files are in a binary format.
    The endian-ism of the data depends on which of the two
    subformats below are chosen.
    The <code>-binary</code>
    argument is the primary difference between <code>xgraph</code>
    and <code>pxgraph</code>.  The
    <A HREF="http://ptolemy.eecs.berkeley.edu">Ptolemy Project</A> software
    makes extensive use of <code>-binary</code>.
    <br>There are two binary formats, both of which use 4 byte floats.
    <ol>
      <li>If the first byte of the data file is not a <code>d</code>, then
        we assume that the file contains 4 byte floats in big-endian ordering
        with no plot commands.
      <li>If the first byte of the data file is a <code>d</code>, then
        we assume that the plot commands are encoded as single characters,
        and the numeric data is a 4 byte float encoded in the
        native endian format of the machine that the java interpreter is
        running on.
        <br>The commands are encoded as follows:
        <dl>
          <dt> <code>d <I>&lt;4byte float&gt; &lt;4byte float&gt;</I></code></dt>
          <dd> Draw a X, Y point</dd>
          <dt> <code>e</code></dt>
          <dd> End of dataset</dd>
          <dt> <code>n <I>&lt;dataset name&gt;</I>&#92;</code></dt>
          <dd> New dataset name, ends in <code>&#92;</code></dd>
          <dt> <code>m <I>&lt;4byte float&gt; &lt;4byte float&gt;</I></code></dt>
          <dd> Move to a X, Y point.</dd>
        </dl>
      </li>
    </ol>
    <br>To view a binary plot file under unix, we can use the
    <code>od</code> command.  Note that the first character is a <code>d</code>
    followed by eight bytes of data consisting of two floats of four bytes.
    <pre>
      cxh@carson 324% od -c data/integrator1.plt
      0000000   d  \0  \0  \0  \0  \0  \0  \0  \0   d   ? 200  \0  \0   ? 200
      0000020  \0  \0   d   @  \0  \0  \0   @   , 314 315   d   @   @  \0  \0
    </pre>
    <br>For further information about endian-ism, see the
    <code>-bigendian</code> and <code>-littleendian</code> command
    line argument documentation.
  </dd>

  <dt><code>-brb</code> <code><i>&lt;base&gt;</i></code></dt>
  <dd>This specifies the base for a bar graph. By default,
    the base is zero.
    <b>Unsupported in the Java version.</b></dd>

  <dt><code>-brw</code> <code><i>&lt;width&gt;</i></code></dt>
  <dd>This specifies the width of bars in a bar graph. The
    amount is specified in the user units. By default,
    a bar one pixel wide is drawn.</dd>

  <dt><code>-bw</code> <code><i>&lt;size&gt;</i></code></dt>
  <dd>Border width (in pixels) of the <code>pxgraph</code> window.
    <b>Unsupported in the Java version.</b></dd>

  <dt><code>-db</code></dt>
  <dd>Causes xgraph to run in synchronous mode and prints out
    the values of all known defaults.</dd>

  <dt><code>-fg</code> <code><i>&lt;color&gt;</i></code></dt>
  <dd>Foreground color. This color is used to draw all text
    and the normal grid lines in the window.
    <b>In the Java version, this argument takes hexadecimal color values
      (<code>fffff</code>), not color names.</b></dd>

  <dt><code>-gw</code></dt>
  <dd> Width, in pixels, of normal grid lines.
    <b>Unsupported in the Java version.</b></dd>

  <dt><code>-gs</code></dt>
  <dd> Line style pattern of normal grid lines.</dd>

  <dt><code>-impulses</code></dt>
  <dd>Draw a line from any plotted point down to the x axis.
    (This argument is not present in the X11 <code>pxgraph</code>,
    but it is similar to <code>-nl -bar</code>).</dd>

  <dt><code>-lf</code> <code><i>&lt;fontname&gt;</i></code></dt>
  <dd>Label font. All axis labels and grid labels are drawn
    using this font.
    <b>Note that the Java version does not use X11 style font specification.</b>
    In the Java version, fonts may be specified as
    <menu>
      <li><code><i>fontname</i></code>, where
        <code><i>fontname</i></code> is one of <code>helvetica</code>,
        <code>TimesRoman</code>, <code>Courier</code>,  <code>Dialog</code>,
        <code>DialogInput</code>, <code>ZapfDingbats</code>.

      <li><code><i>fontname</i>-<i>style</i></code>, where
        <code><i>style</i></code> is one of
        <code>PLAIN</code>, <code>ITALIC</code>, <code>BOLD</code>,
        i.e. <code>helvetica-ITALIC</code>
      <li><code><i>fontname</i>-<i>size</i></code>, or
      <li><code><i>fontname</i>-<i>style</i>-<i>size</i></code>, where
        <code><i>size</i></code> is an integer font size in points.
    </menu>
    The default is <code>helvetica-PLAIN-12</code>.
  </dd>

  <dt><a name="littleendian"><code>-littleendian</code></a></dt>
  <dd>Data files are in little-endian, or x86 binary format.
    See the <code>-binary</code> command line argument documentation
    above for details about the format.
    If you are on a big-endian machine, such as a Sun Sparc,
    and you would like to read a binary
    format file created on a little-endian machine, such as Intel x86
    machine, then use the <code>-littleendian</code> flag.</dd>

  <dt><code>-lnx</code></dt>
  <dd>Specifies a logarithmic X axis. Grid labels represent
    powers of ten.  If <code>-lnx</code> is present, then
    x values must be greater than zero.</dd>

  <dt><code>-lny</code></dt>
  <dd>Specifies a logarithmic Y axis. Grid labels represent
    powers of ten.   If <code>-lny</code> is present, then
    y values must be greater than zero.</dd>

  <dt><code>-lw</code> <code><i>width</i></code></dt>
  <dd>Specifies the width of the data lines in pixels. The
    default is zero.
    <b>Unsupported in the Java version.</b></dd>

  <dt><code>-lx</code> <code><i>&lt;xl,xh&gt;</i></code></dt>
  <dd>This option limits the range of the X axis to the
    specified interval. This (along with <code>-ly</code>) can be used
    to zoom in on a particularly interesting portion of a
    larger graph.</dd>

  <dt><code>-ly</code> <code><i>&lt;yl,yh&gt;</i></code></dt>
  <dd>This option limits the range of the Y axis to the
    specified interval.</dd>

  <dt><code>-m</code></dt>
  <dd>Mark each data point with a distinctive marker. There
    are eight distinctive markers used by xgraph. These
    markers are assigned uniquely to each different line
    style on black and white machines and varies with each
    color on color machines.</dd>

  <dt><code>-M</code></dt>
  <dd>Similar to <code>-m</code> but markers are assigned uniquely to each
    eight consecutive data sets (this corresponds to each
    different line style on color machines).</dd>

  <dt><code>-nl</code></dt>
  <dd>Turn off drawing lines. When used with <code>-m</code>,
    <code>-M</code>, <code>-p</code>, or <code>-P</code> this can be used
    to produce scatter plots. When used with -bar, it can be used to
    produce standard bar graphs.</dd>

  <dt><code>-o</code> <code><i>output filename</i></code></dt>
  <dd>The name of the file to place the print output in.  Currently
    defaults to <code>/tmp/t.ps</code>.  See also the
    <code>-print</code> option.</dd>

  <dt><code>-p</code></dt>
  <dd>Marks each data point with a small marker (pixel
    sized). This is usually used with the -nl option for
    scatter plots.</dd>

  <dt><code>-P</code></dt>
  <dd>Similar to <code>-p</code> but marks each pixel with a large dot.</dd>

  <dt><code>-print</code></dt>
  <dd>Bring up the print dialog immediately upon startup.  Unfortunately,
    there is no way to automatically print in JDK1.1, the user must hit
    the <code>Ok</code> button.  See also the <code>-o</code> option.</dd>

  <dt><code>-rv</code></dt>
  <dd>Reverse video. On black and white displays, this will
    invert the foreground and background colors. The
    behaviour on color displays is undefined.</dd>

  <dt><code>-t</code> <code><i>&lt;string&gt;</i></code></dt>
  <dd>Title of the plot. This string is centered at the top
    of the graph.</dd>

  <dt><code>-tf</code> <code><i>&lt;fontname&gt;</i></code></dt>
  <dd>Title font. This is the name of the font to use for
    the graph title.  See the <code>-lf</code> description above
    for how to specify fonts.
    The default is <code>helvetica-BOLD-14</code></dd>

  <dt><code>-tk</code></dt>
  <dd>This option causes <code>pxgraph</code> to draw tick marks rather
    than full grid lines. The <code>-bb</code> option is also useful
    when viewing graphs with tick marks only.</dd>

  <dt><code>-x</code>  <code><i>&lt;unitname&gt;</i></code></dt>
  <dd>This is the unit name for the X axis. Its default is "X".</dd>

  <dt><code>-y</code> <code><i>&lt;unitname&gt;</i></code></dt>
  <dd>This is the unit name for the Y axis. Its default is "Y".</dd>

  <dt><code>-zg</code> <code><i>&lt;color&gt;</i></code></dt>
  <dd>This is the color used to draw the zero grid line.
    <b>Unsupported in the Java version.</b></dd>

  <dt><code>-zw</code> <code><i>&lt;width&gt;</i></code></dt>
  <dd>This is the width of the zero grid line in pixels.
    <b>Unsupported in the Java version.</b></dd>
</dl>

<b><a name="pxgraphScriptCompatibilityIssues">Compatibility Issues</a></b>
<p>Various compatibility issues are documented above in <b>bold</b>.
  Below are some other issues:</p>
<ol>
  <li>The original <code>xgraph</code> program allowed many formatting
    directives inside the file.  This version only supports
    <code>draw</code> and <code>move</code>.</li>
  <li>To read from standard input, specify a dash on the command line.
    Note that mixing reading from standard in and from files is not
    well supported.</li>
  <li>This original <code>xgraph</code> program allowed blank lines
    to separate datasets.  This version does not.  Instead, use the
    <code>move <i>X</i> <i>Y</i></code> directive.</li>
  <li>This version does not support X resources.
  <li>The Java version of <code>pxgraph</code> takes longer to start up
    than the X11 version.  This is an inherent problem with standalone
    Java applications.  One guess is that most of the startup time comes
    from paging in the shared libraries.</li>
</ol>

<p>
  For further information about this tool, see the
  <a href="http://ptolemy.eecs.berkeley.edu/java/ptplot">Java Plot Website</a>.</p>

@author Edward A. Lee and Christopher Hylands

 @version $Id$
 @since Ptolemy II 0.4
 @Pt.ProposedRating red (eal)
 @Pt.AcceptedRating red (cxh)
 @see PxgraphApplication
 @see PxgraphApplet
 */
public class PxgraphParser {
    /** Construct a parser to configure the specified plot.
     *  @param plot The Plot object that is configured.
     */
    public PxgraphParser(Plot plot) {
        _plot = plot;
    }

    ///////////////////////////////////////////////////////////////////
    ////                         public methods                    ////

    /** Parse pxgraph style command-line arguments.
     *  @param args A set of command-line arguments.
     *  @return The number of arguments read.
     *  @exception CmdLineArgException If there is a problem parsing
     *   the command line arguments.
     *  @exception FileNotFoundException If a file is specified that is not
     *   found.
     *  @exception IOException If an error occurs reading an input file.
     */
    public int parseArgs(String[] args)
            throws CmdLineArgException, FileNotFoundException, IOException {
        return parseArgs(args, null);
    }

    /** Parse pxgraph style command-line arguments, using the specified
     *  base URL for any relative URL references.
     *  @param args A set of command-line arguments.
     *  @param base A base URL for relative URL references, or null if
     *   there is none.
     *  @return The number of arguments read.
     *  @exception CmdLineArgException If there is a problem parsing
     *   the command line arguments.
     *  @exception FileNotFoundException If a file is specified that is not
     *   found.
     *  @exception IOException If an error occurs reading an input file.
     */
    public int parseArgs(String[] args, URL base)
            throws CmdLineArgException, FileNotFoundException, IOException {
        int i = 0;
        int j;
        int argumentsRead = 0;

        // If we see both -nl and -bar, assume we do a stem plot.
        boolean sawbararg = false; // Saw -bar arg.
        boolean sawnlarg = false; // Saw -nl arg.
        String savedmarks = "none"; // Save _marks in case we have -P -bar -nl.
        _binary = false; // Read a binary xgraph file.

        int width = 400;
        int height = 400;

        String arg;
        String[] unsupportedOptions = { "-bd", "-brb", "-bw", "-gw", "-lw",
                "-zg", "-zw" };

        // True if we saw an - arg, which means read from stdin
        boolean sawDash = false;

        while (args != null && i < args.length
                && (args[i].startsWith("-") || args[i].startsWith("="))) {
            arg = args[i++];

            if (arg.startsWith("-")) {
                // Search for unsupported options that take arguments
                boolean badarg = false;

                for (j = 0; j < unsupportedOptions.length; j++) {
                    if (arg.equals(unsupportedOptions[j])) {
                        System.err.println("Warning: pxgraph: " + arg
                                + " is not supported");
                        i++;
                        badarg = true;
                    }
                }

                if (badarg) {
                    continue;
                }

                if (arg.equals("-bb")) {
                    // We ignore -bb because the Java version of pxgraph plot
                    // region is a different color from the surrounding region.
                    continue;
                } else if (arg.equals("-bg")) {
                    _plot.setBackground(PlotBox.getColorByName(args[i++]));
                    continue;
                } else if (arg.equals("-brw")) {
                    // -brw <width> BarWidth Bars:
                    // We default the baroffset to 0 here if the value does
                    // not include a comma.
                    double[] spec = _parseDoubles(args[i++]);

                    if (spec.length == 1) {
                        _plot.setBars(spec[0], 0);
                    } else {
                        _plot.setBars(spec[0], spec[1]);
                    }

                    continue;
                } else if (arg.equals("-lf")) {
                    // -lf <labelfont>
                    _plot.setLabelFont(args[i++]);
                    continue;
                } else if (arg.equals("-lx")) {
                    double[] spec = _parseDoubles(args[i++]);

                    if (spec.length == 1) {
                        throw new CmdLineArgException(
                                "Failed to parse `" + arg + "'");
                    } else {
                        _plot.setXRange(spec[0], spec[1]);
                    }

                    continue;
                } else if (arg.equals("-ly")) {
                    double[] spec = _parseDoubles(args[i++]);

                    if (spec.length == 1) {
                        throw new CmdLineArgException(
                                "Failed to parse `" + arg + "'");
                    } else {
                        _plot.setYRange(spec[0], spec[1]);
                    }

                    continue;
                } else if (arg.equals("-t")) {
                    // -t <title> TitleText "An X Graph"
                    String title = args[i++];
                    _plot.setTitle(title);
                    continue;
                } else if (arg.equals("-tf")) {
                    // -tf <titlefont>
                    _plot.setTitleFont(args[i++]);
                    continue;
                } else if (arg.equals("-x")) {
                    // -x <unitName> XUnitText XLabel:
                    _plot.setXLabel(args[i++]);
                    continue;
                } else if (arg.equals("-y")) {
                    // -y <unitName> YUnitText YLabel:
                    _plot.setYLabel(args[i++]);
                    continue;
                } else if (arg.equals("-bar")) {
                    //-bar BarGraph Bars: on Marks: none Lines: off
                    // If we saw the -nl arg, then assume impulses
                    sawbararg = true;

                    if (sawnlarg) {
                        _plot.setImpulses(true);
                    } else {
                        _plot.setBars(true);
                        _plot.setMarksStyle("none");
                    }

                    _plot.setConnected(false);
                    continue;
                } else if (arg.equals("-binary")) {
                    _binary = true;
                    _endian = _NATIVE_ENDIAN;
                    continue;
                } else if (arg.equals("-bigendian")) {
                    _binary = true;
                    _endian = _BIG_ENDIAN;
                    continue;
                } else if (arg.equals("-littleendian")) {
                    _binary = true;
                    _endian = _LITTLE_ENDIAN;
                    continue;
                } else if (arg.equals("-db")) {
                    //_debug = 10;
                    continue;
                } else if (arg.equals("-debug")) {
                    // -debug is not in the original X11 pxgraph.
                    //_debug = (int) Integer.parseInt(args[i++]);
                    continue;
                } else if (arg.equals("-fg")) {
                    _plot.setForeground(PlotBox.getColorByName(args[i++]));
                    continue;
                } else if (arg.equals("-help")) {
                    // -help is not in the original X11 pxgraph.
                    //_help();
                    continue;
                } else if (arg.equals("-impulses")) {
                    // -impulses is not in the original X11 pxgraph.
                    _plot.setImpulses(true);
                    _plot.setConnected(false);
                    continue;
                } else if (arg.equals("-lnx")) {
                    _plot.setXLog(true);
                    continue;
                } else if (arg.equals("-lny")) {
                    _plot.setYLog(true);
                    continue;
                } else if (arg.equals("-m")) {
                    // -m Markers Marks: various
                    _plot.setMarksStyle("various");
                    savedmarks = "various";
                    continue;
                } else if (arg.equals("-M")) {
                    // -M StyleMarkers Marks: various
                    _plot.setMarksStyle("various");
                    savedmarks = "various";
                    continue;
                } else if (arg.equals("-nl")) {
                    // -nl NoLines Lines: off
                    // If we saw the -bar arg, then assume impulses
                    sawnlarg = true;

                    if (sawbararg) {
                        // Restore the _marks in case we did -P -bar -nl
                        _plot.setMarksStyle(savedmarks);
                        _plot.setBars(false);
                        _plot.setImpulses(true);
                    }

                    _plot.setConnected(false);
                    continue;
                } else if (arg.equals("-o")) {
                    // -o <output filename>
                    // _outputFile =  args[i++];
                    i++;
                    continue;
                } else if (arg.equals("-p")) {
                    // -p PixelMarkers Marks: points
                    _plot.setMarksStyle("points");
                    savedmarks = "points";
                    continue;
                } else if (arg.equals("-P")) {
                    // -P LargePixel Marks: dots\n
                    _plot.setMarksStyle("dots");
                    savedmarks = "dots";
                    continue;
                } else if (arg.equals("-print")) {
                    // -print is not in the original X11 pxgraph.
                    continue;
                } else if (arg.equals("-rv")) {
                    _plot.setBackground(PlotBox.getColorByName("black"));
                    _plot.setForeground(PlotBox.getColorByName("white"));
                    continue;
                } else if (arg.equals("-test")) {
                    // -test is not in the original X11 pxgraph.
                    //_test = true;
                    continue;
                } else if (arg.equals("-tk")) {
                    _plot.setGrid(false);
                    continue;
                } else if (arg.equals("-v") || arg.equals("-version")) {
                    // -version is not in the original X11 pxgraph.
                    //_version();
                    continue;
                } else if (arg.length() > 1 && arg.charAt(0) == '-') {
                    // Process '-<digit> <datasetname>'
                    try {
                        int datasetnumber = Integer.parseInt(arg.substring(1));
                        if (datasetnumber >= 0) {
                            _plot.addLegend(datasetnumber, args[i++]);
                            continue;
                        }
                    } catch (NumberFormatException e) {
                    }
                }
            } else {
                if (arg.startsWith("=")) {
                    // Process =WxH+X+Y
                    width = Integer
                            .parseInt(arg.substring(1, arg.indexOf('x')));

                    int plusIndex = arg.indexOf('+');
                    int minusIndex = arg.indexOf('-');

                    if (plusIndex != -1 || minusIndex != -1) {
                        // =WxH+X+Y, =WxH-X+Y, =WxH-X-Y, =WxH+X-Y
                        if (plusIndex != -1 && minusIndex != -1) {
                            // =WxH-X+Y or =WxH+X-Y
                            int index = minusIndex;

                            if (plusIndex < minusIndex) {
                                index = plusIndex;
                            }

                            height = Integer.parseInt(
                                    arg.substring(arg.indexOf('x') + 1, index));
                        } else {
                            if (plusIndex != -1) {
                                // =WxH+X+Y
                                height = Integer.parseInt(arg.substring(
                                        arg.indexOf('x') + 1, plusIndex));
                            } else {
                                // =WxH-X-Y
                                height = Integer.parseInt(arg.substring(
                                        arg.indexOf('x') + 1, minusIndex));
                            }
                        }
                    } else {
                        if (arg.length() > arg.indexOf('x')) {
                            // =WxH
                            height = Integer.parseInt(arg.substring(
                                    arg.indexOf('x') + 1, arg.length()));
                        }
                    }

                    // FIXME: it is unclear what X and Y in =WxH+X+Y mean
                    // in a non-toplevel window, so we don't process
                    // those here.  See Pxgraph.java for how to process
                    // X and Y for a toplevel window.
                    continue;
                }
            }

            if (arg.equals("-")) {
                sawDash = true;
            } else {
                // If we got to here, then we failed to parse the arg
                throw new CmdLineArgException("Failed to parse `" + arg + "'");
            }
        }

        argumentsRead = i++;

        _plot.setSize(width, height);

        InputStream instream;

        if (sawDash) {
            // FIXME: Reading from both standard in and files is
            // not well supported.  We always read from standard in first
            // then from any files.
            instream = System.in;
            read(instream);
        }

        // Findbugs suggests checking for null
        for (i = argumentsRead; args != null && i < args.length; i++) {
            // Have a filename.  First attempt to open it as a URL.
            try {
                URL inurl = new URL(base, args[i]);
                instream = inurl.openStream();
            } catch (MalformedURLException ex) {
                instream = new FileInputStream(args[i]);
            }

            read(instream);
        }

        return argumentsRead;
    }

    /** Split a string containing pxgraph-compatible command-line arguments
     *  into an array and call parseArgs() on the array.  This is used
     *  in the rare circumstance that you want to control the format
     *  of a plot from an applet HTML file rather than in the plot data
     *  file.
     *  @param pxgraphargs The command line arguments.
     *  @param base A base URL for relative URL references, or null if
     *   there is none.
     *  @return The number of arguments read.
     *  @exception CmdLineArgException If there is a problem parsing
     *   the command line arguments.
     *  @exception FileNotFoundException If a file is specified that is not
     *   found.
     *  @exception IOException If an error occurs reading an input file.
     */
    public int parsePxgraphargs(String pxgraphargs, URL base)
            throws CmdLineArgException, FileNotFoundException, IOException {
        // We convert the String to a Stream and then use a StreamTokenizer
        // to parse the arguments into a Vector and then copy
        // the vector into an array of Strings.  We use a Vector
        // so that we can handle an arbitrary number of arguments
        Vector argvector = new Vector();
        boolean prependdash = false; // true if we need to add a -

        StringReader pin = new StringReader(pxgraphargs);

        try {
            StreamTokenizer stoken = new StreamTokenizer(pin);

            // We don't want to parse numbers specially, so we reset
            // the syntax and then add back what we want.
            stoken.resetSyntax();
            stoken.whitespaceChars(0, ' ');
            stoken.wordChars('(', '~');
            stoken.quoteChar('"');
            stoken.quoteChar('\'');

            int c;
            String partialarg = null;
            out: while (true) {
                c = stoken.nextToken();

                //System.out.print(c + " "+stoken.ttype+" "+stoken.sval+" ");
                switch (stoken.ttype) { // same as value of 'c'
                case StreamTokenizer.TT_EOF:
                    break out;

                case StreamTokenizer.TT_WORD:

                    //System.out.println("Word: " + stoken.sval);
                    if (prependdash) {
                        prependdash = false;

                        if (partialarg == null) {
                            argvector.addElement("-" + stoken.sval);
                        } else {
                            argvector
                                    .addElement("-" + partialarg + stoken.sval);
                        }
                    } else {
                        if (partialarg == null) {
                            argvector.addElement(stoken.sval);
                        } else {
                            argvector.addElement(partialarg + stoken.sval);
                        }
                    }

                    partialarg = null;
                    break;

                case '-':
                    prependdash = true;
                    break;

                case '#':
                case '$':
                case '%':
                case '&':

                    // The above chars can be part of a URL.  For example
                    // perl scripts use &.  However, we cannot include
                    // them in the wordChars() range of chars, since
                    // the single quote is between them and the rest of the
                    // chars. So we have to process them by hand.
                    partialarg = (String) argvector.lastElement() + (char) c;
                    argvector.removeElementAt(argvector.size() - 1);
                    break;

                case '"':
                case '\'':

                    //System.out.println("String: " + stoken.sval);
                    argvector.addElement(stoken.sval);
                    break;

                default:
                    throw new IOException("Failed to parse: '" + (char) c
                            + "' in `" + pxgraphargs + "'");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Create a array
        String[] args = new String[argvector.size()];

        for (int i = 0; i < argvector.size(); i++) {
            args[i] = (String) argvector.elementAt(i);
        }

        return parseArgs(args, base);
    }

    /** Read a pxgraph-compatible binary or ASCII encoded file.
     *  @param inputStream The input stream.
     *  @exception java.io.IOException If an I/O error occurs.
     */
    public void read(InputStream inputStream) throws IOException {
        DataInputStream in = new DataInputStream(
                new BufferedInputStream(inputStream));

        if (_binary) {
            int c;
            float x = 0;
            float y = 0;
            float pointCount = 0;
            boolean byteSwapped = false;
            boolean connected = false;
            byte[] input = new byte[4];

            if (_connected) {
                connected = true;
            }

            switch (_endian) {
            case _NATIVE_ENDIAN:

                try {
                    if (System.getProperty("os.arch").equals("x86")) {
                        byteSwapped = true;
                    }
                } catch (SecurityException e) {
                }

                break;

            case _BIG_ENDIAN:
                break;

            case _LITTLE_ENDIAN:
                byteSwapped = true;
                break;

            default:
                throw new IOException("Internal Error: Don't know about '"
                        + _endian + "' style of endian");
            }

            try {
                // Flag that we are starting a new data set.
                _firstInSet = true;

                // Flag that we have not seen a DataSet line in this file.
                _sawFirstDataset = false;

                c = in.readByte();

                if (c != 'd') {
                    // Assume that the data is one data set, consisting
                    // of 4 byte floats.  None of the Ptolemy pxgraph
                    // binary format extensions apply.
                    // Note that the binary format is bigendian, or network
                    // order.  Little-endian machines, like x86 will not
                    // be able to write binary data directly
                    // (However, they could use Java's mechanisms for
                    // writing binary files).
                    // Read 3 more bytes, create the x float.
                    int bits = c;
                    bits = bits << 8;
                    bits += in.readByte();
                    bits = bits << 8;
                    bits += in.readByte();
                    bits = bits << 8;
                    bits += in.readByte();

                    x = Float.intBitsToFloat(bits);
                    y = in.readFloat();

                    // _addLegendIfNecessary might increment _currentdataset
                    connected = _addLegendIfNecessary(connected);
                    _plot.addPoint(_currentdataset, x, y, connected);

                    if (_connected) {
                        connected = true;
                    }

                    while (true) {
                        x = in.readFloat();
                        y = in.readFloat();
                        connected = _addLegendIfNecessary(connected);
                        _plot.addPoint(_currentdataset, x, y, connected);

                        if (_connected) {
                            connected = true;
                        }
                    }
                } else {
                    // Assume that the data is in the pxgraph binary format.
                    while (true) {
                        // For speed reasons, the Ptolemy group extended
                        // pxgraph to read binary format data.
                        // The format consists of a command character,
                        // followed by optional arguments
                        // d <4byte float> <4byte float> - Draw a X, Y point
                        // e                             - End of a data set
                        // n <chars> \n           - New set name, ends in \n
                        // m                             - Move to a point
                        switch (c) {
                        case 'd':

                            // Data point.
                            if (byteSwapped) {
                                in.readFully(input);
                                x = Float.intBitsToFloat((input[3] & 0xFF) << 24
                                        | (input[2] & 0xFF) << 16
                                        | (input[1] & 0xFF) << 8
                                        | input[0] & 0xFF);
                                in.readFully(input);
                                y = Float.intBitsToFloat((input[3] & 0xFF) << 24
                                        | (input[2] & 0xFF) << 16
                                        | (input[1] & 0xFF) << 8
                                        | input[0] & 0xFF);
                            } else {
                                x = in.readFloat();
                                y = in.readFloat();
                            }

                            pointCount++;
                            connected = _addLegendIfNecessary(connected);
                            _plot.addPoint(_currentdataset, x, y, connected);

                            if (_connected) {
                                connected = true;
                            }

                            break;

                        case 'e': // End of set name.
                        case 'm': // a disconnected point
                            connected = false;
                            break;

                        case 'n':
                            _firstInSet = true;
                            _sawFirstDataset = true;

                            StringBuffer datasetname = new StringBuffer();
                            _currentdataset++;

                            // New set name, ends in \n.
                            while (c != '\n') {
                                datasetname.append(in.readChar());
                            }

                            _plot.addLegend(_currentdataset,
                                    datasetname.toString());
                            _plot.setConnected(true);
                            break;

                        default:
                            throw new IOException("Don't understand `"
                                    + (char) c + "' character "
                                    + "(decimal value = " + c
                                    + ") in binary file.  Last point was (" + x
                                    + "," + y + ").\nProcessed " + pointCount
                                    + " points successfully");
                        }

                        c = in.readByte();
                    }
                }
            } catch (EOFException e) {
            }
        } else {
            // Read ASCII files.
            // NOTE: These are not in xgraph format, but rather in the
            // old ptplot format!!
            _plot.read(inputStream);
        }
    }

    ///////////////////////////////////////////////////////////////////
    ////                         protected members                 ////

    /** The current dataset, used for handling multiple files. */
    protected int _currentdataset = -1;

    /** The plot object to which to apply commands. */
    protected Plot _plot;

    ///////////////////////////////////////////////////////////////////
    ////                         private methods                   ////
    // Add a legend if necessary, return the value of the connected flag.
    private boolean _addLegendIfNecessary(boolean connected) {
        if (!_sawFirstDataset || _currentdataset < 0) {
            // We did not set a DataSet line, but
            // we did get called with -<digit> args
            _sawFirstDataset = true;
            _currentdataset++;
        }

        if (_plot.getLegend(_currentdataset) == null) {
            // We did not see a "DataSet" string yet,
            // nor did we call addLegend().
            _firstInSet = true;
            _sawFirstDataset = true;
            _plot.addLegend(_currentdataset, "Set " + _currentdataset);
        }

        if (_firstInSet) {
            connected = false;
            _firstInSet = false;
        }

        return connected;
    }

    // Parse a string with a comma into two doubles.
    // If there is no comma, return a single double.
    private double[] _parseDoubles(String spec) {
        int comma = spec.indexOf(",");

        if (comma < 0) {
            double[] result = new double[1];
            result[0] = Double.parseDouble(spec);
            return result;
        } else {
            double[] result = new double[2];
            String spec1 = spec.substring(0, comma);
            result[0] = Double.parseDouble(spec1);

            String spec2 = spec.substring(comma + 1);
            result[1] = Double.parseDouble(spec2);
            return result;
        }
    }

    ///////////////////////////////////////////////////////////////////
    ////                         private members                   ////
    // Check the osarch and use the appropriate endian.
    private static final int _NATIVE_ENDIAN = 0;

    // Data is in big-endian
    private static final int _BIG_ENDIAN = 1;

    // Data is in little-endian
    private static final int _LITTLE_ENDIAN = 2;

    // Flag indicating whether the command specified that the format
    private boolean _binary = false;

    private boolean _connected = true;

    // For debugging, call with -db or -debug.
    //private static int _debug = 0;

    /** @serial Format to read data in. */
    private int _endian = _NATIVE_ENDIAN;

    // Is this the first datapoint in a set?
    private boolean _firstInSet = true;

    // Have we seen a DataSet line in the current data file?
    private boolean _sawFirstDataset = false;
}