Arduino/app/Compiler.java

/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*
  Compiler - default compiler class that connects to avr-gcc 
  Part of the Arduino project - http://www.arduino.cc/

  Modified by David A. Mellis

  Copyright (c) 2004-05 Hernando Barragan

  Processing version
  Copyright (c) 2004-05 Ben Fry and Casey Reas
  Copyright (c) 2001-04 Massachusetts Institute of Technology

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software Foundation,
  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
  $Id$
*/

package processing.app;

import java.io.*;
import java.util.*;
import java.util.zip.*;
import javax.swing.*;

public class Compiler implements MessageConsumer {
  static final String BUGS_URL =
    "https://developer.berlios.de/bugs/?group_id=3590";
  static final String SUPER_BADNESS =
    "Compiler error, please submit this code to " + BUGS_URL;

  Sketch sketch;
  String buildPath;

  //String buildPath;
  //String className;
  //File includeFolder;
  RunnerException exception;
  //Editor editor;

  /*
  public Compiler(String buildPath, String className,
                     File includeFolder, Editor editor) {
    this.buildPath = buildPath;
    this.includeFolder = includeFolder;
    this.className = className;
    this.editor = editor;
  }


  public boolean compile(PrintStream leechErr) {
  */

  public Compiler() { }  // consider this a warning, you werkin soon.


  public boolean compile(Sketch sketch, String buildPath, Target target)
    throws RunnerException {

    this.sketch = sketch;
    this.buildPath = buildPath;

    // the pms object isn't used for anything but storage
    MessageStream pms = new MessageStream(this);

    String userdir = System.getProperty("user.dir") + File.separator;
    
//    LibraryManager libraryManager;
//
//    try {
//      libraryManager = new LibraryManager();
//    } catch (IOException e) {
//      throw new RunnerException(e.getMessage());
//    }
	String avrBasePath;
    if(Base.isMacOS()) {
    	avrBasePath = new String("tools/avr/bin/"); 
    }
    else if(Base.isLinux()) {
    	avrBasePath = new String("");     	
    }
    else {
    	avrBasePath = new String(userdir + "tools/avr/bin/"); 
    }


    String preCommandCompiler[] = new String[] {
      avrBasePath + "avr-gcc",
      "-c", // compile, don't link
      "-g", // include debugging info (so errors include line numbers)
      "-Os", // optimize for size
      "-I" + target.getPath(),
      "-w", // surpress all warnings
      "-mmcu=" + Preferences.get("build.mcu"),
      "-DF_CPU=" + Preferences.get("build.f_cpu"),
    };

    // use lib directories as include paths
    //String[] libDirs = libraryManager.getFolderPaths();
    String[] libDirs = new String[sketch.importedLibraries.size()];
    
    for (int i = 0; i < sketch.importedLibraries.size(); i++)
      libDirs[i] = ((Library) sketch.importedLibraries.get(i)).getFolder().getPath();
    
    // Last two arguments will specify the file being compiled and the output file.
    String[] baseCommandCompiler = new String[preCommandCompiler.length + libDirs.length + 2];
    System.arraycopy(preCommandCompiler, 0, baseCommandCompiler, 0, preCommandCompiler.length);
    for (int i = 0; i < libDirs.length; ++i) {
      baseCommandCompiler[preCommandCompiler.length + i] = "-I" + libDirs[i];
    }

    String preCommandCompilerCPP[] = new String[] {
      avrBasePath + "avr-g++",
      "-c", // compile, don't link
      "-g", // include debugging info (so errors include line numbers)
      "-Os", // optimize for size
      "-I" + target.getPath(),
      "-w", // surpress all warnings
      "-fno-exceptions",
      "-mmcu=" + Preferences.get("build.mcu"),
      "-DF_CPU=" + Preferences.get("build.f_cpu"),
    };

    // use lib directories as include paths
    // Last two arguments will specify the file being compiled and the output file.
    String[] baseCommandCompilerCPP = new String[preCommandCompilerCPP.length + libDirs.length + 2];
    System.arraycopy(preCommandCompilerCPP, 0, baseCommandCompilerCPP, 0, preCommandCompilerCPP.length);
    for (int i = 0; i < libDirs.length; ++i) {
      baseCommandCompilerCPP[preCommandCompilerCPP.length + i] = "-I" + libDirs[i];
    }

    String preCommandLinker[] = new String[] {
      avrBasePath + "avr-gcc",
      " ",
      "-mmcu=" + Preferences.get("build.mcu"),
      "-o",
      " ",
    };
    
    String runtimeLibraryName = buildPath + File.separator + "core.a";

    String baseCommandAR[] = new String[] {
      avrBasePath + "avr-ar",
      "rcs",
      runtimeLibraryName,
      " "
    };

    // use lib object files during include
    //String[] libObjectFiles = libraryManager.getObjectFiles();
    
    Vector libObjectFilesVec = new Vector();
    
    for (Iterator i = sketch.importedLibraries.iterator(); i.hasNext(); ) {
      Library library = (Library) i.next();
      File[] objectFiles = library.getObjectFiles();
      for (int j = 0; j < objectFiles.length; j++)
        libObjectFilesVec.add(objectFiles[j].getPath());
    }
    
    String[] libObjectFiles = new String[libObjectFilesVec.size()];
    libObjectFiles = (String[]) libObjectFilesVec.toArray(libObjectFiles);
    
    String[] baseCommandLinker = new String[preCommandLinker.length + libObjectFiles.length];
    System.arraycopy(preCommandLinker, 0, baseCommandLinker, 0, preCommandLinker.length);
    for (int i = 0; i < libObjectFiles.length; ++i) {
      baseCommandLinker[preCommandLinker.length + i] = libObjectFiles[i];
    }

    String baseCommandObjcopy[] = new String[] {
      avrBasePath + "avr-objcopy",
      "-O",
      " ",
      "-R",
      " ",
      " ",
      " "
    };

    /*String baseCommand[] = new String[] {
      // user.dir is folder containing P5 (and therefore jikes)
      // macosx needs the extra path info. linux doesn't like it, though
      // windows doesn't seem to care. write once, headache anywhere.
      ((!Base.isMacOS()) ? "jikes" :
       System.getProperty("user.dir") + File.separator + "jikes"),

      // this doesn't help much.. also java 1.4 seems to not support
      // -source 1.1 for javac, and jikes seems to also have dropped it.
      // for versions of jikes that don't complain, "final int" inside
      // a function doesn't throw an error, so it could just be a
      // ms jvm error that this sort of thing doesn't work. blech.
      //"-source",
      //"1.1",

      // necessary to make output classes compatible with 1.1
      // i.e. so that exported applets can work with ms jvm on the web
      "-target",
      Preferences.get("preproc.jdk_version"),  //"1.1",
      // let the incompatability headache begin

      // used when run without a vm ("expert" mode)
      "-bootclasspath",
      calcBootClassPath(),

      // needed for macosx so that the classpath is set properly
      // also for windows because qtjava will most likely be here
      // and for linux, it just doesn't hurt
      "-classpath",
      sketch.classPath, //calcClassPath(includeFolder),

      "-nowarn", // we're not currently interested in warnings
      "+E", // output errors in machine-parsable format
      "-d", buildPath // output the classes in the buildPath
      //buildPath + File.separator + className + ".java" // file to compile
    };*/

    // make list of code files that need to be compiled and the object files
    // that they will be compiled to (includes code from the sketch and the
    // library for the target platform)
    String sourceNames[] = new String[sketch.codeCount + target.getSourceFilenames().size()];
    String sourceNamesCPP[] = new String[sketch.codeCount + target.getSourceFilenames().size()];
    String objectNames[] = new String[sketch.codeCount + target.getSourceFilenames().size()];
    String objectNamesCPP[] = new String[sketch.codeCount + target.getSourceFilenames().size()];
    String targetObjectNames[] = new String[target.getSourceFilenames().size()];
    String sketchObjectNames[] = new String[sketch.codeCount];
    int fileCount = 0;
    int fileCountCPP = 0;
    int targetCount = 0;
    int sketchCount = 0;
    for (int i = 0; i < sketch.codeCount; i++) {
      if (sketch.code[i].preprocName != null) {
        if (sketch.code[i].preprocName.endsWith(".c")) {
          sourceNames[fileCount] = buildPath + File.separator + sketch.code[i].preprocName;
          objectNames[fileCount++] = buildPath + File.separator + sketch.code[i].preprocName + ".o";
          sketchObjectNames[sketchCount++] = buildPath + File.separator + sketch.code[i].preprocName + ".o";
        } else if (sketch.code[i].preprocName.endsWith(".cpp")) {
          sourceNamesCPP[fileCountCPP] = buildPath + File.separator + sketch.code[i].preprocName;
          objectNamesCPP[fileCountCPP++] = buildPath + File.separator + sketch.code[i].preprocName + ".o";
          sketchObjectNames[sketchCount++] = buildPath + File.separator + sketch.code[i].preprocName + ".o";
        } 
      }
    }
    for (Iterator iter = target.getSourceFilenames().iterator(); iter.hasNext(); ) {
      String filename = (String) iter.next();
      if (filename != null) {
        targetObjectNames[targetCount++] = buildPath + File.separator + filename + ".o";
        if (filename.endsWith(".c")) {
          sourceNames[fileCount] = target.getPath() + File.separator + filename;
          objectNames[fileCount++] = buildPath + File.separator + filename + ".o";
        } else if (filename.endsWith(".cpp")) {
          sourceNamesCPP[fileCountCPP] = target.getPath() + File.separator + filename;
          objectNamesCPP[fileCountCPP++] = buildPath + File.separator + filename + ".o";
        } 
      }
    }
    
    
    /*
    String commandCompiler[] = new String[baseCommandCompiler.length + preprocCount];
    System.arraycopy(baseCommandCompiler, 0, commandCompiler, 0, baseCommandCompiler.length);
    // append each of the files to the command string
    for (int i = 0; i < preprocCount; i++) {
      commandCompiler[baseCommandCompiler.length + i] =
        buildPath + File.separator + preprocNames[i];
    }

    String commandCompilerCPP[] = new String[baseCommandCompilerCPP.length + preprocCountCPP];
    System.arraycopy(baseCommandCompilerCPP, 0, commandCompilerCPP, 0, baseCommandCompilerCPP.length);
    for (int i = 0; i < preprocCountCPP; i++) {
      commandCompilerCPP[baseCommandCompilerCPP.length + i] = 
        buildPath + File.separator + preprocNamesCPP[i];
    }
    */
    //PApplet.printarr(command);

    baseCommandLinker[1] = "-Os -Wl,-u,vfprintf -lprintf_flt -lm,-Map=" +
      ((!Base.isMacOS()) ? buildPath : userdir + buildPath)
       + File.separator + sketch.name + ".map,--cref";
    baseCommandLinker[4] = ((!Base.isMacOS()) ? buildPath 
      : buildPath) + File.separator + sketch.name + ".elf";
    String commandLinker[] = new String[baseCommandLinker.length + sketchCount + 2];
    System.arraycopy(baseCommandLinker, 0, commandLinker, 0, baseCommandLinker.length);
    int idx = 0;
    for(int i = 0; i < sketchCount; i++, idx++) {
      commandLinker[baseCommandLinker.length + idx] = sketchObjectNames[i];
    }

    commandLinker[baseCommandLinker.length + idx++] = runtimeLibraryName;
    commandLinker[baseCommandLinker.length + idx] = "-L" + buildPath;
      
    /*String command[] = new String[baseCommand.length + preprocCount];
    System.arraycopy(baseCommand, 0, command, 0, baseCommand.length);
    // append each of the files to the command string
    for (int i = 0; i < preprocCount; i++) {
      command[baseCommand.length + i] =
        buildPath + File.separator + preprocNames[i];
    }
    //PApplet.printarr(command);
    */
    /*
    String command[] = new String[baseCommand.length + sketch.codeCount];
    System.arraycopy(baseCommand, 0, command, 0, baseCommand.length);
    // append each of the files to the command string
    for (int i = 0; i < sketch.codeCount; i++) {
      command[baseCommand.length + i] =
        buildPath + File.separator + sketch.code[i].preprocName;
    }
    */

    //for (int i = 0; i < command.length; i++) {
      //System.out.println("cmd " + i + "  " + command[i]);
    //}

    firstErrorFound = false;  // haven't found any errors yet
    secondErrorFound = false;

    int result = 0; // pre-initialized to quiet a bogus warning from jikes
    try {
      // execute the compiler, and create threads to deal
      // with the input and error streams
      //

      Process process;
      boolean compiling = true;
      for(int i = 0; i < fileCount; i++) {
        baseCommandCompiler[baseCommandCompiler.length - 2] = sourceNames[i];
        baseCommandCompiler[baseCommandCompiler.length - 1] = "-o"+ objectNames[i];
        //System.arraycopy(baseCommandCompiler.length
        result = execAsynchronously(baseCommandCompiler);
        if (result!=0)
          return false;
      }

      for(int i = 0; i < fileCountCPP; i++) {
        baseCommandCompilerCPP[baseCommandCompilerCPP.length - 2] = sourceNamesCPP[i];
        baseCommandCompilerCPP[baseCommandCompilerCPP.length - 1] = "-o"+ objectNamesCPP[i];
        result = execAsynchronously(baseCommandCompilerCPP);
        if (result!=0)
          return false;
      }

      for(int i = 0; i < targetCount; i++) {
        baseCommandAR[baseCommandAR.length - 1] = targetObjectNames[i];
        result = execAsynchronously(baseCommandAR);
        if(result!=0)
          return false;
      }

      result = execAsynchronously(commandLinker);
      if (result!=0)
        return false;

      baseCommandObjcopy[2] = "srec";
      baseCommandObjcopy[4] = ".eeprom";
      baseCommandObjcopy[5] = buildPath + File.separator + sketch.name + ".elf";
      baseCommandObjcopy[6] = buildPath + File.separator + sketch.name + ".rom";
      result = execAsynchronously(baseCommandObjcopy);
      if (result!=0)
        return false;

      baseCommandObjcopy[2] = "ihex";
      baseCommandObjcopy[4] = ".flash";
      baseCommandObjcopy[5] = buildPath + File.separator + sketch.name + ".elf";
      baseCommandObjcopy[6] = buildPath + File.separator + sketch.name + ".hex";
      result = execAsynchronously(baseCommandObjcopy);
      if (result!=0)
        return false;
    } catch (Exception e) {
      String msg = e.getMessage();
      if ((msg != null) && (msg.indexOf("avr-gcc: not found") != -1)) {
        //System.err.println("jikes is missing");
        Base.showWarning("Compiler error",
                            "Could not find the compiler.\n" +
                            "avr-gcc is missing from your PATH,\n" +
                            "see readme.txt for help.", null);
        return false;

      } else {
        e.printStackTrace();
        result = -1;
      }
    }

    // an error was queued up by message(), barf this back to build()
    // which will barf it back to Editor. if you're having trouble
    // discerning the imagery, consider how cows regurgitate their food
    // to digest it, and the fact that they have five stomaches.
    //
    //System.out.println("throwing up " + exception);
    if (exception != null) throw exception;

    // if the result isn't a known, expected value it means that something
    // is fairly wrong, one possibility is that jikes has crashed.
    //
    if (result != 0 && result != 1 ) {
      //exception = new RunnerException(SUPER_BADNESS);
      //editor.error(exception);  // this will instead be thrown
      Base.openURL(BUGS_URL);
      throw new RunnerException(SUPER_BADNESS);
    }

    // success would mean that 'result' is set to zero
    return (result == 0); // ? true : false;
  }
  
  public int execAsynchronously(String[] command)
    throws RunnerException, IOException {
    int result = 0;
    
    if (Preferences.getBoolean("build.verbose")) {
      for(int j = 0; j < command.length; j++) {
        System.out.print(command[j] + " ");
      }
      System.out.println();
    }

    Process process = Runtime.getRuntime().exec(command);
    
    new MessageSiphon(process.getInputStream(), this);
    new MessageSiphon(process.getErrorStream(), this);

    // wait for the process to finish.  if interrupted
    // before waitFor returns, continue waiting
    boolean compiling = true;
    while (compiling) {
      try {
        result = process.waitFor();
        //System.out.println("result is " + result);
        compiling = false;
      } catch (InterruptedException ignored) { }
    }
    
    if (exception != null)  {
      exception.hideStackTrace = true;
      throw exception;
    }
    
    return result;
  }


  boolean firstErrorFound;
  boolean secondErrorFound;

  /**
   * Part of the MessageConsumer interface, this is called
   * whenever a piece (usually a line) of error message is spewed
   * out from the compiler. The errors are parsed for their contents
   * and line number, which is then reported back to Editor.
   */
  public void message(String s) {
    // This receives messages as full lines, so a newline needs
    // to be added as they're printed to the console.
    //System.err.print(s);

    // ignore cautions
    if (s.indexOf("warning") != -1) return;

    // jikes always uses a forward slash character as its separator,
    // so replace any platform-specific separator characters before
    // attemping to compare
    //
    //String buildPathSubst = buildPath.replace(File.separatorChar, '/') + "/";
    String buildPathSubst = buildPath.replace(File.separatorChar,File.separatorChar) + File.separatorChar;

    String partialTempPath = null;
    int partialStartIndex = -1; //s.indexOf(partialTempPath);
    int fileIndex = -1;  // use this to build a better exception

    // iterate through the project files to see who's causing the trouble
    for (int i = 0; i < sketch.codeCount; i++) {
      if (sketch.code[i].preprocName == null) continue;

      partialTempPath = buildPathSubst + sketch.code[i].preprocName;
      partialStartIndex = s.indexOf(partialTempPath);
      if (partialStartIndex != -1) {
        fileIndex = i;
        //System.out.println("fileIndex is " + fileIndex);
        break;
      }
    }
    //+ className + ".java";

    // if the partial temp path appears in the error message...
    //
    //int partialStartIndex = s.indexOf(partialTempPath);
    if (partialStartIndex != -1) {

      // skip past the path and parse the int after the first colon
      //
      String s1 = s.substring(partialStartIndex +
                              partialTempPath.length() + 1);
      //System.out.println(s1);
      int colon = s1.indexOf(':');

      if (s1.indexOf("In function") != -1 || colon == -1) {
        System.err.print(s1);
        //firstErrorFound = true;
        return;
      }

      int lineNumber;
      try {
        lineNumber = Integer.parseInt(s1.substring(0, colon));
      } catch (NumberFormatException e) {
        System.err.print(s1);
        return;
      }
      
      // the "1" corresponds to the amount of lines written to the main code
      // file by PdePreprocessor's writeHeader() routine before prototypes
      if (fileIndex == 0)
        lineNumber -= 1;
        
      //System.out.println("pde / line number: " + lineNumber);
      
      if (fileIndex == 0) {  // main class, figure out which tab
        for (int i = 1; i < sketch.codeCount; i++) {
          if (sketch.code[i].flavor == Sketch.PDE) {
            //System.out.println("preprocOffset "+ sketch.code[i].preprocOffset);
            if (sketch.code[i].preprocOffset < lineNumber) {
              fileIndex = i;
              //System.out.println("i'm thinkin file " + i);
            }
          }
        }
        if (fileIndex != 0) {  // if found another culprit
          lineNumber -= sketch.code[fileIndex].preprocOffset;
          //System.out.println("i'm sayin line " + lineNumber);
        }
      }

      //String s2 = s1.substring(colon + 2);
      int err = s1.indexOf(":");
      if (err != -1) {

        // if the first error has already been found, then this must be
        // (at least) the second error found
        if (firstErrorFound) {
          secondErrorFound = true;
          return;
        }

        // if executing at this point, this is *at least* the first error
        firstErrorFound = true;

        err += ":".length();
        String description = s1.substring(err);
        description = description.trim();
        System.err.print(description);

/*        String hasLoop = "The method \"void loop();\" with default access";
        if (description.indexOf(hasLoop) != -1) {
          description =
            "Rename loop() to draw() in Processing 0070 and higher";
        }
*/
/*        String constructorProblem =
          "No applicable overload was found for a constructor of type";
        if (description.indexOf(constructorProblem) != -1) {
          //"simong.particles.ParticleSystem". Perhaps you wanted the overloaded version "ParticleSystem();" instead?
          int nextSentence = description.indexOf("\".") + 3;
          description = description.substring(nextSentence);
        }
*/
/*        String overloadProblem = "No applicable overload";
        if (description.indexOf(overloadProblem) != -1) {
          int nextSentence = description.indexOf("\".") + 3;
          description = description.substring(nextSentence);
        }
*/
        // c:/fry/processing/build/windows/work/lib/build/Temporary_6858_2476.java:1:34:1:41: Semantic Error: You need to modify your classpath, sourcepath, bootclasspath, and/or extdirs setup. Package "poo/shoe" could not be found in:
/*        String classpathProblem = "You need to modify your classpath";
        if (description.indexOf(classpathProblem) != -1) {
          if (description.indexOf("quicktime/std") != -1) {
            // special case for the quicktime libraries
            description =
              "To run sketches that use the Processing video library, " +
              "you must first install QuickTime for Java.";

          } else {
            int nextSentence = description.indexOf(". Package") + 2;
            description =
              description.substring(nextSentence, description.indexOf(':')) +
              " the code folder or in any libraries.";
          }
        }
*/
        //System.out.println("description = " + description);
        //System.out.println("creating exception " + exception);
        exception = new RunnerException(description, fileIndex, lineNumber-1, -1);

        // NOTE!! major change here, this exception will be queued
        // here to be thrown by the compile() function
        //editor.error(exception);

      } else {
        System.err.println("i suck: " + s);
      }

    } else {
      // this isn't the start of an error line, so don't attempt to parse
      // a line number out of it.

      // if the second error hasn't been discovered yet, these lines
      // are probably associated with the first error message,
      // which is already in the status bar, and are likely to be
      // of interest to the user, so spit them to the console.
      //
      if (!secondErrorFound) {
        System.err.println(s);
      }
    }
  }


  static String bootClassPath;

  static public String calcBootClassPath() {
    if (bootClassPath == null) {
      String additional = "";
      if (Base.isMacOS()) {
        additional =
          contentsToClassPath(new File("/System/Library/Java/Extensions/"));
      }
      bootClassPath =  System.getProperty("sun.boot.class.path") + additional;
    }
    return bootClassPath;
  }


  ///


  /**
   * Return the path for a folder, with appended paths to
   * any .jar or .zip files inside that folder.
   * This will prepend a colon (or whatever the path separator is)
   * so that it can be directly appended to another path string.
   *
   * This will always add the root folder as well, and doesn't bother
   * checking to see if there are any .class files in the folder or
   * within a subfolder.
   */
  static public String contentsToClassPath(File folder) {
    if (folder == null) return "";

    StringBuffer abuffer = new StringBuffer();
    String sep = System.getProperty("path.separator");

    try {
      // add the folder itself in case any unzipped files
      String path = folder.getCanonicalPath();
      abuffer.append(sep);
      abuffer.append(path);

      if (!path.endsWith(File.separator)) {
        path += File.separator;
      }
      //System.out.println("path is " + path);

      String list[] = folder.list();
      for (int i = 0; i < list.length; i++) {
        if (list[i].toLowerCase().endsWith(".o") ||
            list[i].toLowerCase().endsWith(".a")) {
          abuffer.append(sep);
          abuffer.append(path);
          abuffer.append(list[i]);
        }
      }
    } catch (IOException e) {
      e.printStackTrace();  // this would be odd
    }
    //System.out.println("included path is " + abuffer.toString());
    //packageListFromClassPath(abuffer.toString());  // WHY?
    return abuffer.toString();
  }


  /**
   * A classpath, separated by the path separator, will contain
   * a series of .jar/.zip files or directories containing .class
   * files, or containing subdirectories that have .class files.
   *
   * @param path the input classpath
   * @return array of possible package names
   */
/*  static public String[] packageListFromClassPath(String path) {
    Hashtable table = new Hashtable();
    String pieces[] =
      Base.split(path, File.pathSeparatorChar);

    for (int i = 0; i < pieces.length; i++) {
      //System.out.println("checking piece '" + pieces[i] + "'");
      if (pieces[i].length() == 0) continue;

      if (pieces[i].toLowerCase().endsWith(".o") ||
          pieces[i].toLowerCase().endsWith(".a")) {
        packageListFromZip(pieces[i], table);

      } else {  // it's another type of file or directory
        File dir = new File(pieces[i]);
        if (dir.exists() && dir.isDirectory()) {
          packageListFromFolder(dir, null, table);
          //importCount = magicImportsRecursive(dir, null,
          //                                  table);
                                              //imports, importCount);
        }
      }
    }
    int tableCount = table.size();
    String output[] = new String[tableCount];
    int index = 0;
    Enumeration e = table.keys();
    while (e.hasMoreElements()) {
      output[index++] = ((String) e.nextElement()).replace('/', '.');
    }
    //System.arraycopy(imports, 0, output, 0, importCount);
    //PApplet.printarr(output);
    return output;
  }
*/

  static private void packageListFromZip(String filename, Hashtable table) {
    try {
      ZipFile file = new ZipFile(filename);
      Enumeration entries = file.entries();
      while (entries.hasMoreElements()) {
        ZipEntry entry = (ZipEntry) entries.nextElement();

        if (!entry.isDirectory()) {
          String name = entry.getName();

          if (name.endsWith(".class")) {
            int slash = name.lastIndexOf('/');
            if (slash == -1) continue;

            String pname = name.substring(0, slash);
            if (table.get(pname) == null) {
              table.put(pname, new Object());
            }
          }
        }
      }
    } catch (IOException e) {
      System.err.println("Ignoring " + filename + " (" + e.getMessage() + ")");
      //e.printStackTrace();
    }
  }


  /**
   * Make list of package names by traversing a directory hierarchy.
   * Each time a class is found in a folder, add its containing set
   * of folders to the package list. If another folder is found,
   * walk down into that folder and continue.
   */
  static private void packageListFromFolder(File dir, String sofar,
                                            Hashtable table) {
                                          //String imports[],
                                          //int importCount) {
    //System.err.println("checking dir '" + dir + "'");
    boolean foundClass = false;
    String files[] = dir.list();

    for (int i = 0; i < files.length; i++) {
      if (files[i].equals(".") || files[i].equals("..")) continue;

      File sub = new File(dir, files[i]);
      if (sub.isDirectory()) {
        String nowfar =
          (sofar == null) ? files[i] : (sofar + "." + files[i]);
        packageListFromFolder(sub, nowfar, table);
        //System.out.println(nowfar);
        //imports[importCount++] = nowfar;
        //importCount = magicImportsRecursive(sub, nowfar,
        //                                  imports, importCount);
      } else if (!foundClass) {  // if no classes found in this folder yet
        if (files[i].endsWith(".class")) {
          //System.out.println("unique class: " + files[i] + " for " + sofar);
          table.put(sofar, new Object());
          foundClass = true;
        }
      }
    }
    //return importCount;
  }

  /*
  static public int magicImportsRecursive(File dir, String sofar,
                                          Hashtable table) {
                                          //String imports[],
                                          //int importCount) {
    System.err.println("checking dir '" + dir + "'");
    String files[] = dir.list();
    for (int i = 0; i < files.length; i++) {
      if (files[i].equals(".") || files[i].equals("..")) continue;

      File sub = new File(dir, files[i]);
      if (sub.isDirectory()) {
        String nowfar = (sofar == null) ?
          files[i] : (sofar + "." + files[i]);
        //System.out.println(nowfar);
        imports[importCount++] = nowfar;

        importCount = magicImportsRecursive(sub, nowfar,
                                            imports, importCount);
      }
    }
    return importCount;
  }
  */
}