< prev index next >

src/jdk.jextract/share/classes/com/sun/tools/jextract/parser/Parser.java

Print this page




  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package com.sun.tools.jextract.parser;
  24 
  25 import java.nio.file.Path;
  26 import java.nio.file.Paths;
  27 import java.io.PrintWriter;
  28 import java.util.Arrays;
  29 import java.util.ArrayList;
  30 import java.util.Collection;
  31 import java.util.Collections;
  32 import java.util.LinkedHashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Optional;
  36 import java.util.logging.Logger;
  37 import java.util.stream.Collectors;


  38 import jdk.internal.clang.Cursor;
  39 import jdk.internal.clang.CursorKind;
  40 import jdk.internal.clang.Diagnostic;
  41 import jdk.internal.clang.Index;
  42 import jdk.internal.clang.LibClang;
  43 import jdk.internal.clang.SourceLocation;
  44 import jdk.internal.clang.SourceRange;
  45 import jdk.internal.clang.TranslationUnit;
  46 import com.sun.tools.jextract.tree.HeaderTree;
  47 import com.sun.tools.jextract.tree.MacroTree;
  48 import com.sun.tools.jextract.tree.SimpleTreeVisitor;
  49 import com.sun.tools.jextract.tree.Tree;
  50 import com.sun.tools.jextract.tree.TreeMaker;
  51 import com.sun.tools.jextract.tree.TreePrinter;
  52 
  53 public class Parser {
  54     private final PrintWriter out;
  55     private final PrintWriter err;
  56     private final TreeMaker treeMaker;
  57     private final boolean supportMacros;
  58     private final Logger logger = Logger.getLogger(getClass().getPackage().getName());
  59 
  60     public Parser(PrintWriter out, PrintWriter err, boolean supportMacros) {
  61         this.out = out;
  62         this.err = err;
  63         this.treeMaker = new TreeMaker();
  64         this.supportMacros = supportMacros;
  65     }
  66 
  67     public Parser(boolean supportMacros) {
  68         this(new PrintWriter(System.out, true),
  69             new PrintWriter(System.err, true), supportMacros);
  70     }
  71 
  72     public List<HeaderTree> parse(Collection<Path> paths, Collection<String> args) {
  73         final List<HeaderTree> headers = new ArrayList<>();
  74         final Index index = LibClang.createIndex();
  75         for (Path path : paths) {
  76             logger.info(() -> {
  77                 StringBuilder sb = new StringBuilder(
  78                         "Parsing header file " + path + " with following args:\n");
  79                 int i = 0;
  80                 for (String arg : args) {
  81                     sb.append("arg[");
  82                     sb.append(i++);
  83                     sb.append("] = ");
  84                     sb.append(arg);
  85                     sb.append("\n");
  86                 }
  87                 return sb.toString();
  88             });
  89 
  90             Cursor tuCursor = index.parse(path.toString(),
  91                 d -> {


 163 
 164         logger.fine(() -> "Defining macro " + macroName);
 165 
 166         TranslationUnit tu = cursor.getTranslationUnit();
 167         SourceRange range = cursor.getExtent();
 168         String[] tokens = tu.tokens(range);
 169 
 170         macroParser.parse(cursor, tokens);
 171     }
 172 
 173     private boolean isMacro(Cursor c) {
 174         return c.isPreprocessing() && c.kind() == CursorKind.MacroDefinition;
 175     }
 176 
 177     public static void main(String[] args) {
 178         if (args.length == 0) {
 179             System.err.println("Expected a header file");
 180             return;
 181         }
 182 
 183         Parser p = new Parser(true);

 184         List<Path> paths = Arrays.stream(args).map(Paths::get).collect(Collectors.toList());
 185         Path builtinInc = Paths.get(System.getProperty("java.home"), "conf", "jextract");
 186         List<String> clangArgs = List.of("-I" + builtinInc);
 187         List<HeaderTree> headers = p.parse(paths, clangArgs);
 188         TreePrinter printer = new TreePrinter();
 189         for (HeaderTree ht : headers) {
 190             ht.accept(printer, null);
 191         }
 192     }
 193 }


  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package com.sun.tools.jextract.parser;
  24 
  25 import java.nio.file.Path;
  26 import java.nio.file.Paths;
  27 import java.io.PrintWriter;
  28 import java.util.Arrays;
  29 import java.util.ArrayList;
  30 import java.util.Collection;
  31 import java.util.Collections;
  32 import java.util.LinkedHashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Optional;
  36 import java.util.logging.Logger;
  37 import java.util.stream.Collectors;
  38 
  39 import com.sun.tools.jextract.Context;
  40 import jdk.internal.clang.Cursor;
  41 import jdk.internal.clang.CursorKind;
  42 import jdk.internal.clang.Diagnostic;
  43 import jdk.internal.clang.Index;
  44 import jdk.internal.clang.LibClang;
  45 import jdk.internal.clang.SourceLocation;
  46 import jdk.internal.clang.SourceRange;
  47 import jdk.internal.clang.TranslationUnit;
  48 import com.sun.tools.jextract.tree.HeaderTree;
  49 import com.sun.tools.jextract.tree.MacroTree;
  50 import com.sun.tools.jextract.tree.SimpleTreeVisitor;
  51 import com.sun.tools.jextract.tree.Tree;
  52 import com.sun.tools.jextract.tree.TreeMaker;
  53 import com.sun.tools.jextract.tree.TreePrinter;
  54 
  55 public class Parser {
  56     private final PrintWriter out;
  57     private final PrintWriter err;
  58     private final TreeMaker treeMaker;
  59     private final boolean supportMacros;
  60     private final Logger logger = Logger.getLogger(getClass().getPackage().getName());
  61 
  62     public Parser(Context context, boolean supportMacros) {
  63         this.out = context.out;
  64         this.err = context.err;
  65         this.treeMaker = new TreeMaker();
  66         this.supportMacros = supportMacros;
  67     }
  68 





  69     public List<HeaderTree> parse(Collection<Path> paths, Collection<String> args) {
  70         final List<HeaderTree> headers = new ArrayList<>();
  71         final Index index = LibClang.createIndex();
  72         for (Path path : paths) {
  73             logger.info(() -> {
  74                 StringBuilder sb = new StringBuilder(
  75                         "Parsing header file " + path + " with following args:\n");
  76                 int i = 0;
  77                 for (String arg : args) {
  78                     sb.append("arg[");
  79                     sb.append(i++);
  80                     sb.append("] = ");
  81                     sb.append(arg);
  82                     sb.append("\n");
  83                 }
  84                 return sb.toString();
  85             });
  86 
  87             Cursor tuCursor = index.parse(path.toString(),
  88                 d -> {


 160 
 161         logger.fine(() -> "Defining macro " + macroName);
 162 
 163         TranslationUnit tu = cursor.getTranslationUnit();
 164         SourceRange range = cursor.getExtent();
 165         String[] tokens = tu.tokens(range);
 166 
 167         macroParser.parse(cursor, tokens);
 168     }
 169 
 170     private boolean isMacro(Cursor c) {
 171         return c.isPreprocessing() && c.kind() == CursorKind.MacroDefinition;
 172     }
 173 
 174     public static void main(String[] args) {
 175         if (args.length == 0) {
 176             System.err.println("Expected a header file");
 177             return;
 178         }
 179 
 180         Context context = new Context();
 181         Parser p = new Parser(context,true);
 182         List<Path> paths = Arrays.stream(args).map(Paths::get).collect(Collectors.toList());
 183         Path builtinInc = Paths.get(System.getProperty("java.home"), "conf", "jextract");
 184         List<String> clangArgs = List.of("-I" + builtinInc);
 185         List<HeaderTree> headers = p.parse(paths, clangArgs);
 186         TreePrinter printer = new TreePrinter();
 187         for (HeaderTree ht : headers) {
 188             ht.accept(printer, null);
 189         }
 190     }
 191 }
< prev index next >