| /* |
| * Copyright 2003-2004 The Apache Software Foundation. |
| // (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.axis.tools.cbindings; |
| import java.io.BufferedReader; |
| import java.io.BufferedWriter; |
| import java.io.File; |
| import java.io.FileReader; |
| import java.io.FileWriter; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.StringTokenizer; |
| import java.util.Hashtable; |
| import java.util.*; |
| |
| |
| import org.apache.axis.tools.common.CParsingTool; |
| import org.apache.axis.tools.common.Configuration; |
| import org.apache.axis.tools.common.DirectoryTree; |
| import org.apache.axis.tools.common.FileActor; |
| import org.apache.axis.tools.common.FilePart; |
| import org.apache.axis.tools.common.InputCppSourceCode; |
| import org.apache.axis.tools.common.MethodPart; |
| import org.apache.axis.tools.common.Parameter; |
| import org.apache.axis.tools.common.ParsingException; |
| import org.apache.axis.tools.common.PrototypePart; |
| import org.apache.axis.tools.common.Signature; |
| import org.apache.axis.tools.common.Utils; |
| |
| /** |
| * This class is a tool that generates C bindings (header files) from C++ |
| * header files. It contains a main program:- |
| * |
| * usage: Java CBindingGenerator -config <file> -source <dir> -target <dir> |
| */ |
| public class CBindingGenerator extends CParsingTool implements FileActor |
| { |
| private static Hashtable classMapping = new Hashtable(); |
| |
| static{ |
| classMapping.put("AxisCPPConfigDefaults", "axiscConfigDefaults"); |
| classMapping.put("AxisException", "axiscException"); |
| classMapping.put("BasicHandler", "axiscBasicHandler"); |
| classMapping.put("BasicNode", "axiscBasicNode"); |
| classMapping.put("IAttribute", "axiscAttribute"); |
| classMapping.put("IHandlerSoapDeSerializer","axiscHandlerSoapDeSerializer"); |
| classMapping.put("IHandlerSoapSerializer", "axiscHandlerSoapSerializer"); |
| classMapping.put("IHeaderBlock", "axiscHeaderBlock"); |
| classMapping.put("IMessageData", "axiscMessageData"); |
| classMapping.put("INamespace", "axiscNamespace"); |
| classMapping.put("ISoapAttachment", "axiscSoapAttachment"); |
| classMapping.put("ISoapFault", "axiscSoapFault"); |
| classMapping.put("IWrapperSoapDeSerializer","axiscSoapDeSerializer"); |
| classMapping.put("IWrapperSoapSerializer", "axiscSoapSerializer"); |
| classMapping.put("OtherFaultException", "axiscOtherFaultException"); |
| classMapping.put("SoapFaultException", "axiscSoapFaultException"); |
| classMapping.put("TypeMapping", "axiscTypeMapping"); |
| } |
| |
| private CBindingGenerator(String[] args) throws Exception |
| { |
| super(args); |
| } |
| |
| /** |
| * This method is used to determine the prefix to use for the class |
| * methods. All class methods should be prefixed with "axisc + classname". |
| * We use mapping table to try to shorten long names or to remove the 'I' |
| * from the class name. See mapping table above. |
| */ |
| public static String getClassMapping(String theClass) |
| { |
| String val = (String)classMapping.get(theClass); |
| if (val == null) |
| val = "axisc" + theClass; |
| |
| return val; |
| } |
| |
| /** |
| * This method is called by the DirectoryTree with two files: the |
| * input (source) file and the output (target) file. This method parses |
| * the source (header) file and writes out the C bindings to the target |
| * file. The depth is how deep in the source directory tree we are. |
| */ |
| public void actOnFile(File source, File target, int depth) throws Exception |
| { |
| if (Configuration.fileExcluded(source.getName())) |
| return; |
| Utils.outputDebugString("parsing " + source + "..."); |
| String targetName = DirectoryTree.maybeAppendSeparator(target.toString()); |
| targetName += source.getName().substring(0, source.getName().lastIndexOf(".")) + ".h"; |
| FileWriter fw = new FileWriter(new File(targetName), false); |
| BufferedWriter bw = new BufferedWriter(fw); |
| FileReader fr = new FileReader(source); |
| BufferedReader inputFile = new BufferedReader(fr); |
| |
| try |
| { |
| InputCppSourceCode sourceCode = new InputCppSourceCode(inputFile, source.getName()); |
| generateHeader(sourceCode, bw); |
| } |
| catch (ParsingException pe) |
| { |
| failed = true; |
| } |
| |
| bw.flush(); |
| bw.close(); |
| inputFile.close(); |
| } |
| |
| /** |
| * Generates a C header file from a C++ header file. |
| */ |
| private void generateHeader(InputCppSourceCode inputFile, BufferedWriter outputFile) throws Exception |
| { |
| boolean foundCopyright = false; |
| String define = inputFile.getName(); |
| define = define.toUpperCase(); |
| define = define.substring(0, define.indexOf(".")); |
| define += "_INCLUDED"; |
| |
| String syncComment = |
| "/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */\n" + |
| "/* NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE */\n" + |
| "/* ---------------------------------------------------------------- */\n" + |
| "/* THIS HEADER FILE PATTERNED AFTER CORRESPONDING hpp HEADER FILE. */\n" + |
| "/* CHANGES TO hpp HEADER FILE MAY NEED TO BE PROPAGATED HERE AND IN */\n" + |
| "/* THE IMPLEMEMTATION OF THE C APIS. */\n" + |
| "/* */\n" + |
| "/* THIS FILE GENERATED BY CBINDINGGENERATOR TOOL. */\n" + |
| "/* ---------------------------------------------------------------- */\n" + |
| "/* NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE */\n" + |
| "/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */\n"; |
| |
| String cplusplusStart = "#ifdef __cplusplus\n extern \"C\" {\n#endif\n"; |
| String cplusplusEnd = "#ifdef __cplusplus\n }\n#endif\n"; |
| |
| int prevPart = FilePart.COMMENT; // Suppresse newline before copyright |
| String text; |
| Iterator it = inputFile.getPartIterator(); |
| while (it.hasNext()) |
| { |
| FilePart fp = (FilePart) (it.next()); |
| if (!foundCopyright |
| && (FilePart.DIRECTIVE == fp.getType() |
| || FilePart.ENUM == fp.getType() |
| || FilePart.PROTOTYPE == fp.getType())) |
| { |
| outputFile.write("#ifndef " + define); |
| outputFile.newLine(); |
| outputFile.write("#define " + define); |
| outputFile.newLine(); |
| outputFile.newLine(); |
| outputFile.write(syncComment); |
| outputFile.newLine(); |
| outputFile.write(cplusplusStart); |
| outputFile.newLine(); |
| foundCopyright = true; |
| } |
| |
| switch (fp.getType()) |
| { |
| case FilePart.COMMENT : |
| if (FilePart.COMMENT != prevPart) |
| outputFile.newLine(); |
| prevPart = fp.getType(); |
| text = fp.toString().trim(); |
| StringTokenizer tkzr = new StringTokenizer(text, "\n\r"); |
| while (tkzr.hasMoreTokens()) |
| { |
| String line = tkzr.nextToken().trim(); |
| if (-1 == line.indexOf("@author")) |
| { |
| if (line.startsWith("*")) |
| outputFile.write(" "); |
| outputFile.write(line); |
| outputFile.newLine(); |
| } |
| } |
| break; |
| |
| case FilePart.DIRECTIVE : |
| if (FilePart.DIRECTIVE != prevPart) |
| outputFile.newLine(); |
| prevPart = fp.getType(); |
| generateDirective(fp, outputFile, inputFile.getName()); |
| break; |
| |
| case FilePart.TYPEDEF : |
| prevPart = fp.getType(); |
| generateTypedef(fp, outputFile); |
| break; |
| |
| case FilePart.METHOD : |
| case FilePart.PROTOTYPE : |
| if (FilePart.COMMENT != prevPart |
| && FilePart.METHOD != prevPart |
| && FilePart.PROTOTYPE != prevPart) |
| outputFile.newLine(); |
| prevPart = fp.getType(); |
| generateFunctionPrototype(fp, outputFile); |
| break; |
| |
| case FilePart.ENUM : |
| Utils.rude( |
| "Enums should be wrappered with a typedef so " |
| + "they appear the same in C and C++", |
| inputFile.getName(), 0, fp.toString()); |
| break; |
| // do nothing for other file parts |
| } |
| } |
| |
| outputFile.newLine(); |
| |
| outputFile.write(cplusplusEnd); |
| outputFile.newLine(); |
| |
| outputFile.write("#endif /* " + define + " */"); |
| outputFile.newLine(); |
| } |
| |
| private boolean keepIfdef = false; |
| private void generateDirective(FilePart fp, BufferedWriter outputFile,String filename) throws Exception |
| { |
| String text = fp.toString().trim(); |
| if (-1 != text.indexOf("include")) |
| { |
| if (-1 != text.indexOf("axis/")) |
| { |
| // We currently do not support handlers for C bindings |
| if (-1 == text.indexOf("BasicHandler") && |
| -1 == text.indexOf("IHandlerSoap") && |
| -1 == text.indexOf("AxisUserAPIArrays")) // no equivalent |
| { |
| // Change .hpp files to .h files and dump out include |
| text = text.replaceAll(".hpp",".h"); |
| outputFile.write(text); |
| outputFile.newLine(); |
| } |
| } |
| else if (-1 != text.indexOf(".h>")) |
| { |
| // Just dump out .h include statements |
| outputFile.write(text); |
| outputFile.newLine(); |
| } |
| } |
| // DEAD CODE? In AxisUserAPI.h we must keep a #ifdef WIN32/#else/#endif |
| else if (keepIfdef || ("AxisUserAPI.hpp".equals(filename) && -1 != text.indexOf("WIN32"))) |
| { |
| outputFile.write(text); |
| outputFile.newLine(); |
| if (!keepIfdef) |
| keepIfdef = true; |
| else if (-1 != text.indexOf("endif")) |
| keepIfdef = false; |
| } |
| } |
| |
| private void generateTypedef(FilePart fp, BufferedWriter outputFile) throws Exception |
| { |
| // Look to see if this is a typedef of a function pointer |
| // or a typedef of a datatype. Function pointer typedefs |
| // end with a ) before the last semicolon and do not have |
| // their typedef name at the end so don't attempt to prefix |
| // the last token with AXISC_ |
| String text = fp.toString().trim(); |
| String lasttok = null; |
| for (int i=0; i<text.length(); i++) |
| { |
| String s = "" + text.charAt(i); |
| if (!";".equals(s) && -1 == Utils.whitespace.indexOf(s)) |
| lasttok = s; |
| } |
| |
| text = changeAxisToAxisc(text); |
| text = replaceInString(text,"bool","AxiscBool",null); |
| |
| if (!")".equals(lasttok)) |
| { |
| // Put AXISC_ on to the front of the typedef name which is always at the end. |
| StringTokenizer st = new StringTokenizer(text); |
| String tok = null; |
| while (st.hasMoreTokens()) tok = st.nextToken(); |
| text = replaceInString(text,tok,"AXISC_"+tok,null); |
| } |
| |
| outputFile.write(text); |
| outputFile.newLine(); |
| } |
| |
| private void generateFunctionPrototype(FilePart fp, BufferedWriter outputFile) throws Exception |
| { |
| Signature sign = null; |
| if (FilePart.PROTOTYPE == fp.getType()) |
| { |
| PrototypePart pp = (PrototypePart) fp; |
| sign = pp.getSignature(); |
| } |
| else |
| { |
| MethodPart mp = (MethodPart) fp; |
| sign = mp.getSignature(); |
| } |
| |
| // Ignore private methods. |
| if (!sign.getScope().equals("public") && |
| !sign.getScope().equals("protected")) |
| return; |
| |
| String classname = sign.getClassName(); |
| if (null != classname && classname.endsWith("::")) |
| classname = classname.substring(0, classname.length() - 2); |
| |
| String method = sign.getMethodName(); |
| if (Configuration.methodExcluded(classname, method)) |
| return; |
| |
| Parameter[] parms = sign.getParameters(); |
| |
| String text = new String(); |
| |
| // Look to see if this method is overloaded by another method |
| // in the same class. If methods are overloaded in the same class then |
| // convert the longest method prototype to C. We should really |
| // superset the parameters in the two prototypes instead of |
| // picking the longest one. |
| List overloads = headers.getMethods(method); |
| boolean sameClass = true; |
| if (overloads.size() > 1) |
| { |
| Iterator it = overloads.iterator(); |
| while (it.hasNext()) |
| { |
| Signature s = (Signature) it.next(); |
| if (s.getTrimClassName().equals(classname)) |
| { |
| int n1 = 0; |
| int n2 = 0; |
| if (null != s.getParameters()) |
| n1 = s.getParameters().length; |
| if (null != sign.getParameters()) |
| n2 = sign.getParameters().length; |
| if (n1 > n2) |
| return; |
| } |
| } |
| } |
| |
| String classMapping = getClassMapping(classname); |
| |
| text += "AXISC_STORAGE_CLASS_INFO\n"; |
| if (sign.isConstructor()) |
| text += "AXISCHANDLE " + classMapping + "Create("; |
| else if (sign.isDestructor()) |
| { |
| text += "void " + classMapping + "Destroy(AXISCHANDLE "; |
| String prettyClass = classNamePretty(classname); |
| text += Character.toLowerCase(prettyClass.charAt(0)); |
| text += prettyClass.substring(1); |
| if (null != parms) |
| text += ", "; |
| } |
| else |
| { |
| String retType = toCType(sign.getReturnType()); |
| |
| // OS/400 C compiler has a problem with "const xsdc__string" as return type, |
| // so just replace that with "const char *" |
| if (System.getProperty("os.name").equals("OS/400")) |
| retType = retType.replaceAll("const xsdc__string","const char *"); |
| |
| text += retType + " "; |
| text += getClassMapping(classname); |
| text += Character.toUpperCase(method.charAt(0)); |
| text += method.substring(1); |
| |
| String retClass = getClassFromRetType(sign); |
| if ("AXISCHANDLE".equals(retType) && -1 == method.indexOf(retClass)) |
| text += retClass; |
| |
| text += "("; |
| |
| if (null != classname && -1 == sign.getAttributes().indexOf("static")) |
| { |
| text += "AXISCHANDLE "; |
| String prettyClass = classNamePretty(classname); |
| text += Character.toLowerCase(prettyClass.charAt(0)); |
| text += prettyClass.substring(1); |
| if (null != parms) |
| text += ", "; |
| } |
| } |
| |
| // For now, ignore operator-type methods |
| if (-1 != text.indexOf("Operator=")) |
| return; |
| |
| if (parms != null) |
| { |
| for (int i = 0; i < parms.length; i++) |
| { |
| // Do not include prototypes with va_list...since these functions have |
| // probably been added in support of C binding. |
| if (parms[i].isVaListArg()) |
| return; |
| |
| if (0 != i) |
| { |
| text += ", "; |
| // wrap long lines at 50 chars |
| if (text.length() > 50) |
| text += "\n\t"; |
| } |
| text += toCType(parms[i]) + " "; |
| String name = parms[i].getName(); |
| if (null != name) // "..." has no parm name |
| text += name; |
| } |
| } |
| text += ");"; |
| |
| outputFile.write(text); |
| outputFile.newLine(); |
| } |
| |
| private static String classNamePretty(String className) |
| { |
| if (className == null) |
| return null; |
| // namespace is a reserved word so make sure we never return namespace |
| if (className.equals("INamespace")) |
| return className; |
| if (className.startsWith("I")) |
| return className.substring(1); |
| return className; |
| } |
| |
| /** |
| * Converts a C++ datatype to a C-style datatype. |
| * References are converted to pointers. |
| * STL strings are converted to char* C-style strings |
| * String& is converted to char* (not char**) |
| * AXIS, Axis and axis are converted to AXISC, Axisc and axisc |
| */ |
| private String toCType(Parameter p) throws Exception |
| { |
| if (p.isVoid()) |
| return "void"; |
| |
| String type = new String(); |
| Iterator it = p.iterator(); |
| String prev = new String(); |
| while (it.hasNext()) |
| { |
| String tok = (String) it.next(); |
| if ("&".equals(tok)) |
| { |
| if (!"string".equals(prev)) |
| type += "*"; |
| } |
| else if ("string".equals(tok)) |
| { |
| type += "char*"; |
| prev = tok; |
| } |
| else if (headers.isClassName(tok)) |
| return "AXISCHANDLE"; |
| else if ("AnyType".equals(tok)) |
| type += "AxiscAnyType"; |
| else if ("bool".equals(tok)) |
| type += "AxiscBool"; |
| else if ("XML_String".equals(tok)) |
| type += "AXISC_XML_String"; |
| else if (tok.startsWith("xsd__")) |
| type += replaceInString(tok,"xsd__","xsdc__",null); |
| else if (-1 != tok.toLowerCase().indexOf("axis")) |
| type += changeAxisToAxisc(tok); |
| else if (!Utils.cTypeQualifiers.contains(tok) && |
| !Utils.cPrimitives.contains(tok) && |
| !tok.equals("tm") && // Leave struct tm alone |
| !tok.equals("...") && // Leave ... alone |
| !tok.equals("va_list") && // Leave ... alone |
| !tok.startsWith("xsd")) |
| type += "AXISC_"+tok; |
| else |
| type += tok; |
| |
| if (it.hasNext()) |
| type += " "; |
| } |
| return type; |
| } |
| |
| private String getClassFromRetType(Signature sign) |
| { |
| Parameter p = sign.getReturnType(); |
| if (p.isVoid()) |
| return null; |
| |
| Iterator it = p.iterator(); |
| while (it.hasNext()) |
| { |
| String tok = (String) it.next(); |
| if (headers.isClassName(tok)) |
| return classNamePretty(tok); |
| } |
| return null; |
| } |
| |
| /** |
| * Converts AXIS, axis and Axis to AXISC, axisc and Axisc. |
| * Does not convert Axisc, axisc or AXISC_ |
| */ |
| private static String changeAxisToAxisc(String text) throws Exception |
| { |
| text = replaceInString(text,"axis","axisc",null); |
| text = replaceInString(text,"Axis","Axisc","Axisc"); |
| text = replaceInString(text,"AXIS","AXISC","AXISC_"); |
| return text; |
| } |
| |
| /** |
| * Replaces from with to in text, excluding strings that start with exclude. |
| */ |
| private static String replaceInString(String text, String from, String to, String exclude) throws Exception |
| { |
| int idx = 0; |
| while (-1 != text.indexOf(from, idx)) |
| { |
| int start = text.indexOf(from, idx); |
| if (null == exclude || text.indexOf(exclude, idx) != start) |
| { |
| text = text.substring(0, start) + to + text.substring(start + from.length()); |
| idx = start + to.length(); |
| } |
| else |
| idx = start + exclude.length(); |
| } |
| return text; |
| } |
| |
| public static void main(String[] args) |
| { |
| boolean failed = false; |
| try |
| { |
| CBindingGenerator gen = new CBindingGenerator(args); |
| File source = gen.checkFile("-source"); |
| File target = gen.maybeCreateDirectory("-target"); |
| gen.headers = gen.preparseHeaders("-source"); |
| |
| DirectoryTree tree = new DirectoryTree(gen, new HashSet(Arrays.asList(new Object[] { "hpp" }))); |
| tree.walkTree(source, target, 0); |
| failed = gen.failed; |
| } |
| catch (Exception exception) |
| { |
| exception.printStackTrace(); |
| failed = true; |
| } |
| |
| if (failed) |
| { |
| Utils.outputDebugString("Finished! (but encountered problems)"); |
| System.exit(-2); |
| } |
| |
| Utils.outputDebugString("Finished!"); |
| } |
| |
| protected void printUsage() |
| { |
| System.out.println("usage: Java CBindingGenerator -config <file> -source <dir> -target <dir>"); |
| } |
| |
| } |
