Author: nadiramra
Date: Mon Apr 4 03:22:52 2011
New Revision: 1088470
URL: http://svn.apache.org/viewvc?rev=1088470&view=rev
Log:
Move unused code to graveyard
Added:
axis/axis1/c/trunk/graveyard/tools/org/
axis/axis1/c/trunk/graveyard/tools/org/apache/
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/TraceInstrumentor.java
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/Tracer.java
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/tracetool.conf
Added:
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/TraceInstrumentor.java
URL:
http://svn.apache.org/viewvc/axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/TraceInstrumentor.java?rev=1088470&view=auto
==============================================================================
---
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/TraceInstrumentor.java
(added)
+++
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/TraceInstrumentor.java
Mon Apr 4 03:22:52 2011
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2003-2004 The Apache Software Foundation.
+// (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.axis.tools.trace;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.apache.axis.tools.common.BodyPart;
+import org.apache.axis.tools.common.CParsingTool;
+import org.apache.axis.tools.common.Configuration;
+import org.apache.axis.tools.common.DirectoryTree;
+import org.apache.axis.tools.common.FileActor;
+import org.apache.axis.tools.common.FilePart;
+import org.apache.axis.tools.common.InputCppSourceCode;
+import org.apache.axis.tools.common.MethodPart;
+import org.apache.axis.tools.common.ParsingException;
+import org.apache.axis.tools.common.Utils;
+
+/**
+ * This class is a tool that adds entry/exit/catch trace to C and C++
+ * source code. It contains a main program:-
+ *
+ * usage: Java TraceInstrumentor -source <dir> -target <dir> -include <dir>
+ */
+public class TraceInstrumentor extends CParsingTool implements FileActor {
+ private static Set cExtensions =
+ new HashSet(Arrays.asList(new Object[] { "c", "cpp", "h", "hpp"
}));
+
+ private TraceInstrumentor(String[] args) throws Exception {
+ super(args);
+ }
+
+ /**
+ * This method is called by the DirectoryTree with two files: the
+ * input (source) file and the output (target) file. This method parses
+ * the source file and writes out the target files with trace in it.
+ * The depth is how deep in the source directory tree we are. Files are
+ * excluded if they are listed in the configuration because they
shouldn't
+ * have trace added to them.
+ */
+ public void actOnFile(File source, File target, int depth)
+ throws Exception {
+ String sourceName = source.getName();
+ int dot = sourceName.lastIndexOf(".");
+ String ext = new String();
+ if (-1 != dot)
+ ext = sourceName.substring(dot + 1);
+
+ String targetName =
+ DirectoryTree.maybeAppendSeparator(target.toString());
+ File outputFile = new File(targetName + sourceName);
+
+ if (cExtensions.contains(ext)
+ && !Configuration.fileExcluded(sourceName)) {
+ Utils.outputDebugString("parsing " + source + "...");
+
+ // create a tracer to the output file
+ Tracer output =
+ new Tracer(new FileWriter(outputFile, false),
depth, headers);
+
+ // OK, now we have the output file let's read in the
input file !
+ FileReader fr = new FileReader(source);
+ BufferedReader inputFile = new BufferedReader(fr);
+
+ try {
+ parseFile(
+ new InputCppSourceCode(inputFile,
source.getName()),
+ output);
+ } catch (ParsingException pe) {
+ failed = true;
+ }
+
+ output.flush();
+ output.close();
+ inputFile.close();
+ } else {
+ System.out.println("excluding file " + source);
+ FileInputStream fis = new FileInputStream(source);
+ FileOutputStream fos = new FileOutputStream(outputFile);
+ int b = fis.read();
+ while (-1 != b) {
+ fos.write(b);
+ b = fis.read();
+ }
+ }
+ }
+
+ /**
+ * Parses the given file and adds trace to it, placing the newly traced
code
+ * into the outputfile
+ *
+ * @param inputFile the input file reader
+ * @param outputFile the output file writer
+ */
+ private void parseFile(InputCppSourceCode inputFile, Tracer outputFile)
+ throws Exception {
+ Iterator it = inputFile.getPartIterator();
+ while (it.hasNext()) {
+ FilePart fp = (FilePart) (it.next());
+ if (fp.getType() == FilePart.METHOD) {
+ MethodPart mp = (MethodPart) fp;
+ outputFile.writeTrace(mp.getOriginalSignature()
+ "{");
+ outputFile.traceEntry(mp.getSignature());
+ BodyPart[] bps = mp.getBodyParts();
+
+ int returnCount = 0,
+ catchCount = 0,
+ returnIndex = 0,
+ catchIndex = 0;
+ for (int i = 0; i < bps.length - 1; i++)
+ if (bps[i].isReturn())
+ returnCount++;
+ for (int i = 0; i < bps.length - 1; i++)
+ if (bps[i].isCatch())
+ catchCount++;
+
+ for (int i = 0; i < bps.length; i++) {
+
outputFile.writeTrace(bps[i].getCodeFragment());
+ if (bps[i].isReturn()) {
+ if (returnCount > 1)
+ returnIndex++;
+ outputFile.traceExit(
+ bps[i].getReturnValue(),
+ returnIndex);
+ } else if (bps[i].isCatch()) {
+ if (catchCount > 1)
+ catchIndex++;
+ outputFile.traceCatch(
+ bps[i].getCaughtValue(),
+ catchIndex);
+ } else if (i < bps.length - 1) {
+ if (returnCount > 1)
+ returnIndex++;
+
outputFile.traceExit(returnIndex);
+ }
+ }
+ } else {
+ outputFile.writeTrace(fp.toString());
+ }
+ }
+ }
+
+ public static void main(String[] args) {
+ boolean failed = false;
+ try {
+ TraceInstrumentor ti = new TraceInstrumentor(args);
+ File source = ti.checkFile("-source");
+ File target = ti.maybeCreateDirectory("-target");
+ ti.headers = ti.preparseHeaders("-include");
+
+ DirectoryTree tree = new DirectoryTree(ti, null);
+ tree.walkTree(source, target, 0);
+ failed = ti.failed;
+ } catch (Exception exception) {
+ exception.printStackTrace();
+ failed = true;
+ }
+
+ if (failed) {
+ Utils.outputDebugString("Finished! (but encountered
problems)");
+ System.exit(-2);
+ }
+ Utils.outputDebugString("Finished!");
+ }
+
+ protected void printUsage() {
+ System.out.println(
+ "usage: Java TraceInstrumentor "
+ + "-config <file> -source <dir> "
+ + "-target <dir> -include <dir>");
+ }
+
+}
Added:
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/Tracer.java
URL:
http://svn.apache.org/viewvc/axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/Tracer.java?rev=1088470&view=auto
==============================================================================
--- axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/Tracer.java
(added)
+++ axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/Tracer.java
Mon Apr 4 03:22:52 2011
@@ -0,0 +1,404 @@
+/*
+ * Copyright 2003-2004 The Apache Software Foundation.
+// (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.axis.tools.trace;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Set;
+import java.util.StringTokenizer;
+
+import org.apache.axis.tools.common.*;
+
+/**
+ * A Buffered write that also contains the methods to add in in trace
+ * TODO: Add in &this and threadid into each trace record
+ */
+class Tracer extends BufferedWriter {
+ private Signature signature = null;
+ private final static String SIGNATURE = " /* AUTOINSERTED TRACE */";
+ private Headers headers;
+ private String namespace = null;
+ private String hashifdef = null;
+ private String hashelse = null;
+ private String hashendif = null;
+ private String module = null;
+
+ private static Hashtable typetable = new Hashtable();
+ static {
+ typetable.put("char", "CHAR");
+ typetable.put("unsigned char", "CHAR");
+ typetable.put("unsigned short", "USHORT");
+ typetable.put("short", "SHORT");
+ typetable.put("signed short", "SHORT");
+ typetable.put("unsigned", "UINT");
+ typetable.put("unsigned int", "UINT");
+ typetable.put("int", "INT");
+ typetable.put("signed int", "INT");
+ typetable.put("signed", "INT");
+ typetable.put("unsigned long", "ULONG");
+ typetable.put("long", "LONG");
+ typetable.put("signed long", "LONG");
+ typetable.put("double", "DOUBLE");
+ typetable.put("float", "FLOAT");
+ typetable.put("bool", "BOOL");
+ typetable.put("string", "STLSTRING");
+ typetable.put("AxisString", "STLSTRING");
+ typetable.put("AxisXMLString", "STLSTRING");
+ typetable.put("xsd__string", "STRING");
+ }
+
+ private final static Set charSet =
+ new HashSet(
+ Arrays.asList(
+ new Object[] { "char", "AxisChar",
"AxisXMLChar", "XML_Ch" }));
+
+ /**
+ * @param writer a writer to the output file.
+ */
+ Tracer(Writer writer, int depth, Headers headers) throws IOException {
+ super(writer);
+ this.headers = headers;
+ namespace = Configuration.getConfigured("namespace");
+ if (null != namespace)
+ namespace += "::";
+ else
+ namespace = "";
+
+ hashifdef = Configuration.getConfigured("ifdef");
+ if (null != hashifdef) {
+ hashifdef = "#ifdef " + hashifdef + "\n";
+ hashelse = "#else\n";
+ hashendif = "#endif\n";
+ } else {
+ hashifdef = "";
+ hashelse = "";
+ hashendif = "";
+ }
+
+ module = Configuration.getConfigured("module");
+ if (null != module)
+ module += "::";
+ else
+ module = ""; // C-style function
+
+ String include = Configuration.getConfigured("include");
+ String includefile = "";
+ if (null == include) {
+ String prefix = "";
+ if (depth > 1)
+ for (int i = 1; i < depth; i++)
+ prefix += "../";
+ includefile = "\"" + prefix + "common/AxisTrace.h\"";
+
+ } else {
+ includefile = include;
+ }
+
+ String prefix = "";
+ if (depth > 1)
+ for (int i = 1; i < depth; i++)
+ prefix += "../";
+
+ String line =
+ hashifdef
+ + "/* TRACE ADDED BY THE TRACE INSTRUMENTOR
TOOL */\n"
+ + "#include "
+ + includefile
+ + "\n"
+ + hashendif;
+ writeTrace(line);
+ flush();
+ }
+
+ /**
+ * @param signature the signature of this method
+ * TODO: Can't tell the difference between static and non-static
+ * methods so can't tell whether to pass this or not. If we pass
+ * this in a static method it won't compile.
+ */
+ void traceEntry(Signature signature) throws IOException {
+ this.signature = signature;
+ if (!signature.traceable())
+ return;
+
+ Parameter[] parms = signature.getParameters();
+ int len = 0;
+ if (null != parms) {
+ if (parms[parms.length - 1].isDotDotDot())
+ len = parms.length - 1;
+ else
+ len = parms.length;
+ }
+
+ String that = "NULL";
+ if (headers.isInstanceMethod(signature))
+ that = "this";
+
+ String line =
+ "\n"
+ + "\t"
+ + hashifdef
+ + "\t\tif ("
+ + namespace
+ + module
+ + "isTraceOn())\n"
+ + "\t\t\t"
+ + namespace
+ + module
+ + "traceEntry("
+ + getClassName()
+ + ", \""
+ + signature.getMethodName()
+ + "\", "
+ + that
+ + ", "
+ + len;
+ for (int i = 0; null != parms && i < parms.length; i++)
+ line += getTypeParms(parms[i]);
+ line += ");\t" + SIGNATURE + "\n";
+ line += "\t" + hashendif;
+ writeTrace(line);
+ flush();
+ }
+
+ void traceExit(int returnIndex) throws Exception {
+ if (!signature.traceable())
+ return;
+
+ // Check this method really should return void
+ if (null != signature.getReturnType().getType())
+ Utils.rude(
+ "Expecting to return void from a method that
returns a value: "
+ + signature.toString());
+
+ String that = "NULL";
+ if (headers.isInstanceMethod(signature))
+ that = "this";
+
+ // Enclose the printf/return in {} in case if/then doesn't have
{}
+ String line = "\t{\n";
+ line += "\t\t" + hashifdef;
+ line += "\t\t\tif (" + namespace + module + "isTraceOn())\n";
+ line += "\t\t\t\t"
+ + namespace
+ + module
+ + "traceExit("
+ + getClassName()
+ + ", \""
+ + signature.getMethodName()
+ + "\", "
+ + that
+ + ", "
+ + returnIndex
+ + ");\t"
+ + SIGNATURE
+ + "\n";
+ line += "\t\t" + hashendif;
+
+ // now print out the return line itself
+ line += "\t\treturn;\n";
+ line += "\t}\n";
+ writeTrace(line);
+ flush();
+ }
+
+ /**
+ * Takes in the return statement and traces out the exit trace
statement for it
+ * This method prints out the complete return line as well so the user
+ * does not need to print this out themselves.
+ */
+ void traceExit(String value, int returnIndex) throws Exception {
+ if (!signature.traceable())
+ return;
+
+ // Check this method doesn't return void
+ if (null == signature.getReturnType().getType())
+ Utils.rude(
+ "Expecting to return a value from a method that
returns void: "
+ + signature.toString());
+
+ String that = "NULL";
+ if (headers.isInstanceMethod(signature))
+ that = "this";
+
+ // Enclose the printf/return in {} in case if/then doesn't have
{}
+ // Copy the return value into a local called traceRet in case
the
+ // return value has side-effects such as "return i++;" or
"return func();"
+ // This makes sure that we don't execute the return value twice.
+ // Unfortunately if the return value is a class we will invoke
+ // a copy constructor. When initialising traceRet with value,
put value
+ // in brackets in case it contains an operator that might be
invoked
+ // after the assignment, like another assignment.
+ String line = "\t{\n";
+ line += "\t\t" + hashifdef;
+ line += "\t\t\t"
+ + signature.getReturnType().getType()
+ + " traceRet = ("
+ + value
+ + ");\n";
+ line += "\t\t\tif (" + namespace + module + "isTraceOn())\n";
+ line += "\t\t\t\t"
+ + namespace
+ + module
+ + "traceExit("
+ + getClassName()
+ + ", \""
+ + signature.getMethodName()
+ + "\", "
+ + that
+ + ", "
+ + returnIndex
+ + getTypeParms(signature.getReturnType(), true)
+ + ");\t"
+ + SIGNATURE
+ + "\n";
+ line += "\t\t\treturn traceRet;\n";
+ line += "\t\t" + hashelse;
+ if (hashelse.length() > 0)
+ line += "\t\t\treturn " + value + ";\n";
+ line += "\t\t" + hashendif;
+ line += "\t}\n";
+ writeTrace(line);
+ flush();
+ }
+
+ void traceCatch(Parameter value, int catchIndex) throws Exception {
+ if (!signature.traceable())
+ return;
+
+ String that = "NULL";
+ if (headers.isInstanceMethod(signature))
+ that = "this";
+
+ String line =
+ "\n"
+ + "\t"
+ + hashifdef
+ + "\t\tif ("
+ + namespace
+ + module
+ + "isTraceOn())\n"
+ + "\t\t\t"
+ + namespace
+ + module
+ + "traceCatch("
+ + getClassName()
+ + ", \""
+ + signature.getMethodName()
+ + "\", "
+ + that
+ + ", "
+ + catchIndex
+ + getTypeParms(value);
+ line += ");\t" + SIGNATURE + "\n";
+ line += "\t" + hashendif;
+ writeTrace(line);
+ flush();
+ }
+
+ /*
+ * This method is careful to get the line separators because other
+ * other methods have been careless assuming that the line separator
+ * is always only \n, whereas it maybe \r\n.
+ */
+ public void writeTrace(String s) throws IOException {
+ if (s.startsWith("\n") || s.startsWith("\r"))
+ super.newLine();
+ StringTokenizer st = new StringTokenizer(s, "\n\r");
+ while (st.hasMoreTokens()) {
+ super.write(st.nextToken());
+ if (st.hasMoreTokens())
+ super.newLine();
+ }
+ if (s.endsWith("\n") || s.endsWith("\r"))
+ super.newLine();
+ if (Options.verbose())
+ System.out.print(s);
+ }
+
+ // TODO cope with STL strings
+ // TODO cope with pointers to primitives
+ // TODO cope with references
+ private String getTypeParms(Parameter p) { return
getTypeParms(p,false); }
+ private String getTypeParms(Parameter p, boolean isRetType) {
+ // copes with catch (...)
+ if ("...".equals(p.getType()))
+ return " ";
+
+ String parms = ",\n\t\t\t\t\tTRACETYPE_";
+ String name = p.getName();
+ if (isRetType)
+ name = "traceRet";
+ else if (null == name) {
+ // A parameter without a name can't be traced
+ parms += "ANONYMOUS, 0, NULL";
+ return parms;
+ }
+ name = "((void*)&" + name + ")";
+
+ String type = p.getTypeWithoutConst();
+ if (null == type || 0 == type.length()) {
+ parms += "UNKNOWN, 0, NULL";
+ } else if (typetable.keySet().contains(type)) {
+ parms += (String) typetable.get(type) + ", 0, " + name;
+ } else if (type.endsWith("*")) {
+ String contents = type.substring(0, type.length() - 1);
+ if (charSet.contains(contents)) {
+ parms += "STRING, 0, " + name;
+ } else if ("void".equals(contents)) {
+ // We just don't know what this void* is
pointing at
+ // so that best we can do is to print out the
first byte.
+ parms += "POINTER, 1, " + name;
+ } else {
+ parms += "POINTER, sizeof(" + contents + "), "
+ name;
+ }
+ } else if (type.endsWith("&")) {
+ String contents = type.substring(0, type.length() - 1);
+ if (typetable.keySet().contains(contents)) {
+ parms += (String) typetable.get(contents) + ",
0, " + name;
+ } else if (contents.startsWith("Axis") &&
contents.endsWith("Exception")) {
+ parms += "AXISEXCEPTION, sizeof(" + type + "),
" + name;
+ } else if (contents.equals("exception")) {
+ parms += "EXCEPTION, sizeof(" + type + "), " +
name;
+ } else {
+ parms += "DATA, sizeof(" + type + "), " + name;
+ }
+ } else if (type.startsWith("Axis") &&
type.endsWith("Exception")) {
+ parms += "AXISEXCEPTION, sizeof(" + type + "), " + name;
+ } else if (type.equals("exception")) {
+ parms += "EXCEPTION, sizeof(" + type + "), " + name;
+ } else {
+ parms += "DATA, sizeof(" + type + "), " + name;
+ }
+
+ return parms;
+ }
+
+ private String getClassName() {
+ String name;
+ if (null != signature.getClassName()) {
+ name = signature.getClassName();
+ name = name.substring(0, name.indexOf("::"));
+ name = "\"" + name + "\"";
+ } else
+ name = "NULL";
+ return name;
+ }
+}
Added:
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/tracetool.conf
URL:
http://svn.apache.org/viewvc/axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/tracetool.conf?rev=1088470&view=auto
==============================================================================
---
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/tracetool.conf
(added)
+++
axis/axis1/c/trunk/graveyard/tools/org/apache/axis/tools/trace/tracetool.conf
Mon Apr 4 03:22:52 2011
@@ -0,0 +1,92 @@
+#
+# Copyright 2003-2004 The Apache Software Foundation.
+#
+# 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.
+#
+# The default configuration file for the tool that adds trace into Axis C++.
+#
+# Lines in this file are key/value pairs. The keys are...
+# excludefile - stops the trace tool adding trace to that file
+# excludeclass - stops the trace tool adding trace to that class
+# excludemethod - stops the trace tool adding trace to that method
+# define - tells the trace tool to ignore a #define
+# macro - tells the trace tool to ignore a #define macro
+# attribute - tells the trace tool to ignore a #define in a function prototype
+# ifdef - tells the trace tool to surround inserted trace statements with a
#ifdef
+# namespace - tells the trace tool which namespace the runtime trace module is
in
+#
+# Lines beginning with a # are comments and are ignored.
+#
+excludefile=libAxiscpp.cpp
+excludefile=libAxiscpp.h
+excludefile=cpplex.cpp
+excludefile=cppyacc.cpp
+excludefile=Array.hpp
+excludefile=Buffer.hpp
+excludefile=spp_converter.h
+excludefile=asciitab.h
+excludefile=iasciitab.h
+excludefile=latin1tab.h
+excludefile=utf8tab.h
+excludefile=apr_base64.c
+excludefile=apr_base64.h
+excludefile=apr_xlate.h
+#excludefile=Axis.cpp
+excludefile=spp.c
+excludefile=AxisTrace.cpp
+excludefile=AxisTrace.h
+excludefile=AxisFile.h
+excludefile=Axis2TransportInstantiator.cpp
+excludefile=HTTPTransportInstantiator.cpp
+excludefile=HTTPChannelInstantiator.cpp
+excludefile=HTTPSSLChannelInstantiator.cpp
+excludefile=ParserLoader.cpp
+excludefile=httpd.h
+excludefile=http_main.h
+excludefile=cclass.h
+excludefile=cname.h
+excludefile=asciitab.h
+excludefile=iasciitab.h
+excludefile=latin1tab.h
+excludefile=utf8tab.h
+excludefile=xmltok.h
+excludefile=apr_fnmatch.h
+excludefile=apr_network_io.h
+excludefile=apr_thread_proc.h
+excludefile=ap_mpm.h
+excludefile=httpd.h
+excludefile=http_config.h
+excludefile=http_log.h
+excludefile=scoreboard.h
+#
+define=AXIS_CPP_NAMESPACE_START
+define=AXIS_CPP_NAMESPACE_END
+define=AXIS_CPP_NAMESPACE_USE
+define=AXIS_CPP_NAMESPACE_PREFIX
+define=XERCES_CPP_NAMESPACE_USE
+define=TXPP_NAMESPACE_START
+define=TXPP_NAMESPACE_END
+#
+macro=DEFINE_UTF16_TO_UTF8
+macro=DEFINE_UTF16_TO_UTF16
+macro=AXIS_DEFINED_ARRAY
+#
+attribute=AXISCALL
+attribute=STORAGE_CLASS_INFO
+attribute=AXISCCALL
+attribute=AXISC_STORAGE_CLASS_INFO
+#
+ifdef=ENABLE_AXISTRACE
+namespace=axiscpp
+module=AxisTrace
+
