Mercurial > jdk8-mips64-public > langtools / file revision

 /*

  * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 import java.io.*;

 import java.util.*;

 import javax.lang.model.util.*;

 import javax.tools.*;

 import com.sun.tools.javac.api.*;

 import com.sun.source.tree.*;

 import com.sun.source.util.*;

 import com.sun.tools.javac.tree.JCTree;

 import com.sun.tools.javac.tree.JCTree.*;

 import com.sun.tools.javac.util.Position;

 /*

  * Abstract class to help check the scopes in a parsed source file.

  * -- parse source file

  * -- scan trees looking for string literals

  * -- check the scope at that point against the string, using

  *      boolean check(Scope s, String ref)

  */

 abstract class Checker {

     // parse the source file and call check(scope, string) for each string literal found

     void check(String... fileNames) throws IOException {

         File testSrc = new File(System.getProperty("test.src"));

         DiagnosticListener<JavaFileObject> dl = new DiagnosticListener<JavaFileObject>() {

             public void report(Diagnostic d) {

                 System.err.println(d);

                 if (d.getKind() == Diagnostic.Kind.ERROR)

                     errors = true;

                 new Exception().printStackTrace();

             }

         };

         JavacTool tool = JavacTool.create();

         StandardJavaFileManager fm = tool.getStandardFileManager(dl, null, null);

         Iterable<? extends JavaFileObject> files =

             fm.getJavaFileObjectsFromFiles(getFiles(testSrc, fileNames));

         task = tool.getTask(null, fm, dl, null, null, files);

         Iterable<? extends CompilationUnitTree> units = task.parse();

         if (errors)

             throw new AssertionError("errors occurred creating trees");

         ScopeScanner s = new ScopeScanner();

         for (CompilationUnitTree unit: units) {

             TreePath p = new TreePath(unit);

             s.scan(p, getTrees());

         }

         task = null;

         if (errors)

             throw new AssertionError("errors occurred checking scopes");

     }

     // default impl: split ref at ";" and call checkLocal(scope, ref_segment) on scope and its enclosing scopes

     protected boolean check(Scope s, String ref) {

         // System.err.println("check scope: " + s);

         // System.err.println("check ref: " + ref);

         if (s == null && (ref == null || ref.trim().length() == 0))

             return true;

         if (s == null) {

             error(s, ref, "scope missing");

             return false;

         }

         if (ref == null) {

             error(s, ref, "scope unexpected");

             return false;

         }

         String local;

         String encl;

         int semi = ref.indexOf(';');

         if (semi == -1) {

             local = ref;

             encl = null;

         } else {

             local = ref.substring(0, semi);

             encl = ref.substring(semi + 1);

         }

         return checkLocal(s, local.trim())

             & check(s.getEnclosingScope(), encl);

     }

     // override if using default check(Scope,String)

     boolean checkLocal(Scope s, String ref) {

         throw new IllegalStateException();

     }

     void error(Scope s, String ref, String msg) {

         System.err.println("Error: " + msg);

         System.err.println("Scope: " + (s == null ? null : asList(s.getLocalElements())));

         System.err.println("Expect: " + ref);

         System.err.println("javac: " + (s == null ? null : ((JavacScope) s).getEnv()));

         errors = true;

     }

     protected Elements getElements() {

         return task.getElements();

     }

     protected Trees getTrees() {

         return Trees.instance(task);

     }

     boolean errors = false;

     protected JavacTask task;

     // scan a parse tree, and for every string literal found, call check(scope, string) with

     // the string value at the scope at that point

     class ScopeScanner extends TreePathScanner<Boolean,Trees> {

         public Boolean  visitLiteral(LiteralTree tree, Trees trees) {

             TreePath path = getCurrentPath();

             CompilationUnitTree unit = path.getCompilationUnit();

             Position.LineMap lineMap = ((JCCompilationUnit)unit).lineMap;

 //          long line = lineMap.getLineNumber(((JCTree)tree).pos/*trees.getSourcePositions().getStartPosition(tree)*/);

 //          System.err.println(line + ": " + abbrev(tree));

             Scope s = trees.getScope(path);

             if (tree.getKind() == Tree.Kind.STRING_LITERAL)

                 check(s, tree.getValue().toString().trim());

             return null;

         }

         private String abbrev(Tree tree) {

             int max = 48;

             String s = tree.toString().replaceAll("[ \n]+", " ");

             return (s.length() < max ? s : s.substring(0, max-3) + "...");

         }

     }

     // prefix filenames with a directory

     static Iterable<File> getFiles(File dir, String... names) {

         List<File> files = new ArrayList<File>(names.length);

         for (String name: names)

             files.add(new File(dir, name));

         return files;

     }

     static private <T> List<T> asList(Iterable<T> iter) {

         List<T> l = new ArrayList<T>();

         for (T t: iter)

             l.add(t);

         return l;

     }

 }