net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/util/Util.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2004 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.util;
  12
  13 import java.io.BufferedInputStream;
  14 //import java.io.DataInput;
  15 //import java.io.EOFException;
  16 import java.io.IOException;
  17 import java.io.InputStream;
  18 //import java.io.OutputStream;
  19 import java.io.PrintStream;
  20 //import java.io.UTFDataFormatException;
  21 import java.util.Locale;
  22 import java.util.MissingResourceException;
  23 import java.util.ResourceBundle;
  24 //import java.util.StringTokenizer;
  25
  26 import net.sourceforge.phpdt.core.IJavaElement;
  27 import net.sourceforge.phpdt.core.IJavaModelStatusConstants;
  28 import net.sourceforge.phpdt.core.IPackageFragment;
  29 import net.sourceforge.phpdt.core.JavaCore;
  30 import net.sourceforge.phpdt.core.JavaModelException;
  31 import net.sourceforge.phpdt.core.Signature;
  32 import net.sourceforge.phpdt.core.compiler.CharOperation;
  33 //import net.sourceforge.phpdt.internal.compiler.ast.TypeReference;
  34 //incastrix
  35 //import net.sourceforge.phpdt.internal.corext.Assert;
  36 //import org.eclipse.core.runtime.Assert;
  37 //import net.sourceforge.phpdt.internal.core.PackageFragmentRoot;
  38 import net.sourceforge.phpdt.internal.core.util.PHPFileUtil;
  39
  40 import org.eclipse.core.resources.IFile;
  41 //import org.eclipse.core.resources.IFolder;
  42 import org.eclipse.core.resources.IResource;
  43 import org.eclipse.core.runtime.CoreException;
  44 import org.eclipse.core.runtime.IPath;
  45 import org.eclipse.core.runtime.IStatus;
  46 import org.eclipse.core.runtime.Status;
  47 //import org.eclipse.jface.text.BadLocationException;
  48 //import org.eclipse.text.edits.MalformedTreeException;
  49 //import org.eclipse.text.edits.TextEdit;
  50
  51 /**
  52  * Provides convenient utility methods to other types in this package.
  53  */
  54 public class Util {
  55
  56         public interface Comparable {
  57                 /**
  58                  * Returns 0 if this and c are equal, >0 if this is greater than c, or
  59                  * <0 if this is less than c.
  60                  */
  61                 int compareTo(Comparable c);
  62         }
  63
  64         public interface Comparer {
  65                 /**
  66                  * Returns 0 if a and b are equal, >0 if a is greater than b, or <0 if a
  67                  * is less than b.
  68                  */
  69                 int compare(Object a, Object b);
  70         }
  71
  72         private static final String ARGUMENTS_DELIMITER = "#"; //$NON-NLS-1$
  73
  74         /* Bundle containing messages */
  75         protected static ResourceBundle bundle;
  76
  77         private final static String bundleName = "net.sourceforge.phpdt.internal.core.util.messages"; //$NON-NLS-1$
  78
  79         private final static char[] DOUBLE_QUOTES = "''".toCharArray(); //$NON-NLS-1$
  80
  81         private static final String EMPTY_ARGUMENT = "   "; //$NON-NLS-1$
  82
  83         public static final String[] fgEmptyStringArray = new String[0];
  84
  85         private final static char[] SINGLE_QUOTE = "'".toCharArray(); //$NON-NLS-1$
  86
  87         static {
  88                 relocalize();
  89         }
  90
  91         private Util() {
  92                 // cannot be instantiated
  93         }
  94
  95         /**
  96          * Lookup the message with the given ID in this catalog
  97          */
  98         public static String bind(String id) {
  99                 return bind(id, (String[]) null);
 100         }
 101
 102         /**
 103          * Lookup the message with the given ID in this catalog and bind its
 104          * substitution locations with the given string.
 105          */
 106         public static String bind(String id, String binding) {
 107                 return bind(id, new String[] { binding });
 108         }
 109
 110         /**
 111          * Lookup the message with the given ID in this catalog and bind its
 112          * substitution locations with the given strings.
 113          */
 114         public static String bind(String id, String binding1, String binding2) {
 115                 return bind(id, new String[] { binding1, binding2 });
 116         }
 117
 118         /**
 119          * Lookup the message with the given ID in this catalog and bind its
 120          * substitution locations with the given string values.
 121          */
 122         public static String bind(String id, String[] bindings) {
 123                 if (id == null)
 124                         return "No message available"; //$NON-NLS-1$
 125                 String message = null;
 126                 try {
 127                         message = bundle.getString(id);
 128                 } catch (MissingResourceException e) {
 129                         // If we got an exception looking for the message, fail gracefully
 130                         // by just returning
 131                         // the id we were looking for. In most cases this is
 132                         // semi-informative so is not too bad.
 133                         return "Missing message: " + id + " in: " + bundleName; //$NON-NLS-2$ //$NON-NLS-1$
 134                 }
 135                 // for compatibility with MessageFormat which eliminates double quotes
 136                 // in original message
 137                 char[] messageWithNoDoubleQuotes = CharOperation.replace(message
 138                                 .toCharArray(), DOUBLE_QUOTES, SINGLE_QUOTE);
 139
 140                 if (bindings == null)
 141                         return new String(messageWithNoDoubleQuotes);
 142
 143                 int length = messageWithNoDoubleQuotes.length;
 144                 int start = 0;
 145                 int end = length;
 146                 StringBuffer output = null;
 147                 while (true) {
 148                         if ((end = CharOperation.indexOf('{', messageWithNoDoubleQuotes,
 149                                         start)) > -1) {
 150                                 if (output == null)
 151                                         output = new StringBuffer(length + bindings.length * 20);
 152                                 output.append(messageWithNoDoubleQuotes, start, end - start);
 153                                 if ((start = CharOperation.indexOf('}',
 154                                                 messageWithNoDoubleQuotes, end + 1)) > -1) {
 155                                         int index = -1;
 156                                         String argId = new String(messageWithNoDoubleQuotes,
 157                                                         end + 1, start - end - 1);
 158                                         try {
 159                                                 index = Integer.parseInt(argId);
 160                                                 output.append(bindings[index]);
 161                                         } catch (NumberFormatException nfe) { // could be nested
 162                                                                                                                         // message ID
 163                                                                                                                         // {compiler.name}
 164                                                 boolean done = false;
 165                                                 if (!id.equals(argId)) {
 166                                                         String argMessage = null;
 167                                                         try {
 168                                                                 argMessage = bundle.getString(argId);
 169                                                                 output.append(argMessage);
 170                                                                 done = true;
 171                                                         } catch (MissingResourceException e) {
 172                                                                 // unable to bind argument, ignore (will leave
 173                                                                 // argument in)
 174                                                         }
 175                                                 }
 176                                                 if (!done)
 177                                                         output.append(messageWithNoDoubleQuotes, end + 1,
 178                                                                         start - end);
 179                                         } catch (ArrayIndexOutOfBoundsException e) {
 180                                                 output
 181                                                                 .append("{missing " + Integer.toString(index) + "}"); //$NON-NLS-2$ //$NON-NLS-1$
 182                                         }
 183                                         start++;
 184                                 } else {
 185                                         output.append(messageWithNoDoubleQuotes, end, length);
 186                                         break;
 187                                 }
 188                         } else {
 189                                 if (output == null)
 190                                         return new String(messageWithNoDoubleQuotes);
 191                                 output.append(messageWithNoDoubleQuotes, start, length - start);
 192                                 break;
 193                         }
 194                 }
 195                 return output.toString();
 196         }
 197
 198         /**
 199          * Checks the type signature in String sig, starting at start and ending
 200          * before end (end is not included). Returns the index of the character
 201          * immediately after the signature if valid, or -1 if not valid.
 202          */
 203         private static int checkTypeSignature(String sig, int start, int end,
 204                         boolean allowVoid) {
 205                 if (start >= end)
 206                         return -1;
 207                 int i = start;
 208                 char c = sig.charAt(i++);
 209                 int nestingDepth = 0;
 210                 while (c == '[') {
 211                         ++nestingDepth;
 212                         if (i >= end)
 213                                 return -1;
 214                         c = sig.charAt(i++);
 215                 }
 216                 switch (c) {
 217                 case 'B':
 218                 case 'C':
 219                 case 'D':
 220                 case 'F':
 221                 case 'I':
 222                 case 'J':
 223                 case 'S':
 224                 case 'Z':
 225                         break;
 226                 case 'V':
 227                         if (!allowVoid)
 228                                 return -1;
 229                         // array of void is not allowed
 230                         if (nestingDepth != 0)
 231                                 return -1;
 232                         break;
 233                 case 'L':
 234                         int semicolon = sig.indexOf(';', i);
 235                         // Must have at least one character between L and ;
 236                         if (semicolon <= i || semicolon >= end)
 237                                 return -1;
 238                         i = semicolon + 1;
 239                         break;
 240                 default:
 241                         return -1;
 242                 }
 243                 return i;
 244         }
 245
 246         /**
 247          * Combines two hash codes to make a new one.
 248          */
 249         public static int combineHashCodes(int hashCode1, int hashCode2) {
 250                 return hashCode1 * 17 + hashCode2;
 251         }
 252
 253         /**
 254          * Compares two byte arrays. Returns <0 if a byte in a is less than the
 255          * corresponding byte in b, or if a is shorter, or if a is null. Returns >0
 256          * if a byte in a is greater than the corresponding byte in b, or if a is
 257          * longer, or if b is null. Returns 0 if they are equal or both null.
 258          */
 259         public static int compare(byte[] a, byte[] b) {
 260                 if (a == b)
 261                         return 0;
 262                 if (a == null)
 263                         return -1;
 264                 if (b == null)
 265                         return 1;
 266                 int len = Math.min(a.length, b.length);
 267                 for (int i = 0; i < len; ++i) {
 268                         int diff = a[i] - b[i];
 269                         if (diff != 0)
 270                                 return diff;
 271                 }
 272                 if (a.length > len)
 273                         return 1;
 274                 if (b.length > len)
 275                         return -1;
 276                 return 0;
 277         }
 278
 279         /**
 280          * Compares two strings lexicographically. The comparison is based on the
 281          * Unicode value of each character in the strings.
 282          *
 283          * @return the value <code>0</code> if the str1 is equal to str2; a value
 284          *         less than <code>0</code> if str1 is lexicographically less than
 285          *         str2; and a value greater than <code>0</code> if str1 is
 286          *         lexicographically greater than str2.
 287          */
 288         public static int compare(char[] str1, char[] str2) {
 289                 int len1 = str1.length;
 290                 int len2 = str2.length;
 291                 int n = Math.min(len1, len2);
 292                 int i = 0;
 293                 while (n-- != 0) {
 294                         char c1 = str1[i];
 295                         char c2 = str2[i++];
 296                         if (c1 != c2) {
 297                                 return c1 - c2;
 298                         }
 299                 }
 300                 return len1 - len2;
 301         }
 302
 303         /**
 304          * Concatenate two strings with a char in between.
 305          *
 306          * @see #concat(String, String)
 307          */
 308 //      public static String concat(String s1, char c, String s2) {
 309 //              if (s1 == null)
 310 //                      s1 = "null"; //$NON-NLS-1$
 311 //              if (s2 == null)
 312 //                      s2 = "null"; //$NON-NLS-1$
 313 //              int l1 = s1.length();
 314 //              int l2 = s2.length();
 315 //              char[] buf = new char[l1 + 1 + l2];
 316 //              s1.getChars(0, l1, buf, 0);
 317 //              buf[l1] = c;
 318 //              s2.getChars(0, l2, buf, l1 + 1);
 319 //              return new String(buf);
 320 //      }
 321
 322         /**
 323          * Concatenate two strings. Much faster than using +, which: - creates a
 324          * StringBuffer, - which is synchronized, - of default size, so the
 325          * resulting char array is often larger than needed. This implementation
 326          * creates an extra char array, since the String constructor copies its
 327          * argument, but there's no way around this.
 328          */
 329         public static String concat(String s1, String s2) {
 330                 if (s1 == null)
 331                         s1 = "null"; //$NON-NLS-1$
 332                 if (s2 == null)
 333                         s2 = "null"; //$NON-NLS-1$
 334                 int l1 = s1.length();
 335                 int l2 = s2.length();
 336                 char[] buf = new char[l1 + l2];
 337                 s1.getChars(0, l1, buf, 0);
 338                 s2.getChars(0, l2, buf, l1);
 339                 return new String(buf);
 340         }
 341
 342         /**
 343          * Concatenate three strings.
 344          *
 345          * @see #concat(String, String)
 346          */
 347 //      public static String concat(String s1, String s2, String s3) {
 348 //              if (s1 == null)
 349 //                      s1 = "null"; //$NON-NLS-1$
 350 //              if (s2 == null)
 351 //                      s2 = "null"; //$NON-NLS-1$
 352 //              if (s3 == null)
 353 //                      s3 = "null"; //$NON-NLS-1$
 354 //              int l1 = s1.length();
 355 //              int l2 = s2.length();
 356 //              int l3 = s3.length();
 357 //              char[] buf = new char[l1 + l2 + l3];
 358 //              s1.getChars(0, l1, buf, 0);
 359 //              s2.getChars(0, l2, buf, l1);
 360 //              s3.getChars(0, l3, buf, l1 + l2);
 361 //              return new String(buf);
 362 //      }
 363
 364         /**
 365          * Converts a type signature from the IBinaryType representation to the DC
 366          * representation.
 367          */
 368         public static String convertTypeSignature(char[] sig) {
 369                 return new String(sig).replace('/', '.');
 370         }
 371
 372         /**
 373          * Apply the given edit on the given string and return the updated string.
 374          * Return the given string if anything wrong happen while applying the edit.
 375          *
 376          * @param original
 377          *            the given string
 378          * @param edit
 379          *            the given edit
 380          *
 381          * @return the updated string
 382          */
 383 //      public final static String editedString(String original, TextEdit edit) {
 384 //              if (edit == null) {
 385 //                      return original;
 386 //              }
 387 //              SimpleDocument document = new SimpleDocument(original);
 388 //              try {
 389 //                      edit.apply(document, TextEdit.NONE);
 390 //                      return document.get();
 391 //              } catch (MalformedTreeException e) {
 392 //                      e.printStackTrace();
 393 //              } catch (BadLocationException e) {
 394 //                      e.printStackTrace();
 395 //              }
 396 //              return original;
 397 //      }
 398
 399         /**
 400          * Returns true iff str.toLowerCase().endsWith(end.toLowerCase())
 401          * implementation is not creating extra strings.
 402          */
 403 //      public final static boolean endsWithIgnoreCase(String str, String end) {
 404 //
 405 //              int strLength = str == null ? 0 : str.length();
 406 //              int endLength = end == null ? 0 : end.length();
 407 //
 408 //              // return false if the string is smaller than the end.
 409 //              if (endLength > strLength)
 410 //                      return false;
 411 //
 412 //              // return false if any character of the end are
 413 //              // not the same in lower case.
 414 //              for (int i = 1; i <= endLength; i++) {
 415 //                      if (Character.toLowerCase(end.charAt(endLength - i)) != Character
 416 //                                      .toLowerCase(str.charAt(strLength - i)))
 417 //                              return false;
 418 //              }
 419 //
 420 //              return true;
 421 //      }
 422
 423         /**
 424          * Compares two arrays using equals() on the elements. Either or both arrays
 425          * may be null. Returns true if both are null. Returns false if only one is
 426          * null. If both are arrays, returns true iff they have the same length and
 427          * all elements are equal.
 428          */
 429 //      public static boolean equalArraysOrNull(int[] a, int[] b) {
 430 //              if (a == b)
 431 //                      return true;
 432 //              if (a == null || b == null)
 433 //                      return false;
 434 //              int len = a.length;
 435 //              if (len != b.length)
 436 //                      return false;
 437 //              for (int i = 0; i < len; ++i) {
 438 //                      if (a[i] != b[i])
 439 //                              return false;
 440 //              }
 441 //              return true;
 442 //      }
 443
 444         /**
 445          * Compares two arrays using equals() on the elements. Either or both arrays
 446          * may be null. Returns true if both are null. Returns false if only one is
 447          * null. If both are arrays, returns true iff they have the same length and
 448          * all elements compare true with equals.
 449          */
 450         public static boolean equalArraysOrNull(Object[] a, Object[] b) {
 451                 if (a == b)
 452                         return true;
 453                 if (a == null || b == null)
 454                         return false;
 455
 456                 int len = a.length;
 457                 if (len != b.length)
 458                         return false;
 459                 for (int i = 0; i < len; ++i) {
 460                         if (a[i] == null) {
 461                                 if (b[i] != null)
 462                                         return false;
 463                         } else {
 464                                 if (!a[i].equals(b[i]))
 465                                         return false;
 466                         }
 467                 }
 468                 return true;
 469         }
 470
 471         /**
 472          * Compares two arrays using equals() on the elements. The arrays are first
 473          * sorted. Either or both arrays may be null. Returns true if both are null.
 474          * Returns false if only one is null. If both are arrays, returns true iff
 475          * they have the same length and iff, after sorting both arrays, all
 476          * elements compare true with equals. The original arrays are left
 477          * untouched.
 478          */
 479 //      public static boolean equalArraysOrNullSortFirst(Comparable[] a,
 480 //                      Comparable[] b) {
 481 //              if (a == b)
 482 //                      return true;
 483 //              if (a == null || b == null)
 484 //                      return false;
 485 //              int len = a.length;
 486 //              if (len != b.length)
 487 //                      return false;
 488 //              if (len >= 2) { // only need to sort if more than two items
 489 //                      a = sortCopy(a);
 490 //                      b = sortCopy(b);
 491 //              }
 492 //              for (int i = 0; i < len; ++i) {
 493 //                      if (!a[i].equals(b[i]))
 494 //                              return false;
 495 //              }
 496 //              return true;
 497 //      }
 498
 499         /**
 500          * Compares two String arrays using equals() on the elements. The arrays are
 501          * first sorted. Either or both arrays may be null. Returns true if both are
 502          * null. Returns false if only one is null. If both are arrays, returns true
 503          * iff they have the same length and iff, after sorting both arrays, all
 504          * elements compare true with equals. The original arrays are left
 505          * untouched.
 506          */
 507 //      public static boolean equalArraysOrNullSortFirst(String[] a, String[] b) {
 508 //              if (a == b)
 509 //                      return true;
 510 //              if (a == null || b == null)
 511 //                      return false;
 512 //              int len = a.length;
 513 //              if (len != b.length)
 514 //                      return false;
 515 //              if (len >= 2) { // only need to sort if more than two items
 516 //                      a = sortCopy(a);
 517 //                      b = sortCopy(b);
 518 //              }
 519 //              for (int i = 0; i < len; ++i) {
 520 //                      if (!a[i].equals(b[i]))
 521 //                              return false;
 522 //              }
 523 //              return true;
 524 //      }
 525
 526         /**
 527          * Compares two objects using equals(). Either or both array may be null.
 528          * Returns true if both are null. Returns false if only one is null.
 529          * Otherwise, return the result of comparing with equals().
 530          */
 531 //      public static boolean equalOrNull(Object a, Object b) {
 532 //              if (a == b) {
 533 //                      return true;
 534 //              }
 535 //              if (a == null || b == null) {
 536 //                      return false;
 537 //              }
 538 //              return a.equals(b);
 539 //      }
 540
 541         /**
 542          * Given a qualified name, extract the last component. If the input is not
 543          * qualified, the same string is answered.
 544          */
 545 //      public static String extractLastName(String qualifiedName) {
 546 //              int i = qualifiedName.lastIndexOf('.');
 547 //              if (i == -1)
 548 //                      return qualifiedName;
 549 //              return qualifiedName.substring(i + 1);
 550 //      }
 551
 552         /**
 553          * Extracts the parameter types from a method signature.
 554          */
 555 //      public static String[] extractParameterTypes(char[] sig) {
 556 //              int count = getParameterCount(sig);
 557 //              String[] result = new String[count];
 558 //              if (count == 0)
 559 //                      return result;
 560 //              int i = CharOperation.indexOf('(', sig) + 1;
 561 //              count = 0;
 562 //              int len = sig.length;
 563 //              int start = i;
 564 //              for (;;) {
 565 //                      if (i == len)
 566 //                              break;
 567 //                      char c = sig[i];
 568 //                      if (c == ')')
 569 //                              break;
 570 //                      if (c == '[') {
 571 //                              ++i;
 572 //                      } else if (c == 'L') {
 573 //                              i = CharOperation.indexOf(';', sig, i + 1) + 1;
 574 //                              Assert.isTrue(i != 0);
 575 //                              result[count++] = convertTypeSignature(CharOperation.subarray(
 576 //                                              sig, start, i));
 577 //                              start = i;
 578 //                      } else {
 579 //                              ++i;
 580 //                              result[count++] = convertTypeSignature(CharOperation.subarray(
 581 //                                              sig, start, i));
 582 //                              start = i;
 583 //                      }
 584 //              }
 585 //              return result;
 586 //      }
 587
 588         /**
 589          * Extracts the return type from a method signature.
 590          */
 591 //      public static String extractReturnType(String sig) {
 592 //              int i = sig.lastIndexOf(')');
 593 //              Assert.isTrue(i != -1);
 594 //              return sig.substring(i + 1);
 595 //      }
 596
 597 //      private static IFile findFirstClassFile(IFolder folder) {
 598 //              try {
 599 //                      IResource[] members = folder.members();
 600 //                      for (int i = 0, max = members.length; i < max; i++) {
 601 //                              IResource member = members[i];
 602 //                              if (member.getType() == IResource.FOLDER) {
 603 //                                      return findFirstClassFile((IFolder) member);
 604 //                                      // } else if
 605 //                                      // (net.sourceforge.phpdt.internal.compiler.util.Util.isClassFileName(member.getName()))
 606 //                                      // {
 607 //                                      // return (IFile) member;
 608 //                              }
 609 //                      }
 610 //              } catch (CoreException e) {
 611 //                      // ignore
 612 //              }
 613 //              return null;
 614 //      }
 615
 616         /**
 617          * Finds the first line separator used by the given text.
 618          *
 619          * @return</code> "\n"</code> or</code> "\r"</code> or</code> "\r\n"</code>,
 620          *         or <code>null</code> if none found
 621          */
 622         public static String findLineSeparator(char[] text) {
 623                 // find the first line separator
 624                 int length = text.length;
 625                 if (length > 0) {
 626                         char nextChar = text[0];
 627                         for (int i = 0; i < length; i++) {
 628                                 char currentChar = nextChar;
 629                                 nextChar = i < length - 1 ? text[i + 1] : ' ';
 630                                 switch (currentChar) {
 631                                 case '\n':
 632                                         return "\n"; //$NON-NLS-1$
 633                                 case '\r':
 634                                         return nextChar == '\n' ? "\r\n" : "\r"; //$NON-NLS-1$ //$NON-NLS-2$
 635                                 }
 636                         }
 637                 }
 638                 // not found
 639                 return null;
 640         }
 641
 642         // public static IClassFileAttribute getAttribute(IClassFileReader
 643         // classFileReader, char[] attributeName) {
 644         // IClassFileAttribute[] attributes = classFileReader.getAttributes();
 645         // for (int i = 0, max = attributes.length; i < max; i++) {
 646         // if (CharOperation.equals(attributes[i].getAttributeName(),
 647         // attributeName)) {
 648         // return attributes[i];
 649         // }
 650         // }
 651         // return null;
 652         // }
 653         //
 654         // public static IClassFileAttribute getAttribute(ICodeAttribute
 655         // codeAttribute, char[] attributeName) {
 656         // IClassFileAttribute[] attributes = codeAttribute.getAttributes();
 657         // for (int i = 0, max = attributes.length; i < max; i++) {
 658         // if (CharOperation.equals(attributes[i].getAttributeName(),
 659         // attributeName)) {
 660         // return attributes[i];
 661         // }
 662         // }
 663         // return null;
 664         // }
 665
 666         // public static IClassFileAttribute getAttribute(IFieldInfo fieldInfo,
 667         // char[] attributeName) {
 668         // IClassFileAttribute[] attributes = fieldInfo.getAttributes();
 669         // for (int i = 0, max = attributes.length; i < max; i++) {
 670         // if (CharOperation.equals(attributes[i].getAttributeName(),
 671         // attributeName)) {
 672         // return attributes[i];
 673         // }
 674         // }
 675         // return null;
 676         // }
 677         //
 678         // public static IClassFileAttribute getAttribute(IMethodInfo methodInfo,
 679         // char[] attributeName) {
 680         // IClassFileAttribute[] attributes = methodInfo.getAttributes();
 681         // for (int i = 0, max = attributes.length; i < max; i++) {
 682         // if (CharOperation.equals(attributes[i].getAttributeName(),
 683         // attributeName)) {
 684         // return attributes[i];
 685         // }
 686         // }
 687         // return null;
 688         // }
 689         /**
 690          * Get the jdk level of this root. The value can be:
 691          * <ul>
 692          * <li>major < <16 + minor : see predefined constants on ClassFileConstants</li>
 693          * <li><code>0</null> if the root is a source package fragment root or if a Java model exception occured</li>
 694          * </ul>
 695          * Returns the jdk level
 696          */
 697         // public static long getJdkLevel(Object targetLibrary) {
 698         // try {
 699         // ClassFileReader reader = null;
 700         // if (targetLibrary instanceof IFolder) {
 701         // IFile classFile = findFirstClassFile((IFolder) targetLibrary); // only
 702         // internal classfolders are allowed
 703         // if (classFile != null) {
 704         // byte[] bytes = Util.getResourceContentsAsByteArray(classFile);
 705         // IPath location = classFile.getLocation();
 706         // reader = new ClassFileReader(bytes, location == null ? null :
 707         // location.toString().toCharArray());
 708         // }
 709         // } else {
 710         // // root is a jar file or a zip file
 711         // ZipFile jar = null;
 712         // try {
 713         // IPath path = null;
 714         // if (targetLibrary instanceof IResource) {
 715         // path = ((IResource)targetLibrary).getLocation();
 716         // } else if (targetLibrary instanceof File){
 717         // File f = (File) targetLibrary;
 718         // if (!f.isDirectory()) {
 719         // path = new Path(((File)targetLibrary).getPath());
 720         // }
 721         // }
 722         // if (path != null) {
 723         // jar = JavaModelManager.getJavaModelManager().getZipFile(path);
 724         // for (Enumeration e= jar.entries(); e.hasMoreElements();) {
 725         // ZipEntry member= (ZipEntry) e.nextElement();
 726         // String entryName= member.getName();
 727         // if
 728         // (net.sourceforge.phpdt.internal.compiler.util.Util.isClassFileName(entryName))
 729         // {
 730         // reader = ClassFileReader.read(jar, entryName);
 731         // break;
 732         // }
 733         // }
 734         // }
 735         // } catch (CoreException e) {
 736         // // ignore
 737         // } finally {
 738         // JavaModelManager.getJavaModelManager().closeZipFile(jar);
 739         // }
 740         // }
 741         // if (reader != null) {
 742         // return reader.getVersion();
 743         // }
 744         // } catch(JavaModelException e) {
 745         // // ignore
 746         // } catch(ClassFormatException e) {
 747         // // ignore
 748         // } catch(IOException e) {
 749         // // ignore
 750         // }
 751         // return 0;
 752         // }
 753         /**
 754          * Returns the line separator used by the given buffer. Uses the given text
 755          * if none found.
 756          *
 757          * @return</code> "\n"</code> or</code> "\r"</code> or</code> "\r\n"</code>
 758          */
 759         private static String getLineSeparator(char[] text, char[] buffer) {
 760                 // search in this buffer's contents first
 761                 String lineSeparator = findLineSeparator(buffer);
 762                 if (lineSeparator == null) {
 763                         // search in the given text
 764                         lineSeparator = findLineSeparator(text);
 765                         if (lineSeparator == null) {
 766                                 // default to system line separator
 767                                 return net.sourceforge.phpdt.internal.compiler.util.Util.LINE_SEPARATOR;
 768                         }
 769                 }
 770                 return lineSeparator;
 771         }
 772
 773         /**
 774          * Returns the number of parameter types in a method signature.
 775          */
 776 //      public static int getParameterCount(char[] sig) {
 777 //              int i = CharOperation.indexOf('(', sig) + 1;
 778 //              Assert.isTrue(i != 0);
 779 //              int count = 0;
 780 //              int len = sig.length;
 781 //              for (;;) {
 782 //                      if (i == len)
 783 //                              break;
 784 //                      char c = sig[i];
 785 //                      if (c == ')')
 786 //                              break;
 787 //                      if (c == '[') {
 788 //                              ++i;
 789 //                      } else if (c == 'L') {
 790 //                              ++count;
 791 //                              i = CharOperation.indexOf(';', sig, i + 1) + 1;
 792 //                              Assert.isTrue(i != 0);
 793 //                      } else {
 794 //                              ++count;
 795 //                              ++i;
 796 //                      }
 797 //              }
 798 //              return count;
 799 //      }
 800
 801         /**
 802          * Put all the arguments in one String.
 803          */
 804         public static String getProblemArgumentsForMarker(String[] arguments) {
 805                 StringBuffer args = new StringBuffer(10);
 806
 807                 args.append(arguments.length);
 808                 args.append(':');
 809
 810                 for (int j = 0; j < arguments.length; j++) {
 811                         if (j != 0)
 812                                 args.append(ARGUMENTS_DELIMITER);
 813
 814                         if (arguments[j].length() == 0) {
 815                                 args.append(EMPTY_ARGUMENT);
 816                         } else {
 817                                 args.append(arguments[j]);
 818                         }
 819                 }
 820
 821                 return args.toString();
 822         }
 823
 824         /**
 825          * Separate all the arguments of a String made by
 826          * getProblemArgumentsForMarker
 827          */
 828 //      public static String[] getProblemArgumentsFromMarker(String argumentsString) {
 829 //              if (argumentsString == null)
 830 //                      return null;
 831 //              int index = argumentsString.indexOf(':');
 832 //              if (index == -1)
 833 //                      return null;
 834 //
 835 //              int length = argumentsString.length();
 836 //              int numberOfArg;
 837 //              try {
 838 //                      numberOfArg = Integer.parseInt(argumentsString.substring(0, index));
 839 //              } catch (NumberFormatException e) {
 840 //                      return null;
 841 //              }
 842 //              argumentsString = argumentsString.substring(index + 1, length);
 843 //
 844 //              String[] args = new String[length];
 845 //              int count = 0;
 846 //
 847 //              StringTokenizer tokenizer = new StringTokenizer(argumentsString,
 848 //                              ARGUMENTS_DELIMITER);
 849 //              while (tokenizer.hasMoreTokens()) {
 850 //                      String argument = tokenizer.nextToken();
 851 //                      if (argument.equals(EMPTY_ARGUMENT))
 852 //                              argument = ""; //$NON-NLS-1$
 853 //                      args[count++] = argument;
 854 //              }
 855 //
 856 //              if (count != numberOfArg)
 857 //                      return null;
 858 //
 859 //              System.arraycopy(args, 0, args = new String[count], 0, count);
 860 //              return args;
 861 //      }
 862
 863         /**
 864          * Returns the given file's contents as a byte array.
 865          */
 866         public static byte[] getResourceContentsAsByteArray(IFile file)
 867                         throws JavaModelException {
 868                 InputStream stream = null;
 869                 try {
 870                         stream = new BufferedInputStream(file.getContents(true));
 871                 } catch (CoreException e) {
 872                         throw new JavaModelException(e);
 873                 }
 874                 try {
 875                         return net.sourceforge.phpdt.internal.compiler.util.Util
 876                                         .getInputStreamAsByteArray(stream, -1);
 877                 } catch (IOException e) {
 878                         throw new JavaModelException(e,
 879                                         IJavaModelStatusConstants.IO_EXCEPTION);
 880                 } finally {
 881                         try {
 882                                 stream.close();
 883                         } catch (IOException e) {
 884                                 // ignore
 885                         }
 886                 }
 887         }
 888
 889         /**
 890          * Returns the given file's contents as a character array.
 891          */
 892         public static char[] getResourceContentsAsCharArray(IFile file)
 893                         throws JavaModelException {
 894                 // Get encoding from file
 895                 String encoding = null;
 896                 try {
 897                         encoding = file.getCharset();
 898                 } catch (CoreException ce) {
 899                         // do not use any encoding
 900                 }
 901                 return getResourceContentsAsCharArray(file, encoding);
 902         }
 903
 904         public static char[] getResourceContentsAsCharArray(IFile file,
 905                         String encoding) throws JavaModelException {
 906                 // Get resource contents
 907                 InputStream stream = null;
 908                 try {
 909                         stream = new BufferedInputStream(file.getContents(true));
 910                 } catch (CoreException e) {
 911                         throw new JavaModelException(e,
 912                                         IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST);
 913                 }
 914                 try {
 915                         return net.sourceforge.phpdt.internal.compiler.util.Util
 916                                         .getInputStreamAsCharArray(stream, -1, encoding);
 917                 } catch (IOException e) {
 918                         throw new JavaModelException(e,
 919                                         IJavaModelStatusConstants.IO_EXCEPTION);
 920                 } finally {
 921                         try {
 922                                 stream.close();
 923                         } catch (IOException e) {
 924                                 // ignore
 925                         }
 926                 }
 927         }
 928
 929         /**
 930          * Returns a trimmed version the simples names returned by Signature.
 931          */
 932         public static String[] getTrimmedSimpleNames(String name) {
 933                 String[] result = Signature.getSimpleNames(name);
 934                 if (result == null)
 935                         return null;
 936                 for (int i = 0, length = result.length; i < length; i++) {
 937                         result[i] = result[i].trim();
 938                 }
 939                 return result;
 940         }
 941
 942         /*
 943          * Returns the index of the most specific argument paths which is strictly
 944          * enclosing the path to check
 945          */
 946         public static int indexOfEnclosingPath(IPath checkedPath, IPath[] paths,
 947                         int pathCount) {
 948
 949                 int bestMatch = -1, bestLength = -1;
 950                 for (int i = 0; i < pathCount; i++) {
 951                         if (paths[i].equals(checkedPath))
 952                                 continue;
 953                         if (paths[i].isPrefixOf(checkedPath)) {
 954                                 int currentLength = paths[i].segmentCount();
 955                                 if (currentLength > bestLength) {
 956                                         bestLength = currentLength;
 957                                         bestMatch = i;
 958                                 }
 959                         }
 960                 }
 961                 return bestMatch;
 962         }
 963
 964         /*
 965          * Returns the index of the first argument paths which is equal to the path
 966          * to check
 967          */
 968         public static int indexOfMatchingPath(IPath checkedPath, IPath[] paths,
 969                         int pathCount) {
 970
 971                 for (int i = 0; i < pathCount; i++) {
 972                         if (paths[i].equals(checkedPath))
 973                                 return i;
 974                 }
 975                 return -1;
 976         }
 977
 978         /*
 979          * Returns the index of the first argument paths which is strictly nested
 980          * inside the path to check
 981          */
 982 //      public static int indexOfNestedPath(IPath checkedPath, IPath[] paths,
 983 //                      int pathCount) {
 984 //
 985 //              for (int i = 0; i < pathCount; i++) {
 986 //                      if (checkedPath.equals(paths[i]))
 987 //                              continue;
 988 //                      if (checkedPath.isPrefixOf(paths[i]))
 989 //                              return i;
 990 //              }
 991 //              return -1;
 992 //      }
 993
 994         /*
 995          * Returns whether the given java element is exluded from its root's
 996          * classpath. It doesn't check whether the root itself is on the classpath
 997          * or not
 998          */
 999         public static final boolean isExcluded(IJavaElement element) {
1000                 int elementType = element.getElementType();
1001                 //PackageFragmentRoot root = null;
1002                 //IResource resource = null;
1003                 switch (elementType) {
1004                 case IJavaElement.JAVA_MODEL:
1005                 case IJavaElement.JAVA_PROJECT:
1006                 case IJavaElement.PACKAGE_FRAGMENT_ROOT:
1007                         return false;
1008
1009                         // case IJavaElement.PACKAGE_FRAGMENT:
1010                         // PackageFragmentRoot root =
1011                         // (PackageFragmentRoot)element.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
1012                         // IResource resource = element.getResource();
1013                         // return resource != null && isExcluded(resource,
1014                         // root.fullInclusionPatternChars(),
1015                         // root.fullExclusionPatternChars());
1016
1017                 case IJavaElement.COMPILATION_UNIT:
1018 //                      root = (PackageFragmentRoot) element
1019 //                                      .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
1020                         //resource = element.getResource();
1021                         // if (resource != null && isExcluded(resource,
1022                         // root.fullInclusionPatternChars(),
1023                         // root.fullExclusionPatternChars()))
1024                         // return true;
1025                         return isExcluded(element.getParent());
1026
1027                 default:
1028                         IJavaElement cu = element
1029                                         .getAncestor(IJavaElement.COMPILATION_UNIT);
1030                         return cu != null && isExcluded(cu);
1031                 }
1032         }
1033
1034         /*
1035          * Returns whether the given resource path matches one of the
1036          * inclusion/exclusion patterns. NOTE: should not be asked directly using
1037          * pkg root pathes
1038          *
1039          * @see IClasspathEntry#getInclusionPatterns
1040          * @see IClasspathEntry#getExclusionPatterns
1041          */
1042         public final static boolean isExcluded(IPath resourcePath,
1043                         char[][] inclusionPatterns, char[][] exclusionPatterns,
1044                         boolean isFolderPath) {
1045                 if (inclusionPatterns == null && exclusionPatterns == null)
1046                         return false;
1047                 char[] path = resourcePath.toString().toCharArray();
1048
1049                 inclusionCheck: if (inclusionPatterns != null) {
1050                         for (int i = 0, length = inclusionPatterns.length; i < length; i++) {
1051                                 char[] pattern = inclusionPatterns[i];
1052                                 char[] folderPattern = pattern;
1053                                 if (isFolderPath) {
1054                                         int lastSlash = CharOperation.lastIndexOf('/', pattern);
1055                                         if (lastSlash != -1 && lastSlash != pattern.length - 1) { // trailing
1056                                                                                                                                                                 // slash
1057                                                                                                                                                                 // ->
1058                                                                                                                                                                 // adds
1059                                                                                                                                                                 // '**'
1060                                                                                                                                                                 // for
1061                                                                                                                                                                 // free
1062                                                                                                                                                                 // (see
1063                                                 // http://ant.apache.org/manual/dirtasks.html)
1064                                                 int star = CharOperation.indexOf('*', pattern,
1065                                                                 lastSlash);
1066                                                 if ((star == -1 || star >= pattern.length - 1 || pattern[star + 1] != '*')) {
1067                                                         folderPattern = CharOperation.subarray(pattern, 0,
1068                                                                         lastSlash);
1069                                                 }
1070                                         }
1071                                 }
1072                                 if (CharOperation.pathMatch(folderPattern, path, true, '/')) {
1073                                         break inclusionCheck;
1074                                 }
1075                         }
1076                         return true; // never included
1077                 }
1078                 if (isFolderPath) {
1079                         path = CharOperation.concat(path, new char[] { '*' }, '/');
1080                 }
1081                 exclusionCheck: if (exclusionPatterns != null) {
1082                         for (int i = 0, length = exclusionPatterns.length; i < length; i++) {
1083                                 if (CharOperation.pathMatch(exclusionPatterns[i], path, true,
1084                                                 '/')) {
1085                                         return true;
1086                                 }
1087                         }
1088                 }
1089                 return false;
1090         }
1091
1092         public final static boolean isExcluded(IResource resource,
1093                         char[][] exclusionPatterns) {
1094                 IPath path = resource.getFullPath();
1095                 // ensure that folders are only excluded if all of their children are
1096                 // excluded
1097                 return isExcluded(path, null, exclusionPatterns,
1098                                 resource.getType() == IResource.FOLDER);
1099         }
1100
1101         /*
1102          * Returns whether the given resource matches one of the exclusion patterns.
1103          * NOTE: should not be asked directly using pkg root pathes
1104          *
1105          * @see IClasspathEntry#getExclusionPatterns
1106          */
1107         public final static boolean isExcluded(IResource resource,
1108                         char[][] inclusionPatterns, char[][] exclusionPatterns) {
1109                 IPath path = resource.getFullPath();
1110                 // ensure that folders are only excluded if all of their children are
1111                 // excluded
1112                 return isExcluded(path, inclusionPatterns, exclusionPatterns, resource
1113                                 .getType() == IResource.FOLDER);
1114         }
1115
1116         /**
1117          * Validate the given .class file name. A .class file name must obey the
1118          * following rules:
1119          * <ul>
1120          * <li>it must not be null
1121          * <li>it must include the <code>".class"</code> suffix
1122          * <li>its prefix must be a valid identifier
1123          * </ul>
1124          * </p>
1125          *
1126          * @param name
1127          *            the name of a .class file
1128          * @return a status object with code <code>IStatus.OK</code> if the given
1129          *         name is valid as a .class file name, otherwise a status object
1130          *         indicating what is wrong with the name
1131          */
1132         // public static boolean isValidClassFileName(String name) {
1133         // return JavaConventions.validateClassFileName(name).getSeverity() !=
1134         // IStatus.ERROR;
1135         // }
1136         /**
1137          * Validate the given compilation unit name. A compilation unit name must
1138          * obey the following rules:
1139          * <ul>
1140          * <li>it must not be null
1141          * <li>it must include the <code>".java"</code> suffix
1142          * <li>its prefix must be a valid identifier
1143          * </ul>
1144          * </p>
1145          *
1146          * @param name
1147          *            the name of a compilation unit
1148          * @return a status object with code <code>IStatus.OK</code> if the given
1149          *         name is valid as a compilation unit name, otherwise a status
1150          *         object indicating what is wrong with the name
1151          */
1152         public static boolean isValidCompilationUnitName(String name) {
1153                 return PHPFileUtil.isPHPFileName(name);
1154                 // return
1155                 // JavaConventions.validateCompilationUnitName(name).getSeverity() !=
1156                 // IStatus.ERROR;
1157         }
1158
1159         /**
1160          * Returns true if the given folder name is valid for a package, false if it
1161          * is not.
1162          */
1163         public static boolean isValidFolderNameForPackage(String folderName) {
1164                 // return JavaConventions.validateIdentifier(folderName).getSeverity()
1165                 // != IStatus.ERROR;
1166                 return true;
1167         }
1168
1169         /**
1170          * Returns true if the given method signature is valid, false if it is not.
1171          */
1172         public static boolean isValidMethodSignature(String sig) {
1173                 int len = sig.length();
1174                 if (len == 0)
1175                         return false;
1176                 int i = 0;
1177                 char c = sig.charAt(i++);
1178                 if (c != '(')
1179                         return false;
1180                 if (i >= len)
1181                         return false;
1182                 while (sig.charAt(i) != ')') {
1183                         // Void is not allowed as a parameter type.
1184                         i = checkTypeSignature(sig, i, len, false);
1185                         if (i == -1)
1186                                 return false;
1187                         if (i >= len)
1188                                 return false;
1189                 }
1190                 ++i;
1191                 i = checkTypeSignature(sig, i, len, true);
1192                 return i == len;
1193         }
1194
1195         /**
1196          * Returns true if the given type signature is valid, false if it is not.
1197          */
1198         public static boolean isValidTypeSignature(String sig, boolean allowVoid) {
1199                 int len = sig.length();
1200                 return checkTypeSignature(sig, 0, len, allowVoid) == len;
1201         }
1202
1203         /*
1204          * Add a log entry
1205          */
1206         public static void log(Throwable e, String message) {
1207                 Throwable nestedException;
1208                 if (e instanceof JavaModelException
1209                                 && (nestedException = ((JavaModelException) e).getException()) != null) {
1210                         e = nestedException;
1211                 }
1212                 IStatus status = new Status(IStatus.ERROR, JavaCore.PLUGIN_ID,
1213                                 IStatus.ERROR, message, e);
1214                 JavaCore.getPlugin().getLog().log(status);
1215         }
1216
1217         /**
1218          * Normalizes the cariage returns in the given text. They are all changed to
1219          * use the given buffer's line separator.
1220          */
1221         public static char[] normalizeCRs(char[] text, char[] buffer) {
1222                 CharArrayBuffer result = new CharArrayBuffer();
1223                 int lineStart = 0;
1224                 int length = text.length;
1225                 if (length == 0)
1226                         return text;
1227                 String lineSeparator = getLineSeparator(text, buffer);
1228                 char nextChar = text[0];
1229                 for (int i = 0; i < length; i++) {
1230                         char currentChar = nextChar;
1231                         nextChar = i < length - 1 ? text[i + 1] : ' ';
1232                         switch (currentChar) {
1233                         case '\n':
1234                                 int lineLength = i - lineStart;
1235                                 char[] line = new char[lineLength];
1236                                 System.arraycopy(text, lineStart, line, 0, lineLength);
1237                                 result.append(line);
1238                                 result.append(lineSeparator);
1239                                 lineStart = i + 1;
1240                                 break;
1241                         case '\r':
1242                                 lineLength = i - lineStart;
1243                                 if (lineLength >= 0) {
1244                                         line = new char[lineLength];
1245                                         System.arraycopy(text, lineStart, line, 0, lineLength);
1246                                         result.append(line);
1247                                         result.append(lineSeparator);
1248                                         if (nextChar == '\n') {
1249                                                 nextChar = ' ';
1250                                                 lineStart = i + 2;
1251                                         } else {
1252                                                 // when line separator are mixed in the same file
1253                                                 // \r might not be followed by a \n. If not, we should
1254                                                 // increment
1255                                                 // lineStart by one and not by two.
1256                                                 lineStart = i + 1;
1257                                         }
1258                                 } else {
1259                                         // when line separator are mixed in the same file
1260                                         // we need to prevent NegativeArraySizeException
1261                                         lineStart = i + 1;
1262                                 }
1263                                 break;
1264                         }
1265                 }
1266                 char[] lastLine;
1267                 if (lineStart > 0) {
1268                         int lastLineLength = length - lineStart;
1269                         if (lastLineLength > 0) {
1270                                 lastLine = new char[lastLineLength];
1271                                 System.arraycopy(text, lineStart, lastLine, 0, lastLineLength);
1272                                 result.append(lastLine);
1273                         }
1274                         return result.getContents();
1275                 }
1276                 return text;
1277         }
1278
1279         /**
1280          * Normalizes the cariage returns in the given text. They are all changed to
1281          * use given buffer's line sepatator.
1282          */
1283         public static String normalizeCRs(String text, String buffer) {
1284                 return new String(
1285                                 normalizeCRs(text.toCharArray(), buffer.toCharArray()));
1286         }
1287
1288         /**
1289          * Converts the given relative path into a package name. Returns null if the
1290          * path is not a valid package name.
1291          */
1292         public static String packageName(IPath pkgPath) {
1293                 StringBuffer pkgName = new StringBuffer(
1294                                 IPackageFragment.DEFAULT_PACKAGE_NAME);
1295                 for (int j = 0, max = pkgPath.segmentCount(); j < max; j++) {
1296                         String segment = pkgPath.segment(j);
1297                         // if (!isValidFolderNameForPackage(segment)) {
1298                         // return null;
1299                         // }
1300                         pkgName.append(segment);
1301                         if (j < pkgPath.segmentCount() - 1) {
1302                                 pkgName.append("."); //$NON-NLS-1$
1303                         }
1304                 }
1305                 return pkgName.toString();
1306         }
1307
1308         /**
1309          * Returns the length of the common prefix between s1 and s2.
1310          */
1311 //      public static int prefixLength(char[] s1, char[] s2) {
1312 //              int len = 0;
1313 //              int max = Math.min(s1.length, s2.length);
1314 //              for (int i = 0; i < max && s1[i] == s2[i]; ++i)
1315 //                      ++len;
1316 //              return len;
1317 //      }
1318
1319         /**
1320          * Returns the length of the common prefix between s1 and s2.
1321          */
1322 //      public static int prefixLength(String s1, String s2) {
1323 //              int len = 0;
1324 //              int max = Math.min(s1.length(), s2.length());
1325 //              for (int i = 0; i < max && s1.charAt(i) == s2.charAt(i); ++i)
1326 //                      ++len;
1327 //              return len;
1328 //      }
1329
1330 //      private static void quickSort(char[][] list, int left, int right) {
1331 //              int original_left = left;
1332 //              int original_right = right;
1333 //              char[] mid = list[(left + right) / 2];
1334 //              do {
1335 //                      while (compare(list[left], mid) < 0) {
1336 //                              left++;
1337 //                      }
1338 //                      while (compare(mid, list[right]) < 0) {
1339 //                              right--;
1340 //                      }
1341 //                      if (left <= right) {
1342 //                              char[] tmp = list[left];
1343 //                              list[left] = list[right];
1344 //                              list[right] = tmp;
1345 //                              left++;
1346 //                              right--;
1347 //                      }
1348 //              } while (left <= right);
1349 //              if (original_left < right) {
1350 //                      quickSort(list, original_left, right);
1351 //              }
1352 //              if (left < original_right) {
1353 //                      quickSort(list, left, original_right);
1354 //              }
1355 //      }
1356
1357         /**
1358          * Sort the comparable objects in the given collection.
1359          */
1360         private static void quickSort(Comparable[] sortedCollection, int left,
1361                         int right) {
1362                 int original_left = left;
1363                 int original_right = right;
1364                 Comparable mid = sortedCollection[(left + right) / 2];
1365                 do {
1366                         while (sortedCollection[left].compareTo(mid) < 0) {
1367                                 left++;
1368                         }
1369                         while (mid.compareTo(sortedCollection[right]) < 0) {
1370                                 right--;
1371                         }
1372                         if (left <= right) {
1373                                 Comparable tmp = sortedCollection[left];
1374                                 sortedCollection[left] = sortedCollection[right];
1375                                 sortedCollection[right] = tmp;
1376                                 left++;
1377                                 right--;
1378                         }
1379                 } while (left <= right);
1380                 if (original_left < right) {
1381                         quickSort(sortedCollection, original_left, right);
1382                 }
1383                 if (left < original_right) {
1384                         quickSort(sortedCollection, left, original_right);
1385                 }
1386         }
1387
1388 //      private static void quickSort(int[] list, int left, int right) {
1389 //              int original_left = left;
1390 //              int original_right = right;
1391 //              int mid = list[(left + right) / 2];
1392 //              do {
1393 //                      while (list[left] < mid) {
1394 //                              left++;
1395 //                      }
1396 //                      while (mid < list[right]) {
1397 //                              right--;
1398 //                      }
1399 //                      if (left <= right) {
1400 //                              int tmp = list[left];
1401 //                              list[left] = list[right];
1402 //                              list[right] = tmp;
1403 //                              left++;
1404 //                              right--;
1405 //                      }
1406 //              } while (left <= right);
1407 //              if (original_left < right) {
1408 //                      quickSort(list, original_left, right);
1409 //              }
1410 //              if (left < original_right) {
1411 //                      quickSort(list, left, original_right);
1412 //              }
1413 //      }
1414
1415         /**
1416          * Sort the objects in the given collection using the given comparer.
1417          */
1418         private static void quickSort(Object[] sortedCollection, int left,
1419                         int right, Comparer comparer) {
1420                 int original_left = left;
1421                 int original_right = right;
1422                 Object mid = sortedCollection[(left + right) / 2];
1423                 do {
1424                         while (comparer.compare(sortedCollection[left], mid) < 0) {
1425                                 left++;
1426                         }
1427                         while (comparer.compare(mid, sortedCollection[right]) < 0) {
1428                                 right--;
1429                         }
1430                         if (left <= right) {
1431                                 Object tmp = sortedCollection[left];
1432                                 sortedCollection[left] = sortedCollection[right];
1433                                 sortedCollection[right] = tmp;
1434                                 left++;
1435                                 right--;
1436                         }
1437                 } while (left <= right);
1438                 if (original_left < right) {
1439                         quickSort(sortedCollection, original_left, right, comparer);
1440                 }
1441                 if (left < original_right) {
1442                         quickSort(sortedCollection, left, original_right, comparer);
1443                 }
1444         }
1445
1446         /**
1447          * Sort the objects in the given collection using the given sort order.
1448          */
1449         private static void quickSort(Object[] sortedCollection, int left,
1450                         int right, int[] sortOrder) {
1451                 int original_left = left;
1452                 int original_right = right;
1453                 int mid = sortOrder[(left + right) / 2];
1454                 do {
1455                         while (sortOrder[left] < mid) {
1456                                 left++;
1457                         }
1458                         while (mid < sortOrder[right]) {
1459                                 right--;
1460                         }
1461                         if (left <= right) {
1462                                 Object tmp = sortedCollection[left];
1463                                 sortedCollection[left] = sortedCollection[right];
1464                                 sortedCollection[right] = tmp;
1465                                 int tmp2 = sortOrder[left];
1466                                 sortOrder[left] = sortOrder[right];
1467                                 sortOrder[right] = tmp2;
1468                                 left++;
1469                                 right--;
1470                         }
1471                 } while (left <= right);
1472                 if (original_left < right) {
1473                         quickSort(sortedCollection, original_left, right, sortOrder);
1474                 }
1475                 if (left < original_right) {
1476                         quickSort(sortedCollection, left, original_right, sortOrder);
1477                 }
1478         }
1479
1480         /**
1481          * Sort the strings in the given collection.
1482          */
1483         private static void quickSort(String[] sortedCollection, int left, int right) {
1484                 int original_left = left;
1485                 int original_right = right;
1486                 String mid = sortedCollection[(left + right) / 2];
1487                 do {
1488                         while (sortedCollection[left].compareTo(mid) < 0) {
1489                                 left++;
1490                         }
1491                         while (mid.compareTo(sortedCollection[right]) < 0) {
1492                                 right--;
1493                         }
1494                         if (left <= right) {
1495                                 String tmp = sortedCollection[left];
1496                                 sortedCollection[left] = sortedCollection[right];
1497                                 sortedCollection[right] = tmp;
1498                                 left++;
1499                                 right--;
1500                         }
1501                 } while (left <= right);
1502                 if (original_left < right) {
1503                         quickSort(sortedCollection, original_left, right);
1504                 }
1505                 if (left < original_right) {
1506                         quickSort(sortedCollection, left, original_right);
1507                 }
1508         }
1509
1510         /**
1511          * Sort the strings in the given collection in reverse alphabetical order.
1512          */
1513 //      private static void quickSortReverse(String[] sortedCollection, int left,
1514 //                      int right) {
1515 //              int original_left = left;
1516 //              int original_right = right;
1517 //              String mid = sortedCollection[(left + right) / 2];
1518 //              do {
1519 //                      while (sortedCollection[left].compareTo(mid) > 0) {
1520 //                              left++;
1521 //                      }
1522 //                      while (mid.compareTo(sortedCollection[right]) > 0) {
1523 //                              right--;
1524 //                      }
1525 //                      if (left <= right) {
1526 //                              String tmp = sortedCollection[left];
1527 //                              sortedCollection[left] = sortedCollection[right];
1528 //                              sortedCollection[right] = tmp;
1529 //                              left++;
1530 //                              right--;
1531 //                      }
1532 //              } while (left <= right);
1533 //              if (original_left < right) {
1534 //                      quickSortReverse(sortedCollection, original_left, right);
1535 //              }
1536 //              if (left < original_right) {
1537 //                      quickSortReverse(sortedCollection, left, original_right);
1538 //              }
1539 //      }
1540
1541         /**
1542          * Reads in a string from the specified data input stream. The string has
1543          * been encoded using a modified UTF-8 format.
1544          * <p>
1545          * The first two bytes are read as if by <code>readUnsignedShort</code>.
1546          * This value gives the number of following bytes that are in the encoded
1547          * string, not the length of the resulting string. The following bytes are
1548          * then interpreted as bytes encoding characters in the UTF-8 format and are
1549          * converted into characters.
1550          * <p>
1551          * This method blocks until all the bytes are read, the end of the stream is
1552          * detected, or an exception is thrown.
1553          *
1554          * @param in
1555          *            a data input stream.
1556          * @return a Unicode string.
1557          * @exception EOFException
1558          *                if the input stream reaches the end before all the bytes.
1559          * @exception IOException
1560          *                if an I/O error occurs.
1561          * @exception UTFDataFormatException
1562          *                if the bytes do not represent a valid UTF-8 encoding of a
1563          *                Unicode string.
1564          * @see java.io.DataInputStream#readUnsignedShort()
1565          */
1566 //      public final static char[] readUTF(DataInput in) throws IOException {
1567 //              int utflen = in.readUnsignedShort();
1568 //              char str[] = new char[utflen];
1569 //              int count = 0;
1570 //              int strlen = 0;
1571 //              while (count < utflen) {
1572 //                      int c = in.readUnsignedByte();
1573 //                      int char2, char3;
1574 //                      switch (c >> 4) {
1575 //                      case 0:
1576 //                      case 1:
1577 //                      case 2:
1578 //                      case 3:
1579 //                      case 4:
1580 //                      case 5:
1581 //                      case 6:
1582 //                      case 7:
1583 //                              // 0xxxxxxx
1584 //                              count++;
1585 //                              str[strlen++] = (char) c;
1586 //                              break;
1587 //                      case 12:
1588 //                      case 13:
1589 //                              // 110x xxxx 10xx xxxx
1590 //                              count += 2;
1591 //                              if (count > utflen)
1592 //                                      throw new UTFDataFormatException();
1593 //                              char2 = in.readUnsignedByte();
1594 //                              if ((char2 & 0xC0) != 0x80)
1595 //                                      throw new UTFDataFormatException();
1596 //                              str[strlen++] = (char) (((c & 0x1F) << 6) | (char2 & 0x3F));
1597 //                              break;
1598 //                      case 14:
1599 //                              // 1110 xxxx 10xx xxxx 10xx xxxx
1600 //                              count += 3;
1601 //                              if (count > utflen)
1602 //                                      throw new UTFDataFormatException();
1603 //                              char2 = in.readUnsignedByte();
1604 //                              char3 = in.readUnsignedByte();
1605 //                              if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80))
1606 //                                      throw new UTFDataFormatException();
1607 //                              str[strlen++] = (char) (((c & 0x0F) << 12)
1608 //                                              | ((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0));
1609 //                              break;
1610 //                      default:
1611 //                              // 10xx xxxx, 1111 xxxx
1612 //                              throw new UTFDataFormatException();
1613 //                      }
1614 //              }
1615 //              if (strlen < utflen) {
1616 //                      System.arraycopy(str, 0, str = new char[strlen], 0, strlen);
1617 //              }
1618 //              return str;
1619 //      }
1620
1621         /**
1622          * Creates a NLS catalog for the given locale.
1623          */
1624         public static void relocalize() {
1625                 try {
1626                         bundle = ResourceBundle.getBundle(bundleName, Locale.getDefault());
1627                 } catch (MissingResourceException e) {
1628                         System.out
1629                                         .println("Missing resource : " + bundleName.replace('.', '/') + ".properties for locale " + Locale.getDefault()); //$NON-NLS-1$//$NON-NLS-2$
1630                         throw e;
1631                 }
1632         }
1633
1634 //      public static void sort(char[][] list) {
1635 //              if (list.length > 1)
1636 //                      quickSort(list, 0, list.length - 1);
1637 //      }
1638
1639         /**
1640          * Sorts an array of Comparable objects in place.
1641          */
1642         public static void sort(Comparable[] objects) {
1643                 if (objects.length > 1)
1644                         quickSort(objects, 0, objects.length - 1);
1645         }
1646
1647 //      public static void sort(int[] list) {
1648 //              if (list.length > 1)
1649 //                      quickSort(list, 0, list.length - 1);
1650 //      }
1651
1652         /**
1653          * Sorts an array of objects in place. The given comparer compares pairs of
1654          * items.
1655          */
1656         public static void sort(Object[] objects, Comparer comparer) {
1657                 if (objects.length > 1)
1658                         quickSort(objects, 0, objects.length - 1, comparer);
1659         }
1660
1661         /**
1662          * Sorts an array of objects in place, using the sort order given for each
1663          * item.
1664          */
1665         public static void sort(Object[] objects, int[] sortOrder) {
1666                 if (objects.length > 1)
1667                         quickSort(objects, 0, objects.length - 1, sortOrder);
1668         }
1669
1670         /**
1671          * Sorts an array of strings in place using quicksort.
1672          */
1673         public static void sort(String[] strings) {
1674                 if (strings.length > 1)
1675                         quickSort(strings, 0, strings.length - 1);
1676         }
1677
1678         /**
1679          * Sorts an array of Comparable objects, returning a new array with the
1680          * sorted items. The original array is left untouched.
1681          */
1682 //      public static Comparable[] sortCopy(Comparable[] objects) {
1683 //              int len = objects.length;
1684 //              Comparable[] copy = new Comparable[len];
1685 //              System.arraycopy(objects, 0, copy, 0, len);
1686 //              sort(copy);
1687 //              return copy;
1688 //      }
1689
1690         /**
1691          * Sorts an array of Strings, returning a new array with the sorted items.
1692          * The original array is left untouched.
1693          */
1694 //      public static Object[] sortCopy(Object[] objects, Comparer comparer) {
1695 //              int len = objects.length;
1696 //              Object[] copy = new Object[len];
1697 //              System.arraycopy(objects, 0, copy, 0, len);
1698 //              sort(copy, comparer);
1699 //              return copy;
1700 //      }
1701
1702         /**
1703          * Sorts an array of Strings, returning a new array with the sorted items.
1704          * The original array is left untouched.
1705          */
1706 //      public static String[] sortCopy(String[] objects) {
1707 //              int len = objects.length;
1708 //              String[] copy = new String[len];
1709 //              System.arraycopy(objects, 0, copy, 0, len);
1710 //              sort(copy);
1711 //              return copy;
1712 //      }
1713
1714         /**
1715          * Sorts an array of strings in place using quicksort in reverse
1716          * alphabetical order.
1717          */
1718 //      public static void sortReverseOrder(String[] strings) {
1719 //              if (strings.length > 1)
1720 //                      quickSortReverse(strings, 0, strings.length - 1);
1721 //      }
1722
1723         /**
1724          * Converts a String[] to char[][].
1725          */
1726 //      public static char[][] toCharArrays(String[] a) {
1727 //              int len = a.length;
1728 //              char[][] result = new char[len][];
1729 //              for (int i = 0; i < len; ++i) {
1730 //                      result[i] = toChars(a[i]);
1731 //              }
1732 //              return result;
1733 //      }
1734
1735         /**
1736          * Converts a String to char[].
1737          */
1738 //      public static char[] toChars(String s) {
1739 //              int len = s.length();
1740 //              char[] chars = new char[len];
1741 //              s.getChars(0, len, chars, 0);
1742 //              return chars;
1743 //      }
1744
1745         /**
1746          * Converts a String to char[][], where segments are separate by '.'.
1747          */
1748         public static char[][] toCompoundChars(String s) {
1749                 int len = s.length();
1750                 if (len == 0) {
1751                         return CharOperation.NO_CHAR_CHAR;
1752                 }
1753                 int segCount = 1;
1754                 for (int off = s.indexOf('.'); off != -1; off = s.indexOf('.', off + 1)) {
1755                         ++segCount;
1756                 }
1757                 char[][] segs = new char[segCount][];
1758                 int start = 0;
1759                 for (int i = 0; i < segCount; ++i) {
1760                         int dot = s.indexOf('.', start);
1761                         int end = (dot == -1 ? s.length() : dot);
1762                         segs[i] = new char[end - start];
1763                         s.getChars(start, end, segs[i], 0);
1764                         start = end + 1;
1765                 }
1766                 return segs;
1767         }
1768
1769         /**
1770          * Converts a char[] to String.
1771          */
1772         public static String toString(char[] c) {
1773                 return new String(c);
1774         }
1775
1776         /**
1777          * Converts a char[][] to String, where segments are separated by '.'.
1778          */
1779         public static String toString(char[][] c) {
1780                 StringBuffer sb = new StringBuffer();
1781                 for (int i = 0, max = c.length; i < max; ++i) {
1782                         if (i != 0)
1783                                 sb.append('.');
1784                         sb.append(c[i]);
1785                 }
1786                 return sb.toString();
1787         }
1788
1789         /**
1790          * Converts a char[][] and a char[] to String, where segments are separated
1791          * by '.'.
1792          */
1793 //      public static String toString(char[][] c, char[] d) {
1794 //              if (c == null)
1795 //                      return new String(d);
1796 //              StringBuffer sb = new StringBuffer();
1797 //              for (int i = 0, max = c.length; i < max; ++i) {
1798 //                      sb.append(c[i]);
1799 //                      sb.append('.');
1800 //              }
1801 //              sb.append(d);
1802 //              return sb.toString();
1803 //      }
1804
1805         /*
1806          * Returns the unresolved type parameter signatures of the given method e.g.
1807          * {"QString;", "[int", "[[Qjava.util.Vector;"}
1808          */
1809         // public static String[] typeParameterSignatures(AbstractMethodDeclaration
1810         // method) {
1811         // Argument[] args = method.arguments;
1812         // if (args != null) {
1813         // int length = args.length;
1814         // String[] signatures = new String[length];
1815         // for (int i = 0; i < args.length; i++) {
1816         // Argument arg = args[i];
1817         // signatures[i] = typeSignature(arg.type);
1818         // }
1819         // return signatures;
1820         // }
1821         // return new String[0];
1822         // }
1823         /*
1824          * Returns the unresolved type signature of the given type reference, e.g.
1825          * "QString;", "[int", "[[Qjava.util.Vector;"
1826          */
1827         // public static String typeSignature(TypeReference type) {
1828         // char[][] compoundName = type.getTypeName();
1829         // char[] typeName =CharOperation.concatWith(compoundName, '.');
1830         // String signature = Signature.createTypeSignature(typeName, false/*don't
1831         // resolve*/);
1832         // int dimensions = type.dimensions();
1833         // if (dimensions > 0) {
1834         // signature = Signature.createArraySignature(signature, dimensions);
1835         // }
1836         // return signature;
1837         // }
1838         /*
1839          * Returns the unresolved type signature of the given type reference, e.g.
1840          * "QString;", "[int", "[[Qjava.util.Vector;"
1841          */
1842 //      public static String typeSignature(TypeReference type) {
1843 //              char[][] compoundName = type.getTypeName();
1844 //              char[] typeName = CharOperation.concatWith(compoundName, '.');
1845 //              String signature = Signature
1846 //                              .createTypeSignature(typeName, false/* don't resolve */);
1847 //              int dimensions = type.dimensions();
1848 //              if (dimensions > 0) {
1849 //                      signature = Signature.createArraySignature(signature, dimensions);
1850 //              }
1851 //              return signature;
1852 //      }
1853
1854         /**
1855          * Asserts that the given method signature is valid.
1856          */
1857 //      public static void validateMethodSignature(String sig) {
1858 //              Assert.isTrue(isValidMethodSignature(sig));
1859 //      }
1860
1861         /**
1862          * Asserts that the given type signature is valid.
1863          */
1864 //      public static void validateTypeSignature(String sig, boolean allowVoid) {
1865 //              Assert.isTrue(isValidTypeSignature(sig, allowVoid));
1866 //      }
1867
1868         public static void verbose(String log) {
1869                 verbose(log, System.out);
1870         }
1871
1872         public static synchronized void verbose(String log, PrintStream printStream) {
1873                 int start = 0;
1874                 do {
1875                         int end = log.indexOf('\n', start);
1876                         printStream.print(Thread.currentThread());
1877                         printStream.print(" "); //$NON-NLS-1$
1878                         printStream.print(log.substring(start, end == -1 ? log.length()
1879                                         : end + 1));
1880                         start = end + 1;
1881                 } while (start != 0);
1882                 printStream.println();
1883         }
1884
1885         /**
1886          * Writes a string to the given output stream using UTF-8 encoding in a
1887          * machine-independent manner.
1888          * <p>
1889          * First, two bytes are written to the output stream as if by the
1890          * <code>writeShort</code> method giving the number of bytes to follow.
1891          * This value is the number of bytes actually written out, not the length of
1892          * the string. Following the length, each character of the string is output,
1893          * in sequence, using the UTF-8 encoding for the character.
1894          *
1895          * @param str
1896          *            a string to be written.
1897          * @return the number of bytes written to the stream.
1898          * @exception IOException
1899          *                if an I/O error occurs.
1900          * @since JDK1.0
1901          */
1902 //      public static int writeUTF(OutputStream out, char[] str) throws IOException {
1903 //              int strlen = str.length;
1904 //              int utflen = 0;
1905 //              for (int i = 0; i < strlen; i++) {
1906 //                      int c = str[i];
1907 //                      if ((c >= 0x0001) && (c <= 0x007F)) {
1908 //                              utflen++;
1909 //                      } else if (c > 0x07FF) {
1910 //                              utflen += 3;
1911 //                      } else {
1912 //                              utflen += 2;
1913 //                      }
1914 //              }
1915 //              if (utflen > 65535)
1916 //                      throw new UTFDataFormatException();
1917 //              out.write((utflen >>> 8) & 0xFF);
1918 //              out.write((utflen >>> 0) & 0xFF);
1919 //              if (strlen == utflen) {
1920 //                      for (int i = 0; i < strlen; i++)
1921 //                              out.write(str[i]);
1922 //              } else {
1923 //                      for (int i = 0; i < strlen; i++) {
1924 //                              int c = str[i];
1925 //                              if ((c >= 0x0001) && (c <= 0x007F)) {
1926 //                                      out.write(c);
1927 //                              } else if (c > 0x07FF) {
1928 //                                      out.write(0xE0 | ((c >> 12) & 0x0F));
1929 //                                      out.write(0x80 | ((c >> 6) & 0x3F));
1930 //                                      out.write(0x80 | ((c >> 0) & 0x3F));
1931 //                              } else {
1932 //                                      out.write(0xC0 | ((c >> 6) & 0x1F));
1933 //                                      out.write(0x80 | ((c >> 0) & 0x3F));
1934 //                              }
1935 //                      }
1936 //              }
1937 //              return utflen + 2; // the number of bytes written to the stream
1938 //      }
1939 }