net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/builder/PHPBuilder.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.internal.core.builder;
  12
  13 import java.io.DataInputStream;
  14 import java.io.DataOutputStream;
  15 import java.io.IOException;
  16 import java.util.ArrayList;
  17 import java.util.Date;
  18 import java.util.HashSet;
  19 import java.util.Iterator;
  20 import java.util.Map;
  21
  22 import net.sourceforge.phpdt.core.IClasspathEntry;
  23 import net.sourceforge.phpdt.core.IJavaModelMarker;
  24 import net.sourceforge.phpdt.core.JavaCore;
  25 import net.sourceforge.phpdt.core.JavaModelException;
  26 import net.sourceforge.phpdt.core.compiler.CharOperation;
  27 import net.sourceforge.phpdt.internal.core.JavaModel;
  28 import net.sourceforge.phpdt.internal.core.JavaModelManager;
  29 import net.sourceforge.phpdt.internal.core.JavaProject;
  30 import net.sourceforge.phpdt.internal.core.util.SimpleLookupTable;
  31 import net.sourceforge.phpdt.internal.core.util.Util;
  32 import net.sourceforge.phpdt.internal.core.util.PHPFileUtil;
  33 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  34 import net.sourceforge.phpeclipse.builder.IdentifierIndexManager;
  35
  36 import org.eclipse.core.resources.IFile;
  37 import org.eclipse.core.resources.IMarker;
  38 import org.eclipse.core.resources.IProject;
  39 import org.eclipse.core.resources.IResource;
  40 import org.eclipse.core.resources.IResourceChangeEvent;
  41 import org.eclipse.core.resources.IResourceDelta;
  42 import org.eclipse.core.resources.IResourceVisitor;
  43 import org.eclipse.core.resources.IWorkspaceRoot;
  44 import org.eclipse.core.resources.IncrementalProjectBuilder;
  45 import org.eclipse.core.runtime.CoreException;
  46 import org.eclipse.core.runtime.IPath;
  47 import org.eclipse.core.runtime.IProgressMonitor;
  48 import org.eclipse.core.runtime.OperationCanceledException;
  49
  50 public class PHPBuilder extends IncrementalProjectBuilder {
  51         IProject currentProject;
  52
  53         JavaProject javaProject;
  54
  55         IWorkspaceRoot workspaceRoot;
  56
  57         NameEnvironment nameEnvironment;
  58
  59         SimpleLookupTable binaryLocationsPerProject; // maps a project to its
  60                                                                                                         // binary
  61
  62         // resources (output folders,
  63         // class folders, zip/jar files)
  64         State lastState;
  65
  66         BuildNotifier notifier;
  67
  68         char[][] extraResourceFileFilters;
  69
  70         String[] extraResourceFolderFilters;
  71
  72         public static final String CLASS_EXTENSION = "class"; //$NON-NLS-1$
  73
  74         public static boolean DEBUG = false;
  75
  76         /**
  77          * A list of project names that have been built. This list is used to reset
  78          * the JavaModel.existingExternalFiles cache when a build cycle begins so
  79          * that deleted external jars are discovered.
  80          */
  81         static ArrayList builtProjects = null;
  82
  83         public static IMarker[] getProblemsFor(IResource resource) {
  84                 try {
  85                         if (resource != null && resource.exists())
  86                                 return resource.findMarkers(
  87                                                 IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, false,
  88                                                 IResource.DEPTH_INFINITE);
  89                 } catch (CoreException e) {
  90                 } // assume there are no problems
  91                 return new IMarker[0];
  92         }
  93
  94         public static IMarker[] getTasksFor(IResource resource) {
  95                 try {
  96                         if (resource != null && resource.exists())
  97                                 return resource.findMarkers(IJavaModelMarker.TASK_MARKER,
  98                                                 false, IResource.DEPTH_INFINITE);
  99                 } catch (CoreException e) {
 100                 } // assume there are no tasks
 101                 return new IMarker[0];
 102         }
 103
 104         public static void finishedBuilding(IResourceChangeEvent event) {
 105                 BuildNotifier.resetProblemCounters();
 106         }
 107
 108         /**
 109          * Hook allowing to initialize some static state before a complete build
 110          * iteration. This hook is invoked during PRE_AUTO_BUILD notification
 111          */
 112         public static void buildStarting() {
 113                 // do nothing
 114                 // TODO (philippe) is it still needed?
 115         }
 116
 117         /**
 118          * Hook allowing to reset some static state after a complete build
 119          * iteration. This hook is invoked during POST_AUTO_BUILD notification
 120          */
 121         public static void buildFinished() {
 122                 BuildNotifier.resetProblemCounters();
 123         }
 124
 125         public static void removeProblemsFor(IResource resource) {
 126                 try {
 127                         if (resource != null && resource.exists())
 128                                 resource.deleteMarkers(
 129                                                 IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, false,
 130                                                 IResource.DEPTH_INFINITE);
 131                 } catch (CoreException e) {
 132                 } // assume there were no problems
 133         }
 134
 135         public static void removeTasksFor(IResource resource) {
 136                 try {
 137                         if (resource != null && resource.exists())
 138                                 resource.deleteMarkers(IJavaModelMarker.TASK_MARKER, false,
 139                                                 IResource.DEPTH_INFINITE);
 140                 } catch (CoreException e) {
 141                 } // assume there were no problems
 142         }
 143
 144         public static void removeProblemsAndTasksFor(IResource resource) {
 145                 try {
 146                         if (resource != null && resource.exists()) {
 147                                 resource.deleteMarkers(
 148                                                 IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, false,
 149                                                 IResource.DEPTH_INFINITE);
 150                                 resource.deleteMarkers(IJavaModelMarker.TASK_MARKER, false,
 151                                                 IResource.DEPTH_INFINITE);
 152                         }
 153                 } catch (CoreException e) {
 154                 } // assume there were no problems
 155         }
 156
 157         public static State readState(IProject project, DataInputStream in)
 158                         throws IOException {
 159                 return State.read(project, in);
 160         }
 161
 162         public static void writeState(Object state, DataOutputStream out)
 163                         throws IOException {
 164                 ((State) state).write(out);
 165         }
 166
 167         public PHPBuilder() {
 168         }
 169
 170         protected IProject[] build(int kind, Map ignored, IProgressMonitor monitor)
 171                         throws CoreException {
 172                 this.currentProject = getProject();
 173                 if (currentProject == null || !currentProject.isAccessible())
 174                         return new IProject[0];
 175                 if (DEBUG)
 176                         System.out
 177                                         .println("\nStarting build of " + currentProject.getName() //$NON-NLS-1$
 178                                                         + " @ " + new Date(System.currentTimeMillis())); //$NON-NLS-1$
 179                 this.notifier = new BuildNotifier(monitor, currentProject);
 180                 notifier.begin();
 181                 boolean ok = false;
 182                 try {
 183                         notifier.checkCancel();
 184                         initializeBuilder();
 185                         if (isWorthBuilding()) {
 186                                 if (kind == FULL_BUILD) {
 187                                         processFullPHPIndex(currentProject, monitor);
 188                                         buildAll();
 189                                 } else {
 190                                         if ((this.lastState = getLastState(currentProject)) == null) {
 191                                                 if (DEBUG)
 192                                                         System.out
 193                                                                         .println("Performing full build since last saved state was not found"); //$NON-NLS-1$
 194                                                 processFullPHPIndex(currentProject, monitor);
 195                                                 buildAll();
 196                                                 // } else if (hasClasspathChanged()) {
 197                                                 // // if the output location changes, do not delete the
 198                                                 // binary files
 199                                                 // // from old location
 200                                                 // // the user may be trying something
 201                                                 // buildAll();
 202                                         } else if (nameEnvironment.sourceLocations.length > 0) {
 203                                                 // if there is no source to compile & no classpath
 204                                                 // changes then we
 205                                                 // are done
 206                                                 SimpleLookupTable deltas = findDeltas();
 207                                                 if (deltas == null)
 208                                                         buildAll();
 209                                                 else if (deltas.elementSize > 0)
 210                                                         buildDeltas(deltas);
 211                                                 else if (DEBUG)
 212                                                         System.out
 213                                                                         .println("Nothing to build since deltas were empty"); //$NON-NLS-1$
 214                                         } else {
 215                                                 if (hasStructuralDelta()) { // double check that a jar
 216                                                                                                         // file didn't
 217                                                         // get replaced in a binary project
 218                                                         processFullPHPIndex(currentProject, monitor);
 219                                                         buildAll();
 220                                                 } else {
 221                                                         if (DEBUG)
 222                                                                 System.out
 223                                                                                 .println("Nothing to build since there are no source folders and no deltas"); //$NON-NLS-1$
 224                                                         lastState.tagAsNoopBuild();
 225                                                 }
 226                                         }
 227                                 }
 228                                 ok = true;
 229                         }
 230                 } catch (CoreException e) {
 231                         Util.log(e, "JavaBuilder handling CoreException"); //$NON-NLS-1$
 232                         IMarker marker = currentProject
 233                                         .createMarker(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER);
 234                         marker.setAttribute(IMarker.MESSAGE, Util.bind(
 235                                         "build.inconsistentProject", e.getLocalizedMessage())); //$NON-NLS-1$
 236                         marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
 237                 } catch (ImageBuilderInternalException e) {
 238                         Util.log(e.getThrowable(),
 239                                         "JavaBuilder handling ImageBuilderInternalException"); //$NON-NLS-1$
 240                         IMarker marker = currentProject
 241                                         .createMarker(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER);
 242                         marker
 243                                         .setAttribute(
 244                                                         IMarker.MESSAGE,
 245                                                         Util
 246                                                                         .bind(
 247                                                                                         "build.inconsistentProject", e.coreException.getLocalizedMessage())); //$NON-NLS-1$
 248                         marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
 249                 } catch (MissingClassFileException e) {
 250                         // do not log this exception since its thrown to handle aborted
 251                         // compiles
 252                         // because of missing class files
 253                         if (DEBUG)
 254                                 System.out.println(Util.bind("build.incompleteClassPath",
 255                                                 e.missingClassFile)); //$NON-NLS-1$
 256                         IMarker marker = currentProject
 257                                         .createMarker(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER);
 258                         marker.setAttribute(IMarker.MESSAGE, Util.bind(
 259                                         "build.incompleteClassPath", e.missingClassFile)); //$NON-NLS-1$
 260                         marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
 261                 } catch (MissingSourceFileException e) {
 262                         // do not log this exception since its thrown to handle aborted
 263                         // compiles
 264                         // because of missing source files
 265                         if (DEBUG)
 266                                 System.out.println(Util.bind("build.missingSourceFile",
 267                                                 e.missingSourceFile)); //$NON-NLS-1$
 268                         removeProblemsAndTasksFor(currentProject); // make this the only
 269                                                                                                                 // problem
 270                         // for this project
 271                         IMarker marker = currentProject
 272                                         .createMarker(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER);
 273                         marker.setAttribute(IMarker.MESSAGE, Util.bind(
 274                                         "build.missingSourceFile", e.missingSourceFile)); //$NON-NLS-1$
 275                         marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
 276                 } catch (Exception e) {
 277                         e.printStackTrace();
 278                 } finally {
 279                         if (!ok)
 280                                 // If the build failed, clear the previously built state,
 281                                 // forcing a
 282                                 // full build next time.
 283                                 clearLastState();
 284                         notifier.done();
 285                         cleanup();
 286                 }
 287                 IProject[] requiredProjects = getRequiredProjects(true);
 288                 if (DEBUG)
 289                         System.out.println("Finished build of " + currentProject.getName() //$NON-NLS-1$
 290                                         + " @ " + new Date(System.currentTimeMillis())); //$NON-NLS-1$
 291                 return requiredProjects;
 292         }
 293
 294         /**
 295          * Performs a <code>FULL_BUILD</code> by visiting all nodes in the
 296          * resource tree under the specified project.
 297          *
 298          * @param iProject
 299          */
 300         private void processFullPHPIndex(final IProject iProject,
 301                         final IProgressMonitor monitor) {
 302                 final IdentifierIndexManager indexManager = PHPeclipsePlugin
 303                                 .getDefault().getIndexManager(iProject);
 304                 // Create resource visitor logic
 305                 IResourceVisitor myVisitor = new IResourceVisitor() {
 306                         public boolean visit(IResource resource) throws CoreException {
 307                                 if (resource.getType() == IResource.FILE) {
 308                                         if (monitor.isCanceled()) {
 309                                                 throw new OperationCanceledException();
 310                                         }
 311                                         if ((resource.getFileExtension() != null)
 312                                                         && PHPFileUtil.isPHPFile((IFile) resource)) {
 313                                                 monitor.worked(1);
 314                                                 monitor.subTask("Parsing: " + resource.getFullPath());
 315                                                 // update indexfile for the project:
 316                                                 // PHPProject nature = (PHPProject) iProject
 317                                                 // .getNature(PHPeclipsePlugin.PHP_NATURE_ID);
 318                                                 indexManager.addFile((IFile) resource);
 319                                         }
 320                                 }
 321                                 return true;
 322                         }
 323                 };
 324                 // Process the project using the visitor just created
 325                 try {
 326                         // if (iProject.hasNature(PHPeclipsePlugin.PHP_NATURE_ID)) {
 327                         // thePHPProject = new PHPProject();
 328                         // thePHPProject.setProject(iProject);
 329                         // }
 330                         indexManager.initialize();
 331                         iProject.accept(myVisitor);
 332                         indexManager.writeFile();
 333                 } catch (CoreException e) {
 334                         e.printStackTrace();
 335                 }
 336         }
 337
 338         private void buildAll() {
 339                 notifier.checkCancel();
 340                 notifier.subTask(Util.bind("build.preparingBuild")); //$NON-NLS-1$
 341                 if (DEBUG && lastState != null)
 342                         System.out.println("Clearing last state : " + lastState); //$NON-NLS-1$
 343                 clearLastState();
 344                 BatchImageBuilder imageBuilder = new BatchImageBuilder(this);
 345                 imageBuilder.build();
 346                 recordNewState(imageBuilder.newState);
 347         }
 348
 349         private void buildDeltas(SimpleLookupTable deltas) {
 350                 notifier.checkCancel();
 351                 notifier.subTask(Util.bind("build.preparingBuild")); //$NON-NLS-1$
 352                 if (DEBUG && lastState != null)
 353                         System.out.println("Clearing last state : " + lastState); //$NON-NLS-1$
 354                 clearLastState(); // clear the previously built state so if the build
 355                 // fails, a full build will occur next time
 356                 IncrementalImageBuilder imageBuilder = new IncrementalImageBuilder(this);
 357                 if (imageBuilder.build(deltas))
 358                         recordNewState(imageBuilder.newState);
 359                 else {
 360                         processFullPHPIndex(currentProject, notifier.monitor);
 361                         buildAll();
 362                 }
 363         }
 364
 365         private void cleanup() {
 366                 this.nameEnvironment = null;
 367                 this.binaryLocationsPerProject = null;
 368                 this.lastState = null;
 369                 this.notifier = null;
 370                 this.extraResourceFileFilters = null;
 371                 this.extraResourceFolderFilters = null;
 372         }
 373
 374         private void clearLastState() {
 375                 JavaModelManager.getJavaModelManager().setLastBuiltState(
 376                                 currentProject, null);
 377         }
 378
 379         boolean filterExtraResource(IResource resource) {
 380                 if (extraResourceFileFilters != null) {
 381                         char[] name = resource.getName().toCharArray();
 382                         for (int i = 0, l = extraResourceFileFilters.length; i < l; i++)
 383                                 if (CharOperation
 384                                                 .match(extraResourceFileFilters[i], name, true))
 385                                         return true;
 386                 }
 387                 if (extraResourceFolderFilters != null) {
 388                         IPath path = resource.getProjectRelativePath();
 389                         String pathName = path.toString();
 390                         int count = path.segmentCount();
 391                         if (resource.getType() == IResource.FILE)
 392                                 count--;
 393                         for (int i = 0, l = extraResourceFolderFilters.length; i < l; i++)
 394                                 if (pathName.indexOf(extraResourceFolderFilters[i]) != -1)
 395                                         for (int j = 0; j < count; j++)
 396                                                 if (extraResourceFolderFilters[i].equals(path
 397                                                                 .segment(j)))
 398                                                         return true;
 399                 }
 400                 return false;
 401         }
 402
 403         private SimpleLookupTable findDeltas() {
 404                 notifier.subTask(Util.bind(
 405                                 "build.readingDelta", currentProject.getName())); //$NON-NLS-1$
 406                 IResourceDelta delta = getDelta(currentProject);
 407                 SimpleLookupTable deltas = new SimpleLookupTable(3);
 408                 if (delta != null) {
 409                         if (delta.getKind() != IResourceDelta.NO_CHANGE) {
 410                                 if (DEBUG)
 411                                         System.out.println("Found source delta for: "
 412                                                         + currentProject.getName()); //$NON-NLS-1$
 413                                 deltas.put(currentProject, delta);
 414                         }
 415                 } else {
 416                         if (DEBUG)
 417                                 System.out
 418                                                 .println("Missing delta for: " + currentProject.getName()); //$NON-NLS-1$
 419                         notifier.subTask(""); //$NON-NLS-1$
 420                         return null;
 421                 }
 422                 Object[] keyTable = binaryLocationsPerProject.keyTable;
 423                 Object[] valueTable = binaryLocationsPerProject.valueTable;
 424                 nextProject: for (int i = 0, l = keyTable.length; i < l; i++) {
 425                         IProject p = (IProject) keyTable[i];
 426                         if (p != null && p != currentProject) {
 427                                 State s = getLastState(p);
 428                                 if (!lastState.wasStructurallyChanged(p, s)) { // see if we can
 429                                                                                                                                 // skip
 430                                         // its delta
 431                                         if (s.wasNoopBuild())
 432                                                 continue nextProject; // project has no source folders
 433                                                                                                 // and can be
 434                                         // skipped
 435                                         // ClasspathLocation[] classFoldersAndJars =
 436                                         // (ClasspathLocation[])
 437                                         // valueTable[i];
 438                                         boolean canSkip = true;
 439                                         // for (int j = 0, m = classFoldersAndJars.length; j < m;
 440                                         // j++) {
 441                                         // if (classFoldersAndJars[j].isOutputFolder())
 442                                         // classFoldersAndJars[j] = null; // can ignore output
 443                                         // folder since
 444                                         // project was not structurally changed
 445                                         // else
 446                                         // canSkip = false;
 447                                         // }
 448                                         if (canSkip)
 449                                                 continue nextProject; // project has no structural
 450                                                                                                 // changes in its
 451                                         // output folders
 452                                 }
 453                                 notifier.subTask(Util.bind("build.readingDelta", p.getName())); //$NON-NLS-1$
 454                                 delta = getDelta(p);
 455                                 if (delta != null) {
 456                                         if (delta.getKind() != IResourceDelta.NO_CHANGE) {
 457                                                 if (DEBUG)
 458                                                         System.out
 459                                                                         .println("Found binary delta for: " + p.getName()); //$NON-NLS-1$
 460                                                 deltas.put(p, delta);
 461                                         }
 462                                 } else {
 463                                         if (DEBUG)
 464                                                 System.out.println("Missing delta for: " + p.getName()); //$NON-NLS-1$
 465                                         notifier.subTask(""); //$NON-NLS-1$
 466                                         return null;
 467                                 }
 468                         }
 469                 }
 470                 notifier.subTask(""); //$NON-NLS-1$
 471                 return deltas;
 472         }
 473
 474         private State getLastState(IProject project) {
 475                 return (State) JavaModelManager.getJavaModelManager()
 476                                 .getLastBuiltState(project, notifier.monitor);
 477         }
 478
 479         /*
 480          * Return the list of projects for which it requires a resource delta. This
 481          * builder's project is implicitly included and need not be specified.
 482          * Builders must re-specify the list of interesting projects every time they
 483          * are run as this is not carried forward beyond the next build. Missing
 484          * projects should be specified but will be ignored until they are added to
 485          * the workspace.
 486          */
 487         private IProject[] getRequiredProjects(boolean includeBinaryPrerequisites) {
 488                 if (javaProject == null || workspaceRoot == null)
 489                         return new IProject[0];
 490                 ArrayList projects = new ArrayList();
 491                 try {
 492                         IClasspathEntry[] entries = javaProject.getExpandedClasspath(true);
 493                         for (int i = 0, l = entries.length; i < l; i++) {
 494                                 IClasspathEntry entry = entries[i];
 495                                 IPath path = entry.getPath();
 496                                 IProject p = null;
 497                                 switch (entry.getEntryKind()) {
 498                                 case IClasspathEntry.CPE_PROJECT:
 499                                         p = workspaceRoot.getProject(path.lastSegment()); // missing
 500                                         // projects are
 501                                         // considered too
 502                                         break;
 503                                 case IClasspathEntry.CPE_LIBRARY:
 504                                         if (includeBinaryPrerequisites && path.segmentCount() > 1) {
 505                                                 // some binary resources on the class path can come from
 506                                                 // projects
 507                                                 // that are not included in the project references
 508                                                 IResource resource = workspaceRoot.findMember(path
 509                                                                 .segment(0));
 510                                                 if (resource instanceof IProject)
 511                                                         p = (IProject) resource;
 512                                         }
 513                                 }
 514                                 if (p != null && !projects.contains(p))
 515                                         projects.add(p);
 516                         }
 517                 } catch (JavaModelException e) {
 518                         return new IProject[0];
 519                 }
 520                 IProject[] result = new IProject[projects.size()];
 521                 projects.toArray(result);
 522                 return result;
 523         }
 524
 525         // private boolean hasClasspathChanged() {
 526         // ClasspathMultiDirectory[] newSourceLocations =
 527         // nameEnvironment.sourceLocations;
 528         // ClasspathMultiDirectory[] oldSourceLocations = lastState.sourceLocations;
 529         // int newLength = newSourceLocations.length;
 530         // int oldLength = oldSourceLocations.length;
 531         // int n, o;
 532         // for (n = o = 0; n < newLength && o < oldLength; n++, o++) {
 533         // if (newSourceLocations[n].equals(oldSourceLocations[o]))
 534         // continue; // checks source & output folders
 535         // try {
 536         // if (newSourceLocations[n].sourceFolder.members().length == 0) { // added
 537         // // new
 538         // // empty
 539         // // source
 540         // // folder
 541         // o--;
 542         // continue;
 543         // }
 544         // } catch (CoreException ignore) {
 545         // }
 546         // if (DEBUG)
 547         // System.out.println(newSourceLocations[n] + " != "
 548         // + oldSourceLocations[o]); //$NON-NLS-1$
 549         // return true;
 550         // }
 551         // while (n < newLength) {
 552         // try {
 553         // if (newSourceLocations[n].sourceFolder.members().length == 0) { // added
 554         // // new
 555         // // empty
 556         // // source
 557         // // folder
 558         // n++;
 559         // continue;
 560         // }
 561         // } catch (CoreException ignore) {
 562         // }
 563         // if (DEBUG)
 564         // System.out.println("Added non-empty source folder"); //$NON-NLS-1$
 565         // return true;
 566         // }
 567         // if (o < oldLength) {
 568         // if (DEBUG)
 569         // System.out.println("Removed source folder"); //$NON-NLS-1$
 570         // return true;
 571         // }
 572         // // ClasspathLocation[] newBinaryLocations =
 573         // // nameEnvironment.binaryLocations;
 574         // // ClasspathLocation[] oldBinaryLocations = lastState.binaryLocations;
 575         // // newLength = newBinaryLocations.length;
 576         // // oldLength = oldBinaryLocations.length;
 577         // // for (n = o = 0; n < newLength && o < oldLength; n++, o++) {
 578         // // if (newBinaryLocations[n].equals(oldBinaryLocations[o])) continue;
 579         // // if (DEBUG)
 580         // // System.out.println(newBinaryLocations[n] + " != " +
 581         // // oldBinaryLocations[o]); //$NON-NLS-1$
 582         // // return true;
 583         // // }
 584         // // if (n < newLength || o < oldLength) {
 585         // // if (DEBUG)
 586         // // System.out.println("Number of binary folders/jar files has changed");
 587         // // //$NON-NLS-1$
 588         // // return true;
 589         // // }
 590         // return false;
 591         // }
 592         private boolean hasStructuralDelta() {
 593                 // handle case when currentProject has only .class file folders and/or
 594                 // jar
 595                 // files... no source/output folders
 596                 IResourceDelta delta = getDelta(currentProject);
 597                 if (delta != null && delta.getKind() != IResourceDelta.NO_CHANGE) {
 598                         // ClasspathLocation[] classFoldersAndJars = (ClasspathLocation[])
 599                         // binaryLocationsPerProject.get(currentProject);
 600                         // if (classFoldersAndJars != null) {
 601                         // for (int i = 0, l = classFoldersAndJars.length; i < l; i++) {
 602                         // ClasspathLocation classFolderOrJar = classFoldersAndJars[i]; //
 603                         // either
 604                         // a .class file folder or a zip/jar file
 605                         // if (classFolderOrJar != null) {
 606                         // IPath p = classFolderOrJar.getProjectRelativePath();
 607                         // if (p != null) {
 608                         // IResourceDelta binaryDelta = delta.findMember(p);
 609                         // if (binaryDelta != null && binaryDelta.getKind() !=
 610                         // IResourceDelta.NO_CHANGE)
 611                         // return true;
 612                         // }
 613                         // }
 614                         // }
 615                         // }
 616                 }
 617                 return false;
 618         }
 619
 620         private void initializeBuilder() throws CoreException {
 621                 this.javaProject = (JavaProject) JavaCore.create(currentProject);
 622                 this.workspaceRoot = currentProject.getWorkspace().getRoot();
 623                 // Flush the existing external files cache if this is the beginning of a
 624                 // build cycle
 625                 String projectName = currentProject.getName();
 626                 if (builtProjects == null || builtProjects.contains(projectName)) {
 627                         JavaModel.flushExternalFileCache();
 628                         builtProjects = new ArrayList();
 629                 }
 630                 builtProjects.add(projectName);
 631                 this.binaryLocationsPerProject = new SimpleLookupTable(3);
 632                 this.nameEnvironment = new NameEnvironment(workspaceRoot, javaProject,
 633                                 binaryLocationsPerProject);
 634                 String filterSequence = javaProject.getOption(
 635                                 JavaCore.CORE_JAVA_BUILD_RESOURCE_COPY_FILTER, true);
 636                 char[][] filters = filterSequence != null
 637                                 && filterSequence.length() > 0 ? CharOperation.splitAndTrimOn(
 638                                 ',', filterSequence.toCharArray()) : null;
 639                 if (filters == null) {
 640                         this.extraResourceFileFilters = null;
 641                         this.extraResourceFolderFilters = null;
 642                 } else {
 643                         int fileCount = 0, folderCount = 0;
 644                         for (int i = 0, l = filters.length; i < l; i++) {
 645                                 char[] f = filters[i];
 646                                 if (f.length == 0)
 647                                         continue;
 648                                 if (f[f.length - 1] == '/')
 649                                         folderCount++;
 650                                 else
 651                                         fileCount++;
 652                         }
 653                         this.extraResourceFileFilters = new char[fileCount][];
 654                         this.extraResourceFolderFilters = new String[folderCount];
 655                         for (int i = 0, l = filters.length; i < l; i++) {
 656                                 char[] f = filters[i];
 657                                 if (f.length == 0)
 658                                         continue;
 659                                 if (f[f.length - 1] == '/')
 660                                         extraResourceFolderFilters[--folderCount] = new String(
 661                                                         CharOperation.subarray(f, 0, f.length - 1));
 662                                 else
 663                                         extraResourceFileFilters[--fileCount] = f;
 664                         }
 665                 }
 666         }
 667
 668         private boolean isClasspathBroken(IClasspathEntry[] classpath, IProject p)
 669                         throws CoreException {
 670                 if (classpath == JavaProject.INVALID_CLASSPATH) // the .classpath file
 671                         // could not be read
 672                         return true;
 673                 IMarker[] markers = p.findMarkers(
 674                                 IJavaModelMarker.BUILDPATH_PROBLEM_MARKER, false,
 675                                 IResource.DEPTH_ZERO);
 676                 for (int i = 0, l = markers.length; i < l; i++)
 677                         if (((Integer) markers[i].getAttribute(IMarker.SEVERITY))
 678                                         .intValue() == IMarker.SEVERITY_ERROR)
 679                                 return true;
 680                 return false;
 681         }
 682
 683         private boolean isWorthBuilding() throws CoreException {
 684                 boolean abortBuilds = JavaCore.ABORT.equals(javaProject.getOption(
 685                                 JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, true));
 686                 if (!abortBuilds)
 687                         return true;
 688                 // Abort build only if there are classpath errors
 689                 // if (isClasspathBroken(javaProject.getRawClasspath(), currentProject))
 690                 // {
 691                 // if (DEBUG)
 692                 // System.out.println("Aborted build because project has classpath
 693                 // errors
 694                 // (incomplete or involved in cycle)"); //$NON-NLS-1$
 695                 //
 696                 // JavaModelManager.getJavaModelManager().deltaProcessor.addForRefresh(javaProject);
 697                 //
 698                 // removeProblemsAndTasksFor(currentProject); // remove all compilation
 699                 // problems
 700                 //
 701                 // IMarker marker =
 702                 // currentProject.createMarker(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER);
 703                 // marker.setAttribute(IMarker.MESSAGE,
 704                 // ProjectPrefUtil.bind("build.abortDueToClasspathProblems"));
 705                 // //$NON-NLS-1$
 706                 // marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
 707                 // return false;
 708                 // }
 709                 // make sure all prereq projects have valid build states... only when
 710                 // aborting builds since projects in cycles do not have build states
 711                 // except for projects involved in a 'warning' cycle (see below)
 712                 IProject[] requiredProjects = getRequiredProjects(false);
 713                 next: for (int i = 0, l = requiredProjects.length; i < l; i++) {
 714                         IProject p = requiredProjects[i];
 715                         if (getLastState(p) == null) {
 716                                 // The prereq project has no build state: if this prereq project
 717                                 // has a
 718                                 // 'warning' cycle marker then allow build (see bug id 23357)
 719                                 JavaProject prereq = (JavaProject) JavaCore.create(p);
 720                                 if (prereq.hasCycleMarker()
 721                                                 && JavaCore.WARNING.equals(javaProject.getOption(
 722                                                                 JavaCore.CORE_CIRCULAR_CLASSPATH, true)))
 723                                         continue;
 724                                 if (DEBUG)
 725                                         System.out.println("Aborted build because prereq project "
 726                                                         + p.getName() //$NON-NLS-1$
 727                                                         + " was not built"); //$NON-NLS-1$
 728                                 removeProblemsAndTasksFor(currentProject); // make this the
 729                                                                                                                         // only
 730                                 // problem for this project
 731                                 IMarker marker = currentProject
 732                                                 .createMarker(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER);
 733                                 marker
 734                                                 .setAttribute(
 735                                                                 IMarker.MESSAGE,
 736                                                                 isClasspathBroken(prereq.getRawClasspath(), p) ? Util
 737                                                                                 .bind(
 738                                                                                                 "build.prereqProjectHasClasspathProblems", p.getName()) //$NON-NLS-1$
 739                                                                                 : Util
 740                                                                                                 .bind(
 741                                                                                                                 "build.prereqProjectMustBeRebuilt", p.getName())); //$NON-NLS-1$
 742                                 marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
 743                                 return false;
 744                         }
 745                 }
 746                 return true;
 747         }
 748
 749         /*
 750          * Instruct the build manager that this project is involved in a cycle and
 751          * needs to propagate structural changes to the other projects in the cycle.
 752          */
 753         void mustPropagateStructuralChanges() {
 754                 HashSet cycleParticipants = new HashSet(3);
 755                 javaProject.updateCycleParticipants(null, new ArrayList(),
 756                                 cycleParticipants, workspaceRoot, new HashSet(3));
 757                 IPath currentPath = javaProject.getPath();
 758                 Iterator i = cycleParticipants.iterator();
 759                 while (i.hasNext()) {
 760                         IPath participantPath = (IPath) i.next();
 761                         if (participantPath != currentPath) {
 762                                 IProject project = this.workspaceRoot
 763                                                 .getProject(participantPath.segment(0));
 764                                 if (hasBeenBuilt(project)) {
 765                                         if (DEBUG)
 766                                                 System.out
 767                                                                 .println("Requesting another build iteration since cycle participant "
 768                                                                                 + project.getName() //$NON-NLS-1$
 769                                                                                 + " has not yet seen some structural changes"); //$NON-NLS-1$
 770                                         needRebuild();
 771                                         return;
 772                                 }
 773                         }
 774                 }
 775         }
 776
 777         private void recordNewState(State state) {
 778                 Object[] keyTable = binaryLocationsPerProject.keyTable;
 779                 for (int i = 0, l = keyTable.length; i < l; i++) {
 780                         IProject prereqProject = (IProject) keyTable[i];
 781                         if (prereqProject != null && prereqProject != currentProject)
 782                                 state.recordStructuralDependency(prereqProject,
 783                                                 getLastState(prereqProject));
 784                 }
 785                 if (DEBUG)
 786                         System.out.println("Recording new state : " + state); //$NON-NLS-1$
 787                 // state.dump();
 788                 JavaModelManager.getJavaModelManager().setLastBuiltState(
 789                                 currentProject, state);
 790         }
 791
 792         /**
 793          * String representation for debugging purposes
 794          */
 795         public String toString() {
 796                 return currentProject == null ? "JavaBuilder for unknown project" //$NON-NLS-1$
 797                                 : "JavaBuilder for " + currentProject.getName(); //$NON-NLS-1$
 798         }
 799 }