util-testing/org/cacert/gigi/localisation/TranslationCollector.java

   1 package org.cacert.gigi.localisation;
   2
   3 import java.io.File;
   4 import java.io.FileInputStream;
   5 import java.io.FileNotFoundException;
   6 import java.io.IOException;
   7 import java.io.InputStreamReader;
   8 import java.io.PrintWriter;
   9 import java.io.UnsupportedEncodingException;
  10 import java.util.ArrayList;
  11 import java.util.Arrays;
  12 import java.util.Collection;
  13 import java.util.HashMap;
  14 import java.util.LinkedList;
  15 import java.util.List;
  16 import java.util.TreeSet;
  17
  18 import org.cacert.gigi.output.template.Template;
  19 import org.eclipse.jdt.core.compiler.CategorizedProblem;
  20 import org.eclipse.jdt.internal.compiler.CompilationResult;
  21 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
  22 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
  23 import org.eclipse.jdt.internal.compiler.batch.CompilationUnit;
  24 import org.eclipse.jdt.internal.compiler.batch.FileSystem;
  25 import org.eclipse.jdt.internal.compiler.batch.Main;
  26 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
  27 import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
  28 import org.eclipse.jdt.internal.compiler.env.IBinaryType;
  29 import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
  30 import org.eclipse.jdt.internal.compiler.env.ISourceType;
  31 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
  32 import org.eclipse.jdt.internal.compiler.impl.ITypeRequestor;
  33 import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
  34 import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
  35 import org.eclipse.jdt.internal.compiler.parser.Parser;
  36 import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
  37
  38 public class TranslationCollector {
  39
  40     static class TranslationEntry implements Comparable<TranslationEntry> {
  41
  42         String text;
  43
  44         String occur1;
  45
  46         List<String> occur;
  47
  48         public TranslationEntry(String text, String occur) {
  49             this.text = text;
  50             occur1 = occur;
  51         }
  52
  53         public List<String> getOccur() {
  54             if (occur == null) {
  55                 return Arrays.asList(occur1);
  56             }
  57             return occur;
  58         }
  59
  60         public void add(String t) {
  61             if (occur == null) {
  62                 occur = new ArrayList<>(Arrays.asList(occur1));
  63             }
  64             occur.add(t);
  65         }
  66
  67         @Override
  68         public int compareTo(TranslationEntry o) {
  69             int i = occur1.compareTo(o.occur1);
  70             if (i != 0) {
  71                 return i;
  72             }
  73
  74             return text.compareTo(o.text);
  75         }
  76     }
  77
  78     private HashMap<String, TranslationEntry> translations = new HashMap<>();
  79
  80     public final File base;
  81
  82     public TranslationCollector(File base, File conf) {
  83         this.base = base;
  84         taint = new LinkedList<>();
  85         for (String s : new FileIterable(conf)) {
  86             taint.add(TaintSource.parseTaint(s));
  87         }
  88     }
  89
  90     public void run(File out) throws IOException {
  91         scanTemplates();
  92         scanCode(taint);
  93
  94         System.out.println("Total Translatable Strings: " + translations.size());
  95         TreeSet<TranslationEntry> trs = new TreeSet<>(translations.values());
  96         writePOFile(out, trs);
  97
  98     }
  99
 100     public void add(String text, String line) {
 101         if (text.contains("\r") || text.contains("\n")) {
 102             throw new Error("Malformed translation in " + line);
 103         }
 104         TranslationEntry i = translations.get(text);
 105         if (i == null) {
 106             translations.put(text, new TranslationEntry(text, line));
 107             return;
 108         }
 109         i.add(line);
 110     }
 111
 112     private void scanCode(LinkedList<TaintSource> taint) throws Error {
 113         PrintWriter out = new PrintWriter(System.out);
 114         Main m = new Main(out, out, false, null, null);
 115         File[] fs = recurse(new File(new File(new File(base, "src"), "org"), "cacert"), new LinkedList<File>(), ".java").toArray(new File[0]);
 116         String[] t = new String[fs.length + 3];
 117         t[0] = "-cp";
 118         t[1] = new File(base, "bin").getAbsolutePath();
 119         t[2] = "-7";
 120         for (int i = 0; i < fs.length; i++) {
 121             t[i + 3] = fs[i].getAbsolutePath();
 122         }
 123         m.configure(t);
 124         FileSystem environment = m.getLibraryAccess();
 125         CompilerOptions compilerOptions = new CompilerOptions(m.options);
 126         compilerOptions.performMethodsFullRecovery = false;
 127         compilerOptions.performStatementsRecovery = false;
 128         // check
 129         compilerOptions.sourceLevel = ClassFileConstants.JDK1_7;
 130         compilerOptions.complianceLevel = ClassFileConstants.JDK1_7;
 131         compilerOptions.originalComplianceLevel = ClassFileConstants.JDK1_7;
 132
 133         ProblemReporter pr = new ProblemReporter(m.getHandlingPolicy(), compilerOptions, m.getProblemFactory());
 134         ITypeRequestor tr = new ITypeRequestor() {
 135
 136             @Override
 137             public void accept(ISourceType[] sourceType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
 138                 throw new IllegalStateException("source type not implemented");
 139             }
 140
 141             @Override
 142             public void accept(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
 143                 le.createBinaryTypeFrom(binaryType, packageBinding, accessRestriction);
 144             }
 145
 146             @Override
 147             public void accept(ICompilationUnit unit, AccessRestriction accessRestriction) {
 148                 throw new IllegalStateException("compilation unit not implemented");
 149             }
 150         };
 151         le = new LookupEnvironment(tr, compilerOptions, pr, environment);
 152         Parser parser = new Parser(pr, compilerOptions.parseLiteralExpressionsAsConstants);
 153         CompilationUnit[] sourceUnits = m.getCompilationUnits();
 154         CompilationUnitDeclaration[] parsedUnits = new CompilationUnitDeclaration[sourceUnits.length];
 155         for (int i = 0; i < parsedUnits.length; i++) {
 156
 157             CompilationResult unitResult = new CompilationResult(sourceUnits[i], i, parsedUnits.length, compilerOptions.maxProblemsPerUnit);
 158             CompilationUnitDeclaration parsedUnit = parser.parse(sourceUnits[i], unitResult);
 159             le.buildTypeBindings(parsedUnit, null /* no access restriction */);
 160             parsedUnits[i] = parsedUnit;
 161         }
 162         le.completeTypeBindings();
 163         for (int i = 0; i < parsedUnits.length; i++) {
 164             CompilationUnitDeclaration parsedUnit = parsedUnits[i];
 165
 166             parser.getMethodBodies(parsedUnit);
 167             parsedUnit.scope.faultInTypes();
 168             parsedUnit.scope.verifyMethods(le.methodVerifier());
 169             parsedUnit.resolve();
 170         }
 171         for (int i = 0; i < parsedUnits.length; i++) {
 172             CompilationUnitDeclaration parsedUnit = parsedUnits[i];
 173             if (parsedUnit.compilationResult.problems != null) {
 174                 int err = 0;
 175                 for (int c = 0; c < parsedUnit.compilationResult.problemCount; c++) {
 176                     CategorizedProblem problem = parsedUnit.compilationResult.problems[c];
 177                     if (problem.isError()) {
 178                         err++;
 179                     }
 180                     if (OUTPUT_WARNINGS || problem.isError()) {
 181                         System.out.println(problem);
 182                         StringBuilder prob = new StringBuilder();
 183                         prob.append(parsedUnit.compilationResult.fileName);
 184                         prob.append(":");
 185                         prob.append(problem.getSourceLineNumber());
 186                         System.out.println(prob.toString());
 187                     }
 188                 }
 189                 if (err > 0) {
 190                     throw new Error();
 191                 }
 192             }
 193
 194             if (parsedUnit.types == null) {
 195                 System.out.println("No types");
 196
 197             } else {
 198                 TranslationCollectingVisitor v = new TranslationCollectingVisitor(parsedUnit, taint.toArray(new TaintSource[taint.size()]), this);
 199                 for (TypeDeclaration td : parsedUnit.types) {
 200                     td.traverse(v, td.scope);
 201                 }
 202             }
 203             parsedUnits[i] = parsedUnit;
 204         }
 205     }
 206
 207     private void scanTemplates() throws UnsupportedEncodingException, FileNotFoundException {
 208         File[] ts = recurse(new File(new File(new File(base, "src"), "org"), "cacert"), new LinkedList<File>(), ".templ").toArray(new File[0]);
 209         for (File file : ts) {
 210             Template t = new Template(new InputStreamReader(new FileInputStream(file), "UTF-8"));
 211             LinkedList<String> i = new LinkedList<String>();
 212             t.addTranslations(i);
 213             for (String string : i) {
 214                 add(string, file.getAbsolutePath().substring(base.getAbsolutePath().length() + 1) + ":1");
 215             }
 216         }
 217     }
 218
 219     static LookupEnvironment le;
 220
 221     private static final boolean OUTPUT_WARNINGS = false;
 222
 223     private LinkedList<TaintSource> taint;
 224
 225     public static void main(String[] args) throws IOException {
 226         new TranslationCollector(new File(args[1]), new File(args[0])).run(new File(args[2]));
 227     }
 228
 229     public static void writePOFile(File target, Collection<TranslationEntry> strings) throws IOException {
 230         PrintWriter out = new PrintWriter(target);
 231         for (TranslationEntry s : strings) {
 232             out.print("#:");
 233             for (String st : s.getOccur()) {
 234                 out.print(" " + st);
 235             }
 236             out.println();
 237             out.println("msgid \"" + s.text.replace("\\", "\\\\").replace("\"", "\\\"") + "\"");
 238             out.println("msgstr \"\"");
 239             out.println();
 240         }
 241         out.close();
 242     }
 243
 244     private static List<File> recurse(File file, List<File> toAdd, String pt) {
 245         if (file.isDirectory()) {
 246             for (File f : file.listFiles()) {
 247                 recurse(f, toAdd, pt);
 248             }
 249         } else {
 250             if (file.getName().endsWith(pt)) {
 251                 toAdd.add(file);
 252             }
 253         }
 254         return toAdd;
 255     }
 256 }