// given a context, returns the enum which belongs to that context. public NddlType getEnum(String qualified) { for (Iterator i = enumsContaining.iterator(); i.hasNext(); ) { NddlType curr = (NddlType) i.next(); if (qualified.equals(NddlUtil.nonull(NddlUtil.butLast(curr.getName())))) ; return curr; } return null; }
class ClassWriter { public static final Set primitives = NddlUtil.immutableSet(new String[] {"int", "float", "bool"}); public static void writeTypedefs(IndentWriter writer, IXMLElement klass) throws IOException { String name = ModelAccessor.getClassName(klass); if (!ModelAccessor.isPredefinedClass(name)) { SharedWriter.writeTypedefs(writer, name); writer.write("typedef ObjectDomain " + name + "Domain;\n\n"); } } public static void generateImplementation(IndentWriter writer, IXMLElement klass) throws IOException { String superClass = ModelAccessor.getSuperClass(klass); String name = XMLUtil.getAttribute(klass, "name"); if (ModelAccessor.isPredefinedClass(name)) { writer.write("// SKIPPING IMPLEMENTATION FOR BUILT-IN CLASS " + name + "\n\n"); return; } ModelAccessor.setCurrentObjectType(name); String longname = XMLUtil.qualifiedName(klass); boolean extendsBuiltIn = ModelAccessor.isPredefinedClass(superClass); String superCppClass = ModelAccessor.getCppClass(superClass); writer.write("\n"); SharedWriter.generateFileLocation(writer, klass); writer.write( longname + "::" + name + "(const PlanDatabaseId& planDatabase, const LabelStr& name)\n"); if (extendsBuiltIn) writer.write(" : " + superCppClass + "(planDatabase, \"" + name + "\", name, true)"); else writer.write(" : " + superCppClass + "(planDatabase, \"" + name + "\", name)"); writer.write(" {\n"); writer.write("}\n"); writer.write( longname + "::" + name + "(const PlanDatabaseId& planDatabase, const LabelStr& type, const LabelStr& name)\n"); if (extendsBuiltIn) writer.write(" : " + superCppClass + "(planDatabase, type, name, true)"); else writer.write(" : " + superCppClass + "(planDatabase, type, name)"); writer.write(" {\n"); writer.write("}\n"); writer.write(longname + "::" + name + "(const ObjectId& parent, const LabelStr& name)\n"); if (extendsBuiltIn) writer.write(" : " + superCppClass + "(parent, \"" + name + "\", name, true)"); else writer.write(" : " + superCppClass + "(parent, \"" + name + "\", name)"); writer.write(" {}\n"); writer.write( longname + "::" + name + "(const ObjectId& parent, const LabelStr& type, const LabelStr& name)\n"); if (extendsBuiltIn) writer.write(" : " + superCppClass + "(parent, type, name, true)"); else writer.write(" : " + superCppClass + "(parent, type, name)"); writer.write(" {}\n"); Vector classVariables = klass.getChildrenNamed("var"); SharedWriter.defineHandleDefaults(writer, klass, classVariables); generateChildren(writer, klass); ModelAccessor.resetCurrentObjectType(); } private static void generateChildren(IndentWriter writer, IXMLElement parent) throws IOException { for (Enumeration e = parent.enumerateChildren(); e.hasMoreElements(); ) { IXMLElement element = (IXMLElement) e.nextElement(); if (element.getName().equals("enum")) { EnumerationWriter.generateImplementation(writer, element); } else if (element.getName().equals("predicate")) { PredicateWriter.generateImplementation(writer, element); } else if (element.getName().equals("var")) { } else if (element.getName().equals("constructor")) { defineConstructor(writer, element); generateFactory(writer, element); } else { System.err.println("generateImplementation:"); XMLUtil.dump(element); } } } public static void declareConstructor(IndentWriter writer, IXMLElement constructor) throws IOException { IXMLElement klass = constructor.getParent(); SharedWriter.generateFileLocation(writer, klass); if (klass == null) { throw new RuntimeException("constructor not contained in a class"); } String name = XMLUtil.getAttribute(klass, "name"); writer.write("virtual void "); generateSignature(writer, constructor); writer.write(";\n"); } public static void defineConstructor(IndentWriter writer, IXMLElement constructor) throws IOException { assert (DebugMsg.debugMsg("ClassWriter", "Begin ClassWriter::defineConstructor")); IXMLElement klass = constructor.getParent(); SharedWriter.generateFileLocation(writer, klass); if (klass == null) { throw new RuntimeException("missing class for constructor"); } String longname = XMLUtil.nameOf(klass); writer.write("void " + longname + "::"); generateSignature(writer, constructor); writer.write(" {\n"); writer.indent(); // If the constructor has a call to the super class, invoke it. assert (DebugMsg.debugMsg( "ClassWriter", "ClassWriter::defineConstructor - getting children named 'super'")); Vector superCalls = constructor.getChildrenNamed("super"); assert (DebugMsg.debugMsg( "ClassWriter", "ClassWriter::defineConstructor - " + superCalls.size() + " children named retrieved")); if (!superCalls.isEmpty()) { assert (DebugMsg.debugMsg("ClassWriter", "ClassWriter::defineConstructor - calling super")); if (superCalls.size() > 1) writer.write("!ERROR: AT MOST ONE CALL TO SUPER ALLOWED\n"); IXMLElement superCall = (IXMLElement) superCalls.elementAt(0); String superClass = ModelAccessor.getParentClassName(klass); String superCppClass = ModelAccessor.getCppClass(superClass); writer.write(superCppClass + "::constructor("); String comma = ""; Enumeration arguments = superCall.enumerateChildren(); while (arguments.hasMoreElements()) { IXMLElement argument = (IXMLElement) arguments.nextElement(); String value = ModelAccessor.getValue(argument); if (argument.getName().equals("value") && XMLUtil.getAttribute(argument, "type").equals("string")) writer.write(comma + "\"" + value + "\""); else writer.write(comma + value); comma = ", "; } writer.write(");\n"); } Set allocatedMemberVariables = new HashSet(); // Store names as we go for reference /* Now capture names of constructor arguments */ Set constructorArguments = new HashSet(); // Store for names of constructor arguments { Vector args = constructor.getChildrenNamed("arg"); assert (DebugMsg.debugMsg( "ClassWriter", "ClassWriter::defineConstructor - getting " + args.size() + " arguments")); for (int i = 0; i < args.size(); i++) { IXMLElement arg = (IXMLElement) args.elementAt(i); String argName = XMLUtil.getAttribute(arg, "name"); constructorArguments.add(argName); } } Vector constructorAssignments = constructor.getChildrenNamed("assign"); Vector classVariables = klass.getChildrenNamed("var"); // Use the set below to track when an assignment is being made more than once for same variable Set assignmentsMade = new HashSet(); for (int i = 0; i < constructorAssignments.size(); i++) { IXMLElement element = (IXMLElement) constructorAssignments.elementAt(i); String target = XMLUtil.getAttribute(element, "name"); if (assignmentsMade.contains(target)) { writer.write("!ERROR: Duplicate assignment for " + target + "\n"); } else { assignmentsMade.add(target); // String type = getVariableType(classVariables, target); // trust in the parser, for it will assign the correct types String type = XMLUtil.getAttribute(element, "type"); IXMLElement sourceElement = element.getChildAtIndex(0); if (sourceElement.getName().equals("new")) { // Handle object allocation assert (DebugMsg.debugMsg( "ClassWriter", "ClassWriter::defineConstructor - allocating object for " + target)); String sourceType = XMLUtil.typeOf(sourceElement); writer.write(target + " = addVariable("); writer.write( sourceType + "Domain((new " + sourceType + "(m_id, \"" + target + "\"))->getId(), \"" + sourceType + "\")"); writer.write(", " + makeObjectVariableNameString(target) + ");\n"); writer.write( "Id<" + type + ">(singleton(" + target + "))->constructor(" + buildArguments( classVariables, constructorArguments, allocatedMemberVariables, sourceElement) + ");\n"); // Invoke initialization writer.write( "Id<" + type + ">(singleton(" + target + "))->handleDefaults();\n"); // Default variable setup } else { // Handle variable allocation String value = ModelAccessor.getValue(sourceElement); if (sourceElement.getName().equals("id") && type.equals(NddlXmlStrings.x_string)) value = XMLUtil.escapeQuotes(value); else if (sourceElement.getName().equals(NddlXmlStrings.x_symbol) || XMLUtil.getAttribute(sourceElement, "type").equals(NddlXmlStrings.x_string)) value = "LabelStr(\"" + XMLUtil.escapeQuotes(value) + "\")"; else if (ModelAccessor.isNumericPrimitive(type) && !type.equals(NddlXmlStrings.x_boolean)) { // Set both bounds to singleton value value = value + ", " + value; } writer.write(target + " = addVariable("); if (allocatedMemberVariables.contains( value)) // If we are assigning one member to another, we obtain the base domain for it writer.write(value + "->baseDomain()"); else writer.write(ModelAccessor.getDomain(type) + "(" + value + ", \"" + type + "\")"); writer.write(", " + makeObjectVariableNameString(target) + ");\n"); } // Add member to the set allocatedMemberVariables.add(target); } } writer.unindent(); writer.write("}\n"); assert (DebugMsg.debugMsg("ClassWriter", "End ClassWriter::defineConstructor")); } /** Test if the given variable name is listed in the vector of variable xml elements */ private static boolean isMember(Vector classVariables, String name) { for (int i = 0; i < classVariables.size(); i++) { IXMLElement variable = (IXMLElement) classVariables.elementAt(i); if (XMLUtil.nameOf(variable).equals(name)) return true; } return false; } private static String getVariableType(Vector classVariables, String name) { String type = "!ERROR"; for (int i = 0; i < classVariables.size(); i++) { IXMLElement variable = (IXMLElement) classVariables.elementAt(i); if (XMLUtil.nameOf(variable).equals(name)) { type = XMLUtil.getAttribute(variable, "type"); String _class = XMLUtil.getAttribute(variable.getParent(), "name"); if (ModelAccessor.isEnumeration(_class + "::" + type)) type = _class + "::" + type; break; } } return type; } /** @brief Generates the signature for the class constructors */ private static void generateSignature(IndentWriter writer, IXMLElement constructor) throws IOException { assert (DebugMsg.debugMsg("ClassWriter", "Begin ClassWriter::generateSignature")); writer.write("constructor("); boolean comma = false; for (Enumeration e = constructor.enumerateChildren(); e.hasMoreElements(); ) { IXMLElement element = (IXMLElement) e.nextElement(); if (!element.getName().equals("arg")) { break; } String argType = XMLUtil.typeOf(element); String argName = XMLUtil.getAttribute(element, "name"); if (comma) { writer.write(", "); } // Argument are structured as: <arg name="argName" type="argType"/> if (argType.equals(NddlXmlStrings.x_int)) writer.write("int " + argName); else if (argType.equals(NddlXmlStrings.x_float)) writer.write("double " + argName); else if (argType.equals(NddlXmlStrings.x_boolean)) writer.write("bool " + argName); else if (argType.equals(NddlXmlStrings.x_string) || argType.equals(NddlXmlStrings.x_symbol) || ModelAccessor.isEnumeration(argType)) writer.write("const LabelStr& " + argName); else writer.write("const " + argType + "Id& " + argName); comma = true; } writer.write(")"); assert (DebugMsg.debugMsg("ClassWriter", "End ClassWriter::generateSignature")); } /** * Builds the argument invocation string for calling a constructor * * @param classVariables The collection of member variables as XMLElements * @param constructorArguments The set of names for constructor arguments * @param allocatedMemberVariables The set of member variables already allocated * @param element The specific 'new' xml element */ private static String buildArguments( Vector classVariables, Set constructorArguments, Set allocatedMemberVariables, IXMLElement element) throws IOException { XMLUtil.checkExpectedNode("new", element); boolean comma = false; String arguments = ""; for (Enumeration e = element.enumerateChildren(); e.hasMoreElements(); ) { IXMLElement argument = (IXMLElement) e.nextElement(); String argType = ModelAccessor.getValueType(argument); String value = ModelAccessor.getValue(argument); /* Exclude cases where we do nothing to the value */ if (!primitives.contains(argType) && !value.equals("true") && !value.equals("false")) { // CASE 0: Translate 'this' if (value.equalsIgnoreCase("this")) { value = "m_id"; } // CASE 1: It is a singleton member variable which must be mapped to the singleton else if (allocatedMemberVariables.contains(value)) { String singletonType = getVariableType(classVariables, value); if (primitives.contains(singletonType)) { value = "(" + singletonType + ") singleton(" + value + ")"; } else value = "singleton(" + value + ")"; } // CASE 2: It is a constructor argument else if (constructorArguments.contains(value)) { // Do nothing, just use the string as is. } // CASE 3: Test for error - using a member before initializing it else if (!allocatedMemberVariables.contains(value) && isMember(classVariables, value)) { value = "!ERROR: Cannot use " + value + " without prior initialization."; } // Otherwise it is a string or enumerataion else if (argType.equals("string") || // It is an enumeartion of some kind ModelAccessor.isEnumeration(argType) || argType.equals("symbol")) { value = "LabelStr(\"" + XMLUtil.escapeQuotes(value) + "\")"; } // If we fall through to here, there is an error. else value = "!ERROR:BAD ASSIGNMENT"; } // CASE 3: It is a true or false value if (comma) arguments = arguments + ", "; arguments = arguments + value; comma = true; } return arguments; } public static void declareDefaultConstructor(IndentWriter writer, String superClass) throws IOException { // If it is a built in class then define the default 'constructor' call if (ModelAccessor.isPredefinedClass(superClass)) writer.write("virtual void constructor(); // default constructoror\n"); } public static void generateDefaultFactory(IndentWriter writer, IXMLElement klass) throws IOException { SharedWriter.generateFileLocation(writer, klass); if (klass == null) { throw new RuntimeException("missing class for factory"); } String longname = XMLUtil.nameOf(klass) + "Factory" + s_factoryCounter++; String klassName = XMLUtil.nameOf(klass); writer.write("DECLARE_DEFAULT_OBJECT_FACTORY(" + longname + ", " + klassName + ");\n"); // Generate all appropriate registration information SchemaWriter.addFactory("REGISTER_OBJECT_FACTORY(id," + longname + ", " + klassName + ");\n"); } public static void generateFactory(IndentWriter writer, IXMLElement constructor) throws IOException { IXMLElement klass = constructor.getParent(); SharedWriter.generateFileLocation(writer, klass); if (klass == null) throw new RuntimeException("missing class for factory"); String longname = XMLUtil.nameOf(klass) + "Factory" + s_factoryCounter++; writer.write("class " + longname + ": public ObjectFactory {\n"); writer.write("public:\n"); writer.indent(); writer.write(longname + "(const LabelStr& name): ObjectFactory(name){}\n"); writer.unindent(); writer.write("private:\n"); writer.indent(); writer.write("ObjectId createInstance(const PlanDatabaseId& planDb,\n"); writer.write(" const LabelStr& objectType, \n"); writer.write(" const LabelStr& objectName,\n"); writer.write( " const std::vector<const AbstractDomain*>& arguments) const {\n"); writer.indent(); Vector constructorAssignments = constructor.getChildrenNamed("arg"); String klassName = XMLUtil.nameOf(klass); String constructorArguments = ""; String comma = ""; // Do some type checking - at least the size must match! writer.write("check_error(arguments.size() == " + constructorAssignments.size() + ");\n"); // Process arguments, defining local variables and giving them initial values for (int i = 0; i < constructorAssignments.size(); i++) { IXMLElement element = (IXMLElement) constructorAssignments.elementAt(i); String target = XMLUtil.getAttribute(element, "name"); String type = XMLUtil.getAttribute(element, "type"); writer.write("check_error(AbstractDomain::canBeCompared(*arguments[" + i + "], \n"); writer.write( " planDb->getConstraintEngine()->getCESchema()->baseDomain(\"" + type + "\")), \n"); writer.write( " \"Cannot convert \" + arguments[" + i + "]->getTypeName().toString() + \" to " + type + "\");\n"); writer.write("check_error(arguments[" + i + "]->isSingleton());\n"); String localVarType = makeArgumentType( type); // Some conversion may be required for Id's or strings or enumerations // Declare local variable for current argument writer.write( localVarType + " " + target + "((" + localVarType + ")arguments[" + i + "]->getSingletonValue());\n\n"); constructorArguments = constructorArguments + comma + target; comma = ", "; } // Now do the declaration and allocation of the instance writer.write( klassName + "Id instance = (new " + klassName + "(planDb, objectType, objectName))->getId();\n"); writer.write("instance->constructor(" + constructorArguments + ");\n"); writer.write("instance->handleDefaults();\n"); writer.write("return instance;\n"); writer.unindent(); writer.write("}\n"); writer.unindent(); writer.write("};\n"); // Generate all appropriate registration informationLabelStr Vector factoryNames = makeFactoryNames(constructor); for (int i = 0; i < factoryNames.size(); i++) { String factoryName = (String) factoryNames.elementAt(i); SchemaWriter.addFactory( "REGISTER_OBJECT_FACTORY(id," + longname + ", " + factoryName + ");\n"); } } /** * Helper method to generate the signatures for binding the factory. Must account for the * inheritance relationships for any arguments that are classes. Ths, each argument can * potentially result in a range of values for type, and we have to handle the cross product of * all of these. */ private static Vector makeFactoryNames(IXMLElement constructor) { String factoryName = XMLUtil.nameOf(constructor.getParent()); Vector allPermutations = new Vector(); for (Enumeration e = constructor.enumerateChildren(); e.hasMoreElements(); ) { IXMLElement element = (IXMLElement) e.nextElement(); if (!element.getName().equals("arg")) { break; } String argType = XMLUtil.typeOf(element); Vector argTypeAlternates = new Vector(); argTypeAlternates.add(argType); if (ModelAccessor.isClass(argType)) { List ancestors = ModelAccessor.getAncestors(argType); if (ancestors != null) argTypeAlternates.addAll(ancestors); } allPermutations.add(argTypeAlternates); } // Generate all the signatures Vector factoryNames = new Vector(); makeFactoryNames(factoryName, allPermutations, 0, factoryNames); return factoryNames; } /** Tail-recursive algorithm to generate all factory signatures */ private static void makeFactoryNames( String prefix, Vector arguments, int startIndex, Vector results) { // if startIndex == arguments.size, then simply add the prefix to the results if (startIndex == arguments.size()) { if (s_allFactorySignatures.contains(prefix)) throw new RuntimeException( "Constructor signature collision detected: Factory already registered with prefix " + prefix); results.add(prefix); assert (DebugMsg.debugMsg("ClassWriter", "makeFactoryNames:adding:" + prefix)); s_allFactorySignatures.add(prefix); return; } // Otherwise, iterate over each element of arguments, and call recursively with adjusted input Vector currentAlternates = (Vector) arguments.elementAt(startIndex); for (int i = 0; i < currentAlternates.size(); i++) { makeFactoryNames( prefix + ":" + (String) currentAlternates.elementAt(i), arguments, startIndex + 1, results); } } private static String makeObjectVariableNameString(String name) { String result = "\"" + name + "\""; return result; } private static String makeArgumentType(String argType) { if (primitives.contains(argType)) return argType; else if (argType.equals("string") || ModelAccessor.isEnumeration(argType)) return "LabelStr"; else return argType + "Id"; } /** * Returns the type for the given member name. We must handle cases of inheritance. * * @param klass The klass context in which it arises * @param memberName The variable name in the class (or parent class */ public static String getMemberVariableType(String klass, String memberName) { return null; } // Store names of enumerations as they are declared private static int s_factoryCounter = 0; // Used to differentitate factory names private static Set s_allFactorySignatures = new HashSet(); }