home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava3 / hotjava3.exe / hotjava / classsrc / java / tools / jsc / ScriptContext.java < prev   
Encoding:
Java Source  |  1995-08-11  |  7.6 KB  |  265 lines
  1. /*
  2.  * @(#)ScriptContext.java    1.1 95/05/10
  3.  * 
  4.  * Copyright (c) 1995 Sun Microsystems, Inc.  All Rights reserved Permission to
  5.  * use, copy, modify, and distribute this software and its documentation for
  6.  * NON-COMMERCIAL purposes and without fee is hereby granted provided that
  7.  * this copyright notice appears in all copies. Please refer to the file
  8.  * copyright.html for further important copyright and licensing information.
  9.  * 
  10.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  11.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  12.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
  13.  * OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY
  14.  * LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR
  15.  * ITS DERIVATIVES.
  16.  */
  17.  
  18. package java.tools.jsc;
  19. import java.util.Hashtable;
  20. import java.io.*;
  21.  
  22. /**
  23.  * A class to define an execution context for a Java Tool Command
  24.  * Language script.
  25.  * @author  James Gosling
  26.  */
  27.  
  28. public class ScriptContext {
  29.     private Hashtable defs = new Hashtable();
  30.     private Hashtable vars = new Hashtable();
  31.     private ScriptContext parent;
  32.     ActiveFunction CurrentCommand;
  33.     static private ScriptCommand unc;
  34.     public boolean verbose;
  35.     static private ScriptContext defaultParent = new ScriptContext ("java.tools.jsc.commands.cmd_");
  36.     static {
  37.     new java.tools.jsc.commands.StandardCommands(defaultParent);
  38.     };
  39.     private String ResolvePackage;
  40.     public ScriptContext (String PackagePrefix) {
  41.     ResolvePackage = PackagePrefix;
  42.     parent = defaultParent;
  43.     }
  44.     public ScriptContext (String PackagePrefix, ScriptContext Parent) {
  45.     ResolvePackage = PackagePrefix;
  46.     parent = Parent != null ? Parent : defaultParent;
  47.     }
  48.     public Object eval(Object expr) {
  49.     if (expr == null || !(expr instanceof ActiveFunction))
  50.         return expr;
  51.     Object ret = null;
  52.     for (ActiveFunction af = (ActiveFunction) expr;
  53.         af != null; af = af.next) {
  54.         if (verbose)
  55.         System.out.print("Evaluating " + af + "\n");
  56.         ScriptCommand cmd = af.resolution;    // Get command to execute
  57.         String cmds = af.command;
  58.     resolve:if (cmd == null) {    // not resolved yet
  59.         for (ScriptContext sc = this; sc != null; sc = sc.parent) {
  60.             cmd = (ScriptCommand) sc.defs.get(cmds);
  61.             if (cmd != null) {    // resolve from contexts definitions
  62.             af.resolution = cmd;
  63.             break resolve;
  64.             }
  65.         }
  66.         for (ScriptContext sc = this; sc != null; sc = sc.parent)
  67.             if (sc.ResolvePackage != null) {
  68.             try {    // resolve by looking for class
  69.                 cmd = (ScriptCommand) new(sc.ResolvePackage + cmds);
  70.                 af.resolution = cmd;
  71.                 sc.defs.put(cmds, cmd);
  72.                 break resolve;
  73.             } catch(Exception e) {
  74.             }
  75.             }
  76.         if (unc == null)// Cant find it anywhere
  77.             unc = new UnknownCommand();
  78.         cmd = unc;
  79.         defs.put(cmds, cmd);
  80.         }
  81.         ActiveFunction prev = CurrentCommand;
  82.         CurrentCommand = af;
  83.         try {
  84.         ret = cmd.eval(this);
  85.         } finally {
  86.         CurrentCommand = prev;
  87.         }
  88.     }
  89.     if (verbose)
  90.         System.out.print(ret == null ? "Returned NULL\n"
  91.                  : "Returned " + ret + "\n");
  92.     return ret;        // evaluate command
  93.     }
  94.     static public ActiveFunction parse(InputStream is) {
  95.     StreamTokenizer st = new StreamTokenizer(is);
  96.     st.resetSyntax();
  97.     st.wordChars(0, 0xFF);
  98.     st.whitespaceChars(0, ' ');
  99.     st.quoteChar('"');
  100.     st.ordinaryChar(';');
  101.     st.ordinaryChar('(');
  102.     st.ordinaryChar(')');
  103.     st.ordinaryChar('[');
  104.     st.ordinaryChar(']');
  105.     st.ordinaryChar('{');
  106.     st.ordinaryChar('}');
  107.     st.commentChar('#');
  108.     st.eolIsSignificant = true;
  109.     return parse(st);
  110.     }
  111.     static public ActiveFunction parse(String s) {
  112.     return parse(new StringInputStream(s));
  113.     }
  114.     static ActiveFunction parse(StreamTokenizer st) {
  115.     st.nextToken();
  116.     switch (st.ttype) {
  117.       case ')':
  118.       case ']':
  119.       case '}':
  120.       case StreamTokenizer.TT_EOF:
  121.         return null;
  122.       case '\n':
  123.       case ';':
  124.         return parse(st);
  125.       default:
  126.         throw new MalformedScriptException("Word expected at " + st);
  127.       case StreamTokenizer.TT_WORD:
  128.         return new ActiveFunction(st, st.sval);
  129.     }
  130.     }
  131.     public Object parseEval(InputStream is) {
  132.     return parseEval(is, false);
  133.     }
  134.     public Object parseEval(InputStream is, boolean print) {
  135.     StreamTokenizer st = new StreamTokenizer(is);
  136.     st.resetSyntax();
  137.     st.wordChars(0, 0xFF);
  138.     st.whitespaceChars(0, ' ');
  139.     st.quoteChar('"');
  140.     st.ordinaryChar(';');
  141.     st.ordinaryChar('(');
  142.     st.ordinaryChar(')');
  143.     st.ordinaryChar('[');
  144.     st.ordinaryChar(']');
  145.     st.ordinaryChar('{');
  146.     st.ordinaryChar('}');
  147.     st.commentChar('#');
  148.     st.eolIsSignificant = true;
  149.     Object ret = null;
  150.     if (print)
  151.         verbose = true;
  152.     if (verbose)
  153.         System.out.print("ParseEval " + is + "   " + st + "\n");
  154.     do {
  155.         Object c = parse(st);
  156.         if (c != null) {
  157.         ret = eval(c);
  158.         if (print) {
  159.             System.out.print(c + ": ");
  160.             if (ret == null)
  161.             System.out.print("NULL");
  162.             else
  163.             System.out.print(ret.toString());
  164.             System.out.print("\n");
  165.         }
  166.         } else if (verbose)
  167.         System.out.print("Parse returned null\n");
  168.     } while (st.ttype != StreamTokenizer.TT_EOF);
  169.     return ret;
  170.     }
  171.     public Object parseEval(String s) {
  172.     return parseEval(new StringInputStream(s));
  173.     }
  174.     public Object arg(int n) {
  175.     return CurrentCommand.args[n];
  176.     }
  177.     public Object evarg(int n) {
  178.     return eval(CurrentCommand.args[n]);
  179.     }
  180.     public int nargs() {
  181.     return CurrentCommand.args.length;
  182.     }
  183.     public String arg(int n, String def) {
  184.     Object oa[] = CurrentCommand.args;
  185.     if (n >= oa.length)
  186.         return def;
  187.     Object o = evarg(n);
  188.     return o == null ? null : o.toString();
  189.     }
  190.     public double arg(int n, double def) {
  191.     Object oa[] = CurrentCommand.args;
  192.     if (n >= oa.length)
  193.         return def;
  194.     Object o = evarg(n);
  195.     if (o == null)
  196.         return 0;
  197.     else if (o instanceof Number)
  198.         return ((Number) o).doubleValue();
  199.     else if (o instanceof String)
  200.         return Double.valueOf((String) o).doubleValue();
  201.     else
  202.         throw new MalformedScriptException("Number expected: " + o);
  203.     }
  204.     public int arg(int n, int def) {
  205.     Object oa[] = CurrentCommand.args;
  206.     if (n >= oa.length)
  207.         return def;
  208.     Object o = evarg(n);
  209.     if (o == null)
  210.         return 0;
  211.     else if (o instanceof Number)
  212.         return ((Number) o).intValue();
  213.     else if (o instanceof String)
  214.         return Integer.parseInt((String) o);
  215.     else
  216.         throw new MalformedScriptException("Number expected: " + o);
  217.     }
  218.     public String toString() {
  219.     return (CurrentCommand == null
  220.         ? "No current command"
  221.         : CurrentCommand.toString());
  222.     }
  223.     static public void main(String argv[]) {
  224.     if (argv == null || argv.length <= 0) {
  225.         defaultParent.parseEval(new BufferedInputStream(new FileInputStream("test.jsc")),
  226.         false);
  227.     } else
  228.         for (int i = 0; i < argv.length; i++) {
  229.         System.out.print(argv[i]);
  230.         System.out.print(": ");
  231.         try {
  232.             System.out.print(defaultParent.parseEval(argv[i]));
  233.         } catch(Exception e) {
  234.             // System.out.print(e+"\n");
  235.             e.printStackTrace();
  236.         }
  237.         System.out.print("\n");
  238.         }
  239.     }
  240.     public final void put(String key, Object value) {
  241.     if (verbose)
  242.         System.out.print("Set variable " + key + " to " + value + "\n");
  243.     vars.put(key.toLowerCase(), value);
  244.     }
  245.     public final Object get(String key) {
  246.     Object ret = vars.get(key.toLowerCase());
  247.     if (verbose)
  248.         System.out.print("Get variable " + key + " finds " + ret + "\n");
  249.     return ret;
  250.     }
  251.     public final void defun(String key, Object value) {
  252.     defs.put(key.toLowerCase(), value);
  253.     }
  254.     public final String command() {
  255.     return CurrentCommand.command;
  256.     }
  257. }
  258.  
  259. class UnknownCommand implements ScriptCommand {
  260.     public Object eval(ScriptContext ctx) {
  261.     throw new MalformedScriptException("Undefined command: " +
  262.                            ctx.CurrentCommand);
  263.     }
  264. }
  265.