home *** CD-ROM | disk | FTP | other *** search
/ PC User 2001 August / APC_Aug2001_CD2.iso / features / web_dev / files / mwjpp516.exe / %MAINDIR% / Tools / Library / jdkUtilities.script < prev    next >
Encoding:
Text File  |  2001-06-19  |  12.3 KB  |  441 lines
  1. !!Script
  2. // Copyright ⌐ 1997-1998 - Modelworks Software
  3. // @Modified build 216 cm19980914 - see below
  4. // @Modified build 228 cm19981020 - added GetClasspathArgument function
  5. // @Modified build 247 cm19981230 - leave '\' in classpaths
  6. // @Modified build 262 cm19990202 - added support for boot classpaths
  7. // @Modified build 290 cm19990427 - check for duplicate classpaths
  8. // @Modified build 309 cm19990630 - removed empty classpath from the command line 
  9. // @Modified build 314 cm19990723 - fixed problem with no ';' in classpath
  10. // @Modified build 316 cm19990725 - fixed bougs "space in classpath" message
  11. // @Modified build 334 cm19991220 - added archive files in project to classpath
  12.  
  13. // Utility functions for JDK tool scripts
  14.  
  15. // removed function DoCommand warning - cm19980914
  16.  
  17. function GetJDKCompileCommandLine(sourcefile) // cm19981020
  18. {
  19.     // Get the compiler and systemClasses file objects
  20.     var compiler = helpers.lookup("jdk-compiler");
  21.     var systemClasses = helpers.lookup("jdk-classes.zip");
  22.     var appendSystemClasses = getMapFileValue("Preferences", "Append JDK classes.zip file to classpaths", true);
  23.     
  24.     var standardOptions = gOptions.lookup("jdk-compiler", "");
  25.     var useEnvironmentClasspath = gOptions.lookup("useEnvironmentClasspath", false);
  26.     
  27.     if (compiler && compiler.exists)
  28.     {       
  29.         // Quote all paths in case a path contains spaces
  30.         
  31.         // Add the path of the compiler -- this must be first
  32.         var command = "\"" + compiler.path + "\" ";
  33.         
  34.         // Add other options for the compiler
  35.         if (standardOptions.length > 0)
  36.         {
  37.             command += standardOptions + " ";
  38.         }
  39.         
  40.         var jikes = compiler.path.indexOf("jikes") > -1;
  41.         if (jikes)
  42.         {
  43.             command += "+E ";
  44.         }
  45.         
  46.         if (!systemClasses) // Java 2 platform
  47.         {        
  48.             var bootPaths = GetBootClassPaths();
  49.             if (bootPaths.length > 0)
  50.             {
  51.                command += "-bootclasspath \"" + bootPaths + "\" ";
  52.             }
  53.         }
  54.  
  55.         if (useEnvironmentClasspath)
  56.         {
  57.             var tool = newTool();
  58.             tool.setEnvironmentVariable("Classpath", getGlobal("EnvironmentClasspath"));
  59.         }
  60.         else
  61.         {
  62.             // Add the classpaths quoting the classpaths argument
  63.             command +=  "-classpath \"";   // Add the current directory
  64.             var classpath = "";
  65.             if (sourcefile != "")
  66.             {
  67.                 classpath += Java.getClassPath(sourcefile);
  68.             }
  69.             classpath = GetBuildPackageClassPaths(classpath);
  70.             classpath = GetCustomClassPaths(classpath);
  71.             if (appendSystemClasses && systemClasses && systemClasses.exists)
  72.             {
  73.                 if (classpath.length > 0)
  74.                 {
  75.                     classpath += ";" + systemClasses.path;
  76.                 }
  77.                 else
  78.                 {
  79.                     classpath += systemClasses.path;
  80.                 }
  81.             }
  82.             
  83.             if (jikes && !systemClasses)
  84.             {
  85.                 var jdkDirectory = helpers.lookup("jdk-directory", null);
  86.                 if (jdkDirectory)
  87.                 {
  88.                     var rtjar = jdkDirectory.path + "\\jre\\lib\\rt.jar";
  89.                     if (classpath.length > 0)
  90.                     {
  91.                         classpath += ";" + rtjar;
  92.                     }
  93.                     else
  94.                     {
  95.                         classpath += rtjar;
  96.                     }
  97.                 }
  98.             }
  99.             
  100.             command += classpath + "\" ";
  101.         }
  102.         
  103.         return command;
  104.     }
  105.     else
  106.     {
  107.         var result = confirm("You need to run the JDK setup script\n"
  108.         + "before you can use this command.\n" +
  109.         "Do you want to run the setup script now?");
  110.         if (result)
  111.         {
  112.             run("Configuration\\JDK");
  113.         }
  114.     }
  115. }
  116.  
  117. // This function set the global environment CLASSPATH
  118. // Use it as an alternative to the standard "-classpath "
  119. // command line argument
  120. function setCLASSPATH(tool)
  121. { 
  122.     var systemClasses = helpers.lookup("jdk-classes.zip");  
  123.     var appendSystemClasses = getMapFileValue("Preferences", "Append JDK classes.zip file to classpaths", true);
  124.     
  125.     var value = ".";    // Add the current directory
  126.     value = GetPackageClassPaths(value);    
  127.     value = GetCustomClassPaths(value);
  128.     
  129.     if (appendSystemClasses && systemClasses && systemClasses.exists)
  130.     {
  131.         if (value.length > 0)
  132.         {
  133.             value += ";" + systemClasses.path;    
  134.         }
  135.         else
  136.         {
  137.             value += systemClasses.path;    
  138.         }
  139.     }
  140.     
  141.     CheckForSpaceInClasspath(value);
  142.     
  143.     var currentClasspath = 
  144.     tool.setEnvironmentVariable("CLASSPATH", value);
  145.     
  146.     // Return the current CLASSPATH
  147.     return currentClasspath;
  148. }
  149.  
  150. function GetCustomClassPaths(classpaths)
  151. {    
  152.     var entry = gOptions.lookup("standardClasspaths", "");
  153.     if (entry != "")
  154.     {
  155.         if (classpaths.length > 0)
  156.         {
  157.             classpaths += ";" + entry;
  158.         }
  159.         else
  160.         {
  161.             classpaths += entry;
  162.         }
  163.     }
  164.     
  165.     var entry = gOptions.lookup("customClasspaths", "");
  166.     if (entry != "")
  167.     {
  168.         if (classpaths.length > 0)
  169.         {
  170.             classpaths += ";" + entry;
  171.         }
  172.         else
  173.         {
  174.             classpaths += entry;
  175.         }
  176.     }
  177.     
  178.     CheckForSpaceInClasspath(classpaths);
  179.     
  180.     return classpaths;
  181. }
  182.  
  183. function GetBootClassPaths()
  184. {
  185.     var classpaths = "";
  186.     var entry = gOptions.lookup("bootClasspaths", "");
  187.     if (entry != "")
  188.     {
  189.         classpaths = entry;
  190.     }
  191.  
  192.     CheckForSpaceInClasspath(classpaths);
  193.     return classpaths;
  194. }
  195.  
  196. function GetArchiveClassPaths(packagePath) //cm19991220
  197. {
  198.     var classpath = "";
  199.     
  200.     return classpath; // Comment this out if you need to add archive files 
  201.                       // to your classpath
  202.     
  203.     var list = getDirectoryFiles(packagePath, "*.jar;*.zip", true, false);
  204.     if (list)
  205.     {
  206.         var semicolon = "";
  207.         var position = list.getHeadPosition();
  208.         while(position && position.valid)
  209.         {
  210.             classpath += semicolon + list.getNext(position).path;
  211.             semicolon = ";";
  212.         }
  213.     }
  214.     //gOutput.writeLine("found: " + classpath);
  215.     return classpath;
  216. }
  217.  
  218. function GetPackageClassPaths(classpaths)
  219. {
  220.     var project = getCurrentProject();
  221.     if (project)
  222.     {
  223.         var packageList = project.getPackageList();
  224.         if (packageList)
  225.         {
  226.             var position = packageList.getHeadPosition();
  227.             while (position.valid)
  228.             {
  229.                 var packageClassPath = 
  230.                 packageList.getNext(position).getJavaClassPath();
  231.                 if (packageClassPath && classpaths.indexOf(packageClassPath) == -1)
  232.                 {
  233.                     if (classpaths.length > 0)
  234.                     {
  235.                         classpaths += ";" + packageClassPath;
  236.                     }
  237.                     else
  238.                     {
  239.                         classpaths += packageClassPath;
  240.                     }
  241.                 }
  242.                 var archivePaths = GetArchiveClassPaths(packageClassPath); //cm19991220
  243.                 if (archivePaths.length > 0)
  244.                 {
  245.                     classpaths += ";" + archivePaths;
  246.                 }
  247.             }
  248.         }
  249.     }
  250.     CheckForSpaceInClasspath(classpaths);
  251.     
  252.     return classpaths;
  253. }
  254.  
  255. function GetBuildPackageClassPaths(classpaths)
  256. {
  257.     var project = getCurrentProject();
  258.     if (project)
  259.     {
  260.         var packageList = project.getPackageList();
  261.         if (packageList)
  262.         {
  263.             var position = packageList.getHeadPosition();
  264.             while (position.valid)
  265.             {
  266.                 var packageClassPath = packageList.getNext(position).getJavaClassPath();
  267.                 if (packageClassPath && classpaths.indexOf(packageClassPath) == -1)
  268.                 {
  269.                     if (classpaths.length == 0)
  270.                     {
  271.                         classpaths += packageClassPath;
  272.                     }
  273.                     else
  274.                     {
  275.                         classpaths += ";" + packageClassPath;
  276.                     }
  277.                 }
  278.                 var archivePaths = GetArchiveClassPaths(packageClassPath); //cm19991220
  279.                 if (archivePaths.length > 0)
  280.                 {
  281.                     classpaths += ";" + archivePaths;
  282.                 }
  283.             }
  284.             
  285.             // Add SourcePath directories if needed
  286.             position = packageList.getHeadPosition();
  287.             while (position.valid)
  288.             {
  289.                 var pkg = packageList.getNext(position);
  290.                 if (pkg.destinationNotSource)
  291.                 {
  292.                     var packageClassPath = 
  293.                         pkg.getJavaSourceClassPath();
  294.                     if (packageClassPath && classpaths.indexOf(packageClassPath) == -1)
  295.                     {
  296.                         if (classpaths.length == 0)
  297.                         {
  298.                             classpaths += packageClassPath;
  299.                         }
  300.                         else
  301.                         {
  302.                             classpaths += ";" + packageClassPath;
  303.                         }
  304.                     }
  305.                 }
  306.             }
  307.         }
  308.     }
  309.     CheckForSpaceInClasspath(classpaths);
  310.     
  311.     return classpaths;
  312. }
  313.  
  314. function CheckForSpaceInClasspath(classpaths)
  315. {
  316.     var spaceIndex = classpaths.indexOf(" ");
  317.     if (spaceIndex > -1)
  318.     {
  319.         gOutput.writeLine("Warning: Space found in classpath: " + classpaths);
  320.         gOutput.writeLine("Sun's JDK debugger will not work correctly with a space in the classpath.");
  321.     }
  322. }
  323.  
  324. function GetDestinationPath(sourcePath)
  325. {
  326.     var destinationPath = "";
  327.     var project = getCurrentProject();
  328.     if (project)
  329.     {
  330.         var sourcePackage = project.getPackage(sourcePath);
  331.         if (sourcePackage)
  332.         {
  333.             return sourcePackage.getDestinationPath(sourcePath);
  334.         }
  335.     }
  336.     return destinationPath;
  337. }
  338.  
  339. function AppendSeparator(classpath)
  340. {
  341.     if (classpath.length > 0)
  342.     {
  343.         var lastChar = classpath.charAt(classpath.length-1);
  344.         if (lastChar != '"' && lastChar != ';')
  345.         {
  346.             classpath += ';';
  347.         }
  348.     }
  349.     return classpath;
  350. }
  351.  
  352. function GetClasspathArgument(classfilepath, special) // cm19981020
  353. {
  354.     var appendSystemClasses = getMapFileValue("Preferences", "Append JDK classes.zip file to classpaths", true);
  355.     var systemClasses = helpers.lookup("jdk-classes.zip");
  356.  
  357.     var bootclasspath = "";
  358.     
  359.     if (!systemClasses) // Java 2 platform
  360.     {        
  361.         var bootPaths = GetBootClassPaths();
  362.         if (bootPaths.length > 0)
  363.         {
  364.             bootclasspath += "-Xbootclasspath:" + bootPaths + " ";
  365.         }
  366.     }
  367.  
  368.     var classpath = "";
  369.     
  370.     if (classfilepath != "")
  371.     {
  372.         classpath += Java.getClassPath(classfilepath); // Add a local classpath for classfilepath if needed  
  373.     }
  374.  
  375.     classpath = GetPackageClassPaths(classpath);     
  376.     classpath = GetCustomClassPaths(classpath); 
  377.     if (appendSystemClasses && systemClasses && systemClasses.exists)
  378.     {
  379.         classpath = AppendSeparator(classpath);
  380.         classpath += systemClasses.path;
  381.     }
  382.     
  383.     if (special)
  384.     {
  385.         classpath = AppendSeparator(classpath);
  386.         classpath += special;
  387.     }
  388.  
  389.     if (classpath == "")
  390.     {
  391.         return bootclasspath; 
  392.     }
  393.     else
  394.     {
  395.         return bootclasspath + "-classpath \"" + classpath + "\" "; 
  396.     }
  397. }
  398.  
  399. function AddFilesToCompile(commandLine, filePathList)  //cm20000530
  400. {
  401.     var result = "";
  402.     if (gOptions.lookup("useCommandFileWhenCompiling",false))
  403.     {
  404.         result = AddFilePathsToBatchFile(filePathList);
  405.     }
  406.     else
  407.     {
  408.         var position = filePathList.getHeadPosition();
  409.         while(position && position.valid) 
  410.         {
  411.             var path = filePathList.getNext(position);
  412.             result += " \"" + path + "\"";
  413.         }
  414.     }
  415.     return result;
  416. }
  417.  
  418. function AddFilePathsToBatchFile(buildList)  //cm19991223
  419. {
  420.     var path = File.getDataPath() + "\\JDKCommandFile.txt";
  421.     var commandFile = "@" + "\"" + path + "\""; //Bruno Konik20001215
  422.     var editor = newEditor(path, false);
  423.     if (editor)
  424.     {
  425.         editor.removeAll();
  426.         var position = buildList.getHeadPosition();
  427.         while (position && position.valid)
  428.         {
  429.             var path = buildList.getNext(position);
  430.             editor.append(path + "\n");
  431.         }
  432.         
  433.         file = editor.getFile();
  434.         editor.close();
  435.         return commandFile;
  436.     }
  437.     return "";
  438. }
  439.  
  440. !!/Script
  441.