gogo/shell/src/main/java/org/apache/felix/gogo/shell/Builtin.java - felix - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.felix.gogo.shell;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.StringWriter;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;
 import java.util.Map.Entry;

 import org.apache.felix.gogo.options.Option;
 import org.apache.felix.gogo.options.Options;
 import org.apache.felix.service.command.CommandSession;
 import org.apache.felix.service.command.Converter;

 /**
  * gosh built-in commands.
  */
 public class Builtin
 {

     static final String[] functions = { "format", "getopt", "new", "set", "tac", "type" };

     private static final String[] packages = { "java.lang", "java.io", "java.net",
             "java.util" };

     public CharSequence format(CommandSession session)
     {
         return format(session, session.get("_"));    // last result
     }

     public CharSequence format(CommandSession session, Object arg)
     {
         CharSequence result = session.format(arg, Converter.INSPECT);
         System.out.println(result);
         return result;
     }

     /**
      * script access to Options.
      * @param spec the spec
      * @param args the args
      * @return Option
      */
     public Option getopt(List<Object> spec, Object[] args)
     {
         String[] optSpec = new String[spec.size()];
         for (int i = 0; i < optSpec.length; ++i)
         {
             optSpec[i] = spec.get(i).toString();
         }
         return Options.compile(optSpec).parse(args);
     }

     // FIXME: the "new" command should be provided by runtime,
     // so it can leverage same argument coercion mechanism, used to invoke methods.
     public Object _new(CommandSession session, Object name, Object[] argv) throws Exception
     {
         Class<?> clazz = null;

         if (name instanceof Class<?>)
         {
             clazz = (Class<?>) name;
         }
         else
         {
             clazz = loadClass(session, name.toString());
         }

         for (Constructor<?> c : clazz.getConstructors())
         {
             Class<?>[] types = c.getParameterTypes();
             if (types.length != argv.length)
             {
                 continue;
             }

             boolean match = true;

             for (int i = 0; i < argv.length; ++i)
             {
                 if (!types[i].isAssignableFrom(argv[i].getClass()))
                 {
                     if (!types[i].isAssignableFrom(String.class))
                     {
                         match = false;
                         break;
                     }
                     argv[i] = argv[i].toString();
                 }
             }

             if (!match)
             {
                 continue;
             }

             try
             {
                 return c.newInstance(argv);
             }
             catch (InvocationTargetException ite)
             {
                 Throwable cause = ite.getCause();
                 if (cause instanceof Exception)
                 {
                     throw (Exception) cause;
                 }
                 throw ite;
             }
         }

         throw new IllegalArgumentException("can't coerce " + Arrays.asList(argv)
             + " to any of " + Arrays.asList(clazz.getConstructors()));
     }

     private Class<?> loadClass(CommandSession session, String name) throws ClassNotFoundException
     {
         if (!name.contains("."))
         {
             for (String p : packages)
             {
                 String pkg = p + "." + name;
                 try
                 {
                     return Class.forName(pkg, true, session.classLoader());
                 }
                 catch (ClassNotFoundException e)
                 {
                 }
             }
         }
         return Class.forName(name, true, session.classLoader());
     }

     public void set(CommandSession session, String[] argv) {
         final String[] usage = {
                 "set - show session variables",
                 "Usage: set [OPTIONS] [PREFIX]",
                 "  -? --help                show help",
                 "  -a --all                 show all variables, including those starting with .",
                 "  -x                       set xtrace option",
                 "  +x                       unset xtrace option",
                 "If PREFIX given, then only show variable(s) starting with PREFIX" };

         Option opt = Options.compile(usage).parse(argv);

         if (opt.isSet("help"))
         {
             opt.usage();
             return;
         }

         List<String> args = opt.args();
         String prefix = (args.isEmpty() ? "" : args.get(0));

         if (opt.isSet("x"))
         {
             session.put("echo", true);
         }
         else if ("+x".equals(prefix))
         {
             session.put("echo", null);
         }
         else
         {
             boolean all = opt.isSet("all");
             for (String key : new TreeSet<>(Shell.getVariables(session)))
             {
                 if (!key.startsWith(prefix))
                     continue;

                 if (key.startsWith(".") && !(all || prefix.length() > 0))
                     continue;

                 Object target = session.get(key);
                 String type = null;
                 String value = null;

                 if (target != null)
                 {
                     Class<?> clazz = target.getClass();
                     type = clazz.getSimpleName();
                     value = target.toString();
                 }

                 String trunc = value == null || value.length() < 55 ? "" : "...";
                 System.out.println(String.format("%-15.15s %-15s %.45s%s", type, key,
                     value, trunc));
             }
         }
     }

     public Object tac(CommandSession session, String[] argv) throws IOException
     {
         final String[] usage = {
                 "tac - capture stdin as String or List and optionally write to file.",
                 "Usage: tac [-al] [FILE]", "  -a --append              append to FILE",
                 "  -l --list                return List<String>",
                 "  -? --help                show help" };

         Option opt = Options.compile(usage).parse(argv);

         if (opt.isSet("help"))
         {
             opt.usage();
             return null;
         }

         List<String> args = opt.args();
         BufferedWriter fw = null;

         if (args.size() == 1)
         {
             String path = args.get(0);
             File file = new File(Shell.cwd(session).resolve(path));
             fw = new BufferedWriter(new FileWriter(file, opt.isSet("append")));
         }

         StringWriter sw = new StringWriter();
         BufferedReader rdr = new BufferedReader(new InputStreamReader(System.in));

         ArrayList<String> list = null;

         if (opt.isSet("list"))
         {
             list = new ArrayList<>();
         }

         boolean first = true;
         String s;

         while ((s = rdr.readLine()) != null)
         {
             if (list != null)
             {
                 list.add(s);
             }
             else
             {
                 if (!first)
                 {
                     sw.write(' ');
                 }
                 first = false;
                 sw.write(s);
             }

             if (fw != null)
             {
                 fw.write(s);
                 fw.newLine();
             }
         }

         if (fw != null)
         {
             fw.close();
         }

         return list != null ? list : sw.toString();
     }

     // FIXME: expose API in runtime so type command doesn't have to duplicate the runtime
     // command search strategy.
     public boolean type(CommandSession session, String[] argv) throws Exception
     {
         final String[] usage = { "type - show command type",
                 "Usage: type [OPTIONS] [name[:]]",
                 "  -a --all                 show all matches",
                 "  -? --help                show help",
                 "  -q --quiet               don't print anything, just return status",
                 "  -s --scope=NAME          list all commands in named scope",
                 "  -t --types               show full java type names" };

         Option opt = Options.compile(usage).parse(argv);
         List<String> args = opt.args();

         if (opt.isSet("help"))
         {
             opt.usage();
             return true;
         }

         boolean all = opt.isSet("all");

         String optScope = null;
         if (opt.isSet("scope"))
         {
             optScope = opt.get("scope");
         }

         if (args.size() == 1)
         {
             String arg = args.get(0);
             if (arg.endsWith(":"))
             {
                 optScope = args.remove(0);
             }
         }

         if (optScope != null || (args.isEmpty() && all))
         {
             Set<String> snames = new TreeSet<>();

             for (String sname : (getCommands(session)))
             {
                 if ((optScope == null) || sname.startsWith(optScope))
                 {
                     snames.add(sname);
                 }
             }

             for (String sname : snames)
             {
                 System.out.println(sname);
             }

             return true;
         }

         if (args.size() == 0)
         {
             Map<String, Integer> scopes = new TreeMap<>();

             for (String sname : getCommands(session))
             {
                 int colon = sname.indexOf(':');
                 String scope = sname.substring(0, colon);
                 Integer count = scopes.get(scope);
                 if (count == null)
                 {
                     count = 0;
                 }
                 scopes.put(scope, ++count);
             }

             for (Entry<String, Integer> entry : scopes.entrySet())
             {
                 System.out.println(entry.getKey() + ":" + entry.getValue());
             }

             return true;
         }

         final String name = args.get(0).toLowerCase();

         final int colon = name.indexOf(':');
         final String MAIN = "_main"; // FIXME: must match Reflective.java

         StringBuilder buf = new StringBuilder();
         Set<String> cmds = new LinkedHashSet<>();

         // get all commands
         if ((colon != -1) || (session.get(name) != null))
         {
             cmds.add(name);
         }
         else if (session.get(MAIN) != null)
         {
             cmds.add(MAIN);
         }
         else
         {
             String path = session.get("SCOPE") != null ? session.get("SCOPE").toString()
                 : "*";

             for (String s : path.split(":"))
             {
                 if (s.equals("*"))
                 {
                     for (String sname : getCommands(session))
                     {
                         if (sname.endsWith(":" + name))
                         {
                             cmds.add(sname);
                             if (!all)
                             {
                                 break;
                             }
                         }
                     }
                 }
                 else
                 {
                     String sname = s + ":" + name;
                     if (session.get(sname) != null)
                     {
                         cmds.add(sname);
                         if (!all)
                         {
                             break;
                         }
                     }
                 }
             }
         }

         for (String key : cmds)
         {
             Object target = session.get(key);
             if (target == null)
             {
                 continue;
             }

             CharSequence source = getClosureSource(session, key);

             if (source != null)
             {
                 buf.append(name);
                 buf.append(" is function {");
                 buf.append(source);
                 buf.append("}");
                 continue;
             }

             for (Method m : getMethods(session, key))
             {
                 StringBuilder params = new StringBuilder();

                 for (Class<?> type : m.getParameterTypes())
                 {
                     if (params.length() > 0)
                     {
                         params.append(", ");
                     }
                     params.append(type.getSimpleName());
                 }

                 String rtype = m.getReturnType().getSimpleName();

                 if (buf.length() > 0)
                 {
                     buf.append("\n");
                 }

                 if (opt.isSet("types"))
                 {
                     String cname = m.getDeclaringClass().getName();
                     buf.append(String.format("%s %s.%s(%s)", rtype, cname, m.getName(),
                         params));
                 }
                 else
                 {
                     buf.append(String.format("%s is %s %s(%s)", name, rtype, key, params));
                 }
             }
         }

         if (buf.length() > 0)
         {
             if (!opt.isSet("quiet"))
             {
                 System.out.println(buf);
             }
             return true;
         }

         if (!opt.isSet("quiet"))
         {
             System.err.println("type: " + name + " not found.");
         }

         return false;
     }

     /*
      * the following methods depend on the internals of the runtime implementation.
      * ideally, they should be available via some API.
      */

     @SuppressWarnings("unchecked")
     static Set<String> getCommands(CommandSession session)
     {
         return (Set<String>) session.get(".commands");
     }

     private boolean isClosure(Object target)
     {
         return target.getClass().getSimpleName().equals("Closure");
     }

     private boolean isCommand(Object target)
     {
         return target.getClass().getSimpleName().equals("CommandProxy");
     }

     private CharSequence getClosureSource(CommandSession session, String name)
         throws Exception
     {
         Object target = session.get(name);

         if (target == null)
         {
             return null;
         }

         if (!isClosure(target))
         {
             return null;
         }

         Field sourceField = target.getClass().getDeclaredField("source");
         sourceField.setAccessible(true);
         return (CharSequence) sourceField.get(target);
     }

     private List<Method> getMethods(CommandSession session, String scmd) throws Exception
     {
         final int colon = scmd.indexOf(':');
         final String function = colon == -1 ? scmd : scmd.substring(colon + 1);
         final String name = KEYWORDS.contains(function) ? ("_" + function) : function;
         final String get = "get" + function;
         final String is = "is" + function;
         final String set = "set" + function;
         final String MAIN = "_main"; // FIXME: must match Reflective.java

         Object target = session.get(scmd);
         if (target == null)
         {
             return null;
         }

         if (isClosure(target))
         {
             return null;
         }

         if (isCommand(target))
         {
             Method method = target.getClass().getMethod("getTarget", (Class[])null);
             method.setAccessible(true);
             target = method.invoke(target, (Object[])null);
         }

         ArrayList<Method> list = new ArrayList<>();
         Class<?> tc = (target instanceof Class<?>) ? (Class<?>) target
             : target.getClass();
         Method[] methods = tc.getMethods();

         for (Method m : methods)
         {
             String mname = m.getName().toLowerCase();

             if (mname.equals(name) || mname.equals(get) || mname.equals(set)
                 || mname.equals(is) || mname.equals(MAIN))
             {
                 list.add(m);
             }
         }

         return list;
     }

     private final static Set<String> KEYWORDS = new HashSet<>(
             Arrays.asList("abstract", "continue", "for", "new", "switch",
                     "assert", "default", "goto", "package", "synchronized", "boolean", "do",
                     "if", "private", "this", "break", "double", "implements", "protected",
                     "throw", "byte", "else", "import", "public", "throws", "case", "enum",
                     "instanceof", "return", "transient", "catch", "extends", "int", "short",
                     "try", "char", "final", "interface", "static", "void", "class",
                     "finally", "long", "strictfp", "volatile", "const", "float", "native",
                     "super", "while"));

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.felix.gogo.shell;

	import java.io.BufferedReader;
	import java.io.BufferedWriter;
	import java.io.File;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.StringWriter;
	import java.lang.reflect.Constructor;
	import java.lang.reflect.Field;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashSet;
	import java.util.LinkedHashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.TreeMap;
	import java.util.TreeSet;
	import java.util.Map.Entry;

	import org.apache.felix.gogo.options.Option;
	import org.apache.felix.gogo.options.Options;
	import org.apache.felix.service.command.CommandSession;
	import org.apache.felix.service.command.Converter;

	/**
	* gosh built-in commands.
	*/
	public class Builtin
	{

	static final String[] functions = { "format", "getopt", "new", "set", "tac", "type" };

	private static final String[] packages = { "java.lang", "java.io", "java.net",
	"java.util" };

	public CharSequence format(CommandSession session)
	{
	return format(session, session.get("_")); // last result
	}

	public CharSequence format(CommandSession session, Object arg)
	{
	CharSequence result = session.format(arg, Converter.INSPECT);
	System.out.println(result);
	return result;
	}

	/**
	* script access to Options.
	* @param spec the spec
	* @param args the args
	* @return Option
	*/
	public Option getopt(List<Object> spec, Object[] args)
	{
	String[] optSpec = new String[spec.size()];
	for (int i = 0; i < optSpec.length; ++i)
	{
	optSpec[i] = spec.get(i).toString();
	}
	return Options.compile(optSpec).parse(args);
	}

	// FIXME: the "new" command should be provided by runtime,
	// so it can leverage same argument coercion mechanism, used to invoke methods.
	public Object _new(CommandSession session, Object name, Object[] argv) throws Exception
	{
	Class<?> clazz = null;

	if (name instanceof Class<?>)
	{
	clazz = (Class<?>) name;
	}
	else
	{
	clazz = loadClass(session, name.toString());
	}

	for (Constructor<?> c : clazz.getConstructors())
	{
	Class<?>[] types = c.getParameterTypes();
	if (types.length != argv.length)
	{
	continue;
	}

	boolean match = true;

	for (int i = 0; i < argv.length; ++i)
	{
	if (!types[i].isAssignableFrom(argv[i].getClass()))
	{
	if (!types[i].isAssignableFrom(String.class))
	{
	match = false;
	break;
	}
	argv[i] = argv[i].toString();
	}
	}

	if (!match)
	{
	continue;
	}

	try
	{
	return c.newInstance(argv);
	}
	catch (InvocationTargetException ite)
	{
	Throwable cause = ite.getCause();
	if (cause instanceof Exception)
	{
	throw (Exception) cause;
	}
	throw ite;
	}
	}

	throw new IllegalArgumentException("can't coerce " + Arrays.asList(argv)
	+ " to any of " + Arrays.asList(clazz.getConstructors()));
	}

	private Class<?> loadClass(CommandSession session, String name) throws ClassNotFoundException
	{
	if (!name.contains("."))
	{
	for (String p : packages)
	{
	String pkg = p + "." + name;
	try
	{
	return Class.forName(pkg, true, session.classLoader());
	}
	catch (ClassNotFoundException e)
	{
	}
	}
	}
	return Class.forName(name, true, session.classLoader());
	}

	public void set(CommandSession session, String[] argv) {
	final String[] usage = {
	"set - show session variables",
	"Usage: set [OPTIONS] [PREFIX]",
	" -? --help show help",
	" -a --all show all variables, including those starting with .",
	" -x set xtrace option",
	" +x unset xtrace option",
	"If PREFIX given, then only show variable(s) starting with PREFIX" };

	Option opt = Options.compile(usage).parse(argv);

	if (opt.isSet("help"))
	{
	opt.usage();
	return;
	}

	List<String> args = opt.args();
	String prefix = (args.isEmpty() ? "" : args.get(0));

	if (opt.isSet("x"))
	{
	session.put("echo", true);
	}
	else if ("+x".equals(prefix))
	{
	session.put("echo", null);
	}
	else
	{
	boolean all = opt.isSet("all");
	for (String key : new TreeSet<>(Shell.getVariables(session)))
	{
	if (!key.startsWith(prefix))
	continue;

	if (key.startsWith(".") && !(all \|\| prefix.length() > 0))
	continue;

	Object target = session.get(key);
	String type = null;
	String value = null;

	if (target != null)
	{
	Class<?> clazz = target.getClass();
	type = clazz.getSimpleName();
	value = target.toString();
	}

	String trunc = value == null \|\| value.length() < 55 ? "" : "...";
	System.out.println(String.format("%-15.15s %-15s %.45s%s", type, key,
	value, trunc));
	}
	}
	}

	public Object tac(CommandSession session, String[] argv) throws IOException
	{
	final String[] usage = {
	"tac - capture stdin as String or List and optionally write to file.",
	"Usage: tac [-al] [FILE]", " -a --append append to FILE",
	" -l --list return List<String>",
	" -? --help show help" };

	Option opt = Options.compile(usage).parse(argv);

	if (opt.isSet("help"))
	{
	opt.usage();
	return null;
	}

	List<String> args = opt.args();
	BufferedWriter fw = null;

	if (args.size() == 1)
	{
	String path = args.get(0);
	File file = new File(Shell.cwd(session).resolve(path));
	fw = new BufferedWriter(new FileWriter(file, opt.isSet("append")));
	}

	StringWriter sw = new StringWriter();
	BufferedReader rdr = new BufferedReader(new InputStreamReader(System.in));

	ArrayList<String> list = null;

	if (opt.isSet("list"))
	{
	list = new ArrayList<>();
	}

	boolean first = true;
	String s;

	while ((s = rdr.readLine()) != null)
	{
	if (list != null)
	{
	list.add(s);
	}
	else
	{
	if (!first)
	{
	sw.write(' ');
	}
	first = false;
	sw.write(s);
	}

	if (fw != null)
	{
	fw.write(s);
	fw.newLine();
	}
	}

	if (fw != null)
	{
	fw.close();
	}

	return list != null ? list : sw.toString();
	}

	// FIXME: expose API in runtime so type command doesn't have to duplicate the runtime
	// command search strategy.
	public boolean type(CommandSession session, String[] argv) throws Exception
	{
	final String[] usage = { "type - show command type",
	"Usage: type [OPTIONS] [name[:]]",
	" -a --all show all matches",
	" -? --help show help",
	" -q --quiet don't print anything, just return status",
	" -s --scope=NAME list all commands in named scope",
	" -t --types show full java type names" };

	Option opt = Options.compile(usage).parse(argv);
	List<String> args = opt.args();

	if (opt.isSet("help"))
	{
	opt.usage();
	return true;
	}

	boolean all = opt.isSet("all");

	String optScope = null;
	if (opt.isSet("scope"))
	{
	optScope = opt.get("scope");
	}

	if (args.size() == 1)
	{
	String arg = args.get(0);
	if (arg.endsWith(":"))
	{
	optScope = args.remove(0);
	}
	}

	if (optScope != null \|\| (args.isEmpty() && all))
	{
	Set<String> snames = new TreeSet<>();

	for (String sname : (getCommands(session)))
	{
	if ((optScope == null) \|\| sname.startsWith(optScope))
	{
	snames.add(sname);
	}
	}

	for (String sname : snames)
	{
	System.out.println(sname);
	}

	return true;
	}

	if (args.size() == 0)
	{
	Map<String, Integer> scopes = new TreeMap<>();

	for (String sname : getCommands(session))
	{
	int colon = sname.indexOf(':');
	String scope = sname.substring(0, colon);
	Integer count = scopes.get(scope);
	if (count == null)
	{
	count = 0;
	}
	scopes.put(scope, ++count);
	}

	for (Entry<String, Integer> entry : scopes.entrySet())
	{
	System.out.println(entry.getKey() + ":" + entry.getValue());
	}

	return true;
	}

	final String name = args.get(0).toLowerCase();

	final int colon = name.indexOf(':');
	final String MAIN = "_main"; // FIXME: must match Reflective.java

	StringBuilder buf = new StringBuilder();
	Set<String> cmds = new LinkedHashSet<>();

	// get all commands
	if ((colon != -1) \|\| (session.get(name) != null))
	{
	cmds.add(name);
	}
	else if (session.get(MAIN) != null)
	{
	cmds.add(MAIN);
	}
	else
	{
	String path = session.get("SCOPE") != null ? session.get("SCOPE").toString()
	: "*";

	for (String s : path.split(":"))
	{
	if (s.equals("*"))
	{
	for (String sname : getCommands(session))
	{
	if (sname.endsWith(":" + name))
	{
	cmds.add(sname);
	if (!all)
	{
	break;
	}
	}
	}
	}
	else
	{
	String sname = s + ":" + name;
	if (session.get(sname) != null)
	{
	cmds.add(sname);
	if (!all)
	{
	break;
	}
	}
	}
	}
	}

	for (String key : cmds)
	{
	Object target = session.get(key);
	if (target == null)
	{
	continue;
	}

	CharSequence source = getClosureSource(session, key);

	if (source != null)
	{
	buf.append(name);
	buf.append(" is function {");
	buf.append(source);
	buf.append("}");
	continue;
	}

	for (Method m : getMethods(session, key))
	{
	StringBuilder params = new StringBuilder();

	for (Class<?> type : m.getParameterTypes())
	{
	if (params.length() > 0)
	{
	params.append(", ");
	}
	params.append(type.getSimpleName());
	}

	String rtype = m.getReturnType().getSimpleName();

	if (buf.length() > 0)
	{
	buf.append("\n");
	}

	if (opt.isSet("types"))
	{
	String cname = m.getDeclaringClass().getName();
	buf.append(String.format("%s %s.%s(%s)", rtype, cname, m.getName(),
	params));
	}
	else
	{
	buf.append(String.format("%s is %s %s(%s)", name, rtype, key, params));
	}
	}
	}

	if (buf.length() > 0)
	{
	if (!opt.isSet("quiet"))
	{
	System.out.println(buf);
	}
	return true;
	}

	if (!opt.isSet("quiet"))
	{
	System.err.println("type: " + name + " not found.");
	}

	return false;
	}

	/*
	* the following methods depend on the internals of the runtime implementation.
	* ideally, they should be available via some API.
	*/

	@SuppressWarnings("unchecked")
	static Set<String> getCommands(CommandSession session)
	{
	return (Set<String>) session.get(".commands");
	}

	private boolean isClosure(Object target)
	{
	return target.getClass().getSimpleName().equals("Closure");
	}

	private boolean isCommand(Object target)
	{
	return target.getClass().getSimpleName().equals("CommandProxy");
	}

	private CharSequence getClosureSource(CommandSession session, String name)
	throws Exception
	{
	Object target = session.get(name);

	if (target == null)
	{
	return null;
	}

	if (!isClosure(target))
	{
	return null;
	}

	Field sourceField = target.getClass().getDeclaredField("source");
	sourceField.setAccessible(true);
	return (CharSequence) sourceField.get(target);
	}

	private List<Method> getMethods(CommandSession session, String scmd) throws Exception
	{
	final int colon = scmd.indexOf(':');
	final String function = colon == -1 ? scmd : scmd.substring(colon + 1);
	final String name = KEYWORDS.contains(function) ? ("_" + function) : function;
	final String get = "get" + function;
	final String is = "is" + function;
	final String set = "set" + function;
	final String MAIN = "_main"; // FIXME: must match Reflective.java

	Object target = session.get(scmd);
	if (target == null)
	{
	return null;
	}

	if (isClosure(target))
	{
	return null;
	}

	if (isCommand(target))
	{
	Method method = target.getClass().getMethod("getTarget", (Class[])null);
	method.setAccessible(true);
	target = method.invoke(target, (Object[])null);
	}

	ArrayList<Method> list = new ArrayList<>();
	Class<?> tc = (target instanceof Class<?>) ? (Class<?>) target
	: target.getClass();
	Method[] methods = tc.getMethods();

	for (Method m : methods)
	{
	String mname = m.getName().toLowerCase();

	if (mname.equals(name) \|\| mname.equals(get) \|\| mname.equals(set)
	\|\| mname.equals(is) \|\| mname.equals(MAIN))
	{
	list.add(m);
	}
	}

	return list;
	}

	private final static Set<String> KEYWORDS = new HashSet<>(
	Arrays.asList("abstract", "continue", "for", "new", "switch",
	"assert", "default", "goto", "package", "synchronized", "boolean", "do",
	"if", "private", "this", "break", "double", "implements", "protected",
	"throw", "byte", "else", "import", "public", "throws", "case", "enum",
	"instanceof", "return", "transient", "catch", "extends", "int", "short",
	"try", "char", "final", "interface", "static", "void", "class",
	"finally", "long", "strictfp", "volatile", "const", "float", "native",
	"super", "while"));

	}