1 16 19 package com.sun.org.apache.xalan.internal.xslt; 20 21 import java.io.File ; 22 import java.io.FileWriter ; 23 import java.io.PrintWriter ; 24 import java.lang.reflect.Field ; 25 import java.lang.reflect.Method ; 26 import java.util.Enumeration ; 27 import java.util.Hashtable ; 28 import java.util.StringTokenizer ; 29 import java.util.Vector ; 30 31 import org.w3c.dom.Document ; 32 import org.w3c.dom.Element ; 33 import org.w3c.dom.Node ; 34 35 90 public class EnvironmentCheck 91 { 92 93 99 public static void _main(String [] args) 100 { 101 PrintWriter sendOutputTo = new PrintWriter (System.out, true); 103 104 for (int i = 0; i < args.length; i++) 106 { 107 if ("-out".equalsIgnoreCase(args[i])) 108 { 109 i++; 110 111 if (i < args.length) 112 { 113 try 114 { 115 sendOutputTo = new PrintWriter (new FileWriter (args[i], true)); 116 } 117 catch (Exception e) 118 { 119 System.err.println("# WARNING: -out " + args[i] + " threw " 120 + e.toString()); 121 } 122 } 123 else 124 { 125 System.err.println( 126 "# WARNING: -out argument should have a filename, output sent to console"); 127 } 128 } 129 } 130 131 EnvironmentCheck app = new EnvironmentCheck(); 132 app.checkEnvironment(sendOutputTo); 133 } 134 135 159 public boolean checkEnvironment(PrintWriter pw) 160 { 161 162 if (null != pw) 164 outWriter = pw; 165 166 Hashtable hash = getEnvironmentHash(); 168 169 boolean environmentHasErrors = writeEnvironmentReport(hash); 171 172 if (environmentHasErrors) 173 { 174 logMsg("# WARNING: Potential problems found in your environment!"); 177 logMsg("# Check any 'ERROR' items above against the Xalan FAQs"); 178 logMsg("# to correct potential problems with your classes/jars"); 179 logMsg("# http://xml.apache.org/xalan-j/faq.html"); 180 if (null != outWriter) 181 outWriter.flush(); 182 return false; 183 } 184 else 185 { 186 logMsg("# YAHOO! Your environment seems to be OK."); 187 if (null != outWriter) 188 outWriter.flush(); 189 return true; 190 } 191 } 192 193 213 public Hashtable getEnvironmentHash() 214 { 215 Hashtable hash = new Hashtable (); 217 218 checkJAXPVersion(hash); 222 checkProcessorVersion(hash); 223 checkParserVersion(hash); 224 checkAntVersion(hash); 225 checkDOMVersion(hash); 226 checkSAXVersion(hash); 227 checkSystemProperties(hash); 228 229 return hash; 230 } 231 232 246 protected boolean writeEnvironmentReport(Hashtable h) 247 { 248 249 if (null == h) 250 { 251 logMsg("# ERROR: writeEnvironmentReport called with null Hashtable"); 252 return false; 253 } 254 255 boolean errors = false; 256 257 logMsg( 258 "#---- BEGIN writeEnvironmentReport($Revision: 1.26 $): Useful stuff found: ----"); 259 260 for (Enumeration keys = h.keys(); 262 keys.hasMoreElements(); 263 264 ) 265 { 266 Object key = keys.nextElement(); 267 String keyStr = (String ) key; 268 try 269 { 270 if (keyStr.startsWith(FOUNDCLASSES)) 272 { 273 Vector v = (Vector ) h.get(keyStr); 274 errors |= logFoundJars(v, keyStr); 275 } 276 else 278 { 279 if (keyStr.startsWith(ERROR)) 284 { 285 errors = true; 286 } 287 logMsg(keyStr + "=" + h.get(keyStr)); 288 } 289 } 290 catch (Exception e) 291 { 292 logMsg("Reading-" + key + "= threw: " + e.toString()); 293 } 294 } 295 296 logMsg( 297 "#----- END writeEnvironmentReport: Useful properties found: -----"); 298 299 return errors; 300 } 301 302 303 public static final String ERROR = "ERROR."; 304 305 306 public static final String WARNING = "WARNING."; 307 308 309 public static final String ERROR_FOUND = "At least one error was found!"; 310 311 312 public static final String VERSION = "version."; 313 314 315 public static final String FOUNDCLASSES = "foundclasses."; 316 317 318 public static final String CLASS_PRESENT = "present-unknown-version"; 319 320 321 public static final String CLASS_NOTPRESENT = "not-present"; 322 323 324 public String [] jarNames = 325 { 326 "xalan.jar", "xalansamples.jar", "xalanj1compat.jar", "xalanservlet.jar", 327 "xerces.jar", "xercesImpl.jar", "testxsl.jar", 330 "crimson.jar", 331 "lotusxsl.jar", 332 "jaxp.jar", "parser.jar", "dom.jar", "sax.jar", "xml.jar", 333 "xml-apis.jar", 334 "xsltc.jar" 335 }; 336 337 350 protected boolean logFoundJars(Vector v, String desc) 351 { 352 353 if ((null == v) || (v.size() < 1)) 354 return false; 355 356 boolean errors = false; 357 358 logMsg("#---- BEGIN Listing XML-related jars in: " + desc + " ----"); 359 360 for (int i = 0; i < v.size(); i++) 361 { 362 Hashtable subhash = (Hashtable ) v.elementAt(i); 363 364 for (Enumeration keys = subhash.keys(); 365 keys.hasMoreElements(); 366 367 ) 368 { 369 Object key = keys.nextElement(); 370 String keyStr = (String ) key; 371 try 372 { 373 if (keyStr.startsWith(ERROR)) 374 { 375 errors = true; 376 } 377 logMsg(keyStr + "=" + subhash.get(keyStr)); 378 379 } 380 catch (Exception e) 381 { 382 errors = true; 383 logMsg("Reading-" + key + "= threw: " + e.toString()); 384 } 385 } 386 } 387 388 logMsg("#----- END Listing XML-related jars in: " + desc + " -----"); 389 390 return errors; 391 } 392 393 406 public void appendEnvironmentReport(Node container, Document factory, Hashtable h) 407 { 408 if ((null == container) || (null == factory)) 409 { 410 return; 411 } 412 413 try 414 { 415 Element envCheckNode = factory.createElement("EnvironmentCheck"); 416 envCheckNode.setAttribute("version", "$Revision: 1.26 $"); 417 container.appendChild(envCheckNode); 418 419 if (null == h) 420 { 421 Element statusNode = factory.createElement("status"); 422 statusNode.setAttribute("result", "ERROR"); 423 statusNode.appendChild(factory.createTextNode("appendEnvironmentReport called with null Hashtable!")); 424 envCheckNode.appendChild(statusNode); 425 return; 426 } 427 428 boolean errors = false; 429 430 Element hashNode = factory.createElement("environment"); 431 envCheckNode.appendChild(hashNode); 432 433 for (Enumeration keys = h.keys(); 434 keys.hasMoreElements(); 435 436 ) 437 { 438 Object key = keys.nextElement(); 439 String keyStr = (String ) key; 440 try 441 { 442 if (keyStr.startsWith(FOUNDCLASSES)) 444 { 445 Vector v = (Vector ) h.get(keyStr); 446 errors |= appendFoundJars(hashNode, factory, v, keyStr); 448 } 449 else 451 { 452 if (keyStr.startsWith(ERROR)) 457 { 458 errors = true; 459 } 460 Element node = factory.createElement("item"); 461 node.setAttribute("key", keyStr); 462 node.appendChild(factory.createTextNode((String )h.get(keyStr))); 463 hashNode.appendChild(node); 464 } 465 } 466 catch (Exception e) 467 { 468 errors = true; 469 Element node = factory.createElement("item"); 470 node.setAttribute("key", keyStr); 471 node.appendChild(factory.createTextNode(ERROR + " Reading " + key + " threw: " + e.toString())); 472 hashNode.appendChild(node); 473 } 474 } 476 Element statusNode = factory.createElement("status"); 477 statusNode.setAttribute("result", (errors ? "ERROR" : "OK" )); 478 envCheckNode.appendChild(statusNode); 479 } 480 catch (Exception e2) 481 { 482 System.err.println("appendEnvironmentReport threw: " + e2.toString()); 483 e2.printStackTrace(); 484 } 485 } 486 487 502 protected boolean appendFoundJars(Node container, Document factory, 503 Vector v, String desc) 504 { 505 506 if ((null == v) || (v.size() < 1)) 507 return false; 508 509 boolean errors = false; 510 511 for (int i = 0; i < v.size(); i++) 512 { 513 Hashtable subhash = (Hashtable ) v.elementAt(i); 514 515 for (Enumeration keys = subhash.keys(); 516 keys.hasMoreElements(); 517 518 ) 519 { 520 Object key = keys.nextElement(); 521 try 522 { 523 String keyStr = (String ) key; 524 if (keyStr.startsWith(ERROR)) 525 { 526 errors = true; 527 } 528 Element node = factory.createElement("foundJar"); 529 node.setAttribute("name", keyStr.substring(0, keyStr.indexOf("-"))); 530 node.setAttribute("desc", keyStr.substring(keyStr.indexOf("-") + 1)); 531 node.appendChild(factory.createTextNode((String )subhash.get(keyStr))); 532 container.appendChild(node); 533 } 534 catch (Exception e) 535 { 536 errors = true; 537 Element node = factory.createElement("foundJar"); 538 node.appendChild(factory.createTextNode(ERROR + " Reading " + key + " threw: " + e.toString())); 539 container.appendChild(node); 540 } 541 } 542 } 543 return errors; 544 } 545 546 559 protected void checkSystemProperties(Hashtable h) 560 { 561 562 if (null == h) 563 h = new Hashtable (); 564 565 try 567 { 568 String javaVersion = System.getProperty("java.version"); 569 570 h.put("java.version", javaVersion); 571 } 572 catch (SecurityException se) 573 { 574 575 h.put( 577 "java.version", 578 "WARNING: SecurityException thrown accessing system version properties"); 579 } 580 581 try 584 { 585 586 String cp = System.getProperty("java.class.path"); 588 589 h.put("java.class.path", cp); 590 591 Vector classpathJars = checkPathForJars(cp, jarNames); 592 593 if (null != classpathJars) 594 h.put(FOUNDCLASSES + "java.class.path", classpathJars); 595 596 String othercp = System.getProperty("sun.boot.class.path"); 598 599 if (null != othercp) 600 { 601 h.put("sun.boot.class.path", othercp); 602 603 classpathJars = checkPathForJars(othercp, jarNames); 604 605 if (null != classpathJars) 606 h.put(FOUNDCLASSES + "sun.boot.class.path", classpathJars); 607 } 608 609 othercp = System.getProperty("java.ext.dirs"); 612 613 if (null != othercp) 614 { 615 h.put("java.ext.dirs", othercp); 616 617 classpathJars = checkPathForJars(othercp, jarNames); 618 619 if (null != classpathJars) 620 h.put(FOUNDCLASSES + "java.ext.dirs", classpathJars); 621 } 622 623 } 627 catch (SecurityException se2) 628 { 629 h.put( 631 "java.class.path", 632 "WARNING: SecurityException thrown accessing system classpath properties"); 633 } 634 } 635 636 653 protected Vector checkPathForJars(String cp, String [] jars) 654 { 655 656 if ((null == cp) || (null == jars) || (0 == cp.length()) 657 || (0 == jars.length)) 658 return null; 659 660 Vector v = new Vector (); 661 StringTokenizer st = new StringTokenizer (cp, File.pathSeparator); 662 663 while (st.hasMoreTokens()) 664 { 665 666 String filename = st.nextToken(); 668 669 for (int i = 0; i < jars.length; i++) 670 { 671 if (filename.indexOf(jars[i]) > -1) 672 { 673 File f = new File (filename); 674 675 if (f.exists()) 676 { 677 678 try 681 { 682 Hashtable h = new Hashtable (2); 683 h.put(jars[i] + "-path", f.getAbsolutePath()); 685 686 if (!("xalan.jar".equalsIgnoreCase(jars[i]))) { 692 h.put(jars[i] + "-apparent.version", 693 getApparentVersion(jars[i], f.length())); 694 } 695 v.addElement(h); 696 } 697 catch (Exception e) 698 { 699 700 701 } 702 } 703 else 704 { 705 Hashtable h = new Hashtable (2); 706 h.put(jars[i] + "-path", WARNING + " Classpath entry: " 708 + filename + " does not exist"); 709 h.put(jars[i] + "-apparent.version", CLASS_NOTPRESENT); 710 v.addElement(h); 711 } 712 } 713 } 714 } 715 716 return v; 717 } 718 719 737 protected String getApparentVersion(String jarName, long jarSize) 738 { 739 String foundSize = (String ) jarVersions.get(new Long (jarSize)); 743 744 if ((null != foundSize) && (foundSize.startsWith(jarName))) 745 { 746 return foundSize; 747 } 748 else 749 { 750 if ("xerces.jar".equalsIgnoreCase(jarName) 751 || "xercesImpl.jar".equalsIgnoreCase(jarName)) 752 { 754 755 return jarName + " " + WARNING + CLASS_PRESENT; 759 } 760 else 761 { 762 763 return jarName + " " + CLASS_PRESENT; 765 } 766 } 767 } 768 769 778 protected void checkJAXPVersion(Hashtable h) 779 { 780 781 if (null == h) 782 h = new Hashtable (); 783 784 final Class noArgs[] = new Class [0]; 785 Class clazz = null; 786 787 try 788 { 789 final String JAXP1_CLASS = "javax.xml.parsers.DocumentBuilder"; 790 final String JAXP11_METHOD = "getDOMImplementation"; 791 792 clazz = ObjectFactory.findProviderClass( 793 JAXP1_CLASS, ObjectFactory.findClassLoader(), true); 794 795 Method method = clazz.getMethod(JAXP11_METHOD, noArgs); 796 797 h.put(VERSION + "JAXP", "1.1 or higher"); 799 } 800 catch (Exception e) 801 { 802 if (null != clazz) 803 { 804 805 h.put(ERROR + VERSION + "JAXP", "1.0.1"); 808 h.put(ERROR, ERROR_FOUND); 809 } 810 else 811 { 812 h.put(ERROR + VERSION + "JAXP", CLASS_NOTPRESENT); 816 h.put(ERROR, ERROR_FOUND); 817 } 818 } 819 } 820 821 828 protected void checkProcessorVersion(Hashtable h) 829 { 830 831 if (null == h) 832 h = new Hashtable (); 833 834 try 835 { 836 final String XALAN1_VERSION_CLASS = 837 "com.sun.org.apache.xalan.internal.xslt.XSLProcessorVersion"; 838 839 Class clazz = ObjectFactory.findProviderClass( 840 XALAN1_VERSION_CLASS, ObjectFactory.findClassLoader(), true); 841 842 StringBuffer buf = new StringBuffer (); 844 Field f = clazz.getField("PRODUCT"); 845 846 buf.append(f.get(null)); 847 buf.append(';'); 848 849 f = clazz.getField("LANGUAGE"); 850 851 buf.append(f.get(null)); 852 buf.append(';'); 853 854 f = clazz.getField("S_VERSION"); 855 856 buf.append(f.get(null)); 857 buf.append(';'); 858 h.put(VERSION + "xalan1", buf.toString()); 859 } 860 catch (Exception e1) 861 { 862 h.put(VERSION + "xalan1", CLASS_NOTPRESENT); 863 } 864 865 try 866 { 867 final String XALAN2_VERSION_CLASS = 870 "com.sun.org.apache.xalan.internal.processor.XSLProcessorVersion"; 871 872 Class clazz = ObjectFactory.findProviderClass( 873 XALAN2_VERSION_CLASS, ObjectFactory.findClassLoader(), true); 874 875 StringBuffer buf = new StringBuffer (); 877 Field f = clazz.getField("S_VERSION"); 878 buf.append(f.get(null)); 879 880 h.put(VERSION + "xalan2x", buf.toString()); 881 } 882 catch (Exception e2) 883 { 884 h.put(VERSION + "xalan2x", CLASS_NOTPRESENT); 885 } 886 try 887 { 888 final String XALAN2_2_VERSION_CLASS = 890 "com.sun.org.apache.xalan.internal.Version"; 891 final String XALAN2_2_VERSION_METHOD = "getVersion"; 892 final Class noArgs[] = new Class [0]; 893 894 Class clazz = ObjectFactory.findProviderClass( 895 XALAN2_2_VERSION_CLASS, ObjectFactory.findClassLoader(), true); 896 897 Method method = clazz.getMethod(XALAN2_2_VERSION_METHOD, noArgs); 898 Object returnValue = method.invoke(null, new Object [0]); 899 900 h.put(VERSION + "xalan2_2", (String )returnValue); 901 } 902 catch (Exception e2) 903 { 904 h.put(VERSION + "xalan2_2", CLASS_NOTPRESENT); 905 } 906 } 907 908 917 protected void checkParserVersion(Hashtable h) 918 { 919 920 if (null == h) 921 h = new Hashtable (); 922 923 try 924 { 925 final String XERCES1_VERSION_CLASS = "com.sun.org.apache.xerces.internal.framework.Version"; 926 927 Class clazz = ObjectFactory.findProviderClass( 928 XERCES1_VERSION_CLASS, ObjectFactory.findClassLoader(), true); 929 930 Field f = clazz.getField("fVersion"); 932 String parserVersion = (String ) f.get(null); 933 934 h.put(VERSION + "xerces1", parserVersion); 935 } 936 catch (Exception e) 937 { 938 h.put(VERSION + "xerces1", CLASS_NOTPRESENT); 939 } 940 941 try 943 { 944 final String XERCES2_VERSION_CLASS = "com.sun.org.apache.xerces.internal.impl.Version"; 945 946 Class clazz = ObjectFactory.findProviderClass( 947 XERCES2_VERSION_CLASS, ObjectFactory.findClassLoader(), true); 948 949 Field f = clazz.getField("fVersion"); 951 String parserVersion = (String ) f.get(null); 952 953 h.put(VERSION + "xerces2", parserVersion); 954 } 955 catch (Exception e) 956 { 957 h.put(VERSION + "xerces2", CLASS_NOTPRESENT); 958 } 959 960 try 961 { 962 final String CRIMSON_CLASS = "org.apache.crimson.parser.Parser2"; 963 964 Class clazz = ObjectFactory.findProviderClass( 965 CRIMSON_CLASS, ObjectFactory.findClassLoader(), true); 966 967 h.put(VERSION + "crimson", CLASS_PRESENT); 969 } 970 catch (Exception e) 971 { 972 h.put(VERSION + "crimson", CLASS_NOTPRESENT); 973 } 974 } 975 976 981 protected void checkAntVersion(Hashtable h) 982 { 983 984 if (null == h) 985 h = new Hashtable (); 986 987 try 988 { 989 final String ANT_VERSION_CLASS = "org.apache.tools.ant.Main"; 990 final String ANT_VERSION_METHOD = "getAntVersion"; final Class noArgs[] = new Class [0]; 992 993 Class clazz = ObjectFactory.findProviderClass( 994 ANT_VERSION_CLASS, ObjectFactory.findClassLoader(), true); 995 996 Method method = clazz.getMethod(ANT_VERSION_METHOD, noArgs); 997 Object returnValue = method.invoke(null, new Object [0]); 998 999 h.put(VERSION + "ant", (String )returnValue); 1000 } 1001 catch (Exception e) 1002 { 1003 h.put(VERSION + "ant", CLASS_NOTPRESENT); 1004 } 1005 } 1006 1007 1016 protected void checkDOMVersion(Hashtable h) 1017 { 1018 1019 if (null == h) 1020 h = new Hashtable (); 1021 1022 final String DOM_LEVEL2_CLASS = "org.w3c.dom.Document"; 1023 final String DOM_LEVEL2_METHOD = "createElementNS"; final String DOM_LEVEL2WD_CLASS = "org.w3c.dom.Node"; 1025 final String DOM_LEVEL2WD_METHOD = "supported"; final String DOM_LEVEL2FD_CLASS = "org.w3c.dom.Node"; 1027 final String DOM_LEVEL2FD_METHOD = "isSupported"; final Class twoStringArgs[] = { java.lang.String .class, 1029 java.lang.String .class }; 1030 1031 try 1032 { 1033 Class clazz = ObjectFactory.findProviderClass( 1034 DOM_LEVEL2_CLASS, ObjectFactory.findClassLoader(), true); 1035 1036 Method method = clazz.getMethod(DOM_LEVEL2_METHOD, twoStringArgs); 1037 1038 h.put(VERSION + "DOM", "2.0"); 1041 1042 try 1043 { 1044 clazz = ObjectFactory.findProviderClass( 1047 DOM_LEVEL2WD_CLASS, ObjectFactory.findClassLoader(), true); 1048 1049 method = clazz.getMethod(DOM_LEVEL2WD_METHOD, twoStringArgs); 1050 1051 h.put(ERROR + VERSION + "DOM.draftlevel", "2.0wd"); 1052 h.put(ERROR, ERROR_FOUND); 1053 } 1054 catch (Exception e2) 1055 { 1056 try 1057 { 1058 clazz = ObjectFactory.findProviderClass( 1060 DOM_LEVEL2FD_CLASS, ObjectFactory.findClassLoader(), true); 1061 1062 method = clazz.getMethod(DOM_LEVEL2FD_METHOD, twoStringArgs); 1063 1064 h.put(VERSION + "DOM.draftlevel", "2.0fd"); 1065 } 1066 catch (Exception e3) 1067 { 1068 h.put(ERROR + VERSION + "DOM.draftlevel", "2.0unknown"); 1069 h.put(ERROR, ERROR_FOUND); 1070 } 1071 } 1072 } 1073 catch (Exception e) 1074 { 1075 h.put(ERROR + VERSION + "DOM", 1076 "ERROR attempting to load DOM level 2 class: " + e.toString()); 1077 h.put(ERROR, ERROR_FOUND); 1078 } 1079 1080 } 1085 1086 1094 protected void checkSAXVersion(Hashtable h) 1095 { 1096 1097 if (null == h) 1098 h = new Hashtable (); 1099 1100 final String SAX_VERSION1_CLASS = "org.xml.sax.Parser"; 1101 final String SAX_VERSION1_METHOD = "parse"; final String SAX_VERSION2_CLASS = "org.xml.sax.XMLReader"; 1103 final String SAX_VERSION2_METHOD = "parse"; final String SAX_VERSION2BETA_CLASSNF = "org.xml.sax.helpers.AttributesImpl"; 1105 final String SAX_VERSION2BETA_METHODNF = "setAttributes"; final Class oneStringArg[] = { java.lang.String .class }; 1107 final Class attributesArg[] = { org.xml.sax.Attributes .class }; 1109 1110 try 1111 { 1112 Class clazz = ObjectFactory.findProviderClass( 1115 SAX_VERSION2BETA_CLASSNF, ObjectFactory.findClassLoader(), true); 1116 1117 Method method = clazz.getMethod(SAX_VERSION2BETA_METHODNF, attributesArg); 1118 1119 h.put(VERSION + "SAX", "2.0"); 1122 } 1123 catch (Exception e) 1124 { 1125 h.put(ERROR + VERSION + "SAX", 1127 "ERROR attempting to load SAX version 2 class: " + e.toString()); 1128 h.put(ERROR, ERROR_FOUND); 1129 1130 try 1131 { 1132 Class clazz = ObjectFactory.findProviderClass( 1133 SAX_VERSION2_CLASS, ObjectFactory.findClassLoader(), true); 1134 1135 Method method = clazz.getMethod(SAX_VERSION2_METHOD, oneStringArg); 1136 1137 h.put(VERSION + "SAX-backlevel", "2.0beta2-or-earlier"); 1141 } 1142 catch (Exception e2) 1143 { 1144 h.put(ERROR + VERSION + "SAX", 1146 "ERROR attempting to load SAX version 2 class: " + e.toString()); 1147 h.put(ERROR, ERROR_FOUND); 1148 1149 try 1150 { 1151 Class clazz = ObjectFactory.findProviderClass( 1152 SAX_VERSION1_CLASS, ObjectFactory.findClassLoader(), true); 1153 1154 Method method = clazz.getMethod(SAX_VERSION1_METHOD, oneStringArg); 1155 1156 h.put(VERSION + "SAX-backlevel", "1.0"); 1160 } 1161 catch (Exception e3) 1162 { 1163 h.put(ERROR + VERSION + "SAX-backlevel", 1166 "ERROR attempting to load SAX version 1 class: " + e3.toString()); 1167 1168 } 1169 } 1170 } 1171 } 1172 1173 1181 protected static Hashtable jarVersions = new Hashtable (); 1182 1183 1189 static 1190 { 1191 jarVersions.put(new Long (857192), "xalan.jar from xalan-j_1_1"); 1193 jarVersions.put(new Long (440237), "xalan.jar from xalan-j_1_2"); 1194 jarVersions.put(new Long (436094), "xalan.jar from xalan-j_1_2_1"); 1195 jarVersions.put(new Long (426249), "xalan.jar from xalan-j_1_2_2"); 1196 jarVersions.put(new Long (702536), "xalan.jar from xalan-j_2_0_0"); 1197 jarVersions.put(new Long (720930), "xalan.jar from xalan-j_2_0_1"); 1198 jarVersions.put(new Long (732330), "xalan.jar from xalan-j_2_1_0"); 1199 jarVersions.put(new Long (872241), "xalan.jar from xalan-j_2_2_D10"); 1200 jarVersions.put(new Long (882739), "xalan.jar from xalan-j_2_2_D11"); 1201 jarVersions.put(new Long (923866), "xalan.jar from xalan-j_2_2_0"); 1202 jarVersions.put(new Long (905872), "xalan.jar from xalan-j_2_3_D1"); 1203 jarVersions.put(new Long (906122), "xalan.jar from xalan-j_2_3_0"); 1204 jarVersions.put(new Long (906248), "xalan.jar from xalan-j_2_3_1"); 1205 jarVersions.put(new Long (983377), "xalan.jar from xalan-j_2_4_D1"); 1206 jarVersions.put(new Long (997276), "xalan.jar from xalan-j_2_4_0"); 1207 jarVersions.put(new Long (1031036), "xalan.jar from xalan-j_2_4_1"); 1208 1210 jarVersions.put(new Long (596540), "xsltc.jar from xalan-j_2_2_0"); 1211 jarVersions.put(new Long (590247), "xsltc.jar from xalan-j_2_3_D1"); 1212 jarVersions.put(new Long (589914), "xsltc.jar from xalan-j_2_3_0"); 1213 jarVersions.put(new Long (589915), "xsltc.jar from xalan-j_2_3_1"); 1214 jarVersions.put(new Long (1306667), "xsltc.jar from xalan-j_2_4_D1"); 1215 jarVersions.put(new Long (1328227), "xsltc.jar from xalan-j_2_4_0"); 1216 jarVersions.put(new Long (1344009), "xsltc.jar from xalan-j_2_4_1"); 1217 jarVersions.put(new Long (1348361), "xsltc.jar from xalan-j_2_5_D1"); 1218 1220 jarVersions.put(new Long (1268634), "xsltc.jar-bundled from xalan-j_2_3_0"); 1221 1222 jarVersions.put(new Long (100196), "xml-apis.jar from xalan-j_2_2_0 or xalan-j_2_3_D1"); 1223 jarVersions.put(new Long (108484), "xml-apis.jar from xalan-j_2_3_0, or xalan-j_2_3_1 from xml-commons-1.0.b2"); 1224 jarVersions.put(new Long (109049), "xml-apis.jar from xalan-j_2_4_0 from xml-commons RIVERCOURT1 branch"); 1225 jarVersions.put(new Long (113749), "xml-apis.jar from xalan-j_2_4_1 from factoryfinder-build of xml-commons RIVERCOURT1"); 1226 jarVersions.put(new Long (124704), "xml-apis.jar from tck-jaxp-1_2_0 branch of xml-commons"); 1227 jarVersions.put(new Long (124724), "xml-apis.jar from tck-jaxp-1_2_0 branch of xml-commons, tag: xml-commons-external_1_2_01"); 1228 1229 jarVersions.put(new Long (424490), "xalan.jar from Xerces Tools releases - ERROR:DO NOT USE!"); 1232 1233 jarVersions.put(new Long (1591855), "xerces.jar from xalan-j_1_1 from xerces-1..."); 1234 jarVersions.put(new Long (1498679), "xerces.jar from xalan-j_1_2 from xerces-1_2_0.bin"); 1235 jarVersions.put(new Long (1484896), "xerces.jar from xalan-j_1_2_1 from xerces-1_2_1.bin"); 1236 jarVersions.put(new Long (804460), "xerces.jar from xalan-j_1_2_2 from xerces-1_2_2.bin"); 1237 jarVersions.put(new Long (1499244), "xerces.jar from xalan-j_2_0_0 from xerces-1_2_3.bin"); 1238 jarVersions.put(new Long (1605266), "xerces.jar from xalan-j_2_0_1 from xerces-1_3_0.bin"); 1239 jarVersions.put(new Long (904030), "xerces.jar from xalan-j_2_1_0 from xerces-1_4.bin"); 1240 jarVersions.put(new Long (904030), "xerces.jar from xerces-1_4_0.bin"); 1241 jarVersions.put(new Long (1802885), "xerces.jar from xerces-1_4_2.bin"); 1242 jarVersions.put(new Long (1734594), "xerces.jar from Xerces-J-bin.2.0.0.beta3"); 1243 jarVersions.put(new Long (1808883), "xerces.jar from xalan-j_2_2_D10,D11,D12 or xerces-1_4_3.bin"); 1244 jarVersions.put(new Long (1812019), "xerces.jar from xalan-j_2_2_0"); 1245 jarVersions.put(new Long (1720292), "xercesImpl.jar from xalan-j_2_3_D1"); 1246 jarVersions.put(new Long (1730053), "xercesImpl.jar from xalan-j_2_3_0 or xalan-j_2_3_1 from xerces-2_0_0"); 1247 jarVersions.put(new Long (1728861), "xercesImpl.jar from xalan-j_2_4_D1 from xerces-2_0_1"); 1248 jarVersions.put(new Long (972027), "xercesImpl.jar from xalan-j_2_4_0 from xerces-2_1"); 1249 jarVersions.put(new Long (831587), "xercesImpl.jar from xalan-j_2_4_1 from xerces-2_2"); 1250 jarVersions.put(new Long (891817), "xercesImpl.jar from xalan-j_2_5_D1 from xerces-2_3"); 1251 jarVersions.put(new Long (895924), "xercesImpl.jar from xerces-2_4"); 1252 jarVersions.put(new Long (1010806), "xercesImpl.jar from Xerces-J-bin.2.6.2"); 1253 1254 jarVersions.put(new Long (37485), "xalanj1compat.jar from xalan-j_2_0_0"); 1255 jarVersions.put(new Long (38100), "xalanj1compat.jar from xalan-j_2_0_1"); 1256 1257 jarVersions.put(new Long (18779), "xalanservlet.jar from xalan-j_2_0_0"); 1258 jarVersions.put(new Long (21453), "xalanservlet.jar from xalan-j_2_0_1"); 1259 jarVersions.put(new Long (24826), "xalanservlet.jar from xalan-j_2_3_1 or xalan-j_2_4_1"); 1260 jarVersions.put(new Long (24831), "xalanservlet.jar from xalan-j_2_4_1"); 1261 1263 jarVersions.put(new Long (5618), "jaxp.jar from jaxp1.0.1"); 1265 jarVersions.put(new Long (136133), "parser.jar from jaxp1.0.1"); 1266 jarVersions.put(new Long (28404), "jaxp.jar from jaxp-1.1"); 1267 jarVersions.put(new Long (187162), "crimson.jar from jaxp-1.1"); 1268 jarVersions.put(new Long (801714), "xalan.jar from jaxp-1.1"); 1269 jarVersions.put(new Long (196399), "crimson.jar from crimson-1.1.1"); 1270 jarVersions.put(new Long (33323), "jaxp.jar from crimson-1.1.1 or jakarta-ant-1.4.1b1"); 1271 jarVersions.put(new Long (152717), "crimson.jar from crimson-1.1.2beta2"); 1272 jarVersions.put(new Long (88143), "xml-apis.jar from crimson-1.1.2beta2"); 1273 jarVersions.put(new Long (206384), "crimson.jar from crimson-1.1.3 or jakarta-ant-1.4.1b1"); 1274 1275 jarVersions.put(new Long (136198), "parser.jar from jakarta-ant-1.3 or 1.2"); 1277 jarVersions.put(new Long (5537), "jaxp.jar from jakarta-ant-1.3 or 1.2"); 1278 } 1279 1280 1281 protected PrintWriter outWriter = new PrintWriter (System.out, true); 1282 1283 1287 protected void logMsg(String s) 1288 { 1289 outWriter.println(s); 1290 } 1291} 1292 | Popular Tags |