This is an automated email from the git hooks/post-receive script.
ebourg-guest pushed a commit to branch master
in repository bsh.
commit 8ac889fef6420d58d679068711a2e227d5ead551
Author: Arnaud Vandyck <av...@debian.org>
Date: Sun Jan 18 22:13:03 2004 +0000
Initial revision
---
debian/README.Debian | 15 ++
debian/bsh | 9 +
debian/bsh.1 | 40 ++++
debian/bsh.html | 652 +++++++++++++++++++++++++++++++++++++++++++++++++++
debian/changelog | 79 +++++++
debian/control | 25 ++
debian/copyright | 45 ++++
debian/dirs | 3 +
debian/menu | 4 +
debian/rules | 61 +++++
debian/xbsh | 4 +
11 files changed, 937 insertions(+)
diff --git a/debian/README.Debian b/debian/README.Debian
new file mode 100644
index 0000000..ae1525d
--- /dev/null
+++ b/debian/README.Debian
@@ -0,0 +1,15 @@
+BeanShell for Debian GNU/Linux
+------------------------------
+
+To start BeanShell, type bsh for the command-line version, or xbsh for the
+windowed version. To use the Swing interface, make sure that the Swing
+libraries are included in your CLASSPATH environment variable before starting
+xbsh.
+
+BeanShell has not been tested with Java virtual machines other than JDK 1.3.
+Please report any feedback (both positive and negative) on using BeanShell with
+"alternative" Java virtual machines.
+
+To compile this package for Debian, certain JDK1.3 features have been disabled.
+
+Ruud de Rooij <r...@debian.org> Fri, 5 Nov 1999 19:48:54 +0100
diff --git a/debian/bsh b/debian/bsh
new file mode 100644
index 0000000..6adb880
--- /dev/null
+++ b/debian/bsh
@@ -0,0 +1,9 @@
+#!/bin/sh
+if [ "$1" = "-classpath" ]
+then
+ CLASSPATH="$2"
+ shift 2
+fi
+CLASSPATH="${CLASSPATH:-.}:/usr/share/java/bsh.jar"
+export CLASSPATH
+exec java bsh.Interpreter "$@"
diff --git a/debian/bsh.1 b/debian/bsh.1
new file mode 100644
index 0000000..a54880d
--- /dev/null
+++ b/debian/bsh.1
@@ -0,0 +1,40 @@
+.TH BSH 1
+.SH NAME
+bsh \- BeanShell: A Java scripting environment.
+.SH SYNOPSIS
+.B bsh
+.RB [\| \-classpath
+.IR path \|]
+.RI [\| file \|]
+.br
+.B xbsh
+.SH "DESCRIPTION
+BeanShell is a small, embeddable, Java source interpreter with object scripting
+language features, written in Java. BeanShell executes standard Java statements
+and expressions, in addition to obvious scripting commands and syntax. You can
+also script objects as simple method closures like those in Perl and
+JavaScript(tm).
+
+.B bsh
+starts the command-line version of BeanShell, whereas
+.B xbsh
+starts the windowed version.
+.SH OPTIONS
+The program
+.B bsh
+optionally takes a
+.B \-classpath
+option which sets the value of the
+.B CLASSPATH
+environment variable to the specified path before starting the BeanShell. This
+option is mainly provided for compatibility with JDE (Java Development
+Environment for Emacs).
+
+In addition, a file to be executed may be given as argument to
+.BR bsh .
+.SH "SEE ALSO"
+More documentation on BeanShell can be found in
+.I /usr/share/doc/bsh/
+.SH AUTHOR
+This manual page was written by Ruud de Rooij <r...@debian.org>
+for the Debian GNU/Linux system (but may be used by others).
diff --git a/debian/bsh.html b/debian/bsh.html
new file mode 100644
index 0000000..b09c0d7
--- /dev/null
+++ b/debian/bsh.html
@@ -0,0 +1,652 @@
+<!-- Originally written by Paul Kinnucan for JDE, licensed under GPL.
+ Modified for bsh Debian package by
+ Ruud de Rooij <r...@debian.org> Sun, 11 Jul 1999 13:59:16 +0200 -->
+
+<HTML>
+<HEAD>
+ <TITLE>BeanShell User's Guide</TITLE>
+</HEAD>
+<BODY>
+
+<H1>
+BeanShell User's Guide</H1>
+
+<H2>
+<A NAME="Introduction"></A>Introduction</H2>
+This guide explains how to use the BeanShell Java interpreter. This guide
+contains the following
+sections:
+<BR>
+<BR>
+<TABLE BORDER=0 WIDTH="100%" >
+<TR>
+<TD><A HREF="#About">About the BeanShell</A> </TD>
+
+<TD>Brief overview of the BeanShell </TD>
+</TR>
+
+<TR>
+<TD VALIGN=TOP><A HREF="#Using">Using the BeanShell</A> </TD>
+
+<TD>Explains how to start and shut down the BeanShell, enter statements,
+and show results.</TD>
+</TR>
+
+<TR>
+<TD VALIGN=TOP><A HREF="#LanguageRef">The BeanShell Language</A> </TD>
+
+<TD>Describes the Java constructs and scripting extensions supported by
+the BeanShell</TD>
+</TR>
+
+<TR>
+<TD><A HREF="#CommandRef">BeanShell Commands</A> </TD>
+
+<TD>Describes the commands supported by the BeanShell</TD>
+</TR>
+</TABLE>
+
+<H2>
+<A NAME="About"></A>About the BeanShell</H2>
+The BeanShell is a Java interpreter that evaluates Java statements directly
+(without first compiling them).
+
+<P>The BeanShell can operate as a stand-alone application or as a part
+of another application. When running as a stand-alone application, the
+interpreter accepts input from the command line of the shell in which it
+runs. The BeanShell distribution includes a shell for running the interpreter.
+It can, however, be run from other shells, such as bash.
+
+<H2>
+<A NAME="Using"></A>Using the BeanShell</H2>
+
+<H3>
+<A NAME="Starting"></A>Starting the BeanShell</H3>
+To start the BeanShell, type <TT>bsh</TT> for the command-line version, or
+<TT>xbsh</TT> for the windowed version. To use the Swing interface, make sure
+that the Swing libraries are included in your <TT>CLASSPATH</TT> environment
+variable before starting xbsh.
+
+<H3>
+<A NAME="Evaluating"></A>Evaluating Statements</H3>
+To evaluate a Java statement, type it at the BeanShell prompt and press
+the <B><FONT SIZE=-1>Enter</FONT></B> key. The BeanShell evaluates the
+statement. When it is done, it redisplays the the BeanShell command prompt.
+You can then enter another statement.
+
+<P>Statements must conform to Java syntax. For example, simple statements
+must end in a semicolon. Compound statements, such as if-then constructs,
+must end in a right brace. Statements may span multiple lines. To continue
+a statement on a new line, press the <B><FONT SIZE=-1>Enter</FONT></B>
+key. The BeanShell does not evaluate the statement until you have entered
+the last line of the statement.
+
+<H3>
+<A NAME="Displaying"></A>Displaying Results</H3>
+You can display the results of evaluating Java statements via the BeanShell
+<TT>print</TT> and <TT>show</TT> commands. The print command accepts any
+Java expression as an argument and displays the result of evaluating that
+expression in the BeanShell window. For example,
+<BLOCKQUOTE><TT>print(2+2);</TT></BLOCKQUOTE>
+displays
+<BLOCKQUOTE><TT>4</TT></BLOCKQUOTE>
+in the BeanShell window. Note that <TT>print(expr)</TT> is equivalent to
+<TT>System.out.println(expr)</TT> and you can use either method to print
+a Java expression.
+
+<P>The <TT>show();</TT> command toggles automatic display of the results
+of evaluating statements as they are entered.
+<H3>
+<A NAME="Exiting"></A>Exiting the Shell</H3>
+To exit the BeanShell, enter
+<BLOCKQUOTE><TT>exit();</TT></BLOCKQUOTE>
+at the commmand prompt.
+<H2>
+<A NAME="LanguageRef"></A>The BeanShell Language</H2>
+
+<H3>
+<A NAME="JavaSupport"></A>Java Language Support</H3>
+The BeanShell language includes most of the constructs of the Java language.
+Standard Java constructs supported by the BeanShell include variable
+assignments, method calls, math expressions, for-loops, etc.. Here are
+some examples:
+<PRE> // Use a hashtable
+ Hashtable h = new Hashtable();
+ Date d = new Date();
+ h.put("today", d);
+
+ // Print the current clock value
+ print( System.currentTimeMillis() );
+
+ // Loop
+ for (int i=0; i<5; i++)
+ print(i);
+
+ // Pop up an AWT frame with a button in it
+ Button b = new Button("My Button");
+ Frame f = new Frame("My Frame");
+ f.add(b, "Center");
+ f.pack();
+ f.show();</PRE>
+By default, the BeanShell imports the Java core classes at startup. You
+can import additional classes, using standard Java import syntax, for example,
+<BLOCKQUOTE><TT>import mypackage.*;</TT></BLOCKQUOTE>
+or
+<PRE> import mypackage.MyClass;</PRE>
+
+<H3>
+<A NAME="ScriptExtensions"></A>Scripting Extensions</H3>
+The BeanShell defines a number of extensions to the Java language designed
+to facilitate creation of scripts. The scripting extensions include
+<UL>
+<LI>
+Script Variables</LI>
+
+<LI>
+Script Methods</LI>
+
+<LI>
+Implicit Objects</LI>
+
+<LI>
+Syntax for accessing Bean properties and Hashtable entries</LI>
+</UL>
+
+<H3>
+<A NAME="ScriptVariables"></A>Script Variables</H3>
+The BeanShell allows you to create a special type of variable named a script
+variable. Unlike a standard Java variable, which can reference objects
+only of a specified type, a script variable can be defined to reference
+any type of object, including primitive types, such as <TT>int</TT> and
+<TT>boolean</TT>. You create a script variable by declaring it with or
+without a type specifier. If you include a type specifier, the variable
+can reference only values of the specified type. If you do not specify
+a type, the variable can reference values of any type. For example, the
+following statement
+<PRE> foo = new Button("Another Button");</PRE>
+creates an untyped script variable named <TT>foo</TT> and assigns it a
+Button object. You are free to subsequently assign <TT>foo</TT> to
+any other type of object.
+<H4>
+Predefined Variables</H4>
+
+<UL>
+<LI>
+<B>$_</B> - the value of the last expression evaluated.</LI>
+
+<LI>
+<B>bsh.Console bsh.console</B> - The primary console, if one exists.</LI>
+
+<LI>
+<B>java.awt.AppletContext bsh.appletcontext</B> - the applet context, if
+one exists.</LI>
+
+<LI>
+<B>String bsh.cwd</B> - used by the cd() and dir() commands.</LI>
+
+<LI>
+<B>boolean bsh.show</B> - used by the show() command.</LI>
+
+<LI>
+<B>boolean bsh.interactive</B> - is this interpreter running in an interactive
+mode or sourcing a file?</LI>
+
+<LI>
+<B>boolean bsh.evalOnly</B> - Does this interpreter have an input stream
+or is it only serving as a bag for eval() operations.</LI>
+</UL>
+
+<H4>
+Undefined variables</H4>
+You can test to see if a variable is "undefined" with the value <TT>void</TT>,
+e.g.:
+<PRE> if ( foobar == void )
+ // undefined</PRE>
+You can return a defined variable to the undefined state using the unset()
+command:
+<BLOCKQUOTE><TT>a == void; // true</TT>
+<BR><TT>a=5;</TT>
+<BR><TT>unset("a"); // note the quotes</TT>
+<BR><TT>a == void; // true</TT></BLOCKQUOTE>
+
+<H3>
+<A NAME="ScriptMethods"></A>Script Methods</H3>
+BeanShell lets you define and use a special type of method called a script
+method. Script methods differ from standard Java methods in the following
+ways:
+<UL>
+<LI>
+Script methods are methods of an implicit, typeless object</LI>
+
+<LI>
+Script methods can be defined to accept and return values of any type</LI>
+
+<LI>
+Script methods can define other script methods</LI>
+</UL>
+You use standard Java syntax to declare a script method that accepts
+and returns specific types. For example, the following code
+<PRE> int addTwoNumbers( int a, int b ) {
+ return a + b;
+ }</PRE>
+defines a BeanShell method called <TT>addTwoNumbers</TT> that accepts and
+returns values of type <TT>int</TT>. The next example
+<PRE> int a = addTwoNumbers( 5, 7 );</PRE>
+uses the newly defined method to add two values of type <TT>int</TT>.
+
+<P>You define an untyped script method by omitting type specifications.
+For example, the following statement
+<PRE> add( a, b ) {
+ return a + b;
+ }</PRE>
+defines a script method that accepts arguments of any type. When you invoke
+an untyped script method, BeanShell interprets the method based on the
+types of the arguments that you pass to the method. Consider, for example,
+the following invocations of the untyped add method defined in the preceding
+example:
+<PRE> foo = add(1, 2);
+ print( foo ); // 3
+
+ foo = add("Oh", " baby");
+ print( foo ); // Oh baby</PRE>
+The first invocation returns the result of adding, the second, of concatenating
+the arguments.
+
+<P>Methods with unspecified return types may return any type of object
+or no object. A return statement is optional. If omitted, the method returns
+the value of the last statement or expression in the method body.
+<H4>
+Method Namespace</H4>
+The namespaces of script methods and variables are separate. Thus, you
+can define a method and a variable having the same name.
+<H4>
+Nested Methods</H4>
+Script methods may define methods, for example,
+<PRE> foo() {
+ bar() {
+ ...
+ }
+ }</PRE>
+Method may be nested in this way to an arbitrary depth. Within a nested
+method, locally declared variables and methods shadow identically
+named variables and methods declared in outer methods. Otherwise, variables
+and methods are visible to an arbitrary depth of scope. Outer methods can
+invoke methods defined by inner methods that return a <TT>this</TT> object,
+for example,
+<H3>
+<A NAME="ImplicitObjects"></A>Implicit Objects</H3>
+The methods and variables defined by a script method are considered to
+be methods and fields of an implicit object. The reserved identifiers,
+<TT>this</TT>, <TT>super</TT>, and <TT>global</TT>, refer, respectively,
+to the current object, the calling object, and the global object. A method
+can access any variable or method in these scopes by qualifying the variable's
+name with the name of the appropriate implicit object.
+<PRE> a = 42;
+ foo() {
+ a = 97;
+ print( a );
+ print( this.a );
+ print( super.a );
+ }
+
+ foo(); // prints 97, 97, 42</PRE>
+A script method can return its implicit object, thereby allowing the invoking
+script to access variables and methods defined by the method, using standard
+Java "." notation. For example,
+<PRE> foo() {
+ int a = 42;
+ bar() {
+ print("The
bar is open!");
+ }
+
+ bar();
+ return this;
+ }
+
+ obj = foo(); // prints "the bar is
open!"
+ print ( obj.a ) // 42
+ obj.bar(); // prints
"the bar is open!"</PRE>
+
+<H4>
+Using Implicit Objects as AWT Event Handlers</H4>
+Implicit method objects can serve as AWT event handlers. To handle an AWT
+event, a script method defines the appropriate event-handling method and
+then registering its implicit (<TT>this</TT>) object with the object in
+which the event originates. For example, the following script
+<PRE> button = new java.awt.Button("foo!");
+
+ actionPerformed( event ) {
+ print( event );
+ }
+
+ button.addActionListener( this );
+ frame( button ); // show it</PRE>
+defines an Action event handler and registers it with a button.
+
+<P>Remember that you don't have to define all of your event handlers globally.
+You can handle events in any bsh object scope. For example, the following
+method creates a button that displays a message when pushed:
+<PRE> messageButton( message ) {
+ b = new Button("Press Me");
+ b.addActionListener( this );
+ frame(b);
+
+ actionPerformed( e ) {
+ print(
message );
+ }
+ }
+
+ messageButton("Hey you!");
+ messageButton("Another message...");</PRE>
+The above will create two buttons and each will display its own message
+when pushed. Each has a separate instance of the event handler object.
+Note too that we could return a 'this' reference from the handler method
+and use it in other contexts to register listeners...
+<H4>
+Using Implicit Objects as Threads</H4>
+'This' type references also implement the standard Runnable interface,
+so you can declare a "run()" method in your objects:
+<BLOCKQUOTE> <TT> foo() {</TT>
+<BR><TT> run() {</TT>
+<BR><TT>
+// do work...</TT>
+<BR><TT> }</TT>
+<BR><TT> return this;</TT>
+
+<P><TT> }</TT>
+<BR><TT> </TT>
+<BR><TT> foo = foo();</TT>
+<BR><TT> new Thread( foo ).start();</TT>
+<BR> </BLOCKQUOTE>
+
+<H4>
+Implicit Object Members</H4>
+Implicit objects have four "magic" members:
+<BLOCKQUOTE>
+<DIR>
+<LI>
+<TT>this.interpreter</TT> refers to the currently executing BeanShell
Interpreter
+object.</LI>
+
+<LI>
+<TT>this.namespace</TT> refers to the BeanShell NameSpace object of the
+current context.</LI>
+
+<LI>
+<TT>this.variables</TT> refers to an array of strings listing the variables
+defined in this namespace.</LI>
+
+<LI>
+<TT>this.methods</TT> refers to an array of strings listing the methods
+defined in this namespace.</LI>
+</DIR>
+</BLOCKQUOTE>
+These are mainly for internal use by BeanShell commands. Note that there
+are certain special situations in which the <TT>this.interpreter</TT> reference
+may not be available, such as in AWT event handlers.
+<H3>
+<A NAME="PropSyntax"></A>Extended Syntax for Accessing Bean Properties
+and Hashtables Entries</H3>
+You may use the following syntax
+<BLOCKQUOTE><TT>x{name}</TT></BLOCKQUOTE>
+to access properties of Java beans and Hashtable entries, where <TT>x</TT>
+is a bean or Hashtable and <TT>name</TT> is a String that identifies a
+bean property or hashtable entry, for example:
+<PRE> b = new java.awt.Button();
+ b{"label"} = "my button";
+ // Equivalent to: b.setLabel("my button");
+
+ h = new Hashtable();
+ h{"foo"} = "bar";
+ // Equivalent to: h.put("foo", "bar");</PRE>
+
+<H2>
+<A NAME="CommandRef"></A>BeanShell Commands</H2>
+The BeanShell provides a set of commands for displaying data, invoking
+system utilities, and performing various other tasks. See the BeanShell
+Command Reference for a description of the syntax and usage of each command.
+The current crop of bsh commands follow. These are, for the most part,
+just very short bsh scripts, supplied in the bsh.jar file. See <A
HREF="#making">making
+bsh commands</A> below for more details on adding to the "built-in" bsh
+command set.
+<BR>
+<BR>
+<HR>
+<H3>
+<A NAME="bgCommand"></A>bg</H3>
+<TT>bg( String script )</TT>
+
+<P>This is like <TT>run()</TT> except that it runs the command in its own
+thread. Returns the thread object (for <TT>stop()</TT>ing, <TT>join()</TT>ing,
+etc.)
+<BR>
+<HR>
+<H3>
+<A NAME="BrowseClassCommand"></A>browseClass</H3>
+<TT>void browseClass(String classname);</TT>
+
+<P>Displays a class browser. The browser enables you to browse the contents
+of any packages packaged as <TT>jar</TT> files on the classpath.
+<BR>
+<BR>
+<HR>
+<H3>
+<A NAME="catCommand"></A>cat</H3>
+<TT>void cat( String filename )</TT>
+
+<P>Print the contents of filename (like Unix cat)
+<BR>
+<HR>
+<H3>
+<A NAME="cdCommand"></A>cd</H3>
+<TT>void cd(String dirname);</TT>
+
+<P>Change working directory for the <TT>dir()</TT> command (like Unix
<TT>cd</TT>).
+<BR>
+<BR>
+<HR>
+<H3>
+<A NAME="consoleCommand"></A>console</H3>
+<TT>bsh.Console console()</TT>
+
+<P>Create a console window attached to the current interpreter. Returns
+the console Frame.
+<BR>
+<HR>
+<H3>
+<A NAME="dirCommand"></A>dir</H3>
+<TT>void dir(String dirname)</TT>
+
+<P>Display the contets of directory dirname. The format is similar to the
+Unix ls -l command.
+<BR>
+<HR>
+<H3>
+<A NAME="debugCommand"></A>debug</H3>
+<TT>void debug()</TT>
+
+<P>Toggle on and off debug mode... Note: debug output is verbose and gross.
+<BR>
+<HR>
+<H3>
+<A NAME="EditorCommand"></A>editor</H3>
+
+<DL>
+<DT>
+<TT>Frame Frame editor();</TT></DT>
+</DL>
+
+
+<P>Create an editor window with an "eval" button. This is primarily useful
+for typing multi-line commands and experimenting with methods when running
+the BeanShell outside of the Emacs environment. Returns the editor Frame.
+<BR>
+<HR>
+<H3>
+<A NAME="evalCommand"></A>eval</H3>
+<TT>void eval( String expression )</TT>
+
+<P>Evaluate the string in the current interpreter (see <TT>source</TT>).
+<BR>
+<HR>
+<H3>
+ <A NAME="execCommand"></A><B>exec</B></H3>
+
+<DL>
+<DT>
+<TT>exec(String process);</TT></DT>
+</DL>
+
+
+<P>Get the Java Runtime and start the external process, display any output.
+<BR>
+<HR>
+<H3>
+<A NAME="exitCommand"></A>exit</H3>
+<TT>void exit()</TT>
+
+<P>Call System.exit(0);
+<BR>
+<HR>
+<H3>
+<A NAME="FrameCommand"></A>frame</H3>
+
+<DL>
+<DT>
+<TT>Frame frame(Component component);</TT></DT>
+</DL>
+
+
+<P>Display the component, centered and packed, in a top level Frame. Returns
+the frame. Frame takes additional steps to handle the WindowClosing AWT
+event and dispose of the frame, so that you an close the window normally.
+<BR>
+<HR>
+<H3>
+ <A NAME="getResourceCommand"></A>getResource</H3>
+<TT>URL getResource( String path )</TT>
+
+<P>The equivalent of calling getResource() on the interpreter class in
+the bsh package. Use absolute paths to get stuff in the classpath.
+<BR>
+<HR>
+<H3>
+<A NAME="LoadCommand"></A>load</H3>
+
+<DL>
+<DT>
+<TT>Object load( String filename )</TT></DT>
+</DL>
+
+
+<P>Load a serialized Java object from filename. Returns the object.
+<BR>
+<HR>
+<H3>
+<A NAME="pathToFileCommand"></A>pathToFile</H3>
+<TT>File pathToFile( String filename )</TT>
+
+<P>Create a File object corresponding to the specified file path name,
+taking into account the bsh current working directory (bsh.cwd)
+<BR>
+<HR>
+<H3>
+<A NAME="PrintCommand"></A>print</H3>
+<TT>void print(item);</TT>
+
+<P>Print the string value of the item. item may be of any type.
+<BR>
+<HR>
+<H3>
+<A NAME="pwdCommand"></A><B>pwd</B></H3>
+
+<DL>
+<DT>
+<TT>void pwd();</TT></DT>
+</DL>
+
+
+<P>Print the bsh working directory. This is the cwd obeyed by all the unix
+like bsh comands.
+<BR>
+<HR>
+<H3>
+<A NAME="rmCommand"></A>rm</H3>
+<TT>void rm();</TT>
+
+<P>Remove the file (like Unix rm)
+<BR>
+<HR>
+<H3>
+<A NAME="runCommand"></A>run</H3>
+<TT>run( String script )</TT>
+
+<P>run() is like source() except that it runs the command in a new, subordinate
+and prune()'d namespace. So it's like "running" a command instead of "sourcing"
+it ;)
+<BR>
+<HR>
+<H3>
+<A NAME="SaveCommand"></A>save</H3>
+<TT>void save(Component component, String filename);</TT>
+
+<P>Save a serializable Java object to filename.
+
+<P>Since the AWT Button class happens to be serializable, we could test
+drive the save() command.
+<PRE> save(foo, "myButton.ser");</PRE>
+If we did save our button, we could revive it later with the load() command.
+<BR> <TT>bar = load("myButton.ser");</TT>
+<BR><TT>frame(bar);</TT>
+<BR>
+<HR>
+<H3>
+ <A NAME="serverCommand"></A>server</H3>
+<TT>void server( int port )</TT>
+
+<P>Create a Server Mode
+server attached to the current interpreter, listening on the specified
+port.
+<BR>
+<HR>
+<H3>
+ <A NAME="setFontCommand"></A>setFont</H3>
+<TT>Font setFont( Component comp, int ptsize )</TT>
+
+<P>Change the point size of the font on the specified component, to ptsize.
+<BR>
+<HR>
+<H3>
+<A NAME="ShowCommand"></A>show</H3>
+<TT>void show();</TT>
+
+<P>Toggle on or off the display of the value of expressions evalauted on
+the command line. Show mode may be useful if you find yourself typing print()
+a lot.
+<BR>
+<HR>
+<H3>
+<A NAME="sourceCommand"></A>source</H3>
+<TT>void source( String filename )</TT>
+
+<P>Read filename into the interpreter and evaluate it in the current namespace.
+Like Bourne Shell "." command.
+<BR>
+<HR>
+<H3>
+<A NAME="unsetCommand"></A>unset</H3>
+<TT>void unset(String name);</TT>
+
+<P>"undefine" the variable specified by 'name' (So that it tests == void).
+<BR>
+<H2>
+<A NAME="MakeCommands"></A>Making BeanShell Commands</H2>
+Adding to the set of "prefab" commands supplied with bsh can be about as
+easy as writing any other bsh methods. You simply have to place your bsh
+scripts in a bsh/commands/ directory in the classpath (or inside the JAR
+file).
+
+<P>
+<BR>
+</BODY>
+</HTML>
diff --git a/debian/changelog b/debian/changelog
new file mode 100644
index 0000000..003b9ea
--- /dev/null
+++ b/debian/changelog
@@ -0,0 +1,79 @@
+bsh (1.3.0-2) unstable; urgency=low
+
+ * debian/bsh.1: changed the location of the 'more documentation'
+ location. Thanks to Alex Malinovich (closes: #226955).
+
+ -- Arnaud Vandyck <av...@debian.org> Sat, 10 Jan 2004 01:00:13 +0100
+
+bsh (1.3.0-1) unstable; urgency=low
+
+ * New upstream release (closes: #192186).
+ * New maintainer (closes: #224860).
+ * debian/control:
+ - Build-Depends-Indep: changed the debhelper version depends, added
+ javacc (now in Debian), added j2sdk1.3.
+ - Standards-Version: 3.6.1 (but did not change anything).
+ - Description: removed the leading `A', added Homepage.
+ * debian/rule:
+ - removed the JAVACC_DIR variable and changed the location of jjtree
+ and javacc
+ * debian/xbsh:
+ - added minimal and maximal size of the virtual machine.
+
+ -- Arnaud Vandyck <av...@debian.org> Sun, 28 Dec 2003 01:42:13 +0100
+
+bsh (1.2b6-2) unstable; urgency=low
+
+ * Orphan the package.
+
+ -- Tollef Fog Heen <tfh...@debian.org> Tue, 23 Dec 2003 02:04:34 +0100
+
+bsh (1.2b6-1) unstable; urgency=low
+
+ * New upstream version (closes: #159673)
+
+ -- Tollef Fog Heen <tfh...@debian.org> Mon, 9 Sep 2002 22:52:59 +0200
+
+bsh (1.1alpha5-1) unstable; urgency=low
+
+ * New maintainer (closes: #90307)
+ * New upstream version
+ * Build with j2sdk1.3 available from blackdown. I think it still works
+ with older jre's. (It does, according to the docs.)
+ * add bsh/classpath/*.class into the jar file
+ * Updated standards-version to 3.5.2
+
+ -- Tollef Fog Heen <tfh...@debian.org> Mon, 16 Apr 2001 22:34:58 +0200
+
+bsh (1.0-beta-2) unstable; urgency=low
+
+ * Forgot to include bsh/commands/*.bsh into jar file.
+
+ -- Ruud de Rooij <r...@debian.org> Fri, 5 Nov 1999 22:28:59 +0100
+
+bsh (1.0-beta-1) unstable; urgency=low
+
+ * New upstream release.
+ * Move from non-free to contrib, since BeanShell is now LGPL but depends
+ on JavaCC for compilation.
+ * Updated debian/control, debian/copyright and debian/rules.
+
+ -- Ruud de Rooij <r...@debian.org> Fri, 5 Nov 1999 21:17:35 +0100
+
+bsh (0.96-3) unstable; urgency=low
+
+ * Standards-Version: 3.0.1.
+
+ -- Ruud de Rooij <r...@debian.org> Tue, 7 Sep 1999 18:42:09 +0200
+
+bsh (0.96-2) unstable; urgency=low
+
+ * Removed `free' from the package description.
+
+ -- Ruud de Rooij <r...@debian.org> Mon, 16 Aug 1999 20:18:45 +0200
+
+bsh (0.96-1) unstable; urgency=low
+
+ * Initial Release.
+
+ -- Ruud de Rooij <r...@debian.org> Sun, 11 Jul 1999 12:41:22 +0200
diff --git a/debian/control b/debian/control
new file mode 100644
index 0000000..b04a27c
--- /dev/null
+++ b/debian/control
@@ -0,0 +1,25 @@
+Source: bsh
+Section: contrib/devel
+Priority: optional
+Maintainer: Debian Java Maintainers
<pkg-java-maintainers@lists.alioth.debian.org>
+Uploaders: Arnaud Vandyck <av...@debian.org>
+Build-Depends-Indep: debhelper (>= 4.0.0), j2sdk1.3 | kaffe (>= 1.1.1) |
java-compiler, libservlet2.3-java, javacc
+Standards-Version: 3.6.1
+
+Package: bsh
+Architecture: all
+Depends: java-common, jdk1.1 | java-virtual-machine
+Suggests: libservlet2.3-java
+Recommends: xlibs
+Description: Java scripting environment
+ BeanShell is a small, free, embeddable, Java source interpreter with object
+ scripting language features, written in Java. BeanShell executes standard Java
+ statements and expressions, in addition to obvious scripting commands and
+ syntax. BeanShell supports scripted objects as simple method closures like
+ those in Perl and JavaScript(tm).
+ .
+ You can use BeanShell interactively for Java experimentation and debugging or
+ as a simple scripting engine for you applications. In short: BeanShell is a
+ dynamically interpreted Java, plus some useful stuff.
+ .
+ Homepage: http://www.beanshell.org/
diff --git a/debian/copyright b/debian/copyright
new file mode 100644
index 0000000..bd36be0
--- /dev/null
+++ b/debian/copyright
@@ -0,0 +1,45 @@
+This is the Debian GNU/Linux prepackaged version of BeanShell (bsh), a Java
+scripting environment. BeanShell was written by Pat Niemeyer.
+
+This package was put together by Ruud de Rooij <r...@debian.org> from source
+obtained from:
+
+http://www.beanshell.org/
+
+BeanShell is Copyright (C) Pat Niemeyer:
+
+/*****************************************************************************
+ * *
+ * This file is part of the BeanShell Java Scripting distribution. *
+ * Documentation and updates may be found at http://www.beanshell.org/ *
+ * *
+ * Sun Public License Notice: *
+ * *
+ * The contents of this file are subject to the Sun Public License Version *
+ * 1.0 (the "License"); you may not use this file except in compliance with *
+ * the License. A copy of the License is available at http://www.sun.com *
+ * *
+ * The Original Code is BeanShell. The Initial Developer of the Original *
+ * Code is Pat Niemeyer. Portions created by Pat Niemeyer are Copyright *
+ * (C) 2000. All Rights Reserved. *
+ * *
+ * GNU Public License Notice: *
+ * *
+ * Alternatively, the contents of this file may be used under the terms of *
+ * the GNU Lesser General Public License (the "LGPL"), in which case the *
+ * provisions of LGPL are applicable instead of those above. If you wish to *
+ * allow use of your version of this file only under the terms of the LGPL *
+ * and not to allow others to use your version of this file under the SPL, *
+ * indicate your decision by deleting the provisions above and replace *
+ * them with the notice and other provisions required by the LGPL. If you *
+ * do not delete the provisions above, a recipient may use your version of *
+ * this file under either the SPL or the LGPL. *
+ * *
+ * Patrick Niemeyer (p...@pat.net) *
+ * Author of Learning Java, O'Reilly & Associates *
+ * http://www.pat.net/~pat/ *
+ * *
+ *****************************************************************************/
+
+On Debian systems, the complete text of the GNU Library General
+Public License can be found in `/usr/share/common-licenses/LGPL-2'.
diff --git a/debian/dirs b/debian/dirs
new file mode 100644
index 0000000..d7ef473
--- /dev/null
+++ b/debian/dirs
@@ -0,0 +1,3 @@
+usr/bin
+usr/share/java
+usr/share/man/man1
diff --git a/debian/menu b/debian/menu
new file mode 100644
index 0000000..92a47e4
--- /dev/null
+++ b/debian/menu
@@ -0,0 +1,4 @@
+?package(bsh):needs="text" section="Apps/Programming" \
+ title="BeanShell (text)" command="/usr/bin/bsh"
+?package(bsh):needs="X11" section="Apps/Programming" \
+ title="BeanShell (windowed)" command="/usr/bin/xbsh"
diff --git a/debian/rules b/debian/rules
new file mode 100755
index 0000000..bfc3bb7
--- /dev/null
+++ b/debian/rules
@@ -0,0 +1,61 @@
+#!/usr/bin/make -f
+
+CLASSPATH=.:/usr/share/java/servlet-2.3.jar
+
+JJTREE=/usr/bin/jjtree
+JAVACC=/usr/bin/javacc
+JAVAC=/usr/bin/javac
+
+build: build-stamp
+build-stamp:
+ dh_testdir
+ mkdir tmp
+ cp -R BeanShell/src/bsh BeanShell/src/Manifest* tmp
+# rm tmp/bsh/XThis.java
+ cd tmp/bsh && $(JJTREE) bsh.jjt
+ cd tmp/bsh && $(JAVACC) bsh.jj
+ cd tmp/bsh && CLASSPATH=$(CLASSPATH) $(JAVAC) \
+ */*.java *.java
+ cd tmp && jar cfm ../bsh.jar Manifest.console bsh/util/*.class \
+ bsh/util/lib/* bsh/commands/*.class bsh/commands/*.bsh \
+ bsh/*.class bsh/classpath/*.class
+ touch build-stamp
+ lynx -dump -nolist BeanShell/src/Changes.html > Changes
+
+clean:
+ dh_testdir
+ dh_testroot
+ rm -rf tmp bsh.jar
+ rm -f build-stamp install-stamp > Changes
+ dh_clean
+
+install: install-stamp
+install-stamp: build-stamp
+ dh_testdir
+ dh_testroot
+ dh_clean -k
+ dh_installdirs
+ install -m 755 debian/bsh debian/xbsh debian/tmp/usr/bin/
+ install -m 644 bsh.jar debian/tmp/usr/share/java/bsh.jar
+ touch install-stamp
+
+binary-indep: build install
+ dh_testdir
+ dh_testroot
+ dh_installdocs BeanShell/src/README.txt debian/bsh.html
+ dh_installexamples
+ dh_installmenu
+ dh_installmanpages
+ dh_installchangelogs BeanShell/src/Changes.html
+ dh_link usr/share/man/man1/bsh.1.gz usr/share/man/man1/xbsh.1.gz
+ dh_compress
+ dh_fixperms
+ dh_installdeb
+ dh_gencontrol
+ dh_md5sums
+ dh_builddeb
+
+binary-arch: build install
+
+binary: binary-indep binary-arch
+.PHONY: build clean binary-indep binary-arch binary
diff --git a/debian/xbsh b/debian/xbsh
new file mode 100644
index 0000000..d593428
--- /dev/null
+++ b/debian/xbsh
@@ -0,0 +1,4 @@
+#!/bin/sh
+CLASSPATH="${CLASSPATH:-.}:/usr/share/java/bsh.jar"
+export CLASSPATH
+exec java -Xms128m -Xmx256m bsh.Console "$@"
--
Alioth's /usr/local/bin/git-commit-notice on
/srv/git.debian.org/git/pkg-java/bsh.git
_______________________________________________
pkg-java-commits mailing list
pkg-java-comm...@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-java-commits
