diff options
| author | jsdelfino <jsdelfino@13f79535-47bb-0310-9956-ffa450edef68> | 2009-11-16 06:37:38 +0000 |
|---|---|---|
| committer | jsdelfino <jsdelfino@13f79535-47bb-0310-9956-ffa450edef68> | 2009-11-16 06:37:38 +0000 |
| commit | d36c8e323a6f8df998edd185de8972dc5e6f87f0 (patch) | |
| tree | 2a402b87f045e8066fcf7743e8654728977f6a8a /sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache | |
| parent | 034ecc7803559acdda5dd6c54ecc081665b19f61 (diff) | |
Cleaning up SVN structure, moving tag under sca-cpp/tags.
git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@880619 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache')
35 files changed, 6390 insertions, 0 deletions
diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/BodyPart.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/BodyPart.java new file mode 100644 index 0000000000..65b1e2f6fa --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/BodyPart.java @@ -0,0 +1,90 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ + +package org.apache.tuscany.sca.cpp.tools.common; + +/** + * A snippet of C or C++ source code. If this snippet ends with a return + * statement, this body part also contains the return value. + */ +public class BodyPart { + public final static int TRAILING = 0; + + public final static int RETURN = 1; + + public final static int CATCH = 2; + + private String codeFragment; + + private String returnValue = null; + + private Parameter caughtValue = null; + + private int type; + + BodyPart(String cf) { + codeFragment = cf; + type = TRAILING; + } + + BodyPart(String cf, String rv) { + codeFragment = cf; + if (null != rv && !Utils.isSpace(rv)) { + type = RETURN; + returnValue = rv; + } else + type = TRAILING; + } + + BodyPart(String cf, Parameter cv) { + codeFragment = cf; + caughtValue = cv; + type = CATCH; + } + + public String getCodeFragment() { + return codeFragment; + } + + public boolean isTrailing() { + return TRAILING == type; + } + + public boolean isReturn() { + return RETURN == type; + } + + public boolean isCatch() { + return CATCH == type; + } + + public String getReturnValue() { + if (returnValue != null) + return returnValue.trim(); + else + return null; + } + + public Parameter getCaughtValue() { + return caughtValue; + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/CParsingTool.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/CParsingTool.java new file mode 100644 index 0000000000..6846bb4096 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/CParsingTool.java @@ -0,0 +1,119 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.io.File; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; + +/** + * The superclass of tools that parse C/C++ code. This CParsingTool provides + * some useful common methods. + */ +public class CParsingTool { + protected boolean failed = false; + + protected Headers headers = new Headers(); + + protected CParsingTool(String[] args) throws Exception { + String text = new String(); + for (int i = 0; i < args.length; i++) + text += args[i] + " "; + Utils.outputDebugString(text); + + Options.set(args); + String config = (String) Options.getOption("-config"); + if (null != config) + Configuration.initialise(config); + } + + /** + * Read in any include files before the main processing of the tool is done. + * This constructs the Headers. + */ + protected Headers preparseHeaders(String option) throws Exception { + Headers headers = new Headers(); + Object o = Options.getOption(option); + if (null != o) { + Utils.outputDebugString("Pre-parsing headers..."); + List includeList; + if (o instanceof List) + includeList = (List) o; + else { + includeList = new ArrayList(); + includeList.add(o); + } + Iterator it = includeList.iterator(); + while (it.hasNext()) { + File include = new File((String) it.next()); + if (!include.isDirectory()) + Utils.rude("Bad include directory " + include); + + DirectoryTree tree = new DirectoryTree(headers, new HashSet( + Arrays.asList(new Object[] { "hpp", "h" }))); + tree.walkTree(include, null, 0); + } + Utils.outputDebugString("Parsing files..."); + } + + return headers; + } + + /** + * Checks the source directory looks good. + */ + protected File checkFile(String option) throws Exception { + String name = (String) Options.getOption(option); + if (null == name) { + printUsage(); + System.exit(-1); + } + + File file = new File(name); + if (!file.isFile() && !file.isDirectory()) + Utils.rude("Bad file or directory " + file); + return file; + } + + /** + * Checks the target directory and creates it if it doesn't already exist. + */ + protected File maybeCreateDirectory(String option) throws Exception { + String name = (String) Options.getOption(option); + if (null == name) { + printUsage(); + System.exit(-1); + } + + File file = new File(name); + if (!file.exists() && !file.mkdir()) + Utils.screenMessage("Failed to create directory " + file); + return file; + } + + protected void printUsage() { + System.out.println("usage: ??"); + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Configuration.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Configuration.java new file mode 100644 index 0000000000..1a900ff711 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Configuration.java @@ -0,0 +1,126 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +/** + * Encapsulates the tool's configuration file + */ +public class Configuration { + private static Set files = new HashSet(); + + private static Set classes = new HashSet(); + + private static Set methods = new HashSet(); + + private static Set macros = new HashSet(); + + private static Set defines = new HashSet(); + + private static Set attributes = new HashSet(); + + private static Map others = new HashMap(); + + /** + * No one creates an instance of this class. + */ + private Configuration() { + } + + /** + * Reads in the configuration file + */ + public static void initialise(String filename) throws Exception { + File file = new File(filename); + FileReader fr = new FileReader(file); + BufferedReader br = new BufferedReader(fr); + String line = br.readLine(); + for (int lineno = 1; null != line; lineno++, line = br.readLine()) { + // Ignore lines starting with a # (comments) and blank lines + if (line.startsWith("#")) + continue; + boolean blank = true; + for (int i = 0; i < line.length() && blank; i++) + if (!Character.isWhitespace(line.charAt(i))) + blank = false; + if (blank) + continue; + + int equals = line.indexOf("="); + if (-1 == equals) + Utils.rude("Bad line in configuration file " + filename + + " lineno " + lineno); + String key = line.substring(0, equals).trim(); + String value = line.substring(equals + 1).trim(); + if ("excludefile".equals(key)) { + files.add(value); + } else if ("excludeclass".equals(key)) { + classes.add(value); + } else if ("excludemethod".equals(key)) { + methods.add(value); + } else if ("macro".equals(key)) { + macros.add(value); + } else if ("define".equals(key)) { + defines.add(value); + } else if ("attribute".equals(key)) { + attributes.add(value); + } else { + others.put(key, value); + } + } + } + + public static boolean fileExcluded(String s) { + return files.contains(s); + } + + public static boolean classExcluded(String s) { + return classes.contains(s); + } + + public static boolean methodExcluded(String className, String method) { + return methods.contains(className + "::" + method); + } + + public static boolean isMacro(String s) { + return macros.contains(s); + } + + public static boolean isDefine(String s) { + return defines.contains(s); + } + + public static boolean isAttribute(String s) { + return attributes.contains(s); + } + + public static String getConfigured(String key) { + return (String) others.get(key); + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/DirectoryTree.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/DirectoryTree.java new file mode 100644 index 0000000000..a4f1ca9a21 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/DirectoryTree.java @@ -0,0 +1,100 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.io.File; +import java.util.Set; +import java.util.StringTokenizer; + +public class DirectoryTree { + private FileActor actor; + + private Set extensions; + + public DirectoryTree(FileActor actor, Set extensions) { + this.actor = actor; + this.extensions = extensions; + } + + /** + * Starts adding trace into the given file. If the given file is a directory + * then this the starting directory and all code beneath and in this + * directory will be given trace. + * + * @param source - + * either the starting directory or one file to add trace to. + */ + public void walkTree(File source, File target, int depth) throws Exception { + depth++; + boolean noTarget = (null == target); + + if (!source.canRead()) + Utils.rude("Cannot read from source directory " + source); + if (!noTarget && !target.canWrite()) + Utils.rude("Cannot write to target directory " + target); + + if (source.isDirectory()) { + File[] filesInDirectory = source.listFiles(); + for (int i = 0; i < filesInDirectory.length; i++) { + File file = filesInDirectory[i]; + String name = file.getName(); + int dot = name.lastIndexOf('.'); + String ext = null; + if (-1 != dot) + ext = name.substring(dot + 1); + + if (file.isDirectory()) { + File newTarget = null; + if (!noTarget) { + StringTokenizer st = new StringTokenizer( + file.getPath(), "\\/"); + String newdir = null; + while (st.hasMoreTokens()) + newdir = st.nextToken(); + String targetName = maybeAppendSeparator(target + .toString()); + newTarget = new File(targetName + newdir); + if (!newTarget.mkdir()) + Utils.rude("Failed to create target directory " + + newTarget); + } + + // recurse + walkTree(file, newTarget, depth); + } else if (file.isFile() + && (extensions == null || (!file.isHidden() && extensions + .contains(ext)))) { + // this is a file and we need to add trace into it ! + actor.actOnFile(file, target, depth); + } + } + } else { + actor.actOnFile(source, target, depth); + } + } + + public static String maybeAppendSeparator(String name) { + if (!name.endsWith("/") && !name.endsWith("\\")) + name += "/"; + return name; + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/FileActor.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/FileActor.java new file mode 100644 index 0000000000..fc1c8ec5c3 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/FileActor.java @@ -0,0 +1,32 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.io.File; + +/** + * DirectoryTree calls this interface to allow implementations of this interface + * to act on a file in the directory tree. + */ +public interface FileActor { + public void actOnFile(File source, File target, int depth) throws Exception; +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/FilePart.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/FilePart.java new file mode 100644 index 0000000000..e629751ea4 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/FilePart.java @@ -0,0 +1,75 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ + +package org.apache.tuscany.sca.cpp.tools.common; + +/** + * A piece of C++ source code + */ +public class FilePart { + public final static int UNKNOWN = 0; + + public final static int COMMENT = 1; + + public final static int METHOD = 2; + + public final static int FIELD = 3; + + public final static int BEGINSCOPE = 4; + + public final static int ENDSCOPE = 5; + + public final static int DIRECTIVE = 6; + + public final static int WHITESPACE = 7; + + public final static int MACRO = 8; + + public final static int CLASSATTRIBUTE = 9; + + public final static int ENUM = 10; + + public final static int PROTOTYPE = 11; + + public final static int TYPEDEF = 12; + + protected String cppsource; + + protected int type; + + FilePart(String s, int type) { + cppsource = s; + this.type = type; + } + + public int getType() { + return type; + } + + int length() { + return cppsource.length(); + } + + public String toString() { + return cppsource; + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Headers.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Headers.java new file mode 100644 index 0000000000..8deba2401d --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Headers.java @@ -0,0 +1,162 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +public class Headers implements FileActor { + private ArrayList instanceMethods = new ArrayList(); + + private ArrayList staticMethods = new ArrayList(); + + private ArrayList allMethods = new ArrayList(); + + private ArrayList classNames = new ArrayList(); + + private boolean failed = false; + + public void actOnFile(File header, File ignored, int depth) + throws Exception { + if (Configuration.fileExcluded(header.getName())) { + Utils.outputDebugString("excluding " + header + "..."); + return; + } + + Utils.outputDebugString("pre-parsing " + header + "..."); + FileReader fr = null; + try { + fr = new FileReader(header); + } catch (FileNotFoundException fnfe) { + throw fnfe; + } + BufferedReader inputFile = new BufferedReader(fr); + + try { + InputCppSourceCode code = new InputCppSourceCode(inputFile, header + .getName()); + Iterator it = code.getPartIterator(); + while (it.hasNext()) { + FilePart fp = (FilePart) (it.next()); + if (fp.getType() != FilePart.PROTOTYPE) + continue; + PrototypePart pp = (PrototypePart) fp; + String className = pp.className(); + if (null == className) + continue; + String trimClassName = className; + if (className.endsWith("::")) + trimClassName = className.substring(0, + className.length() - 2); + if (!classNames.contains(trimClassName)) + classNames.add(trimClassName); + + Signature sign = new Signature(fp.toString()); + sign.setClassName(className); + //Tuscany + sign.setScope(pp.getSignature().getScope()); + sign.setNamespace(pp.getSignature().getNamespace()); + + // "Clean" the signature by stripping off attributes, + // semicolons, etc + Signature cleaned = new Signature(sign.toStringWithoutAttrs()); + //Tuscany - problem + cleaned.setClassName(className); + cleaned.setScope(pp.getSignature().getScope()); + cleaned.setNamespace(pp.getSignature().getNamespace()); + //Tuscany - end of problem + + + if (-1 == sign.getAttributes().indexOf("static")) + instanceMethods.add(cleaned); + else + staticMethods.add(cleaned); + } + } catch (ParsingException pe) { + failed = true; + } + + inputFile.close(); + allMethods.addAll(staticMethods); + allMethods.addAll(instanceMethods); + } + + public boolean failed() { + return failed; + } + + public boolean isInstanceMethod(Signature sign) { + Iterator it = instanceMethods.iterator(); + while (it.hasNext()) { + Signature s = (Signature) it.next(); + if (s.equals(sign)) + return true; + } + return false; + } + + public boolean isStaticMethod(Signature sign) { + Iterator it = staticMethods.iterator(); + while (it.hasNext()) { + Signature s = (Signature) it.next(); + if (s.equals(sign)) + return true; + } + return false; + } + + public List getMethods(String method) { + ArrayList list = new ArrayList(); + if (null == method) + return list; + + Iterator it = allMethods.iterator(); + while (it.hasNext()) { + Signature s = (Signature) it.next(); + if (method.equals(s.getMethodName())) + list.add(s); + } + return list; + } + + /** + * Tuscany change - a method to get all the method signatures at once + */ + public List getAllMethods() { + ArrayList list = new ArrayList(); + Iterator it = allMethods.iterator(); + while (it.hasNext()) { + Signature s = (Signature) it.next(); + list.add(s); + } + return list; + } + + public boolean isClassName(String text) { + return classNames.contains(text); + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/InputCppSourceCode.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/InputCppSourceCode.java new file mode 100644 index 0000000000..ae6a646eaf --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/InputCppSourceCode.java @@ -0,0 +1,412 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.io.BufferedReader; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.StringTokenizer; + +public class InputCppSourceCode { + + private ArrayList parts = new ArrayList(); + + private String name; + + public InputCppSourceCode(BufferedReader br, String name) throws Exception { + this.name = name; + + String s = null; + StringBuffer buff = new StringBuffer(); + for (int i = 1;; i++) { + try { + s = br.readLine(); + } catch (Exception e) { + System.err.println("Ignoring exception thrown parsing file " + + name + " line number " + i); + e.printStackTrace(); + break; + } + if (s == null) + break; + buff.append(s + "\n"); + } + String str = buff.toString(); + + // TODO: When checking for rest.startsWith("struct") should + // check the next letter after struct is not alphanumeric otherwise + // we'll get false matches on a function called structify() for + // instance. Also applies to enum, union, public, typedef, etc + + String rest, text = ""; + int scopedepth = 0; + String scope = "public"; + String currentClass = null; + String currentNamespace = null; + for (int idx = 0; idx < str.length(); /* No idx++ */ + ) { + rest = str.substring(idx); + if (Character.isWhitespace(rest.charAt(0))) { + int ridx = 0; + while (ridx < rest.length() + && Character.isWhitespace(rest.charAt(ridx))) + ridx++; + text = rest.substring(0, ridx); + FilePart fp = new FilePart(text, FilePart.WHITESPACE); + parts.add(fp); + idx += ridx; + + } else if (rest.startsWith("/*")) { + int ridx = rest.indexOf("*/"); // Don't use Utils here + text = str.substring(idx, idx + ridx + 2); + FilePart fp = new FilePart(text, FilePart.COMMENT); + parts.add(fp); + idx += text.length(); + + } else if (rest.startsWith("//")) { + text = str.substring(idx, idx + rest.indexOf("\n")); + FilePart fp = new FilePart(text, FilePart.COMMENT); + parts.add(fp); + idx += text.length(); + + } else if (rest.startsWith("#")) { + int ridx = rest.indexOf("\n"); + char c = rest.charAt(ridx - 1); + while (-1 != ridx && '\\' == c) { + String rest2 = rest.substring(ridx + 1); + ridx += rest2.indexOf("\n") + 1; + c = rest.charAt(ridx - 1); + } + text = str.substring(idx, idx + ridx); + FilePart fp = new FilePart(text, FilePart.DIRECTIVE); + parts.add(fp); + idx += text.length(); + + } else if (rest.startsWith("}")) { + if (scopedepth <= 0) //Tuscany need to increase scopedepth for + // namespaces? + Utils.rude("Braces do not match", name, lineNo(str, idx), + rest.substring(0, rest.indexOf("\n"))); + else + scopedepth--; + // TODO: better checking that this brace really ends the class + if (0 == scopedepth) + currentClass = null; + scope = "public"; + parts.add(new FilePart("}", FilePart.ENDSCOPE)); + idx++; + + } else if (rest.startsWith(";")) { + parts.add(new FilePart(";", FilePart.FIELD)); + idx++; + + } else if (!Character.isLetter(rest.charAt(0)) + && '~' != rest.charAt(0) && '_' != rest.charAt(0)) { + Utils.rude("Lines must start with a letter ", name, lineNo(str, + idx), rest.substring(0, rest.indexOf("\n"))); + + } else if (MacroPart.isAMacro(rest)) { + MacroPart mp = MacroPart.create(rest); + parts.add(mp); + idx += mp.length(); + + } else if (beginsScope(rest)) { + + //Tuscany a namespace comes in here + scopedepth++; + text = rest.substring(0, Utils.indexOf(rest, "{") + 1); + FilePart fp = new FilePart(text, FilePart.BEGINSCOPE); + parts.add(fp); + idx += text.length(); + if (Utils.startsWith(text, "class")) { + // TODO: cope with comments here + // TODO: split out classes into a ClassPart + StringTokenizer st = new StringTokenizer(text, + Utils.whitespace + ":"); + st.nextToken(); // step over "class" + while (st.hasMoreTokens()) { + String word = st.nextToken(); + if (Configuration.isAttribute(word)) + continue; + currentClass = word; + break; + } + } + + //Tuscany + if (Utils.startsWith(text, "namespace")) { + // TODO: cope with comments here + StringTokenizer st = new StringTokenizer(text, + Utils.whitespace + "{"); + st.nextToken(); // step over "namespace" + String word = ""; + while (st.hasMoreTokens()) { + word = st.nextToken(); + if (word.equals("{")) { + break; + } + + } + currentNamespace = word; + //We have not got to the class yet + //so will need ot deal with the namespace + //when we do + } + // Tuscany end + + } else if (isEnumOrUnion(rest)) { + int ridx = Utils.findMatching(rest, '{', '}') + 1; + String rest2 = rest.substring(ridx); + ridx = idx + ridx + Utils.indexOf(rest2, ';') + 1; + text = str.substring(idx, ridx); + FilePart fp = new FilePart(text, FilePart.ENUM); + parts.add(fp); + idx += text.length(); + + } else if (scopedepth > 0 + && (rest.startsWith("public") + || rest.startsWith("protected") || rest + .startsWith("private"))) { + int colon = rest.indexOf(":"); + if (-1 == colon) + Utils.rude("No colon found after public or private ", name, + lineNo(str, idx), rest.substring(0, rest + .indexOf("\n"))); + scope = str.substring(idx, idx + colon); + text = str.substring(idx, idx + colon + 1); + FilePart fp = new FilePart(text, FilePart.CLASSATTRIBUTE); + parts.add(fp); + idx += text.length(); + + } else if (Utils.startsWith(rest, "typedef")) { + int semicolon = Utils.indexOf(rest, ';'); + int brace = Utils.indexOf(rest, '{'); + + if (-1 == semicolon) + Utils.rude("No semicolon found after typedef", name, + lineNo(str, idx), rest.substring(0, rest + .indexOf("\n"))); + + if (-1 == brace || semicolon < brace) { + // Simple typedef + text = str.substring(idx, idx + semicolon + 1); + } else { + // Typedef of a struct, etc + int endbrace = Utils.findMatching(rest, '{', '}'); + String rest2 = rest.substring(endbrace); + semicolon = Utils.indexOf(rest2, ';'); + text = str.substring(idx, idx + endbrace + semicolon + 1); + } + FilePart fp = new FilePart(text, FilePart.TYPEDEF); + parts.add(fp); + idx += text.length(); + + } else { + if (isMethod(rest)) { + + int brace = Utils.indexOf(rest, '{'); + Signature signature = new Signature(str.substring(idx, idx + + brace)); + if (signature.failed()) + Utils.rude("Signature parsing failed", name, lineNo( + str, idx), signature.getOriginal()); + if (null != currentClass + && null == signature.getClassName()) + signature.setClassName(currentClass); + signature.setScope(scope); + signature.setNamespace(currentNamespace); + + String body = rest.substring(brace); + int endBrace = Utils.findMatching(body, '{', '}'); + body = body.substring(0, endBrace + 1); + int endIdx = idx + signature.originalLength() + + body.length(); + text = str.substring(idx, endIdx); + MethodPart mp = new MethodPart(text, signature, body); + parts.add(mp); + idx += text.length(); + + } else if (isField(rest)) { + int semicolon = Utils.indexOf(rest, ';'); + text = str.substring(idx, idx + semicolon + 1); + FilePart fp = new FilePart(text, FilePart.FIELD); + parts.add(fp); + idx += text.length(); + + } else if (isPrototype(rest)) { + int semicolon = Utils.indexOf(rest, ';'); + text = str.substring(idx, idx + semicolon + 1); + PrototypePart pp = new PrototypePart(text, currentClass, currentNamespace); + pp.setScope(scope); + parts.add(pp); + idx += text.length(); + + } else { + //TODO other file parts here - not sure if there are any + // others? + Utils.rude("Unrecognised file part", name, + lineNo(str, idx), rest.substring(0, rest + .indexOf("\n"))); + } // end if + } // end if + } // end for + } + + public Iterator getPartIterator() { + return parts.iterator(); + } + + private int lineNo(String s, int idx) { + int n = 0; + for (int i = 0; i < idx && i < s.length(); i++) + if ('\n' == s.charAt(i)) + n++; + return n; + } + + /** + * Find out whether we are defining a class, struct or extern "C" which may + * contain function implementations. These will have braces which begin a + * new scope. Ignore function prototypes that return a struct. struct mystr { + * int f1; }; struct mystr func(); struct mystr func() { struct mystr a; + * return a; } + */ + private static boolean beginsScope(String s) throws ParsingException { + if (isMethod(s)) + return false; + + int brace = Utils.indexOf(s, '{'); + int semicolon = Utils.indexOf(s, ';'); + + // Return false for class prototypes, but true for class definitions. + if (Utils.startsWith(s, "class")) { + if (-1 == brace) + return false; + if (-1 == semicolon) + return true; + return brace < semicolon; + } + + if (Utils.startsWith(s, "struct")) { + if (-1 == brace || -1 == semicolon) + return false; + return brace < semicolon; + } + + //Tuscany handle namespace for prototypes + //in a similar way to "class" + if (Utils.startsWith(s, "namespace")) { + if (-1 == brace || -1 == semicolon) + return false; + return brace < semicolon; + } + + return startsWithExternScope(s); + } + + /** + * There are 4 types of extern ... extern int field; extern int func(); + * extern "C" int func() { return 2; } extern "C" { int func() { return 2; } } + * This method should return true only for the last of these three examples + * since only the last one creates a new scope using braces. + */ + private static boolean startsWithExternScope(String s) + throws ParsingException { + if (!s.startsWith("extern")) + return false; + + int brace = Utils.indexOf(s, '{'); + int semicolon = Utils.indexOf(s, ';'); + int bracket = Utils.indexOf(s, '('); + + if (-1 == brace) + return false; + return (-1 == semicolon || brace < semicolon) + && (-1 == bracket || brace < bracket); + } + + /** + * Find out whether we are defining an enum or union which will contain + * braces. Ignore function prototypes that return an enum or union. enum + * colour { red, blue }; enum colour func(); enum colour func() { return + * colour.red; } + */ + private static boolean isEnumOrUnion(String s) throws ParsingException { + if ((!Utils.startsWith(s, "enum") && !Utils.startsWith(s, "union")) + || isMethod(s)) + return false; + + int brace = Utils.indexOf(s, '{'); + int semicolon = Utils.indexOf(s, ';'); + return -1 != brace && (-1 == semicolon || brace < semicolon); + } + + /** + * Rules to recognise fields and methods... + * + * Fields must contain a semicolon Methods may or may not contain a + * semicolon Prototypes must contain a semicolon Fields may or may not + * contain a brace (array initialisers do) Methods must contain a brace + * Prototypes must not contain a brace Fields may or may not contain a + * bracket (casts do) Methods must contain a bracket Prototypes must contain + * a bracket + * + * It's a method if it contains a bracket and then a brace before the first + * semicolon (if there is a semicolon). It's a prototype if it's not a + * method and it contains brackets before a semicolon. It's a field if it's + * not a method or a prototype and it contains a semicolon. If it's not a + * field, a method or a prototype and we haven't recognised it previously + * then it's an error. + */ + private static boolean isMethod(String s) throws ParsingException { + int semicolon = Utils.indexOf(s, ';'); + int brace = Utils.indexOf(s, '{'); + int bracket = Utils.indexOf(s, '('); + + return (-1 != bracket && -1 != brace && bracket < brace && (-1 == semicolon || brace < semicolon)); + } + + private static boolean isPrototype(String s) throws ParsingException { + int semicolon = Utils.indexOf(s, ';'); + int bracket = Utils.indexOf(s, '('); + return !isMethod(s) && -1 != semicolon && -1 != bracket + && bracket < semicolon; + } + + private static boolean isField(String s) throws ParsingException { + int semicolon = Utils.indexOf(s, ';'); + return !isMethod(s) && !isPrototype(s) && -1 != semicolon; + } + + public String getName() { + return name; + } + + public String toString() { + StringBuffer text = new StringBuffer(); + for (int i = 0; i < parts.size(); i++) { + text.append(((FilePart) (parts.get(i))).toString()); + } + return text.toString(); + } + +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/MacroPart.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/MacroPart.java new file mode 100644 index 0000000000..813de0ff56 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/MacroPart.java @@ -0,0 +1,82 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ + +/* + * A C or C++ macro as it is used in the source code + */ +package org.apache.tuscany.sca.cpp.tools.common; + +class MacroPart extends FilePart { + /** + * Factory method to create a MacroPart. + * + * @param s + * unparsed source code which may start with a define or macro. + */ + static MacroPart create(String s) { + String orig = getOriginalText(s); + if (null == orig) + return null; + return new MacroPart(orig); + } + + MacroPart(String s) { + super(s, FilePart.MACRO); + } + + /** + * @param s + * unparsed source code which may start with a define or macro. + * @return all of s up to the end of the define or macro. + */ + private static String getOriginalText(String s) { + String name = getName(s); + int len = name.length(); + if (null == name) + return null; + else if (Configuration.isDefine(name)) { + return s.substring(0, len); + } else if (Configuration.isMacro(name)) { + String rest = s.substring(len); + len += Utils.findMatching(rest, '(', ')'); + return s.substring(0, len + 1); + } else + return null; + } + + static boolean isAMacro(String s) { + if (s == null || 0 == s.length()) + return false; + String name = getName(s); + return Configuration.isMacro(name) || Configuration.isDefine(name); + } + + private static String getName(String s) { + int i; + for (i = 0; i < s.length(); i++) + if (!Character.isLetterOrDigit(s.charAt(i)) && '_' != s.charAt(i)) + break; + if (s.length() == i) + return null; + return s.substring(0, i); + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/MethodPart.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/MethodPart.java new file mode 100644 index 0000000000..facebe84ef --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/MethodPart.java @@ -0,0 +1,128 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.util.ArrayList; + +/** + * A C or C++ method from a piece of source code. The method has a signature and + * a body (the bit between the braces). + */ +public class MethodPart extends FilePart { + private Signature signature; + + private String body; + + MethodPart(String s, Signature signature, String body) { + super(s, METHOD); + this.signature = signature; + this.body = body; + } + + public Signature getSignature() { + return signature; + } + + public String getOriginalSignature() { + return signature.getOriginal(); + } + + /** + * Returns the method body as code snippets, each ending with a place where + * a trace statement belongs. The end of the first code snippet is where the + * entry trace should go. The end of every other snippet is a return from + * the method. + */ + public BodyPart[] getBodyParts() throws ParsingException { + String b = body; // Don't alter field member + if (b.startsWith("{")) + b = b.substring(1); + + // Add in trace exit at all the return statements in the method. + ArrayList al = new ArrayList(); + int idxR = Utils.indexOf(b, "return"); + int idxC = Utils.indexOf(b, "catch"); + while (-1 != idxR || -1 != idxC) { + if (-1 == idxC || (-1 != idxR && idxR < idxC)) { + String frag = b.substring(0, idxR); + String rest = b.substring(idxR + "return".length()); + + int semicolon = Utils.indexOf(rest, ';'); + if (-1 == semicolon) + Utils.rude("Missing semicolon in " + signature); + String retVal = rest.substring(0, semicolon); + BodyPart bp = new BodyPart(frag, retVal); + al.add(bp); + b = b.substring(idxR + "return".length() + retVal.length() + 1); + } else { + String frag = b.substring(0, idxC); + String rest = b.substring(idxC); + + int brace = Utils.indexOf(rest, "{"); + if (-1 == brace) + Utils.rude("Missing open brace in " + signature); + Signature signature = new Signature(rest.substring(0, brace)); + frag = frag + rest.substring(0, brace + 1); + BodyPart bp = new BodyPart(frag, signature.getParameters()[0]); + al.add(bp); + b = rest.substring(brace + 1); + } + idxR = Utils.indexOf(b, "return"); + idxC = Utils.indexOf(b, "catch"); + } + + // Add in trace exit before the last } if there are no returns in + // the method or there is code after the last return and the method + // returns void. + // int f1(){try{return f2();}catch(Exception& e){throw;}} + // has code after the last return but having a traceexit before the + // last brace wouldn't compile since the method returns an int. We + // cope with this by only adding in a traceexit before the last brace + // if the method returns void. That may mean we add in an unreachable + // traceexit which may give a compiler warning, but that should be + // benign. + // + // TODO: Not quite good enough for + // void f(int a){if(a){printf("a");}else{printf("!a");return;}} + // as a trace exit is needed before the last } in case a>0 but + // void f(int a){if(a){printf("a");return;}else{printf("!a");return;}} + // would give compiler warnings about unreachable code if a trace + // exit is added before the last brace. This could be tricky to fix. + if ((0 == al.size() || -1 != Utils.indexOf(b, ';')) + && null == signature.getReturnType().getType()) { + + int last = b.lastIndexOf('}'); + if (-1 == last) + Utils.rude("Missing end brace in " + signature); + String b2 = b.substring(0, last); + al.add(new BodyPart(b2)); + b = b.substring(last); + } + + // The final body part is the last } + al.add(new BodyPart(b)); + + BodyPart[] bps = new BodyPart[al.size()]; + System.arraycopy(al.toArray(), 0, bps, 0, al.size()); + return bps; + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Options.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Options.java new file mode 100644 index 0000000000..dc9d941849 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Options.java @@ -0,0 +1,159 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + * + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +/** + * Command line options passed to a tool's main program. All command line + * options should begin with a dash "-". Some command line options take a value + * which is the next parameter after the option. Others do not. + */ +public class Options { + static HashMap pairs = new HashMap(); + + static List values = new ArrayList(); + + /** + * No one constructs this class. + */ + private Options() { + } + + public static void reset() { + pairs = new HashMap(); + values = new ArrayList(); + } + + /** + * Initialises the options based on the args passed to main + */ + public static void set(String args[]) { + for (int i = 0; i < args.length; i++) { + if (args[i].startsWith("-")) { + if ((i + 1 <= args.length - 1) && // next one is testable + !args[i + 1].startsWith("-") // and it starts with a "-" + ) { + String key = args[i]; + Object pairValue = pairs.get(key); + if (null == pairValue) { + pairs.put(args[i], args[i + 1]); + } else if (pairValue instanceof String) { + List l = new ArrayList(); + l.add(pairValue); + l.add(args[i + 1]); + pairs.put(key, l); + } else if (pairValue instanceof List) { + ((List) pairValue).add(args[i + 1]); + } + i++; // Step over value for this key + } else + values.add(args[i]); + } + } + } + + public static Object getOption(String key) { + return pairs.get(key); + } + + static boolean isOptionSet(String key) { + return values.contains(key) || null!=pairs.get(key); + } + + /** + * This option will cause scagen to print out messages + * about the artefacts it is processing + * @return + */ + public static boolean verbose() { + return isOptionSet("-verbose"); + } + + /** + * This option will cause scagen to print out some + * basic internal log type messages + * @return + */ + public static boolean debug() { + return isOptionSet("-debug"); + } + + /** + * This option will cause scagen to print out some + * text that can be used or pasted into a command + * file to copy all the relevant artefacts from + * where they are found or generated to a specific + * deployment location + * + * @return + */ + public static boolean deploy() { + return isOptionSet("-deploy"); + } + + /** + * This option will prevent scagen from actually writing out + * the generated files. It is useful if used in conjunction + * with the "-deploy" option. + * @return + */ + public static boolean noGenerate() { + return isOptionSet("-nogenerate"); + } + + /** + * This option is useful only when used in conjunction with + * the "-deploy" option. It changes the output to be more like the + * source code of a command script to copy the files to a + * specific place. + * @return + */ + public static boolean outputCommand() { + return isOptionSet("-outputCommand"); + } + + /** + * This option is useful only when used in conjunction with + * the "-deploy" option. It changes the output to be a simple + * list of artefacts. It has no effect if the "-outputCommand" + * option is set. + * + * @return + */ + public static boolean list() { + return isOptionSet("-list"); + } + + /** + * This option is maintained for compatibility with the + * original package source. It is not used by new scagen code. + * + * @return + */ + public static boolean quiet() { + return isOptionSet("-quiet"); + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Parameter.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Parameter.java new file mode 100644 index 0000000000..3f4b3e971e --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Parameter.java @@ -0,0 +1,211 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + * + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +/** + * A parameter from a method signature. The parameter is the datatype plus its + * name but not its value. + */ +public class Parameter { + private ArrayList type = new ArrayList(); + + private String name = null; + + private boolean failed = false; + + /** + * Defaults to a parameter in a parameter list so it HAS a parameter name in + * it + */ + Parameter(List parts) { + this(parts, false); + } + + /** + * A parameter which is a return type does not have a parameter name. + * Parameters in a parameter list do have parameter names embedded in them + */ + Parameter(List parts, boolean isRetType) { + if (parts == null || parts.size() == 0) + return; + + // Tuscany: The original code below from apache axis blocks int + // getCustomer(long) + // i.e. no spaces in parameter list. + // We do not need to deal with "..." as parameters to SCS methods. + // + // if (!isRetType && parts.size() == 1) { + // if ("...".equals(parts.get(0))) { + // type.add("..."); + // name = ""; + // } else if (!"void".equals(parts.get(0))) + // failed = true; // Seems like bad C++ code here + // return; + // } + + if (isRetType) { + Iterator it = parts.iterator(); + while (it.hasNext()) + type.add(it.next()); + + // Some methods return have void on their signature and others + // have nothing. So to make them both the same, if a method + // doesn't return anything make type null. + // TODO: This assumption is wrong - methods that return nothing + // default to returning an int! + if (1 == type.size() && "void".equals(type.get(0))) + type = new ArrayList(); + + } else { + // Cope with array subscripts [] after the name + int arrIdx = -1; + for (int i = 0; i < parts.size(); i++) { + String tok = (String) parts.get(i); + if ("[".equals(tok)) { + arrIdx = i; + break; + } + } + + // Find the name + int nameIdx = parts.size() - 1; + if (-1 != arrIdx) + nameIdx = arrIdx - 1; + + // Even in real method declarations, parameters may not have a name + boolean noName = false; + name = (String) parts.get(nameIdx); + // Tuscany: The original code below from apache axis + // was updated to work with signatures of + // the form fn(int) a non-named, no-space, parameter list. + // if (Utils.cPrimitives.contains(name) || + // Utils.cTypeQualifiers.contains(name) ) + // + if (Utils.cPrimitives.contains(name) + || Utils.cTypeQualifiers.contains(name) + || parts.size() == 1) + noName = true; + + if (noName) { + name = null; + for (int i = 0; i < parts.size(); i++) + type.add(parts.get(i)); + } else { + // Construct the type + for (int i = 0; i < nameIdx; i++) + type.add(parts.get(i)); + + if (-1 != arrIdx) + for (int i = arrIdx; i < parts.size(); i++) + type.add(parts.get(i)); + } + } + } + + public boolean failed() { + return failed; + } + + public String getType() { + String s = null; + Iterator it = type.iterator(); + while (it.hasNext()) { + String next = (String) it.next(); + if (null == s) + s = next; + else if ("*".equals(next) || "&".equals(next)) + s += next; + else + s += " " + next; + } + return s; + } + + public String getTypeWithoutConst() { + String s = null; + Iterator it = type.iterator(); + while (it.hasNext()) { + String next = (String) it.next(); + if ("const".equals(next)) + continue; + else if (null == s) + s = next; + else if ("*".equals(next) || "&".equals(next)) + s += next; + else + s += " " + next; + } + return s; + } + + public String getName() { + return name; + } + + public boolean isVoid() { + return 0 == type.size(); + } + + public boolean isDotDotDot() { + return 1 == type.size() && "...".equals(type.get(0)); + } + + /** + * For two parameters to match their types must match or both be null, but + * the parameters names don't have to match. Just because a parameter is + * called something different in a header file as in the the source file + * doesn't mean it's a different parameter. + */ + public boolean equals(Object o) { + if (null == o || !(o instanceof Parameter)) + return false; + Parameter that = (Parameter) o; + if (type.size() != that.type.size()) + return false; + for (int i = 0; i < type.size(); i++) { + String s1 = (String) type.get(i); + String s2 = (String) that.type.get(i); + if (!Utils.safeEquals(s1, s2)) + return false; + } + return true; + } + + public String toString() { + if (0 == type.size()) + return "void"; + if (null == name) + return getType(); + return getType() + " " + name; + } + + public Iterator iterator() { + if (null == type) + return null; + return type.iterator(); + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/ParsingException.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/ParsingException.java new file mode 100644 index 0000000000..3f140c0f9f --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/ParsingException.java @@ -0,0 +1,42 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + * + */ +package org.apache.tuscany.sca.cpp.tools.common; + +public class ParsingException extends Exception { + + public ParsingException() { + super(); + } + + public ParsingException(String message) { + super(message); + } + + public ParsingException(String message, Throwable cause) { + super(message, cause); + } + + public ParsingException(Throwable cause) { + super(cause); + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/PrototypePart.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/PrototypePart.java new file mode 100644 index 0000000000..64ed2e9542 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/PrototypePart.java @@ -0,0 +1,51 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + * + */ +package org.apache.tuscany.sca.cpp.tools.common; + +/** + * A function prototype in an include file and possibly in a class definition. + */ +public class PrototypePart extends FilePart { + private Signature signature; + + public PrototypePart(String s, String className, String namespace) { + super(s, PROTOTYPE); + signature = new Signature(s); + if (null != className) + signature.setClassName(className); + if (null != namespace && namespace.length()>0) + signature.setNamespace(namespace); + } + + String className() { + return signature.getClassName(); + } + + public Signature getSignature() { + return signature; + } + + public void setScope(String scope) { + signature.setScope(scope); + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Signature.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Signature.java new file mode 100644 index 0000000000..3650839cab --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Signature.java @@ -0,0 +1,501 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +/* + * Branched from the original class that was also contributed to the + * org.apache.axis.tools.common package. + * + */ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +/** + * A C or C++ method signature with the ability to parse it. TODO: properly + * support variable length argument lists using "..." TODO: passing or returning + * function pointers (hopefully not needed) TODO: Cope with ~ <space>Classname() + */ +public class Signature { + private String originalText; + + private String attributes; + + private String className = null; + + private String namespace = null; + + private String methodName = null; + + private Parameter returnType = null; + + private Parameter[] params = null; + + private String trailingAttributes; + + private String scope = "public"; + + private boolean failed = false; + + private boolean traceable = true; + + private final static Set knownAttrs = new HashSet(Arrays + .asList(new Object[] { "public", "private", "extern", "\"C\"", + "virtual", "static", "inline" })); + + private final static Set specialOperators = new HashSet( + Arrays.asList(new Object[] { "(", ")", "*", ",", "&", "]", "[", + "=", "~" })); + + /** + * Takes an unparsed signature string and parses it. + * + * TODO: Should optionally pass in the className here in case it's an inline + * method implementation inside the class{}. Just so the className comes out + * in the trace. + */ + Signature(String s) { + originalText = s; + + try { + List tokens = tokenise(s); + + ArrayList alAttrs = new ArrayList(); + ArrayList alName = new ArrayList(); + ArrayList alParms = new ArrayList(); + ArrayList alTrailAttrs = new ArrayList(); + ArrayList alInits = new ArrayList(); + if (!splitUp(tokens, alAttrs, alName, alParms, alTrailAttrs, + alInits)) { + failed = true; + return; + } + + parseAttributes(alAttrs); + parseNameAndRetType(alName); + parseParameters(alParms); + parseTrailingAttributes(alTrailAttrs); + + // Ignore any tokens after the ) since these are (hopefully) + // constructor initialisers + + traceable = !Configuration.methodExcluded(className, methodName); + } catch (NullPointerException npe) { + failed = true; + traceable = false; + } + } + + /** + * Parse the signature into tokens. This removes whitespace and comments and + * separates out "*", ",", "(", ")", "&", "[" and "]". + */ + private static List tokenise(String s) { + ArrayList tokens = new ArrayList(); + String tok = null; + boolean space = true; + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + if (Character.isWhitespace(c)) { + space = true; + continue; + } + if (space) { + if (tok != null) + tokens.add(tok); + tok = "" + c; + } else + tok += c; + space = false; + + if (tok.endsWith("/*")) { + String sub = s.substring(i); + int endcomm = sub.indexOf("*/"); + if (endcomm == -1) + break; + i += endcomm + 1; + if (tok.equals("/*")) + tok = ""; + else + tok = tok.substring(0, tok.length() - 2); + continue; + } + + if (tok.endsWith("//")) { + String sub = s.substring(i); + int endcomm = sub.indexOf("\n"); + if (endcomm == -1) + break; + i += endcomm; + if (tok.equals("//")) + tok = ""; + else + tok = tok.substring(0, tok.length() - 1); + continue; + } + + if (tok.endsWith("::")) + space = true; + + String sc = "" + c; + if (specialOperators.contains(sc)) { + if (!tok.equals(sc)) { + tokens.add(tok.substring(0, tok.length() - 1)); + tok = sc; + } + space = true; + } + } + tokens.add(tok); + return tokens; + } + + /** + * Split up a tokenised method signature into a list of attributes, a list + * of name and return type tokens, a list of parameter tokens and a list of + * initialiser tokens. + */ + private static boolean splitUp(List tokens, List attrs, List nameAndRet, + List parms, List trailAttrs, List inits) { + + // nameStart points to the start of the return type if there is one + // else the start of the method name + int nameStart; + for (nameStart = 0; nameStart < tokens.size(); nameStart++) { + String tok = (String) (tokens.get(nameStart)); + if (!knownAttrs.contains(tok) && !Configuration.isAttribute(tok)) + break; + } + if (nameStart == tokens.size()) + return false; + + // initStart points to the initialisers, or thrown exceptions after + // the parameter list. throw is a keyword so we can safely search for + // it. + int initStart = tokens.size(); + for (int i = nameStart; i < tokens.size(); i++) { + String tok = (String) tokens.get(i); + if ((tok.startsWith(":") && !tok.startsWith("::")) + || "throw".equals(tok)) + initStart = i; + } + + int parmEnd; + for (parmEnd = initStart - 1; parmEnd > nameStart; parmEnd--) + if (")".equals(tokens.get(parmEnd))) + break; + if (parmEnd == nameStart) + return false; + + int parmStart = parmEnd; + for (parmStart = parmEnd; parmStart > nameStart; parmStart--) + if ("(".equals(tokens.get(parmStart))) + break; + + for (int i = 0; i < tokens.size(); i++) { + Object tok = tokens.get(i); + if (i < nameStart || Configuration.isAttribute((String) tok)) + attrs.add(tok); + else if (i < parmStart) + nameAndRet.add(tok); + else if (i <= parmEnd) + parms.add(tok); + else if (i < initStart) + trailAttrs.add(tok); + else + inits.add(tok); + } + return true; + } + + private void parseAttributes(List list) { + attributes = new String(); + Iterator it = list.iterator(); + while (it.hasNext()) { + if (attributes.length() > 0) + attributes += " "; + String next = (String) it.next(); + + //Tuscancy + //the scope is not present in the attributes + //but is set later in the InputCppSource contructor + if ("public".equals(next) || "protected".equals(next) + || "private".equals(next)) + scope = next; + attributes += next; + } + } + + private void parseNameAndRetType(List list) { + int size = list.size(); + int idx; + // "operator" is a key word so if it's present we know we're + // dealing with operator overloading. The operator that's been + // overloaded might have been split up into multiple tokens. + for (idx = 0; idx < size; idx++) + if ("operator".equals(list.get(idx))) + break; + + if (idx < size) { + methodName = ""; + for (int i = idx; i < size; i++) + methodName += (String) list.get(i); + } else { // No operator overloading + methodName = "" + list.get(size - 1); + idx = size - 1; + } + + // If it's a destructor, the "~" will be split out into a separate + // token, so add it onto the methodName here. + if (idx > 0 && "~".equals(list.get(idx - 1))) { + methodName = "~" + methodName; + idx--; + } + + // The class name comes before the method name + while (idx > 0 && ((String) list.get(idx - 1)).endsWith("::")) { + if (null == className) + className = (String) list.get(idx - 1); + else + className = (String) list.get(idx - 1) + className; + idx--; + } + + // Whatever's left before the classname/methodname must be the + // return type + ArrayList retParm = new ArrayList(); + for (int i = 0; i < idx; i++) + retParm.add(list.get(i)); + + returnType = new Parameter(retParm, true); + } + + /** + * Constructs the parameter list + */ + private void parseParameters(List list) { + ArrayList alParams = new ArrayList(); + Iterator it = list.iterator(); + String token = (String) it.next(); // step over the ( + while (it.hasNext() && !")".equals(token)) { + token = (String) it.next(); + + int template = 0; // Depth of template scope + boolean foundEquals = false; + // Ignore default value for an optional parameter + ArrayList parm = new ArrayList(); + while (!token.equals(")") && (!token.equals(",") || template > 0)) { + if (token.equals("=")) + foundEquals = true; + if (!foundEquals) + parm.add(token); + if (contains(token, "<")) + template++; + if (contains(token, ">")) + template--; + token = (String) it.next(); + } + + // No parameters so break out + if (token.equals(")") && 0 == parm.size()) + break; + + Parameter p = new Parameter(parm); + if (p.failed()) { + failed = true; + return; + } + + // Copes with void func(void) + if (!p.isVoid()) + alParams.add(p); + } + + int size = alParams.size(); + if (size > 0) { + params = new Parameter[size]; + System.arraycopy(alParams.toArray(), 0, params, 0, size); + } + } + + private void parseTrailingAttributes(List list) { + trailingAttributes = new String(); + Iterator it = list.iterator(); + while (it.hasNext()) { + if (trailingAttributes.length() > 0) + trailingAttributes += " "; + trailingAttributes += (String) it.next(); + } + } + + public String getOriginal() { + return originalText; + } + + public int originalLength() { + return originalText.length(); + } + + public boolean failed() { + return failed; + } + + public String getAttributes() { + return attributes; + } + + public String getClassName() { + return className; + } + + /** + * @param namespace The namespace to set. + */ + public void setNamespace(String namespace) { + this.namespace = namespace; + } + + /** + * @return Returns the namespace. + */ + public String getNamespace() { + return namespace; + } + + public String getTrimClassName() { + return trimClassName(className); + } + + public String getMethodName() { + return methodName; + } + + public Parameter getReturnType() { + return returnType; + } + + public Parameter[] getParameters() { + return params; + } + + public boolean isConstructor() { + return className != null && methodName != null + && trimClassName(className).equals(methodName); + } + + public boolean isDestructor() { + return className != null && methodName != null + && methodName.startsWith("~") + && methodName.endsWith(trimClassName(className)); + } + + private static String trimClassName(String name) { + if (name.endsWith("::")) + return name.substring(0, name.length() - 2); + return name; + } + + void setClassName(String className) { + if (null == className) + return; + if (!className.endsWith("::")) + className += "::"; + this.className = className; + } + + public String getScope() { + return scope; + } + + /** + * Sets the scope, but only if the scope is not set by an explicit attribute + * in the signature. + */ + public void setScope(String scope) { + if (-1 == attributes.indexOf(this.scope)) + this.scope = scope; + } + + /** + * Should this method be traced? + */ + public boolean traceable() { + return traceable; + } + + private static boolean contains(String src, String tgt) { + if (src == null || tgt == null) + return false; + if (-1 == src.indexOf(tgt)) + return false; + return true; + } + + public boolean equals(Object obj) { + if (null == obj || !(obj instanceof Signature)) + return false; + Signature that = (Signature) obj; + if (!Utils.safeEquals(className, that.className)) + return false; + if (!Utils.safeEquals(methodName, that.methodName)) + return false; + if (!Utils.safeEquals(returnType, that.returnType)) + return false; + if (null == params && null == that.params) + return true; + if (null != params && null == that.params) + return false; + if (null == params && null != that.params) + return false; + if (params.length != that.params.length) + return false; + for (int i = 0; i < params.length; i++) + if (!Utils.safeEquals(params[i], that.params[i])) + return false; + return true; + } + + public String toStringWithoutAttrs() { + String s = new String(); + if (returnType != null) + s += returnType + " "; + if (className != null) + s += className; + s += methodName + "("; + for (int i = 0; params != null && i < params.length; i++) { + if (i > 0) + s += ", "; + s += params[i].toString(); + } + s += ")"; + return s; + } + + public String toString() { + String s = attributes; + if (attributes.length() > 0) + s += " "; + s += toStringWithoutAttrs(); + if (trailingAttributes.length() > 0) + s += " " + trailingAttributes; + return s; + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Utils.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Utils.java new file mode 100644 index 0000000000..5bd80fc37a --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/Utils.java @@ -0,0 +1,543 @@ +/* +* +* Copyright 2005 The Apache Software Foundation or its licensors, as applicable. +* +* 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. +*/ + +/* +* Branched from the original class that was also contributed to the +* org.apache.axis.tools.common package. +* +*/ +package org.apache.tuscany.sca.cpp.tools.common; + +import java.io.File; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +//Apache Common Logging +//import org.apache.commons.logging.Log; +//import org.apache.commons.logging.LogFactory; + +/** +* Static utility methods. Some of these methods are similar to the methods on +* java.lang.String except they are aware of C/C++ comments and string literals. +* +* TODO: Many of these methods would perform better using StringBuffer not +* String +*/ +public final class Utils { + // All the C primitive data types + public final static Set cPrimitives = new HashSet(Arrays + .asList(new Object[] { "void", "byte", "char", "unsigned", + "signed", "int", "short", "long", "double", "float", + "struct", "class", "enum", "union" })); + + // All the qualifiers that can affect C types + public final static Set cTypeQualifiers = new HashSet( + Arrays.asList(new Object[] { "(", ")", "*", ",", "&", "]", "[", + "const" })); + + public final static String whitespace = " \t\r\n"; + + //private static Log log = LogFactory.getLog(CLASS.class); + + /** + * Never instantiate this class + */ + private Utils() { + } + + /** + * Is this string all whitespace? + */ + static boolean isSpace(String s) { + for (int i = 0; i < s.length(); i++) + if (!Character.isWhitespace(s.charAt(i))) + return false; + return true; + } + + // TODO look for other trailing chars like { (because of class{) + static boolean startsWith(String source, String target) { + if (source == null || target == null) + return false; + if (!source.startsWith(target)) + return false; + if (source.length() == target.length()) + return true; + if (Character.isWhitespace(source.charAt(target.length()))) + return true; + return false; + } + + /** + * Performs a C-aware version of String.indexOf(char) in that it skips + * characters in string literals and comments. + */ + static int indexOf(String s, char c) throws ParsingException { + if ('"' == c) + rude("Utils.indexOf cannot be passed quotes"); + + for (int i = 0; i < s.length(); i++) { + if (s.charAt(i) == c) + return i; + + i = skip(s.substring(i), i); + if (-1 == i) + return -1; + } + return -1; + } + + /** + * Performs a C-aware version of String.indexOf(String) in that it skips + * characters in string literals and comments and makes sure that the target + * string is not embedded in a longer word. + */ + static int indexOf(String s, String t) { + char t0 = t.charAt(0); + for (int i = 0; i < s.length(); i++) { + if (s.charAt(i) == t0 + && s.substring(i).startsWith(t) + && (0 == i || !Character.isLetterOrDigit(s.charAt(i - 1))) + && (s.length() == (i + t.length()) || !Character + .isLetterOrDigit(s.charAt(i + t.length())))) + return i; + + i = skip(s.substring(i), i); + if (-1 == i) + return -1; + } + return -1; + } + + /** + * Matches braces or quotes and is C-aware. It skips characters in string + * literals and comments. + */ + static int findMatching(String s, char c1, char c2) { + int depth = 0; + for (int i = 0; i < s.length(); i++) { + if (s.charAt(i) == c1) + depth++; + else if (s.charAt(i) == c2) { + depth--; + if (depth == 0) + return i; + } else { + i = skip(s.substring(i), i); + if (-1 == i) + return -1; + } + } + return -1; + } + + /** + * Failed to parse the source code for some reason. This method prints out a + * suitably rude message, and then what? I haven't quite decided yet. + * + * TODO: Do something sensible here like throw an Exception which will give + * up on this file completely and tidy up the output file. It may be just + * too dangerous to try to carry on. But we need to fail in such a way that + * the build system knows that we've failed for this file and can build this + * file without trace. + */ + public static void rude(String reason, String filename, int lineno, + String codefragment) throws ParsingException { + + String text = "Bad C++ code!! "; + if (reason != null) + text += reason; + if (filename != null) + text += " " + filename + " lineno=" + lineno; + if (codefragment != null) + text += " <" + codefragment + ">"; + System.err.println(text); + throw new ParsingException(); + } + + /** + * This method reports an error level problem + * + * @param reason + * why we have an error level problem + */ + public static void rude(String reason) throws ParsingException { + // Apache commons logging + // log.error(Object line, null); + // or for now.... + rude(reason, null, 0, null); + } + + /** + * This method reports an error level problem + * + * @param reason + * why we have an error level problem + */ + public static void screenMessage(String msg) { + // Apache commons logging + // log.error(Object line, null); + // or for now.... + System.out.println(msg); + } + + /** + * Escapes special characters like " so that they can be output in a C + * string literal. Also removes newlines, since C string literals can't be + * split over lines. + */ + String pretty(String s) { + StringBuffer sb = new StringBuffer(s); + for (int i = 0; i < sb.length(); i++) + switch (sb.charAt(i)) { + case '"': + sb = sb.insert(i, '\\'); + i++; + break; + case '\n': + sb = sb.deleteCharAt(i); + i--; + break; + } + return sb.toString(); + } + + private static boolean startsWithComment(String s) { + if (null == s || s.length() < 2) + return false; + if (s.startsWith("//")) + return true; + if (s.startsWith("/*")) + return true; + return false; + } + + private static int endOfComment(String s) { + int idx; + if (s.startsWith("//")) + idx = s.indexOf("\n"); + else { + idx = s.indexOf("*/"); + if (-1 != idx) + idx++; // Step over */ + } + return idx; + } + + private static boolean startsWithStringLiteral(String s) { + if (null == s || s.length() < 1) + return false; + if (s.startsWith("\"") || s.startsWith("'")) + return true; + return false; + } + + private static int endOfStringLiteral(String s) { + boolean escape = false; + char c0 = s.charAt(0); + for (int i = 1; i < s.length(); i++) { + if (!escape && s.charAt(i) == c0) + return i; + + // \" or \' does not end the literal + if ('\\' == s.charAt(i)) + // Escaping a \ should switch escape off so \\' does end + // the literal + escape = !escape; + else + escape = false; + } + return -1; + } + + /** + * If the String s starts with a string literal or a comment, return i plus + * the index of the end of the literal or comment. String literals are + * enclosed in " or ' and comments start with /* or //. + */ + private static int skip(String s, int i) { + int j = 0; + if (startsWithStringLiteral(s)) { + j = endOfStringLiteral(s); + if (-1 == j) + return -1; + } else if (startsWithComment(s)) { + j = endOfComment(s); + if (-1 == j) + return -1; + } + return i + j; + } + + /** + * A better method than .equals() because it doesn't NullPointerException + * when one of the parameters is null. + */ + public static boolean safeEquals(Object o1, Object o2) { + if (null == o1 && null == o2) + return true; + if (null == o1 && null != o2) + return false; + if (null != o1 && null == o2) + return false; + return o1.equals(o2); + } + + public static void outputDebugString(String line) { + if (!Options.quiet()) { + if (Options.debug()) + // Apache commons logging + // log.debug(Object line, null); + // or for now + System.out.println(line); + } + } + + /** + * This static method allows different parts of the code to inform about + * significant events. Code interested in specific types of event can + * register a listener against that type (not written yet) + * + * @param eventType + * An int type enum indicating the type of event. + * @param message + * A message that can be output to the user. + */ + public static final int EVENT_TYPE_XML_ITEM_PARSED = 1; + + public static final int EVENT_TYPE_FILE_PARSED = 2; + + public static final int EVENT_TYPE_FILE_CREATE = 3; + + public static final int VERBOSE_LIMIT = 1024; + + public static final int DEPLOYMENT_ARTEFACT = VERBOSE_LIMIT; + + public static final int DEPLOYMENT_ARTEFACT_ENCOUNTERED = DEPLOYMENT_ARTEFACT + 1; + + public static final int DEPLOYMENT_ARTEFACT_GENERATED = DEPLOYMENT_ARTEFACT + 2; + + public static final int DEPLOYMENT_INPUT_DIRECTORY = DEPLOYMENT_ARTEFACT + 3; + + public static final int DEPLOYMENT_OUTPUT_DIRECTORY = DEPLOYMENT_ARTEFACT + 4; + + private static boolean reportArtefacts = false; + + /** + * An easily callable method to allow tracking/reposting of events in scagen + * and other tools. + * + * @param eventType + * used for classifying event + * @param message + * a user readable message + */ + public static void postEvent(int eventType, String message) { + if (Options.verbose() && eventType < VERBOSE_LIMIT) { + screenMessage(message); + } + + if ((eventType & DEPLOYMENT_ARTEFACT) > 0) { + reportArtefact(message, eventType); + } + + } + + /** + * @param message + * The user message + * @param eventType + * The type of event (input or output). This is used to determine + * if the path name of the file starts with the MODULE_ROOT + * directory or the given output directory as the one of these + * prefixes is removed from the path name in order to give the + * new (destination) path relative to the new module root + * + * + */ + + static String scagenInputDir = "MODULE_ROOT"; + + static String scagenOutputDir = "SCAGEN_OUTPUT"; + + static String newModuleRoot = "NEW_MODULE_ROOT"; + + static String generatedDirName = "$sourceDir1"; + + private static void reportArtefact(String message, int eventType) { + + if (Utils.isReportArtefacts()) { + + // Changing the value of the variable below will alter the output of + // the + // deploy assist strings: + // true will result in a "copy source NEW_MODULE_ROOT\dest" output + // and + // false will result in a "inputDir c:\fred" + // "outputDir c:\bob" + // "input c:\fred\sca.module" + // "output c:\bob\proxy.h" type output + String command = null; + + try { + newModuleRoot = (String) Options.getOption("-deploy"); + command = (String) Options.getOption("-command"); + } catch (Exception e) { + // let it default + } + + if (null == newModuleRoot) { + newModuleRoot = "DEPLOY_MODULE_ROOT"; + } + + if (null == command) { + command = "copy"; + } + + if (Options.outputCommand()) { + + String tail = message; + switch (eventType) { + case DEPLOYMENT_ARTEFACT_ENCOUNTERED: + if (message.startsWith(scagenInputDir)) { + tail = message.substring(scagenInputDir.length()); + } + + String dest = joinPathElements(newModuleRoot, tail); + + System.out.println(command + " " + platformSlashes(message) + + " " + platformSlashes(dest)); + break; + + case DEPLOYMENT_ARTEFACT_GENERATED: + if (message.startsWith(scagenOutputDir)) { + tail = message.substring(scagenOutputDir.length()); + } + + dest = joinPathElements(newModuleRoot, tail); + System.out.println(command + " " + platformSlashes(message) + + " " + platformSlashes(dest)); + break; + case DEPLOYMENT_INPUT_DIRECTORY: + scagenInputDir = message; + //System.out.println("inputDir " + message); + break; + case DEPLOYMENT_OUTPUT_DIRECTORY: + scagenOutputDir = message; + //System.out.println("outputDir " + message); + break; + default: + break; + } + + } else { + + if (Options.list()) { + switch (eventType) { + case DEPLOYMENT_ARTEFACT_ENCOUNTERED: + case DEPLOYMENT_ARTEFACT_GENERATED: + System.out.println(platformSlashes(message)); + break; + case DEPLOYMENT_INPUT_DIRECTORY: + case DEPLOYMENT_OUTPUT_DIRECTORY: + default: + break; + } + } else { + switch (eventType) { + case DEPLOYMENT_ARTEFACT_ENCOUNTERED: + //TODO make efficient + System.out.println("$sourceDir1" + + platformSlashes(message.substring(scagenInputDir.length()))); + break; + case DEPLOYMENT_ARTEFACT_GENERATED: + //TODO make efficient + System.out.println(generatedDirName + + platformSlashes(message.substring(scagenOutputDir.length()))); + break; + case DEPLOYMENT_INPUT_DIRECTORY: + scagenInputDir = platformSlashes(message); + System.out.println("sourceDir1=" + scagenInputDir); + break; + case DEPLOYMENT_OUTPUT_DIRECTORY: + scagenOutputDir = platformSlashes(message); + if (!scagenInputDir.equals(scagenOutputDir)) { + generatedDirName = "$sourceDir2"; + System.out.println("sourceDir2=" + scagenOutputDir); + } else { + //generatedDirName = "sourceDir1"; + } + break; + default: + break; + } + } + } + } + } + + /** + * @param tail + * @param tail + * @return + */ + public static String joinPathElements(String root, String tail) { + String separator; + // Stick in a "/" (File.separator) if required. + if ((tail.substring(0, 1).equals("/") || newModuleRoot.substring( + root.length() - 1, root.length()).equals("/")) + || (tail.substring(0, 1).equals("\\") || root.substring( + root.length() - 1, root.length()).equals("\\")) + + ) { + separator = ""; + } else { + separator = File.separator; + } + String dest = newModuleRoot + separator + tail; + return dest; + } + + /** + * @param reportArtefacts + * The reportArtefacts to set. + */ + public static void setReportArtefacts(boolean reportArtefacts) { + Utils.reportArtefacts = reportArtefacts; + } + + /** + * @return Returns the reportArtefacts. + */ + private static boolean isReportArtefacts() { + return reportArtefacts; + } + + private static String platformSlashes(String path) { + if (null == path) { + return path; + } + // We need a double level of \\ escapes if the slashes are + // this way round. + String separatorForRegex = File.separator + .replaceAll("\\\\", "\\\\\\\\"); + return path.replaceAll("[/\\\\]+", separatorForRegex); + + } + +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/package.html b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/package.html new file mode 100644 index 0000000000..c86184f441 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/common/package.html @@ -0,0 +1,39 @@ +<html> + +<head> +<title>Design documentation for org\apache\tuscany\sca\cpp\tools\common</title> +</head> + +<body lang=EN-GB> + +<div class=Section1> + +<h1>Overview</h1> + +This package can be used to reflect across C++ source code. It can produce +a network of descriptive objects describing C++ Headers, Signatures, Parameters and so +on that it finds in a given location of the file system. +Each of the descriptive objects has a set of getters that return either +the descriptive child objects, or for primitives, the string that represents the actual +value such as "int" or "myFunction". +<p> +There are also various utility methods that help with navigating the information, for example the Signature +class has an isConstructor method. The API Javadoc contains further details of these. +<p> +The package can scan a directory using a file mask to identify what types +of files are to be scanned. In this application we are interested only +in the function prototypes in the C++ header files. +<p> +The implementation was originated using some java code that was also +contributed to the Apache org.apache.axis.tools.common package. Care +has been taken that the original code was not sourced via Apache. If +this project is adopted by Apache then it is very possible that this +package could be merged with or made obsolete by org.apache.axis.tools.common +and because of this the design and interfaces have been preserved from +the original code as much as possible. + +<p> +</div> +</body> + +</html> diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ComponentDomNodeHandler.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ComponentDomNodeHandler.java new file mode 100644 index 0000000000..ea27e33d09 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ComponentDomNodeHandler.java @@ -0,0 +1,352 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import org.apache.tuscany.sca.cpp.tools.common.Headers; +import org.apache.tuscany.sca.cpp.tools.common.Signature; +import org.apache.tuscany.sca.cpp.tools.common.Utils; +import org.w3c.dom.Node; + +/** + * This class will do the required processing for the <component>element of a + * sca module or fragment file. + */ +public class ComponentDomNodeHandler extends GenericDomNodeHandler { + + /** + * This method will do the "normal" processing and then trigger a call to + * processComponentNode. + * + * @param node + * the node being processed + * @param contextXPath + * the XPath to the node + * @param handlers + * the map pf element names to DomNodeHandlers + * @param parameters + * a map of XPaths to parameters values found so far + */ + + public void handleNode(Node node, String contextXPath, Map handlers, + Map parameters) { + + // Pick up attrs and the interface.cpp child elements + super.handleNode(node, contextXPath, handlers, parameters); + + try { + //OK now go and create the wrapper and proxy for the service + processComponentNode(contextXPath, parameters); + } catch (Exception e) { + e.printStackTrace(); + } + + } + + /** + * This method basically moved from the text names of things to operating on + * the actual Files. It will also verify or work out the correct class name + * for the implmentation and complain if this does match at least one + * potential service method in the class. + * + * @param contextXPath + * used to pull the correct values from the parameters map (as + * there can be multiple implementation.cpp elelements in there). + * @param parameters + * a map of XPath keys to attribute values + * @throws Exception + */ + private void processComponentNode(String contextXPath, Map parameters) + throws Exception { + + String implHeader = (String) parameters.get(contextXPath + + "/implementation.cpp/@header"); + String implClass = (String) parameters.get(contextXPath + + "/implementation.cpp/@class"); + + File moduleOrFragmentFile = (File) parameters + .get("moduleOrFragmentFile"); + File implHeaderFile = null; + if (null != moduleOrFragmentFile) { + File dir = moduleOrFragmentFile.getParentFile(); + implHeaderFile = new File(dir, implHeader); + } else { + throw new InternalError( + "Internal error: sca.module or fragment file not present in interal parameters"); + } + + try { + String resolvedImplClassName = getClassName(implHeaderFile, + implClass); + + // Check or retrieve the impl Class name. + if (null == resolvedImplClassName) { + try { + //A class attribute was set but there were no methods of + // the + // class in the header + System.out + .println("Classname given (" + + implClass + + ") does not match any header file method's classes in file: " + + implHeaderFile.getCanonicalPath()); + } catch (IOException e) { + System.out + .println("Classname given (" + + implClass + + ") does not match any header file method's classes in file: " + + implHeaderFile.getAbsolutePath()); + } + return; + } else { + File target = (File) parameters.get("targetFile"); + // go into the .componentType file and generate the cpp + processComponentTypeFile(implHeaderFile, target, + resolvedImplClassName); + + } + } catch (Exception e) { + String compName = (String) parameters + .get("/moduleFragment/component/@name"); + Utils + .screenMessage("Problem interpreting header or class attributes in " + + compName + + " component, in " + + moduleOrFragmentFile.getPath() + " file"); + System.exit(-2); + } + + } + + /** + * The purpose of this method is to move from the DOM parameters to dealing + * with the actual Files involved. It is from this method that we kick off + * the processing of the componentType file. + * + * @param header + * the implementation header + * @param target + * the directory for the output + * @param implClass + * @throws Exception + */ + private void processComponentTypeFile(File header, File target, + String implClass) throws Exception { + + // The componentType files should be in the same dir as the Impl + // header... + if (header == null || target == null) { + return; + } + + File componentTypeDirectory = header.getParentFile(); + String headerFileName = header.getName(); + String componentTypeName = headerFileName.substring(0, headerFileName + .lastIndexOf(".")); + + File componentTypeFile = new File(componentTypeDirectory, + componentTypeName + ".componentType"); + + ComponentTypeFileHandler ctParser = new ComponentTypeFileHandler(); + + // The implClass is used in the generated wrapper code so we need to + // store + // it so we can tunnel through the standard actOnFile signature. + + int namespaceEnd = -1; + if (null != implClass) { + namespaceEnd = implClass.lastIndexOf("::"); + } + + String namespace = null; + + if (-1 != namespaceEnd) { + namespace = implClass.substring(0, namespaceEnd); + ctParser.setParameter("namespace", namespace); + implClass = implClass.substring(namespaceEnd + 2); + } + + if (implClass != null) { + ctParser.setParameter("implClass", implClass); + } + + try { + ctParser.handleComponentTypeFile(componentTypeFile, target); + } catch (Exception e) { + Utils + .screenMessage("There has been a problem parsing the componentType file: " + + componentTypeFile.getCanonicalPath()); + Utils.screenMessage(" the reported errors is " + + e.getLocalizedMessage()); + Utils.screenMessage(" and the java exception stack is below."); + e.printStackTrace(); + throw e; + } + } + + /** + * The resolve and check the classname of the service. If we have an + * implementation class name we have to check that there is: at least one + * (non-private, non constructor or finalizer) method of that class in the + * header If there is no implementation class then we will return the class + * of the first non-private/constructor/finalizer method we find. + * + * @param header + * @param implementationCppClass + * @return + * @throws Exception + */ + private String getClassName(File header, String implementationCppClass) + throws Exception { + String methodClassName = null; + List methods = null; + + if (null == header) { + return null; + } + + Utils.postEvent(Utils.DEPLOYMENT_ARTEFACT_ENCOUNTERED, header + .getAbsolutePath()); + Utils.postEvent(Utils.EVENT_TYPE_FILE_PARSED, + "Scagen processing C++ implementation header " + + header.getAbsolutePath()); + + try { + Headers headers = new Headers(); + + headers.actOnFile(header, null, 1); + + methods = headers.getAllMethods(); + + } catch (FileNotFoundException fnfe) { + String path; + try { + path = header.getCanonicalPath(); + } catch (IOException e1) { + path = header.getPath(); + } + Utils.screenMessage("The header file: " + path + + " referenced cannot be found."); + throw fnfe; + } catch (Exception e) { + String path = header.getPath(); + Utils.screenMessage("The header file: " + path + + " referenced is not valid. Reason given is " + + e.getLocalizedMessage()); + throw e; + } + + // We need at least some methods + if (null == methods) { + return null; + } + + // We need at least one service method of to do anything + methods = trimMethodsOfPrivatesConstructorsAndDestrutors(methods); + if (null == methods || methods.size() == 0) { + return null; + } + + // If the user specifies an implementation class then we need at + // least one service method of that class + if (implementationCppClass != null) { + methods = filterMethodsToOneClass(methods, implementationCppClass); + + if (null == methods || methods.size() == 0) { + return null; + } else { + // There was at least one method of the correct type + return implementationCppClass; + } + } else { + // Implementation class is null so we return the classname of the + // first service method + return ((Signature) methods.get(0)).getTrimClassName(); + } + } + + /** + * Filter the mthods supplied to only ones fo the supplied class. + * + * @param methods + * the list of methods + * @param implementationCppClass + * the class we wish + * @return a list of methods of the correct class + */ + private List filterMethodsToOneClass(List methods, + String implementationCppClass) { + + if (null == methods) { + return null; + } + + if (null == implementationCppClass + || implementationCppClass.length() == 0) { + return null; + } + + for (Iterator iter = methods.listIterator(); iter.hasNext();) { + Signature method = (Signature) iter.next(); + + String className = method.getTrimClassName(); + String namespace = method.getNamespace(); + + if (namespace != null && namespace.length() > 0) { + className = namespace + "::" + className; + } + + if (!implementationCppClass.equals(className)) { + iter.remove(); + } + } + + return methods; + + } + + /** + * This method removes contructor and destructor methods from the list. + * + * @param methods + * the list of methods + * @return + */ + private List trimMethodsOfPrivatesConstructorsAndDestrutors(List methods) { + + if (null == methods) { + return null; + } + + for (Iterator iter = methods.listIterator(); iter.hasNext();) { + Signature method = (Signature) iter.next(); + + if (method.isConstructor() || method.isDestructor()) { + iter.remove(); + } + } + + return methods; + } + +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ComponentTypeFileHandler.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ComponentTypeFileHandler.java new file mode 100644 index 0000000000..0ee9b97138 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ComponentTypeFileHandler.java @@ -0,0 +1,124 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.io.File; + +import org.apache.tuscany.sca.cpp.tools.common.FileActor; +import org.apache.tuscany.sca.cpp.tools.common.Utils; + +/** + * The purpose of this class is to specialise the map of XML element handlers + * for a XXX.componentType file that is used by the XMLFileActor + */ +public class ComponentTypeFileHandler extends XMLFileActor { + + static { + // We set up a map for each element type we wish to handle + // this alows the XML handling code to be generic and type free + // while the handlers don't have to do mcuh XML handling. + + GenericDomNodeHandler gdnh = new GenericDomNodeHandler(); + handlers.put("componentType", gdnh); + handlers.put("interface.cpp", gdnh); + + ServiceDomNodeHandler sdnh = new ServiceDomNodeHandler(); + handlers.put("service", sdnh); + + ReferenceDomNodeHandler rdnh = new ReferenceDomNodeHandler(); + handlers.put("reference", rdnh); + } + + /** + * This method just exists to add the default starting depth of 1 to the + * underlying actOnFile interface + * + * @param componentTypeXML + * @param target + * @throws Exception + */ + public void handleComponentTypeFile(File componentTypeXML, File target) + throws Exception { + // We have already set up the XML element handlers. + actOnFile(componentTypeXML, target, 1); + // We need do no more, the service and reference handlers + // ServiceDomNodeHandler and ReferenceDomNodeHandler + // will take appropriate action. + } + + /** + * This method is the main FileActor method + * + * @see FileActor#actOnFile(File, File, int) Here we create an initial DOM + * and kick off the processing (using the handler map that has been set + * up by the concrete subclass). + * + * @param moduleXML + * the sca.module or fragment file + * @param target + * the target directory + * @param depth + * not uesed here but in the + * @see FileActor#actOnFile(File, File, int) interface to allow for + * recursive diving into a directory structure. + */ + public void actOnFile(File fileXML, File target, int depth) + throws Exception { + + if (null == fileXML || null == target) { + return; + } + + parameters.put("componentTypeFile", fileXML); + + Utils.postEvent(Utils.DEPLOYMENT_ARTEFACT_ENCOUNTERED, fileXML.getAbsolutePath()); + Utils.postEvent(Utils.EVENT_TYPE_FILE_PARSED, "Scagen processing SCA componentType file " + fileXML.getAbsolutePath()); + + super.actOnFile(fileXML, target, depth); + + } + + /** + * @return an error message - usually over-ridden. + */ + protected String getContextMessage() { + + String module = ((File) parameters.get("moduleOrFragmentFile")).getPath(); + if (null == module) { + module = "unknown"; + } + + String component = (String) parameters.get("/module/component/@name"); + if (null == component) { + component = (String) parameters + .get("/moduleFragment/component/@name"); + } + if (null == component) { + module = "unknown"; + } + + String msg = "when processing module " + module; + + msg = msg + + "\nin this module file, the component \"" + + component + + "\" has an implementation.cpp element with a header attribute \nwhere the C++ header can be found but it has no matching .componentType file present in\nthe same directory as the header."; + + return msg; + } + +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/DirectoryScanner.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/DirectoryScanner.java new file mode 100644 index 0000000000..1ff4504fff --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/DirectoryScanner.java @@ -0,0 +1,87 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.io.File; +import java.util.Set; + +import org.apache.tuscany.sca.cpp.tools.common.FileActor; +import org.apache.tuscany.sca.cpp.tools.common.Utils; + +public class DirectoryScanner { + private FileActor actor; + + private Set actOnTheseFileExtensions; + + public DirectoryScanner(FileActor actor, Set extensions) { + this.actor = actor; + this.actOnTheseFileExtensions = extensions; + } + + /** + * + * @param source + * The module root directory + * @param target + * The directory that will hold the generated output + * @param depth + * The depth from the initial starting point, not significant for + * the Scagen tool as we are only interested in the module root + * directory but present due to the FileActor actOnFile interface + * method. This code is pulled from the code in the CParsingTool + * class and further work is needed to remove the duplication. + * Tnterface has been left unchanged as we hope to reconverge the + * parser here with the original one once the changes are fed + * back into the original code. + * @throws Exception + */ + public void walkTree(File source, File target, int depth) throws Exception { + depth++; + boolean noTarget = (null == target); + + if (!source.canRead()) + Utils.rude("Cannot read from source directory " + source); + if (!noTarget && !target.canWrite()) + Utils.rude("Cannot write to target directory " + target); + + if (source.isDirectory()) { + File[] filesInDirectory = source.listFiles(); + for (int i = 0; i < filesInDirectory.length; i++) { + File file = filesInDirectory[i]; + String name = file.getName(); + int dot = name.lastIndexOf('.'); + String ext = null; + if (-1 != dot) { + ext = name.substring(dot + 1); + } + + if (file.isFile() + && (actOnTheseFileExtensions == null || (!file + .isHidden() && actOnTheseFileExtensions + .contains(ext)))) { + // this is a file we need to act on! + actor.actOnFile(file, target, depth); + } + } + } else { + return; // Do not act on single files for now we expect a module + // root directory + // and the "main" class checks its parameters to ensure this is so. + } + } + +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/DomHandler.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/DomHandler.java new file mode 100644 index 0000000000..2ca4c7c881 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/DomHandler.java @@ -0,0 +1,77 @@ +/* +* +* Copyright 2005 The Apache Software Foundation or its licensors, as applicable. +* +* 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.tuscany.sca.cpp.tools.services; + +import java.util.Map; + +import org.w3c.dom.Document; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * The purpose of this class it to provide a generic class that can handle both + * a DOM and a DOM node. + * + */ +public class DomHandler extends GenericDomNodeHandler { + /** + * This method will run through the initial level of the DOM using the + * handlers map + * + * @param dom + * the document being consumed + * @param handlers + * the map from element name to node handler + * @param parameters + * a map of parameters - this is often used by a handler to place + * a name-value pair, the name is often an Xpath representation + * of the location of the data in the DOM but handlers are free + * to use whatever they like - the contextXpath is generated as + * an Xpath prefix for those handlers that wish to use it. + */ + public static void handleDom(Document dom, Map handlers, Map parameters) { + if (dom != null) { + NodeList childNodes = dom.getChildNodes(); + for (int i = 0; i < childNodes.getLength(); i++) { + Node childNode = childNodes.item(i); + mapNodeToHandlerAndHandle(childNode, "/" + + childNode.getNodeName(), handlers, parameters); + } + } + } + + /** + * + * @param node + * The DOM node being consumed + * @param contextXPath + * The XPath to this node + * @param handlers + * The map from element name to node handler + * @param parameters + * A map of parameters - this is often used by a handler to place + * a name-value pair, the name is often an Xpath representation + * of the location of the data in the DOM but handlers are free + * to use whatever they like - the contextXpath is generated as + * an Xpath prefix for those handlers that wish to use it. + */ + public void handleNode(Node node, String contextXPath, Map handlers, + Map parameters) { + mapNodeToHandlerAndHandle(node, contextXPath, handlers, parameters); + } + +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/DomNodeHandler.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/DomNodeHandler.java new file mode 100644 index 0000000000..00942bd9ca --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/DomNodeHandler.java @@ -0,0 +1,40 @@ +/* +* +* Copyright 2005 The Apache Software Foundation or its licensors, as applicable. +* +* 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.tuscany.sca.cpp.tools.services; + +import java.util.Map; + +import org.w3c.dom.Node; + +public interface DomNodeHandler { + + public static int ELEMENT = 1; + /** + * An interface for classes that can process DOM nodes. + * + * @param node the DOM node being consumed + * @param contextXPath the XPath to this node + * @param handlers The map from element name to node handler + * @param parameters A map of parameters - this is often used by a handler to place + * a name-value pair, the name is often an Xpath like representation of the + * location of the data in the DOM but handlers are free to use whatever + * they like - the contextXpath is generated as an Xpath prefix for those + * handlers that wish to use it. + */ + void handleNode( Node node, String contextXPath, Map handlers, Map parameters ); + +} diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/GenericDomNodeHandler.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/GenericDomNodeHandler.java new file mode 100644 index 0000000000..3f9fb359f5 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/GenericDomNodeHandler.java @@ -0,0 +1,214 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.io.File; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; +import java.util.Map.Entry; + +import org.apache.tuscany.sca.cpp.tools.common.Utils; +import org.w3c.dom.NamedNodeMap; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * + * + * + * + */ +public class GenericDomNodeHandler implements DomNodeHandler { + /** + * This method parses the DOM attributes into name value pairs in the + * parameter map each valued keyed by its XPath. + * + * @param node + * the DOM node being processed + * @param contextPath + * the XPath to the DOM node being processed + * @param parameters + * a scratchpad map of name value pairs + */ + public void transferAttrsToParameters(Node node, String contextPath, + Map parameters) { + + if (node == null || contextPath == null || parameters == null) + return; + + NamedNodeMap attrs = node.getAttributes(); + if (attrs != null) { + for (int i = 0; i < attrs.getLength(); i++) { + Node attr = attrs.item(i); + parameters.put(contextPath + "/" + "@" + attr.getNodeName(), + attr.getNodeValue()); + + // Report the dll name to the deployment tool if required. + if ("dll".equals(attr.getNodeName())) { + //This is a path relative to the module root. + //so we need to add it in. + File mod = (File) parameters.get("moduleOrFragmentFile"); + if (null != mod) { + String separatorForRegex = File.separator.replaceAll( + "\\\\", "\\\\\\\\"); + + String end = attr.getNodeValue().replaceAll("[/\\\\]+", + separatorForRegex); + + if (!end.startsWith(File.separator)) { + end = File.separator + end; + } + + String fullPath = mod.getParentFile().getAbsolutePath() + + end; + Utils.postEvent(Utils.DEPLOYMENT_ARTEFACT_ENCOUNTERED, + fullPath); + } + + } + + } + } + return; + } + + /** + * This method will iterate through the DOM node's children and call the + * appropriate handler for each one. + * + * @param node + * the DOM node being processed + * @param contextPath + * the XPath to the DOM node being processed + * @param handlers + * a map of element name to handler objects + * @param parameters + * a scratchpad map of name value pairs + */ + public void handleChildElements(Node node, String contextPath, + Map handlers, Map parameters) { + + if (node == null || contextPath == null) + return; + + NodeList children = node.getChildNodes(); + if (children != null) { + for (int i = 0; i < children.getLength(); i++) { + Node child = children.item(i); + mapNodeToHandlerAndHandle(child, contextPath + "/" + + child.getNodeName(), handlers, parameters); + } + } + return; + } + + /** + * This method will resolve any registered handler for a particular DOM + * element and call the handleNode method on it. If the handlers map has a + * mapping from "entity" to an instance of EntityHandler which implements + * the DomNodeHandler interface then any node that looks like <entity> + * <any_other/><stuff/></entity> + * + * Will be passed to the EntityHandler to process. + * + * @param node + * the DOM node being processed + * @param contextPath + * the XPath to the DOM node being processed + * @param handlers + * a map of element name to handler objects + * @param parameters + * a scratchpad map of name value pairs + */ + public static void mapNodeToHandlerAndHandle(Node node, String contextPath, + Map handlers, Map parameters) { + if (node != null && node.getNodeType() == DomNodeHandler.ELEMENT) { + String nodeName = node.getNodeName(); + if (nodeName != null && nodeName.length() > 0) { + DomNodeHandler handler = (DomNodeHandler) handlers + .get(nodeName); + if (handler != null) { + handler.handleNode(node, contextPath, handlers, parameters); + } + } + } + } + + /** + * This method will place the attributes in this node into the parameter map + * keyed by the XPath and recursively continue processing for any + * sub-elements of the node. + * + * @param node + * The DOM node being consumed + * @param contextXPath + * The XPath to this node + * @param handlers + * The map from element name to node handler + * @param parameters + * A map of parameters - this is often used by a handler to place + * a name-value pair, the name is often an Xpath representation + * of the location of the data in the DOM but handlers are free + * to use whatever they like - the contextXpath is generated as + * an Xpath prefix for those handlers that wish to use it. + */ + public void handleNode(Node node, String contextXPath, Map handlers, + Map parameters) { + + clearParametersAtThisXPath(contextXPath, parameters); + transferAttrsToParameters(node, contextXPath, parameters); + handleChildElements(node, contextXPath, handlers, parameters); + } + + /** + * @param contextXPath + * @param parameters + */ + private void clearParametersAtThisXPath(String contextXPath, Map parameters) { + + // TODO: Slow but works, improve parameters mechanism overall + // to make this unecessary + if (contextXPath == null || parameters == null) { + return; + } + + // We want to clear both /moduleFragment and /module + // subtrees when we come across the root of either.. + if (contextXPath.equals("/moduleFragment")) { + //clear both this and "module" + contextXPath = "/module"; + } + + Set parms = parameters.entrySet(); + if (null != parms) { + Iterator iter = parms.iterator(); + Map.Entry item = null; + String thisKey; + + while (iter.hasNext()) { + item = (Entry) iter.next(); + thisKey = (String) item.getKey(); + if (thisKey.startsWith(contextXPath)) { + //System.out.println(" removing " + thisKey + " for " + + // item.getValue().toString() + " against " + contextXPath); + iter.remove(); + } + } + } + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/LittleClass.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/LittleClass.java new file mode 100644 index 0000000000..699abf7a08 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/LittleClass.java @@ -0,0 +1,27 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +/** + * This class is just a convenient application class that is loaded in order to + * get the application class loader. We are interested in the application class + * loader as we use its getResource method to resolve XML files independantly of + * where they are. + */ +public class LittleClass { + +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ModuleOrFragmentFileHandler.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ModuleOrFragmentFileHandler.java new file mode 100644 index 0000000000..3bd8129401 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ModuleOrFragmentFileHandler.java @@ -0,0 +1,85 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.io.File; + +import org.apache.tuscany.sca.cpp.tools.common.FileActor; +import org.apache.tuscany.sca.cpp.tools.common.Utils; + +/** + * The purpose of this class is purely to specialise the handler map to one with + * a specific ComponentDomNodeHandler. + */ +public class ModuleOrFragmentFileHandler extends XMLFileActor { + + static { + + GenericDomNodeHandler gdnh = new GenericDomNodeHandler(); + + /* + * We use a specific Component node handler in order to be able to + * process multiple components in the same XML file + */ + ComponentDomNodeHandler componentdnh = new ComponentDomNodeHandler(); + handlers.put("component", componentdnh); + + /* + * We are interested inthe elements below but they only need standard + * processing + */ + handlers.put("module", gdnh); + handlers.put("moduleFragment", gdnh); + handlers.put("implementation.cpp", gdnh); + } + + /** + * This method is the main FileActor method + * + * @see FileActor#actOnFile(File, File, int) Here we create an initial DOM + * and kick off the processing (using the handler map that has been set + * up by the concrete subclass). + * + * @param moduleXML + * the sca.module or fragment file + * @param target + * the target directory + * @param depth + * not uesed here but in the + * @see FileActor#actOnFile(File, File, int) interface to allow for + * recursive diving into a directory structure. + */ + public void actOnFile(File moduleXML, File target, int depth) + throws Exception { + + if (null == moduleXML || null == target) { + return; + } + + parameters.put("moduleOrFragmentFile", moduleXML); + + Utils.postEvent(Utils.DEPLOYMENT_ARTEFACT_ENCOUNTERED, moduleXML + .getAbsolutePath()); + + Utils.postEvent(Utils.EVENT_TYPE_FILE_PARSED, + "Scagen processing SCA module file " + + moduleXML.getAbsolutePath()); + + super.actOnFile(moduleXML, target, depth); + + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ReferenceDomNodeHandler.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ReferenceDomNodeHandler.java new file mode 100644 index 0000000000..a490d184d1 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ReferenceDomNodeHandler.java @@ -0,0 +1,67 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.util.Map; + +import org.apache.tuscany.sca.cpp.tools.common.Options; +import org.w3c.dom.Node; + +/** + * The purpose of this class is to process a <reference>element in a + * componentType file and then trigger a call to the method in ServicesGenerator + * to process the interface header file + */ +public class ReferenceDomNodeHandler extends GenericDomNodeHandler { + + /* + * (non-Javadoc) + * + * @see org.apache.tuscany.sca.cpp.services.DomNodeHandler#handleNode(org.w3c.dom.Node, + * java.lang.String, java.util.Map, java.util.Map) + */ + public void handleNode(Node node, String contextXPath, Map handlers, + Map parameters) { + + // Pick up attrs and children + super.handleNode(node, contextXPath, handlers, parameters); + + //OK we know we are handling a reference + //now go and create the wrapper and proxy for it + createProxyForReference(parameters); + + } + + /** + * This method is really just an adapter that adapts the -dir Option to a + * value int he parameters map for "module_root" + * + * @param parameters + * the map of name-value parameters. + */ + private void createProxyForReference(Map parameters) { + try { + String mr = (String) Options.getOption("-dir"); + parameters.put("module_root", mr); + ServicesGenerator.handleInterfaceHeader(parameters, true); + + } catch (Exception e) { + e.printStackTrace(); + } + + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/Scagen.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/Scagen.java new file mode 100644 index 0000000000..a6f6f58644 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/Scagen.java @@ -0,0 +1,170 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.io.File; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +import org.apache.tuscany.sca.cpp.tools.common.CParsingTool; +import org.apache.tuscany.sca.cpp.tools.common.Options; +import org.apache.tuscany.sca.cpp.tools.common.Utils; + +/** + * This is the main top level class. Its purpose is to create a + * Module/FragmentFile handler visitor and pass it to a DirectoryScanner for + * processing. + */ +public class Scagen extends CParsingTool { + + public static Set MODULE_EXTENSIONS = new HashSet(Arrays + .asList(new Object[] { "module", "fragment" })); + + /** + * @throws Exception + * + */ + public Scagen(String[] args) throws Exception { + super(args); + } + + /** + * Take a directory scanning class and create a vistor that knows how to + * handle any sca.module or .fragment that the scanner comes across. + * + * @param args + * standard main args. THe values we expect in this class are + * scagen -dir input_dir -output output_dir + * + */ + public static void main(String[] args) { + boolean failed = false; + try { + Scagen env = new Scagen(args); + ModuleOrFragmentFileHandler module_handler = new ModuleOrFragmentFileHandler(); + + // Check and access the input SCA module directory + String name = (String) Options.getOption("-dir"); + if (null == name) { + Utils + .screenMessage("Please provide a SCA module directory name as a \"-dir\" option."); + env.printUsage(); + System.exit(-1); + } + File source = new File(name); + if (!source.isFile() && !source.isDirectory()) { + Utils + .screenMessage("The SCA module directory provided as the \"-dir\" option cannot be accessed,"); + Utils.screenMessage("the option given was: " + source); + env.printUsage(); + System.exit(-1); + } + + String deployDir = null; + try { + deployDir = (String) Options.getOption("-deploy"); + if (null != deployDir || Options.deploy()) { + Utils.setReportArtefacts(true); + } + } catch (Exception e) { + // let it default to null + } + + Utils.postEvent(Utils.DEPLOYMENT_INPUT_DIRECTORY, source + .getAbsolutePath()); + + // We check the -output option here as we wish to + // reuse the env.maybeCreateDirectory method + // unchanged from the original that went into axis and it will do a + // System.exit if there is no matching Option + String outputDirName = (String) Options.getOption("-output"); + if (null == outputDirName) { + Utils + .screenMessage("Please provide an output directory name for the generated files as a \"-output\" option."); + env.printUsage(); + System.exit(-1); + } + + File outputDir = new File(outputDirName); + + // Check we can create the output directory + if (outputDir == null || !outputDir.exists() && !outputDir.mkdir()) { + Utils.screenMessage("Failed to create output directory: " + + outputDirName); + env.printUsage(); + System.exit(-1); + } + + Utils.postEvent(Utils.DEPLOYMENT_OUTPUT_DIRECTORY, outputDir + .getAbsolutePath()); + + DirectoryScanner scanner = new DirectoryScanner(module_handler, + MODULE_EXTENSIONS); + scanner.walkTree(source, outputDir, 1); + + if (0 == module_handler.getFilesActedOn()) { + Utils + .screenMessage("No SCA module or fragment files were found in: " + + source); + } + + failed = module_handler.failed; + + } catch (Exception exception) { + Utils + .screenMessage("Unexpected error occurred while runnning the Scagen tool. The Java exception is below."); + exception.printStackTrace(); + failed = true; + } + + if (failed) { + Utils + .outputDebugString("Finished! (but encountered problems parsing modules)"); + System.exit(-2); + } + + Utils.outputDebugString("Finished!"); + } + + /** + * Provide a hint to the user on how to call this class + */ + protected void printUsage() { + System.out + .println("usage: Java Scagen -dir <input_directory> -output <output_directory> [-verbose] [-deploy <deploy_dir>] [-nogenerate] [-outputCommand] [-command <copy_cmd>]"); + System.out + .println(" -dir <input_directory>: the SCA module root directory"); + System.out + .println(" -output <output_directory>: a directory to put the generated output into"); + System.out.println(" [-verbose]: report on what scagen is doing"); + System.out + .println(" [-deploy <deploy_dir>]: output text to help in deploying the module's artefacts"); + System.out + .println(" [-command <copy_cmd>]: a string that is injected into the deploy text"); + System.out + .println(" [-list]: change the deploy output text to a simple list of artefacts"); + System.out + .println(" [-outputCommand]: change the deploy output text to command text format"); + System.out + .println(" output is of form \"copy_cmd <dir>file1 <deploy_dir>file1\""); + System.out + .println(" [-nogenerate]: do not generate proxies and wrappers"); + + } + +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ServiceDomNodeHandler.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ServiceDomNodeHandler.java new file mode 100644 index 0000000000..79b74c0450 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ServiceDomNodeHandler.java @@ -0,0 +1,62 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.util.Map; + +import org.apache.tuscany.sca.cpp.tools.common.Options; +import org.w3c.dom.Node; + +public class ServiceDomNodeHandler extends GenericDomNodeHandler { + + /* + * (non-Javadoc) + * + * @see org.apache.tuscany.sca.cpp.services.DomNodeHandler#handleNode(org.w3c.dom.Node, + * java.lang.String, java.util.Map, java.util.Map) + */ + public void handleNode(Node node, String contextXPath, Map handlers, + Map parameters) { + + // Pick up attrs and the interface.cpp child elements + super.handleNode(node, contextXPath, handlers, parameters); + + //OK now go and create the wrapper and proxy for the service + createWrapperAndProxyForService(parameters); + + } + + /** + * This method will generate the wrapper and proxy C++ and header files for + * the service. + * + * @param parameters + * a map of name-value parameters + */ + private void createWrapperAndProxyForService(Map parameters) { + + try { + String mr = (String) Options.getOption("-dir"); + parameters.put("module_root", mr); + ServicesGenerator.handleInterfaceHeader(parameters, false); + + } catch (Exception e) { + e.printStackTrace(); + } + + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ServicesGenerator.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ServicesGenerator.java new file mode 100644 index 0000000000..6442b76992 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/ServicesGenerator.java @@ -0,0 +1,802 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerConfigurationException; +import javax.xml.transform.TransformerException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.stream.StreamResult; +import javax.xml.transform.stream.StreamSource; + +import org.apache.tuscany.sca.cpp.tools.common.CParsingTool; +import org.apache.tuscany.sca.cpp.tools.common.Headers; +import org.apache.tuscany.sca.cpp.tools.common.Options; +import org.apache.tuscany.sca.cpp.tools.common.Parameter; +import org.apache.tuscany.sca.cpp.tools.common.Signature; +import org.apache.tuscany.sca.cpp.tools.common.Utils; +import org.w3c.dom.Attr; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Text; + +/** + * This class is the main class that handles the function that parses a C++ + * interface header file into a DOM that holds all the semantic information + * about the interface - method names, parameters and return values. It then + * uses XSLT to generate different "views" of this data plus the parameter map + * from other sources that are the C++ programs for the proxy and wrapper + * implementations and headers. + */ +public class ServicesGenerator extends CParsingTool { + + private static final String OPERATION_NAME_ATTR = "operationNameAttr"; + + private static final String HEADER_NAME_ATTR = "headerNameAttr"; + + private static final String SCA_OPERATION = "scaOperation"; + + private static final String SCA_SERVICE = "scaService"; + + private static final String SCA_OPERATION_RETURN_TYPE = "scaOperationReturnType"; + + private static final String SCA_OPERATION_PARAMETER = "scaOperationParameter"; + + private static final String SCA_OPERATION_PARAMETER_NAME_ATTR = "scaOperationParameterNameAttr"; + + private static final String SCA_OPERATION_PARAMETER_CONST_ATTR = "scaOperationParameterConstAttr"; + + private static final String SCA_INTERFACE_NAME_ATTR = "scaInterfaceNameAttr"; + + private static final String CPP_HEADER = "cppHeader"; + + private static boolean TESTING = true; + + private static TransformerFactory txmf = null; + + private static ServicesGenerator instance = null; + + public ServicesGenerator(String[] args) throws Exception { + super(args); + txmf = TransformerFactory.newInstance(); + } + + /** + * + * @param parameters + * @param forReference + * true if we are creating a proxy for a reference (rather than + * for a service) + * @throws Exception + * + * The design is + * <ul> + * <li>handleInterfaceHeader + * <li>createDOMofMethods + * <li>createProxyCPPFromDom(outputDir, dom); + * <li>createProxyHeaderFromDom(outputDir, dom); + * </ul> + * + * plus if we are not generating for a reference element + * <ul> + * <li>createWrapperCPPFromDom(outputDir, dom); + * <li>createWrapperHeaderFromDom(outputDir, dom); + * <ul> + * Each of the create.... methods calls createOutputFromDom with a different + * style sheet. + * + */ + public static void handleInterfaceHeader(Map parameters, + boolean forReference) throws Exception { + boolean failed = false; + + String type = null; + if (forReference) { + type = "reference"; + } else { + type = "service"; + } + String interfaceHeaderFilename = (String) parameters + .get("/componentType/" + type + "/interface.cpp/@header"); + + String componentTypeFileHeaderName = interfaceHeaderFilename; + + String sca_module_root = (String) Options.getOption("-dir"); + parameters.put("module_root", sca_module_root); + + if (sca_module_root != null && interfaceHeaderFilename != null + && interfaceHeaderFilename.length() > 0) { + String separator; + // Stick in a "/" (File.separator) if required. + if ((interfaceHeaderFilename.substring(0, 1).equals("/") || sca_module_root + .substring(sca_module_root.length() - 1, + sca_module_root.length()).equals("/")) + || (interfaceHeaderFilename.substring(0, 1).equals("\\") || sca_module_root + .substring(sca_module_root.length() - 1, + sca_module_root.length()).equals("\\")) + + ) { + separator = ""; + } else { + separator = File.separator; + } + interfaceHeaderFilename = sca_module_root + separator + + interfaceHeaderFilename; + } + + File outputDir = (File) parameters.get("targetDirectoryFile"); + + String[] args = new String[] { "-source", interfaceHeaderFilename, + "-target", outputDir.getPath() }; + ServicesGenerator gen = new ServicesGenerator(args); + File file; + try { + if (null == interfaceHeaderFilename) { + gen.printUsage(); + System.exit(-1); + } + + file = new File(interfaceHeaderFilename); + if (!file.isFile()) { + if (file.isDirectory()) { + Utils + .rude("This tool works at the header file level and not for directories like " + + file); + } + Utils.rude("Bad file or directory " + file); + } + File source = file; + if (!outputDir.exists() && !outputDir.mkdir()) + Utils.rude("Failed to create directory " + outputDir); + + // The class below is the one that will go through the header + // file(s) + Headers headers = new Headers(); + + if (null != interfaceHeaderFilename) { + Utils.postEvent(Utils.DEPLOYMENT_ARTEFACT_ENCOUNTERED, file + .getAbsolutePath()); + Utils.postEvent(Utils.EVENT_TYPE_FILE_PARSED, + "Scagen processing C++ interface header " + + file.getAbsolutePath()); + headers.actOnFile(file, outputDir, 1); + Utils.outputDebugString("Parsing files..."); + } + + String nameOfSorR = null; + String referenceName = null; + String serviceName = null; + + if (forReference) { + + Object rn = parameters.get("/componentType/reference/@name"); + + if (rn instanceof String) { + referenceName = (String) rn; + nameOfSorR = referenceName; + } + } else { + + Object sn = parameters.get("/componentType/service/@name"); + + if (sn instanceof String) { + serviceName = (String) sn; + nameOfSorR = serviceName; + } + } + + String moduleXmlFileHeader = null; + String moduleXmlFileHeaderNoExt = null; + Object moduleh = parameters + .get("/module/component/implementation.cpp/@header"); + + if (moduleh == null) { + moduleh = parameters + .get("/moduleFragment/component/implementation.cpp/@header"); + } + + if (moduleh instanceof String) { + File f = new File((String) moduleh); + moduleXmlFileHeader = (String) moduleh; + + String fname = f.getName(); + moduleXmlFileHeaderNoExt = fname.substring(0, fname + .lastIndexOf('.')); + + } + + String implClassNameAttrFromModuleFile = (String) parameters + .get("implClass"); + + String interfaceClassNameAttrFromComponentTypeFile; + if (forReference) { + interfaceClassNameAttrFromComponentTypeFile = (String) parameters + .get("/componentType/reference/interface.cpp/@class"); + } else { + interfaceClassNameAttrFromComponentTypeFile = (String) parameters + .get("/componentType/service/interface.cpp/@class"); + } + + List methods = headers.getAllMethods(); + + // Pull out one of the methods' namespace attributes. + String intfNamespace = null; + if (methods.size() > 0) { + Signature method = (Signature) methods.get(0); + intfNamespace = method.getNamespace(); + } + + if (interfaceClassNameAttrFromComponentTypeFile != null) { + methods = filterToPublicMethodsOfGivenClass(methods, + interfaceClassNameAttrFromComponentTypeFile, true); + } else { + //We want to filter to methods of the class whose + //name matches the header file name. + // String intfClassName = (String) parameters.get("intfClass"); + // + String headerFileBase = file.getName().replaceAll( + "\\.h|\\.hpp|\\.h++", ""); + + methods = filterToPublicMethodsOfGivenClass(methods, + headerFileBase, false); + } + + Document dom = createDOMofMethods(methods, source, serviceName, + referenceName, nameOfSorR, null, + componentTypeFileHeaderName, moduleXmlFileHeader, + moduleXmlFileHeaderNoExt, intfNamespace, + interfaceClassNameAttrFromComponentTypeFile, + implClassNameAttrFromModuleFile); + + createProxyCPPFromDom(outputDir, dom); + createProxyHeaderFromDom(outputDir, dom); + + if (!forReference) { + createWrapperCPPFromDom(outputDir, dom); + createWrapperHeaderFromDom(outputDir, dom); + } + + } catch (Exception exception) { + exception.printStackTrace(); + failed = true; + } + + if (failed) { + Utils.outputDebugString("Finished! (but encountered problems)"); + System.exit(-2); + } + } + + /** + * This methods takes a list of methods and filters them to only contain the + * public methods of the given class + * + * @param methods + * a list of methods + * @param className + * we will return a list of only this classes methods from the + * methods parameter + * @param attrSpecified + * if the user does not specify one we ignore namespaces + * @return + */ + private static List filterToPublicMethodsOfGivenClass(List methods, + String className, boolean useNamespace) { + if (methods != null && className != null && className.length() > 0) { + for (Iterator iter = methods.listIterator(); iter.hasNext();) { + Signature method = (Signature) iter.next(); + String scope = method.getScope(); + String sig = method.getOriginal(); + String namespace = method.getNamespace(); + + String qualifiedClassName; + if (useNamespace && null != namespace && 0 < namespace.length()) { + qualifiedClassName = namespace + "::" + + method.getTrimClassName(); + } else { + qualifiedClassName = method.getTrimClassName(); + } + + // If we are not public or the classname does not match + // remove... + if (!qualifiedClassName.equals(className) + || -1 == scope.indexOf("public")) { + iter.remove(); + } + } + } + return methods; + } + + /** + * Use an XSLT transformation to create a Proxy "view" of the DOM + * information + * + * @param outputDir + * where to put the C++ + * @param dom + * the DOM of semantic method information + * @throws TransformerException + */ + private static void createProxyCPPFromDom(File outputDir, Document dom) + throws TransformerException { + + //Create the Filename from the Service Name in the DOM + if (dom == null) { + return; + } + + String serviceOrReferenceName = "noSorRNameDefined"; + + String implClass = "nomoduleXmlFileHeaderDefined"; + + Element topNode = dom.getDocumentElement(); + if (null != topNode) { + Attr attr = topNode.getAttributeNode("nameOfSorR"); + if (attr != null) { + serviceOrReferenceName = attr.getNodeValue(); + } + + attr = topNode.getAttributeNode("implClass"); + if (attr != null) { + implClass = attr.getNodeValue(); + } + } + + File proxyCPP = new File(outputDir, implClass + "_" + + serviceOrReferenceName + "_Proxy.cpp"); + if (null != proxyCPP) { + + Utils.postEvent(Utils.DEPLOYMENT_ARTEFACT_GENERATED, proxyCPP + .getAbsolutePath()); + Utils.postEvent(Utils.EVENT_TYPE_FILE_CREATE, + "Scagen creating SCA for C++ proxy implementation " + + proxyCPP.getAbsolutePath()); + } + + createOutputFromDom(dom, proxyCPP, + "org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfProxyCPP.xsl"); + + } + + /** + * Use an XSLT transformation to create a Wrapper "view" of the DOM + * information + * + * @param outputDir + * where to put the C++ + * @param dom + * the DOM of semantic method information + * @throws TransformerException + */ + private static void createWrapperCPPFromDom(File outputDir, Document dom) + throws TransformerException { + + //Create the Filename from the Service Name in the DOM + if (dom == null) { + return; + } + + String serviceName = "noServiceDefined"; + + String implClass = "nomoduleXmlFileHeaderDefined"; + + Element topNode = dom.getDocumentElement(); + if (null != topNode) { + Attr attr = topNode.getAttributeNode("serviceName"); + if (attr != null) { + serviceName = attr.getNodeValue(); + } + + attr = topNode.getAttributeNode("implClass"); + if (attr != null) { + implClass = attr.getNodeValue(); + } + } + + File wrapperCPP = new File(outputDir, implClass + "_" + serviceName + + "_Wrapper.cpp"); + if (null != wrapperCPP) { + Utils.postEvent(Utils.DEPLOYMENT_ARTEFACT_GENERATED, wrapperCPP + .getAbsolutePath()); + Utils.postEvent(Utils.EVENT_TYPE_FILE_CREATE, + "Scagen creating SCA for C++ wrapper implementation " + + wrapperCPP.getAbsolutePath()); + } + createOutputFromDom(dom, wrapperCPP, + "org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfWrapperCPP.xsl"); + + } + + /** + * Use an XSLT transformation to create a Proxy header "view" of the DOM + * information + * + * @param outputDir + * where to put the C++ + * @param dom + * the DOM of sematic method information + * @throws TransformerException + */ + private static void createProxyHeaderFromDom(File outputDir, Document dom) + throws TransformerException { + + //Create the Filename from the Service Name in the DOM + if (dom == null) { + return; + } + + String serviceOrReferenceName = "noServiceDefined"; + String intfClass = "noInterfaceClassNameOrDefaultDefined"; + String implClass = "noImplementationClassOrDefaultDefined"; + + Element topNode = dom.getDocumentElement(); + if (null != topNode) { + Attr attr = topNode.getAttributeNode("nameOfSorR"); + if (attr != null) { + serviceOrReferenceName = attr.getNodeValue(); + } + attr = topNode.getAttributeNode("intfClass"); + if (attr != null) { + intfClass = attr.getNodeValue(); + } + attr = topNode.getAttributeNode("implClass"); + if (attr != null) { + implClass = attr.getNodeValue(); + } + } + + File proxyHeader = new File(outputDir, implClass + "_" + + serviceOrReferenceName + "_Proxy.h"); + if (null != proxyHeader) { + Utils.postEvent(Utils.DEPLOYMENT_ARTEFACT_GENERATED, proxyHeader + .getAbsolutePath()); + Utils.postEvent(Utils.EVENT_TYPE_FILE_CREATE, + "Scagen creating SCA for C++ proxy header " + + proxyHeader.getAbsolutePath()); + } + + createOutputFromDom(dom, proxyHeader, + "org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfProxyHeader.xsl"); + + } + + /** + * Use an XSLT transformation to create a Wrapper header "view" of the DOM + * information + * + * @param outputDir + * where to put the C++ + * @param dom + * the DOM of sematic method information + * @throws TransformerException + */ + private static void createWrapperHeaderFromDom(File outputDir, Document dom) + throws TransformerException { + + //Create the Filename from the Service Name in the DOM + if (dom == null) { + return; + } + + String serviceName = "noServiceDefined"; + + String implClass = "nomoduleXmlFileHeaderDefined"; + + Element topNode = dom.getDocumentElement(); + if (null != topNode) { + Attr attr = topNode.getAttributeNode("serviceName"); + if (attr != null) { + serviceName = attr.getNodeValue(); + } + + attr = topNode.getAttributeNode("implClass"); + if (attr != null) { + implClass = attr.getNodeValue(); + } + } + + File wrapperHeader = new File(outputDir, implClass + "_" + serviceName + + "_Wrapper.h"); + + if (null != wrapperHeader) { + Utils.postEvent(Utils.DEPLOYMENT_ARTEFACT_GENERATED, wrapperHeader + .getAbsolutePath()); + Utils.postEvent(Utils.EVENT_TYPE_FILE_CREATE, + "Scagen creating SCA for C++ wrapper header " + + wrapperHeader.getAbsolutePath()); + } + createOutputFromDom(dom, wrapperHeader, + "org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfWrapperHeader.xsl"); + + } + + /** + * This method will return a class loader that can see the resources that + * are parts of "this" package. + */ + private static ClassLoader getALoader() { + + LittleClass lc; + try { + lc = new LittleClass(); + return lc.getClass().getClassLoader(); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + /** + * This method will generically process the DOM using a stylesheet passed + * in. + * + * @param dom + * the source of data (the model) + * @param outputFile + * where to put the result + * @param xslTransformationFileName + * the xsl file containing the "view" + * @throws TransformerException + */ + private static void createOutputFromDom(Document dom, File outputFile, + String xslTransformationFileName) throws TransformerException { + + if(Options.noGenerate()){ + return; + } + + InputStream stream = getALoader().getResourceAsStream( + xslTransformationFileName); + StreamSource ss = new StreamSource(stream); + StreamResult out = new StreamResult(outputFile); + try { + Transformer xslt = txmf.newTransformer(ss); + + // Unless a width is set, there will be only line breaks but no + // indentation. + // The IBM JDK and the Sun JDK don't agree on the property name, + // so we set them both. + // + try { + xslt.setOutputProperty( + "{http://xml.apache.org/xalan}indent-amount", "2"); + } catch (Throwable t) { + //OK to ignore this, depends on XSLT engine and one will fail + } + try { + xslt.setOutputProperty( + "{http://xml.apache.org/xslt}indent-amount", "2"); + } catch (Throwable t) { + //OK to ignore this, depends on XSLT engine and one will fail + } + + DOMSource from = new DOMSource(dom); + + xslt.transform(from, out); + + } catch (TransformerConfigurationException e) { + e.printStackTrace(); + throw (e); + } catch (TransformerException e) { + e.printStackTrace(); + throw (e); + } finally { + try { + stream.close(); + } catch (IOException e1) { + // unlikely but if + // we can't close it, we can't close it + } + } + + } + + //TODO clear up the parameter list below to make it smaller if + // possible + /** + * This method will create A DOM containing all the semantic information + * that it can extract from a C++ header file. + * + * @param methods + * a list of methods that are going into the DOM + * @param source + * the header file the methods came from + * @param serviceName + * the name of the service + * @referenceName the name of the reference + * @nameOfSorR the non null one of the two parameters above + * @headerClassName the name of the header class + * @param moduleXmlFileImplHeaderNameWithPathAndExt + * the source filename + * @param moduleXmlFileHeaderNoExtorPath + * the shortname of the source file + * @param implClass + * the implementation class + * @param intfClass + * the interface we are turning into a service + * @return + */ + private static Document createDOMofMethods(List methods, File source, + String serviceName, String referenceName, String nameOfSorR, + String headerClassName, + String componentTypeXmlFileIntfHeaderNameWithPathAndExt, + String moduleXmlFileImplHeaderNameWithPathAndExt, + String moduleXmlFileHeaderNoExtorPath, String intfNamespace, + String intfClass, String implClass) { + + if (methods == null) { + return null; + } + + // Create a DOM of the methods + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + Document document = null; + try { + DocumentBuilder builder = factory.newDocumentBuilder(); + document = builder.newDocument(); + + Element root = (Element) document.createElement(CPP_HEADER); + + root.setAttribute(HEADER_NAME_ATTR, source.getPath()); + + document.appendChild(root); + + Element intf = (Element) document.createElement(SCA_SERVICE); + root.appendChild(intf); + + // Go through all the signatures we have collected... + Signature s = null; + for (Iterator iter = methods.iterator(); iter.hasNext();) { + s = (Signature) iter.next(); + + // Each signature is an operation + Element op = document.createElement(SCA_OPERATION); + op.setAttribute(OPERATION_NAME_ATTR, s.getMethodName()); + intf.appendChild(op); + + Parameter[] parms = s.getParameters(); + if (parms != null) { + + for (int i = 0; i < parms.length; i++) { + Element parm = (Element) document + .createElement(SCA_OPERATION_PARAMETER); + String type_string = parms[i].getTypeWithoutConst() + .toString(); + + type_string = type_string.replaceAll(":: ", "::"); + + Text text = document.createTextNode(type_string); + parm.appendChild(text); + parm.setAttribute(SCA_OPERATION_PARAMETER_NAME_ATTR, + parms[i].getName()); + + if (parms[i].getTypeWithoutConst().intern() != parms[i] + .getType().intern()) { + parm.setAttribute( + SCA_OPERATION_PARAMETER_CONST_ATTR, "true"); + } + + op.appendChild(parm); + // TO DO only really stores the value + // unsafely/temporarily + // which is fine while we handle everything at the + // end of parsing the "leaf" that represents that actual + // interface/service but the below will cause the second + // service + // processed to overwite the first one in the DOM. I we + // wish + // to do some overall processing at the end we will have + // to + // use a better more XPath like key that varies by + // instance + // of the service. + intf.setAttribute(SCA_INTERFACE_NAME_ATTR, s + .getTrimClassName()); + } + } + + Element rc = document.createElement(SCA_OPERATION_RETURN_TYPE); + rc.appendChild(document.createTextNode(s.getReturnType() + .toString().replaceAll(":: ", "::"))); + op.appendChild(rc); + + root.appendChild(intf); + } + + // Set the name of the Service + // here, if we are not passed one we use + // the classname from the last header function signature... + if (serviceName == null && s != null) { + serviceName = s.getTrimClassName(); + } + + // this is used for the proxy file name but we need to + // use the reference name if this is pulled in due to it + // being a reference!!! + if (serviceName != null) + root.setAttribute("serviceName", serviceName); + if (referenceName != null) + root.setAttribute("referenceName", referenceName); + if (nameOfSorR != null) + root.setAttribute("nameOfSorR", nameOfSorR); + + if (implClass != null) { + root.setAttribute("implClass", implClass); + } else { + root.setAttribute("implClass", moduleXmlFileHeaderNoExtorPath); + } + + // default class name to the name of the header... + if (headerClassName == null && source != null) { + headerClassName = source.getName().replaceAll( + "\\.h|\\.hpp|\\.h++", ""); + } + root.setAttribute("headerClassName", headerClassName); + + if (null == intfClass) { + intfClass = headerClassName; + } + + if (null != intfNamespace) { + root.setAttribute("namespace", intfNamespace); + if (null != intfClass && !intfClass.startsWith(intfNamespace)) { + intfClass = intfNamespace + "::" + intfClass; + } + } + + root.setAttribute("intfClass", intfClass); + + if (componentTypeXmlFileIntfHeaderNameWithPathAndExt == null) { + componentTypeXmlFileIntfHeaderNameWithPathAndExt = "componentTypeHeader"; + } + root.setAttribute("componentTypeHeader", + componentTypeXmlFileIntfHeaderNameWithPathAndExt); + + if (moduleXmlFileImplHeaderNameWithPathAndExt == null) { + moduleXmlFileImplHeaderNameWithPathAndExt = "moduleXmlFileImplHeader"; + } + root.setAttribute("moduleXmlFileHeader", + moduleXmlFileImplHeaderNameWithPathAndExt); + + if (moduleXmlFileHeaderNoExtorPath == null) { + moduleXmlFileHeaderNoExtorPath = "moduleXmlFileHeaderNoExt"; + } + root.setAttribute("moduleXmlFileHeaderNoExt", + moduleXmlFileHeaderNoExtorPath); + + } catch (ParserConfigurationException pce) { + // Parser with specified options can't be built + pce.printStackTrace(); + } + + return document; + + } + +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/XMLFileActor.java b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/XMLFileActor.java new file mode 100644 index 0000000000..047e1ab3f1 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/XMLFileActor.java @@ -0,0 +1,202 @@ +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.sca.cpp.tools.services; + +import java.io.File; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMResult; +import javax.xml.transform.dom.DOMSource; + +import org.apache.tuscany.sca.cpp.tools.common.FileActor; +import org.apache.tuscany.sca.cpp.tools.common.Utils; +import org.w3c.dom.Document; +import org.xml.sax.SAXException; + +/** + * The purpose of this abstract class is to provide a home for the standard + * processing that is involved in turning a XML file into an internal DOM. + */ +public abstract class XMLFileActor implements FileActor { + + protected static Map handlers = new HashMap(); + + protected static Map parameters = new HashMap(); + + public boolean failed; + + private int filesActedOn=0; + + protected static TransformerFactory transformerFactory = TransformerFactory + .newInstance(); + + /** + * This method is the main FileActor method + * + * @see FileActor#actOnFile(File, File, int) Here we create an initial DOM + * and kick off the processing (using the handler map that has been set + * up by the concrete subclass). + * + * @param moduleXML + * the sca.module or fragment file + * @param target + * the target directory + * @param depth + * not uesed here but in the + * @see FileActor#actOnFile(File, File, int) interface to allow for + * recursive diving into a directory structure. + */ + public void actOnFile(File moduleXML, File target, int depth) + throws Exception { + + if (null == moduleXML || null == target) { + return; + } + + filesActedOn++; + + parameters.put("sourceFile", moduleXML); + parameters.put("targetFile", target); + + if (transformerFactory.getFeature(DOMSource.FEATURE) + && transformerFactory.getFeature(DOMResult.FEATURE)) { + Document dom = createDomFromXMLFile(moduleXML); + if (dom != null) { + parameters.put("targetDirectoryFile", target); + DomHandler.handleDom(dom, handlers, parameters); + } + } + } + + /** + * This method builds an in memory DOM from an XML file + * + * @param xmlSourceFile + * the XML file we are handling + * @return the resulting document + */ + protected Document createDomFromXMLFile(File xmlSourceFile) { + Document dom = null; + DocumentBuilderFactory f = DocumentBuilderFactory.newInstance(); + //We do not validate via f.setValidating(true); + f.setNamespaceAware(true); + + try { + DocumentBuilder parser = f.newDocumentBuilder(); + dom = parser.parse(xmlSourceFile); + } catch (SAXException sxe) { + String path; + try { + path = xmlSourceFile.getCanonicalPath(); + } catch (IOException e) { + path = xmlSourceFile.getPath(); + } + Utils.screenMessage("There has been a SAXException of type " + + sxe.getLocalizedMessage()); + if (null != xmlSourceFile) { + Utils.screenMessage(" when processing file " + path); + } else { + Utils.screenMessage(" as the input file is null."); + } + +// Leave for possible future debug option +// Utils.screenMessage(" The returned Java exception is below."); +// if (sxe.getException() != null) +// sxe.getException().printStackTrace(); +// else +// sxe.printStackTrace(); + } catch (ParserConfigurationException pce) { + String path; + try { + path = xmlSourceFile.getCanonicalPath(); + } catch (IOException e) { + path = xmlSourceFile.getPath(); + } + Utils + .screenMessage("There has been a ParserConfigurationException of type " + + pce.getLocalizedMessage()); + if (null != xmlSourceFile) { + Utils.screenMessage(" when processing file " + path); + } else { + Utils.screenMessage(" as the input file is null."); + } + +// Leave for possible future debug option +// Utils.screenMessage(" The returned Java exception is below."); +// pce.printStackTrace(); + + } catch (IOException ioe) { + String path; + try { + path = xmlSourceFile.getCanonicalPath(); + } catch (IOException e) { + path = xmlSourceFile.getPath(); + } + + Utils.screenMessage("Unable to open file " + path); + Utils.screenMessage(this.getContextMessage()); + + + + } + + return dom; + } + + /** + * @return an error message - usually over-ridden. + */ + private String getContextMessage() { + return "Check the file exists and can be read."; + } + + /** + * Set a parameter + * + * @param name + * @param value + */ + public void setParameter(String name, Object value) { + parameters.put(name, value); + } + + /** + * Get a parameter + * + * @param name + * @param value + * @return the value of the parameter + */ + public Object getParameter(String name, Object value) { + return parameters.get(name); + } + + + + /** + * @return Returns the filesActedOn. + */ + public int getFilesActedOn() { + return filesActedOn; + } +}
\ No newline at end of file diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/package.html b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/package.html new file mode 100644 index 0000000000..316e4cd56e --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/package.html @@ -0,0 +1,140 @@ +<html> + +<head> +<title>Design documentation for org\apache\tuscany\sca\cpp\tools\services</title> +</head> + +<body lang=EN-GB> + +<div class=Section1> + +<h1>Overview</h1> + + + +<p>This package contains classes that generate C++ wrappers and +proxies for C++ implementations of SCA services. </p> + +<h2>What the package does</h2> + +<p>The Scagen class main method will take in an input and +output directory name. The input directory is taken to be the SCA module root +directory. The tool will generate the wrapper and proxy headers and methods +bodies in the output directory. </p> + +<p>These proxies and wrappers enable the SCA for C++ runtime to +act as a conduit for SCA C++ calls in a type free manner. Client code can call +the type specific functions that are in the generated proxy classes. The call +is marshalled into a generic format and a SCA for C++ runtime function with a +standard signature is invoked. The details of the call are passed as data. </p> + +<p>On the other end of the runtime, a generated function with a +standard signature is called, this function will inspect the data that +represents the call’s method name and call the appropriate type specific +function in the C++ implementation. </p> + +<h2>The Input Data Used</h2> + +<p>The input directory passed to the Scagen method is taken to +be the SCA module root directory. All the sca.module and .fragment files in +that directory are inspected to resolve all the <component/> elements +within them. </p> + +<p>Each <component/> element found is inspected to see if +it has a <implementation.cpp/> element within it. </p> + +<p>Each <implementation.cpp/> element should have a +header attribute that represents a C++ header file that contains function +prototypes for the C++ implementation of the service. An optional class +attribute can be used to select one class if more than one that is present in +the header file. The default class is the one with the same name as the header +file. The tool will verify that the implementation header contains an +appropriate class prototype. </p> + + + +<p>The directory that contains the implementation header should +also contain a matching .componentType file for the equivalent SCA component. So +for example, a MyServiceImpl.h file would have a corresponding MyServiceImpl.componentType +file in the same directory. </p> + + + +<p>Each componentType file is inspected for <service/> +and <reference/> elements. For each <service/> element that is +found that contains a <interface.cpp/> element within it,</p> + +<p>the header attribute of the <interface.cpp/> is taken +as the filename of the C++ interface header for the SCA service. This C++ +header file is opened and used as a means for specifying the SCA service +resulting in an appropriate wrapper and proxy being generated for this service +interface. Both method bodies and headers are generated in the given output +directory. The processing of a <reference/> element is the same except +that only a proxy header and implementation are generated. </p> + + + + + +<h2>Outline Design: How it Works</h2> + + + +<p>The basic approach is to scan in the XML files by first +creating a DOM document tree of them and then recursively rifling through the DOM +with some generic code in the XMLFileActorClass by default this processing will +build up a map which maps the XPath location of attributes to their values. +Additionally subclasses can add to a “handlers map” which maps from the name of +a particular element to an object that implements the DomNodeHandler interface. +If the XMLFileActor code comes across any element that has an equivalent handler +in the handler map the objects handleNode method will be called. </p> + +<p>Typically the DomNodeHandler’s handle node interface will +use XPath to pull out the parameters that it is interested in from the +parameters map that is being built up by the generic code. </p> + +<p>This design was chosen as the Java level specified for the +original implementation did not have direct XPath query of XML data but it was +known that this would be available in Java 1.5 onwards. The design allows the +DOM and parameters map handling to be replaced in the future with JRE 1.5 code +with less impact on the rest of the code.</p> + + + +<p>The processing leads to the parsing of the C++ interface +files using the org\apache\tuscany\sca\cpp\tools\common package. This results +in a Headers object</p> + +<p>that contains a List of Signature objects, each one +representing a function prototype found in the header. </p> + + + +<p>We are aiming to get all the semantic data we want to use +into a DOM document (this represents the model of our input data) and then use +XSLT to create the 4 different views of this data:</p> + +<p>Proxy C++ header</p> + +<p>Proxy C++ body</p> + +<p>Wrapper C++ header</p> + +<p>Wrapper C++ body</p> + + + +<p>So we prepopulate the DOM with parameter data that comes +from the XML files and then iterate through the Signatures that are returned +from the C++ header parser transferring the useful data into the DOM. </p> + + + +<p>We than use 4 XSLT stylesheets to generate the C++ output +files as required. </p> + +</div> + +</body> + +</html> diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfProxyCPP.xsl b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfProxyCPP.xsl new file mode 100644 index 0000000000..bc98f3a970 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfProxyCPP.xsl @@ -0,0 +1,398 @@ +<!-- +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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 WARRANTY + */ + + TODO There is duplication in the "..no_parms" templates with + the equivalent templates they are based on - that it would be + fairly easy to factor out. +--> +<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> +<!-- Part of the org.apache.tuscany.sca.cpp.tools.services packages + + This stylesheet creates the CPP implementation of the + proxy body for a given SCA service + --> +<xsl:output method="text"/> + +<!-- We do not generate output sourced from cppScopes --> +<xsl:template match="cppScope"></xsl:template> + +<!-- We do not generate output sourced from private scaOperations --> +<xsl:template match="scaOperation[@cppScope='private']"> +</xsl:template> + +<!-- We do not generate output sourced from the operation return types --> +<xsl:template match="scaOperationReturnType"> +</xsl:template> + + +<!-- + CPP Header/Root +--> +<xsl:template match="cppHeader">/* + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +<xsl:apply-templates select="scaService" mode="include_header"/> + +#include "osoa/sca/sca.h" +using namespace osoa::sca; +using namespace tuscany::sca;<!-- thats the prologue over nad done with + now continue with the scaServiceElement --> +<xsl:apply-templates/> <!-- should go on to generic scaService below --> +</xsl:template> + +<!-- --> +<!-- Service --> +<!-- --> +<xsl:template match="scaService"> +<xsl:variable name="clazz"> + <xsl:value-of select="../@implClass"/> + <xsl:text>_</xsl:text> + <xsl:value-of select="../@nameOfSorR"/> + <xsl:text>_Proxy</xsl:text> +</xsl:variable> +<xsl:text> +extern "C" +{ + + #if defined(WIN32) || defined(_WINDOWS) + __declspec(dllexport) + #endif + </xsl:text><xsl:value-of select="$clazz"/> +<xsl:text>* </xsl:text> +<xsl:value-of select="$clazz"/> +<xsl:text>_Factory(ServiceWrapper* target) + { + return new </xsl:text><xsl:value-of select="$clazz"/><xsl:text>(target); + } + + #if defined(WIN32) || defined(_WINDOWS) + __declspec(dllexport) + #endif + void </xsl:text> +<xsl:value-of select="$clazz"/> +<xsl:text>_Destructor(void* proxy) + { + delete (</xsl:text><xsl:value-of select="$clazz"/><xsl:text>*)proxy; + } +} + +</xsl:text> +<xsl:value-of select="$clazz"/><xsl:text>::</xsl:text><xsl:value-of select="$clazz"/>(ServiceWrapper* targ) : target(targ) +{ +} + +<xsl:value-of select="$clazz"/><xsl:text>::~</xsl:text><xsl:value-of select="$clazz"/>() +{ + if (target) + delete target; +}<!-- +OK we have done the stuff that is not specific to any function in the service +now we can do another apply-templates to pick up on the 0, 1 or more scaOperation +DOM nodes that each relate to a function in the service + --> +<xsl:apply-templates/> +<!-- Always make sure we have a (visible) final newline --> +<xsl:text> + +</xsl:text> +</xsl:template> + +<!-- This template is just a small function that will generate the + #include that pulls in the correct C++ header + --> +<xsl:template match="scaService" mode="include_header"> +<xsl:variable name="clazz"> + <xsl:value-of select="../@implClass"/> + <xsl:text>_</xsl:text> + <xsl:value-of select="../@nameOfSorR"/> + <xsl:text>_Proxy</xsl:text> +</xsl:variable> +<xsl:text>#include "</xsl:text> +<xsl:value-of select="$clazz"/> +<xsl:text>.h"</xsl:text> +</xsl:template> + + + +<!-- --> +<!-- Operation --> +<!-- --> +<xsl:template match="scaOperation"> +<xsl:variable name="clazz"> + <xsl:value-of select="../../@implClass"/> + <xsl:text>_</xsl:text> + <xsl:value-of select="../../@nameOfSorR"/> + <xsl:text>_Proxy</xsl:text> +</xsl:variable> + +<xsl:if test="@operationNameAttr != $clazz + and @operationNameAttr != concat('~', $clazz)" > +<xsl:text> +</xsl:text> +<xsl:value-of select="scaOperationReturnType"/> +<xsl:text> </xsl:text> +<xsl:value-of select="$clazz"/><xsl:text>::</xsl:text> +<xsl:value-of select="@operationNameAttr"/><xsl:text>(</xsl:text> +<xsl:if test="count(scaOperationParameter)=0"> +<xsl:text>) +{</xsl:text> +<xsl:call-template name="proxy_method_body_no_parms"/> +<xsl:text> +} +</xsl:text> +</xsl:if> + +<xsl:for-each select="scaOperationParameter"> + +<xsl:if test=".='void'"> +<xsl:text>) +{</xsl:text> +<xsl:call-template name="proxy_method_body"/> +<xsl:text> +} +</xsl:text> +</xsl:if> + +<xsl:if test=".!='void'"> + <xsl:variable name="scaOperationParameterNameAttr"> + <xsl:value-of select="concat('arg', position()-1 )"/> + </xsl:variable> + <xsl:variable name="isConst"> + <xsl:value-of select="@scaOperationParameterConstAttr"/> + </xsl:variable> + <xsl:if test="contains($isConst,'true')">const</xsl:if><xsl:text> </xsl:text> + <xsl:value-of select="."/> <!-- get the actual type --> + <xsl:text> </xsl:text> + <xsl:value-of select="$scaOperationParameterNameAttr"/> + <xsl:choose> + <xsl:when test="position()=last()"><xsl:text>) +{</xsl:text> +<xsl:call-template name="proxy_method_body"/> +<xsl:text> +} +</xsl:text> +</xsl:when> + <xsl:otherwise> + <xsl:text>, </xsl:text> + </xsl:otherwise> + </xsl:choose> +</xsl:if> + +</xsl:for-each> +</xsl:if> +</xsl:template> + + + + +<xsl:template name="proxy_method_body"> + <xsl:variable name="noOfParms"> + <xsl:choose> + <xsl:when test=".='void'"> +<xsl:text>0</xsl:text> + </xsl:when> + <xsl:otherwise> + <xsl:value-of select="last()"/> + </xsl:otherwise> + </xsl:choose> + </xsl:variable> +<xsl:text> + Operation operation("</xsl:text> + <xsl:value-of select="../@operationNameAttr"/> + <xsl:text>", </xsl:text> + <xsl:value-of select="$noOfParms"/> + <xsl:text>);</xsl:text> + <xsl:if test="$noOfParms!=0"> + <xsl:for-each select="../scaOperationParameter"> + <xsl:call-template name="proxy_method_body_set_parameter"/> + </xsl:for-each> + </xsl:if> +<xsl:text> + </xsl:text> + <xsl:call-template name="proxy_method_body_prepare_return_var"/> + <xsl:text> + target->invoke(operation); +</xsl:text> + <xsl:call-template name="proxy_method_body_return"/> +</xsl:template> + +<xsl:template name="proxy_method_body_no_parms"> + <xsl:variable name="noOfParms"> + <xsl:value-of select="0"/> + </xsl:variable> +<xsl:text> + Operation operation("</xsl:text> + <xsl:value-of select="@operationNameAttr"/> + <xsl:text>", </xsl:text> + <xsl:value-of select="$noOfParms"/> + <xsl:text>); + </xsl:text> + <xsl:call-template name="proxy_method_body_prepare_return_var_no_parms"/> + <xsl:text> + target->invoke(operation); +</xsl:text> + <xsl:call-template name="proxy_method_body_return_no_parms"/> +</xsl:template> + + +<xsl:template name="proxy_method_body_return"> + <xsl:variable name="type"> + <xsl:value-of select="../scaOperationReturnType/text()"/> + </xsl:variable> + <xsl:choose> + <xsl:when test="$type='void'"><!-- nothing --> + <xsl:text> return; +</xsl:text> + </xsl:when> + <xsl:when test="contains($type, '&')"><!-- reference --> + <xsl:variable name="type_no_amp"> + <xsl:value-of select="substring-before($type, '&')"/> + </xsl:variable> + <xsl:text> return *(</xsl:text><xsl:value-of select="$type_no_amp"/><xsl:text>*)operation.getReturnValue(); +</xsl:text> + </xsl:when> + <xsl:when test="contains($type, '*')"><!-- pointer --> + <xsl:text> return (</xsl:text><xsl:value-of select="$type"/><xsl:text>)operation.getReturnValue(); +</xsl:text> + </xsl:when> + <xsl:when test="contains($type, 'DataObjectPtr')"><!-- DataObjectPtr --> + <xsl:text> return ret; +</xsl:text> + </xsl:when> + <xsl:otherwise><!-- simple type --> + <xsl:text> return ret; +</xsl:text> + </xsl:otherwise> + </xsl:choose> +</xsl:template> + +<xsl:template name="proxy_method_body_return_no_parms"> + <xsl:variable name="type"> + <xsl:value-of select="scaOperationReturnType/text()"/> + </xsl:variable> + <xsl:choose> + <xsl:when test="$type='void'"><!-- nothing --> + <xsl:text> return; +</xsl:text> + </xsl:when> + <xsl:when test="contains($type, '&')"><!-- reference --> + <xsl:variable name="type_no_amp"> + <xsl:value-of select="substring-before($type, '&')"/> + </xsl:variable> + <xsl:text> return *(</xsl:text><xsl:value-of select="$type_no_amp"/><xsl:text>*)operation.getReturnValue(); +</xsl:text> + </xsl:when> + <xsl:when test="contains($type, '*')"><!-- pointer --> + <xsl:text> return (</xsl:text><xsl:value-of select="$type"/><xsl:text>)operation.getReturnValue(); +</xsl:text> + </xsl:when> + <xsl:when test="contains($type, 'DataObjectPtr')"><!-- DataObjectPtr --> + <xsl:text> return ret; +</xsl:text> + </xsl:when> + <xsl:otherwise><!-- simple type --> + <xsl:text> return ret; +</xsl:text> + </xsl:otherwise> + </xsl:choose> +</xsl:template> + + +<xsl:template name="proxy_method_body_prepare_return_var"> + <xsl:variable name="type"> + <xsl:value-of select="../scaOperationReturnType/text()"/> + </xsl:variable> + <xsl:choose> + <xsl:when test="$type='void'"><!-- nothing --> + <!-- nothing --> + </xsl:when> + <xsl:when test="contains($type, '&')"><!-- reference --> + </xsl:when> + <xsl:when test="contains($type, '*')"><!-- pointer --> + <!-- nothing to do --> + </xsl:when> + <xsl:when test="contains($type, 'DataObjectPtr')"><!-- DataObjectPtr --> + <xsl:text> commonj::sdo::DataObjectPtr ret = 0; + operation.setReturnValue((void*)&ret); +</xsl:text> + </xsl:when> + <xsl:otherwise><!-- simple type - for some reason the inital tab does not appear --> +<xml:text> + </xml:text><xml:text> + </xml:text><xsl:value-of select="$type"/><xsl:text> ret; +</xsl:text> +<xsl:text> operation.setReturnValue((void*)&ret);</xsl:text> + </xsl:otherwise> + </xsl:choose> + +</xsl:template> + +<xsl:template name="proxy_method_body_prepare_return_var_no_parms"> + <xsl:variable name="type"> + <xsl:value-of select="scaOperationReturnType/text()"/> + </xsl:variable> + <xsl:choose> + <xsl:when test="$type='void'"><!-- nothing --> + <!-- nothing --> + </xsl:when> + <xsl:when test="contains($type, '&')"><!-- reference --> + </xsl:when> + <xsl:when test="contains($type, '*')"><!-- pointer --> + <!-- nothing to do --> + </xsl:when> + <xsl:when test="contains($type, 'DataObjectPtr')"><!-- DataObjectPtr --> + <xsl:text> commonj::sdo::DataObjectPtr ret = 0; + operation.setReturnValue((void*)&ret); +</xsl:text> + </xsl:when> + <xsl:otherwise><!-- simple type - for some reason the inital tab does not appear --> +<xml:text> + </xml:text><xml:text> + </xml:text><xsl:value-of select="$type"/><xsl:text> ret; +</xsl:text> +<xsl:text> operation.setReturnValue((void*)&ret);</xsl:text> + </xsl:otherwise> + </xsl:choose> + +</xsl:template> + +<xsl:template name="proxy_method_body_set_parameter"> + <xsl:variable name="scaOperationParameterNameAttrInner"> + <xsl:value-of select="concat('arg', position()-1 )"/> + </xsl:variable> + <xsl:variable name="type"> + <xsl:value-of select="."/> + </xsl:variable> + operation.setParameter(<xsl:value-of select="position()-1"/><xsl:text>, (void*)</xsl:text> +<xsl:if test="not(contains($type, '*'))">&</xsl:if> +<xsl:value-of select="$scaOperationParameterNameAttrInner"/> +<xsl:text>); +</xsl:text> +</xsl:template> +</xsl:stylesheet> diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfProxyHeader.xsl b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfProxyHeader.xsl new file mode 100644 index 0000000000..3df2f83d53 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfProxyHeader.xsl @@ -0,0 +1,215 @@ +<!-- +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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 WARRANTY + */ +--> +<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> +<!-- Part of the org.apache.tuscany.sca.cpp.tools.services packages + - + - This stylesheet creates the CPP implementation of the + - proxy header for a given SCA service + --> + + <xsl:output method="text" /> + + <!-- Delete cppScopes --> + <xsl:template match="cppScope"></xsl:template> + + <!-- Delete private methods cppScopes --> + <xsl:template match="scaOperation[@cppScope='private']"> + </xsl:template> + + <!-- Delete private methods cppScopes --> + <xsl:template match="scaOperationReturnType"></xsl:template> + + + <!-- --> + <!-- CPP Header/Root --> + <!-- --> + <xsl:template match="cppHeader"> + <xsl:variable name="class"> + <xsl:value-of select="concat(@implClass, '_', @nameOfSorR, '_Proxy')"/> + </xsl:variable> +<xsl:text>/* + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +</xsl:text> + <xsl:call-template name="ifndef_start"> + <xsl:with-param name="class" + select="$class"/> + </xsl:call-template> + + + <xsl:call-template name="include_headers"> + <xsl:with-param name="componentTypeHeader" + select="@componentTypeHeader"/> + </xsl:call-template> + + <xsl:apply-templates select="scaService" mode="class_body"/> + + <xsl:call-template name="ifndef_end"> + <xsl:with-param name="class" + select="$class"/> + </xsl:call-template> +<!-- Always make sure we have a (visible) final newline --> +<xsl:text> + +</xsl:text> +</xsl:template> + + +<!-- Here are the subroutine templates in order --> + + <xsl:template name="ifndef_start"> + <!--For example, + #ifndef CustomerInfoImpl_CustomerInfoService_Proxy_h + #define CustomerInfoImpl_CustomerInfoService_Proxy_h + --> + <xsl:param name="class"/> + <xsl:text>#ifndef </xsl:text><xsl:value-of select="$class"/><xsl:text>_h</xsl:text> +<!-- newline --> +<xsl:text> +</xsl:text> + <xsl:text>#define </xsl:text><xsl:value-of select="$class"/><xsl:text>_h</xsl:text> +<!-- newline --> +<xsl:text> + +</xsl:text> + </xsl:template> + + <xsl:template name="include_headers"> + <!--For example, + #include "CustomerInfo.h" + #include "tuscany/sca/core/ServiceWrapper.h" + --> + <xsl:param name="componentTypeHeader"/> + <xsl:text>#include "</xsl:text><xsl:value-of select="translate($componentTypeHeader,'\','/')"/><xsl:text>"</xsl:text> +<!-- newline --> +<xsl:text> +</xsl:text> + <xsl:text>#include "tuscany/sca/core/ServiceWrapper.h"</xsl:text> + </xsl:template> + + <xsl:template match="scaService" mode="class_body"> + <!--For example + class proxyclassname : public interface_class + { + constructor + destructor + then apply operation templates for operations + }; + + E.g. Specifically + + class CustomerInfoImpl_CustomerInfoService_Proxy : public CustomerInfo + { + public: + CustomerInfoImpl_CustomerInfoService_Proxy(tuscany::sca::ServiceWrapper*); + virtual ~CustomerInfoImpl_CustomerInfoService_Proxy(); + virtual const char* getCustomerInformation(const char* customerID); + private: + tuscany::sca::ServiceWrapper* target; + }; + --> + <!-- TODO second definition, remove? --> + <xsl:variable name="class"> + <xsl:value-of select="concat(../@implClass, '_', ../@nameOfSorR, '_Proxy')"/> + </xsl:variable> +<xsl:text> + +class </xsl:text> +<xsl:value-of select="$class"/> +<xsl:text> : public </xsl:text><xsl:value-of select="../@intfClass"/> +<xsl:text> +{ +public: + </xsl:text><xsl:value-of select="$class"/><xsl:text>(tuscany::sca::ServiceWrapper*);</xsl:text> + <xsl:text> + virtual ~</xsl:text><xsl:value-of select="$class"/><xsl:text>(); +</xsl:text> + <!-- operations --> + <xsl:apply-templates/> +<xsl:text>private: + tuscany::sca::ServiceWrapper* target; +}; +</xsl:text> + </xsl:template> + + <xsl:template name="ifndef_end"> + <!--For example, + #endif // CustomerInfoImpl_CustomerInfoService_Proxy_h + --> + <xsl:param name="class"/> + <xsl:text> +#endif // </xsl:text><xsl:value-of select="$class"/><xsl:text>_h</xsl:text> + </xsl:template> + + + + + + +<!-- Operation --> +<!--For example + virtual const char* getCustomerInformation(const char* customerID); +--> +<xsl:template match="scaOperation"> +<xsl:variable name="class"> + <xsl:value-of select="concat(../../@implClass, '_', ../../@nameOfSorR, '_Proxy')"/> +</xsl:variable> +<xsl:if test="@operationNameAttr != $class + and @operationNameAttr != concat('~', $class)" > +<xsl:text> virtual </xsl:text> +<xsl:value-of select="scaOperationReturnType"/> +<xsl:text> </xsl:text> +<xsl:value-of select="@operationNameAttr"/><xsl:text>(</xsl:text> +<xsl:for-each select="scaOperationParameter"> + <xsl:variable name="isConst"> + <xsl:value-of select="@scaOperationParameterConstAttr"/> + </xsl:variable> + <xsl:variable name="noOfParms"> + <xsl:value-of select="last()"/> + </xsl:variable> + <xsl:if test="contains($isConst,'true')">const</xsl:if><xsl:text> </xsl:text> + <xsl:value-of select="."/> <!-- get the actual type --> + <xsl:text> </xsl:text> + <xsl:value-of select="@scaOperationParameterNameAttr"/> + <xsl:choose> + <xsl:when test="position()=last()"></xsl:when> + <xsl:otherwise> + <xsl:text>, </xsl:text> + </xsl:otherwise> + </xsl:choose> + </xsl:for-each> +<xsl:text>); +</xsl:text> +</xsl:if> +</xsl:template> +</xsl:stylesheet> + + + diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfWrapperCPP.xsl b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfWrapperCPP.xsl new file mode 100644 index 0000000000..912df6cf03 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfWrapperCPP.xsl @@ -0,0 +1,278 @@ +<!-- +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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 WARRANTY + */ +--> +<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> +<!-- Part of the org.apache.tuscany.sca.cpp.tools.services packages + - + - This stylesheet creates the CPP implementation of the + - wrapper body for a given SCA service + --> +<xsl:output method="text"/> + +<!-- Delete cppScopes --> +<xsl:template match="cppScope"></xsl:template> + +<!-- Delete private methods cppScopes --> +<xsl:template match="scaOperation[@cppScope='private']"> +</xsl:template> + +<!-- Don't act on return types --> +<xsl:template match="scaOperationReturnType"> +</xsl:template> + + +<!-- --> +<!-- CPP Header/Root --> +<!-- --> +<xsl:template match="cppHeader">/* + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +<xsl:apply-templates select="scaService" mode="include_header"/> + +#include "osoa/sca/sca.h" +using namespace osoa::sca; +using namespace tuscany::sca; +<!-- thats the prologue over and done with + now continue with the scaServiceElement --> +<xsl:apply-templates/> <!-- will be applied to scaService --> +<!-- Always make sure we have a final newline --> +<xsl:text> + +</xsl:text> +</xsl:template> + +<!-- --> +<!-- Service --> +<!-- --> +<xsl:template match="scaService"> +<xsl:variable name="class"> + <xsl:value-of select="../@implClass"/> + <xsl:text>_</xsl:text> + <xsl:value-of select="../@serviceName"/> + <xsl:text>_Wrapper</xsl:text> +</xsl:variable> +<xsl:text>extern "C" +{ + + #if defined(WIN32) || defined(_WINDOWS) + __declspec(dllexport) + #endif + </xsl:text><xsl:value-of select="$class"/> +<xsl:text>* </xsl:text> +<xsl:value-of select="$class"/> +<xsl:text>_Factory(tuscany::sca::model::Service* target) + { + return new </xsl:text><xsl:value-of select="$class"/><xsl:text>(target); + } +} + +</xsl:text> +<xsl:value-of select="$class"/><xsl:text>::</xsl:text><xsl:value-of select="$class"/><xsl:text>(Service* target) : ComponentServiceWrapper(target) +{ + impl = (</xsl:text><xsl:value-of select="../@implClass"/><xsl:text>*)getImplementation(); +} + +</xsl:text> +<xsl:value-of select="$class"/><xsl:text>::~</xsl:text><xsl:value-of select="$class"/><xsl:text>() +{ + releaseImplementation(); +} + +void* </xsl:text> +<xsl:value-of select="$class"/><xsl:text>::newImplementation() +{ + return new </xsl:text><xsl:value-of select="../@implClass"/><xsl:text>; +} + +void </xsl:text> +<xsl:value-of select="$class"/><xsl:text>::deleteImplementation() +{ + delete impl; +} + +void </xsl:text><xsl:value-of select="$class"/><xsl:text>::invokeService(Operation& operation) +{ + const string& operationName = operation.getName(); + +</xsl:text> +<xsl:apply-templates/><!-- an if statment for each operation --> +<xsl:text> + + throw ServiceRuntimeException("Invalid operation"); + +}</xsl:text> +</xsl:template> + +<xsl:template match="scaService" mode="include_header"> +<xsl:variable name="class"> + <xsl:value-of select="../@implClass"/> + <xsl:text>_</xsl:text> + <xsl:value-of select="../@serviceName"/> + <xsl:text>_Wrapper</xsl:text> +</xsl:variable> +<xsl:text>#include "</xsl:text> +<xsl:value-of select="$class"/> +<xsl:text>.h"</xsl:text> +</xsl:template> + +<!-- --> +<!-- Operation --> +<!-- --> +<xsl:template match="scaOperation"> +<!--For example + if (operationName == "getCustomerInformation") + { + operation.setReturnValue(impl->getCustomerInformation((const char*)parms[0])); + return; + } +--> +<xsl:if test="@operationNameAttr != ../../@intfClass + and @operationNameAttr != concat('~', ../../@intfClass)" > +<xsl:text> if (operationName == "</xsl:text> +<xsl:value-of select="@operationNameAttr"/> +<xsl:text>") + { +</xsl:text> + <xsl:call-template name="this_operation_body"/> +<xsl:text> + } +</xsl:text> + +</xsl:if> +</xsl:template> + +<xsl:template name="this_operation_body"> +<xsl:if test="./scaOperationParameter/text() != 'void' "> + <xsl:if test="normalize-space(./scaOperationParameter/text()) != ' ' "> + <xsl:if test="./scaOperationParameter/text() != '' "> + <xsl:for-each select="scaOperationParameter"> + <xsl:call-template name="prepare_parameter_n"/> + </xsl:for-each> + </xsl:if> + </xsl:if> +</xsl:if> +<xsl:call-template name="invoke_for_return_type"/> +<xsl:text> + return;</xsl:text> +</xsl:template> + +<xsl:template name="prepare_parameter_n"> + <xsl:variable name="isConst"> + <xsl:value-of select="@scaOperationParameterConstAttr"/> + </xsl:variable> + <xsl:variable name="type"> + <xsl:value-of select="."/> + </xsl:variable> +<xsl:text> </xsl:text> + <xsl:choose> + <xsl:when test="contains($type, '&')"><!-- reference --> + <xsl:variable name="type_no_amp"> + <xsl:value-of select="substring-before($type, '&')"/> + </xsl:variable> + <xsl:value-of select="$type"/><xsl:text> p</xsl:text><xsl:value-of select="position()-1"/><xsl:text> = *(</xsl:text><xsl:value-of select="$type_no_amp"/> + <xsl:text>*)operation.getParameter(</xsl:text><xsl:value-of select="position()-1"/><xsl:text>); +</xsl:text> + </xsl:when> + <xsl:when test="contains($type, '*')"><!-- pointer --> + <xsl:if test="contains($isConst,'true')">const </xsl:if> + <xsl:value-of select="."/><xsl:text> p</xsl:text><xsl:value-of select="position()-1"/><xsl:text> = (</xsl:text> + <xsl:if test="contains($isConst,'true')">const</xsl:if><xsl:text> </xsl:text> + <xsl:value-of select="$type"/> + <xsl:text>)operation.getParameter(</xsl:text><xsl:value-of select="position()-1"/><xsl:text>); +</xsl:text> + </xsl:when> + <xsl:when test="contains($type, 'DataObjectPtr')"><!-- DataObjectPtr --> + <xsl:text>DataObjectPtr& p</xsl:text><xsl:value-of select="position()-1"/><xsl:text> = *(DataObjectPtr*)operation.getParameter(</xsl:text><xsl:value-of select="position()-1"/><xsl:text>);</xsl:text> + </xsl:when> + <xsl:otherwise><!-- simple type --> + <xsl:if test="contains($isConst,'true')">const </xsl:if><xsl:value-of select="$type"/><xsl:text>& p</xsl:text><xsl:value-of select="position()-1"/><xsl:text> = *(</xsl:text> + <xsl:if test="contains($isConst,'true')">const</xsl:if><xsl:text> </xsl:text> + <xsl:value-of select="$type"/> + <xsl:text>*)operation.getParameter(</xsl:text><xsl:value-of select="position()-1"/><xsl:text>); +</xsl:text> + + </xsl:otherwise> + </xsl:choose> +</xsl:template> + +<xsl:template name="invoke_for_return_type"> + <xsl:variable name="type"> + <xsl:value-of select="./scaOperationReturnType/text()"/> + </xsl:variable> + <xsl:choose> + <!-- VOID --> + <xsl:when test="$type='void'"> +<xsl:text> </xsl:text> + <xsl:call-template name="impl_arrow_op_brackets_and_parms"/><xsl:text>;</xsl:text> + </xsl:when> + <xsl:when test="contains($type, '&')"><!-- reference --> + <xsl:text> </xsl:text><xsl:value-of select="$type"/><xsl:text> ret = </xsl:text><xsl:call-template name="impl_arrow_op_brackets_and_parms"/><xsl:text>;</xsl:text> + <xsl:text> + operation.setReturnValue((void*)&ret);</xsl:text> + </xsl:when> + <xsl:when test="contains($type, '*')"><!-- pointer --> + <xsl:text> + operation.setReturnValue((void*) </xsl:text><xsl:call-template name="impl_arrow_op_brackets_and_parms"/><xsl:text>);</xsl:text> + </xsl:when> + <xsl:when test="contains($type, 'DataObjectPtr')"><!-- DataObjectPtr --> + <xsl:text> *(DataObjectPtr*)operation.getReturnValue() = </xsl:text><xsl:call-template name="impl_arrow_op_brackets_and_parms"/><xsl:text>;</xsl:text> + </xsl:when> + <xsl:otherwise><!-- simple type --> + <xml:text> *(</xml:text><xsl:value-of select="$type"/><xsl:text>*)operation.getReturnValue() = </xsl:text><xsl:call-template name="impl_arrow_op_brackets_and_parms"/><xsl:text>;</xsl:text> + </xsl:otherwise> + </xsl:choose> +</xsl:template> + +<xsl:template name="impl_arrow_op_brackets_and_parms"><!-- context is "scaOperation" --> + <xml:text>impl-></xml:text><xsl:value-of select="./@operationNameAttr"/><xml:text>(</xml:text> +<xsl:if test="./scaOperationParameter/text() != 'void' "> + <xsl:if test="./scaOperationParameter/text() != '' "> + <xsl:if test="normalize-space(./scaOperationParameter/text()) != ' ' "> + <xsl:for-each select="scaOperationParameter"> + <xsl:call-template name="parameter_for_parameter_list"/> + </xsl:for-each> +</xsl:if> +</xsl:if> +</xsl:if> +<xsl:text>)</xsl:text> +</xsl:template> + +<xsl:template name="parameter_for_parameter_list"> +<xsl:text>p</xsl:text><xsl:value-of select="position()-1"/> + <xsl:choose> + <xsl:when test="position()=last()"></xsl:when> + <xsl:otherwise> + <xsl:text>, </xsl:text> + </xsl:otherwise> + </xsl:choose> +</xsl:template> + + + +</xsl:stylesheet> diff --git a/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfWrapperHeader.xsl b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfWrapperHeader.xsl new file mode 100644 index 0000000000..72dc1fc5a6 --- /dev/null +++ b/sca-cpp/tags/cpp-sca-20060405/tools/scagen/src/org/apache/tuscany/sca/cpp/tools/services/xsl/SCA4CPPIntfWrapperHeader.xsl @@ -0,0 +1,178 @@ +<!-- +/* + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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 WARRANTY + */ +--> +<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> +<!-- Part of the org.apache.tuscany.sca.cpp.tools.services packages + - + - This stylesheet creates the CPP implementation of the + - wrapper header for a given SCA service + --> + <xsl:output method="text" /> + + <!-- Delete cppScopes --> + <xsl:template match="cppScope"></xsl:template> + + <!-- Delete private methods cppScopes --> + <xsl:template match="scaOperation[@cppScope='private']"> + </xsl:template> + + <!-- Delete private methods cppScopes --> + <xsl:template match="scaOperationReturnType"></xsl:template> + + + <!-- --> + <!-- CPP Header/Root --> + <!-- --> + <xsl:template match="cppHeader"> + <xsl:variable name="class"> + <xsl:value-of select="concat(@implClass, '_', @serviceName, '_Wrapper')"/> + </xsl:variable> +<xsl:text>/* + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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. + */ + +</xsl:text> + <xsl:call-template name="ifndef_start"> + <xsl:with-param name="class" + select="$class"/> + </xsl:call-template> + + + <xsl:call-template name="include_headers"> + <xsl:with-param name="header" + select="@moduleXmlFileHeader"/> + </xsl:call-template> + + <xsl:apply-templates select="scaService" mode="class_body"/> + + <xsl:call-template name="ifndef_end"> + <xsl:with-param name="class" + select="$class"/> + </xsl:call-template> +<!-- Always make sure we have a (visible) final return --> +<xsl:text> + +</xsl:text> +</xsl:template> + + +<!-- Here are the subroutine templates in order --> + + <xsl:template name="ifndef_start"> + <!--For example, + #ifndef CustomerInfoImpl_CustomerInfoService_Wrapper_h + #define CustomerInfoImpl_CustomerInfoService_Wrapper_h + --> + <xsl:param name="class"/> + <xsl:text>#ifndef </xsl:text><xsl:value-of select="$class"/><xsl:text>_h</xsl:text> +<!-- newline --> +<xsl:text> +</xsl:text> + <xsl:text>#define </xsl:text><xsl:value-of select="$class"/><xsl:text>_h</xsl:text> +<!-- newline --> +<xsl:text> + +</xsl:text> + </xsl:template> + + <xsl:template name="include_headers"> + <!--For example, + #include "CustomerInfoImpl.h" + #include "tuscany/sca/core/ComponentServiceWrapper.h" + --> + <xsl:param name="header"/> + <xsl:text>#include "</xsl:text><xsl:value-of select="translate($header,'\','/')"/><xsl:text>"</xsl:text> +<!-- newline --> +<xsl:text> +</xsl:text> + <xsl:text>#include "tuscany/sca/core/ComponentServiceWrapper.h"</xsl:text> + </xsl:template> + + <xsl:template match="scaService" mode="class_body"> + <!--For example + class wrapperclassname : public tuscany::sca::ComponentServiceWrapper + { + constructor + destructor + then apply operation templates for operations + }; + + E.g. Specifically + + class CustomerInfoImpl_CustomerInfoService_Wrapper : public tuscany::sca::ComponentServiceWrapper + { + public: + CustomerInfoImpl_CustomerInfoService_Wrapper(tuscany::sca::model::Component*); + virtual ~CustomerInfoImpl_CustomerInfoService_Wrapper(); + virtual void invoke(tuscany::sca::Operation& operation); + + private: + CustomerInfoImpl* impl; + }; + --> + <!-- TODO second definition, remove? --> + <xsl:variable name="class"> + <xsl:value-of select="concat(../@implClass, '_', ../@serviceName, '_Wrapper')"/> + </xsl:variable> +<xsl:text> + +class </xsl:text> +<xsl:value-of select="$class"/> +<xsl:text> : public tuscany::sca::ComponentServiceWrapper +{ +public: + </xsl:text><xsl:value-of select="$class"/><xsl:text>(tuscany::sca::model::Service* target);</xsl:text> + <xsl:text> + virtual ~</xsl:text><xsl:value-of select="$class"/><xsl:text>(); + virtual void invokeService(tuscany::sca::Operation& operation); + virtual void* newImplementation(); + virtual void deleteImplementation(); +</xsl:text> +<xsl:text>private: + </xsl:text> + <xsl:value-of select="../@implClass"/><xsl:text>* impl; +}; +</xsl:text> + </xsl:template> + + <xsl:template name="ifndef_end"> + <!--For example, + #endif // CustomerInfoImpl_CustomerInfoService_Wrapper_h + --> + <xsl:param name="class"/> + <xsl:text> +#endif // </xsl:text><xsl:value-of select="$class"/><xsl:text>_h</xsl:text> + </xsl:template> + +<xsl:template match="scaOperation"> +</xsl:template> + +</xsl:stylesheet> + + + |