1aeb686282976eb1d327a9926165f623a06a35cb
[idea/community.git] / plugins / groovy / rt / src / org / jetbrains / groovy / compiler / rt / GroovycRunner.java
1 /*
2  * Copyright 2000-2007 JetBrains s.r.o.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15
16 package org.jetbrains.groovy.compiler.rt;
17
18 import com.intellij.util.lang.UrlClassLoader;
19 import org.jetbrains.annotations.Nullable;
20 import sun.misc.URLClassPath;
21
22 import java.io.BufferedReader;
23 import java.io.File;
24 import java.io.FileReader;
25 import java.io.IOException;
26 import java.lang.reflect.Method;
27 import java.net.URL;
28 import java.util.*;
29
30 /**
31  * @author: Dmitry.Krasilschikov
32  * @date: 16.04.2007
33  * @noinspection UseOfSystemOutOrSystemErr,CallToPrintStackTrace
34  */
35
36 public class GroovycRunner {
37
38   private GroovycRunner() {
39   }
40
41   /*
42   private static Controller initController() {
43     if (!"true".equals(System.getProperty("profile.groovy.compiler"))) {
44       return null;
45     }
46
47     try {
48       return new Controller();
49     }
50     catch (Exception ex) {
51       ex.printStackTrace();
52       return null;
53     }
54   }
55   */
56
57
58   public static void main(String[] args) {
59     /*
60     if (ourController != null) {
61       try {
62         ourController.startCPUProfiling(ProfilingModes.CPU_SAMPLING, null);
63       }
64       catch (Exception e) {
65         e.printStackTrace();
66       }
67     }
68     */
69
70     System.exit(intMain(args));
71     /*
72     finally {
73       if (ourController != null) {
74         try {
75           ourController.captureSnapshot(ProfilingModes.SNAPSHOT_WITHOUT_HEAP);
76           ourController.stopCPUProfiling();
77         }
78         catch (Exception e) {
79           e.printStackTrace();
80         }
81       }
82     }
83     */
84   }
85
86   public static int intMain(String[] args) {
87     boolean indy = false;
88     if (args.length != 3) {
89       if (args.length != 4 || !"--indy".equals(args[3])) {
90         System.err.println("There is no arguments for groovy compiler");
91         return 1;
92       }
93       indy = true;
94     }
95
96     final boolean optimize = GroovyRtConstants.OPTIMIZE.equals(args[0]);
97     final boolean forStubs = "stubs".equals(args[1]);
98     String argPath = args[2];
99
100     return intMain2(indy, optimize, forStubs, argPath, null);
101   }
102
103   public static int intMain2(boolean indy, boolean optimize, boolean forStubs, String argPath, Queue mailbox) {
104     if (indy) {
105       System.setProperty("groovy.target.indy", "true");
106     }
107
108     if (!new File(argPath).exists()) {
109       System.err.println("Arguments file for groovy compiler not found");
110       return 1;
111     }
112
113     ClassLoader loader = optimize ? buildMainLoader(argPath) : GroovycRunner.class.getClassLoader();
114     if (loader == null) {
115       return 1;
116     }
117     if (optimize) {
118       Thread.currentThread().setContextClassLoader(loader);
119     }
120
121     try {
122       Class.forName("org.codehaus.groovy.control.CompilationUnit", true, loader);
123     }
124     catch (Throwable e) {
125       System.err.println(GroovyRtConstants.NO_GROOVY);
126       return 1;
127     }
128
129     try {
130       Class<?> aClass = Class.forName("org.jetbrains.groovy.compiler.rt.DependentGroovycRunner", true, loader);
131       Method method = aClass.getDeclaredMethod("runGroovyc", boolean.class, String.class, Queue.class);
132       method.invoke(null, forStubs, argPath, mailbox);
133     }
134     catch (Throwable e) {
135       while (e.getCause() != null) {
136         e = e.getCause();
137       }
138       e.printStackTrace();
139       return 1;
140     }
141     return 0;
142   }
143
144   @Nullable
145   private static ClassLoader buildMainLoader(String argsPath) {
146     Set<URL> bootstrapUrls = new HashSet<URL>();
147     try {
148       Method method = ClassLoader.class.getDeclaredMethod("getBootstrapClassPath");
149       method.setAccessible(true);
150       URLClassPath ucp = (URLClassPath)method.invoke(null);
151       Collections.addAll(bootstrapUrls, ucp.getURLs());
152     }
153     catch (Exception e) {
154       e.printStackTrace();
155     }
156
157     final List<URL> urls = new ArrayList<URL>();
158     try {
159       //noinspection IOResourceOpenedButNotSafelyClosed
160       BufferedReader reader = new BufferedReader(new FileReader(argsPath));
161       String classpath = reader.readLine();
162       for (String s : classpath.split(File.pathSeparator)) {
163         URL url = new File(s).toURI().toURL();
164         if (!bootstrapUrls.contains(url)) {
165           urls.add(url);
166         }
167       }
168       reader.close();
169     }
170     catch (IOException e) {
171       e.printStackTrace();
172       return null;
173     }
174
175     final ClassLoader[] ref = new ClassLoader[1];
176     new Runnable() {
177       public void run() {
178         ref[0] = UrlClassLoader.build().urls(urls).useCache().get();
179       }
180     }.run();
181     return ref[0];
182   }
183 }