/** * 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; }
/** @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")); }
/** * 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; }
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(); }
/** * Scans a system ID. * * @param reader the reader * @return the system ID * @throws java.io.IOException if an error occurred reading the data */ static String scanSystemID(IXMLReader reader) throws IOException, XMLParseException { if (!XMLUtil.checkLiteral(reader, "YSTEM")) { return null; } XMLUtil.skipWhitespace(reader, null); return XMLUtil.scanString(reader, '\0', null); }
/** * Reads a character from the reader disallowing entities. * * @param reader the reader * @param entityChar the escape character (& or %) used to indicate an entity */ static char readChar(IXMLReader reader, char entityChar) throws IOException, XMLParseException { String str = XMLUtil.read(reader, entityChar); char ch = str.charAt(0); if (ch == entityChar) { XMLUtil.errorUnexpectedEntity(reader.getSystemID(), reader.getLineNr(), str); } return ch; }
/** * Scans a public ID. * * @param publicID will contain the public ID * @param reader the reader * @return the system ID * @throws java.io.IOException if an error occurred reading the data */ static String scanPublicID(StringBuffer publicID, IXMLReader reader) throws IOException, XMLParseException { if (!XMLUtil.checkLiteral(reader, "UBLIC")) { return null; } XMLUtil.skipWhitespace(reader, null); publicID.append(XMLUtil.scanString(reader, '\0', null)); XMLUtil.skipWhitespace(reader, null); return XMLUtil.scanString(reader, '\0', null); }
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; }
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"); }
/** 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; }
/** * Skips the remainder of a comment. It is assumed that <!- is already read. * * @param reader the reader * @throws java.io.IOException if an error occurred reading the data */ static void skipComment(IXMLReader reader) throws IOException, XMLParseException { if (reader.read() != '-') { XMLUtil.errorExpectedInput(reader.getSystemID(), reader.getLineNr(), "<!--"); } int dashesRead = 0; for (; ; ) { char ch = reader.read(); switch (ch) { case '-': dashesRead++; break; case '>': if (dashesRead == 2) { return; } dashesRead = 0; break; default: dashesRead = 0; } } }
/** * Processes an entity. * * @param entity the entity * @param reader the reader * @param entityResolver the entity resolver * @throws java.io.IOException if an error occurred reading the data */ static void processEntity(String entity, IXMLReader reader, IXMLEntityResolver entityResolver) throws IOException, XMLParseException { entity = entity.substring(1, entity.length() - 1); Reader entityReader = entityResolver.getEntity(reader, entity); if (entityReader == null) { XMLUtil.errorInvalidEntity(reader.getSystemID(), reader.getLineNr(), entity); } boolean externalEntity = entityResolver.isExternalEntity(entity); reader.startNewStream(entityReader, !externalEntity); }
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"); }
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); } } }
/** * Retrieves a delimited string from the data. * * @param reader the reader * @param entityChar the escape character (& or %) * @param entityResolver the entity resolver * @throws java.io.IOException if an error occurred reading the data */ static String scanString(IXMLReader reader, char entityChar, IXMLEntityResolver entityResolver) throws IOException, XMLParseException { StringBuffer result = new StringBuffer(); int startingLevel = reader.getStreamLevel(); char delim = reader.read(); if ((delim != '\'') && (delim != '"')) { XMLUtil.errorExpectedInput(reader.getSystemID(), reader.getLineNr(), "delimited string"); } for (; ; ) { String str = XMLUtil.read(reader, entityChar); char ch = str.charAt(0); if (ch == entityChar) { if (str.charAt(1) == '#') { result.append(XMLUtil.processCharLiteral(str)); } else { XMLUtil.processEntity(str, reader, entityResolver); } } else if (ch == '&') { reader.unread(ch); str = XMLUtil.read(reader, '&'); if (str.charAt(1) == '#') { result.append(XMLUtil.processCharLiteral(str)); } else { result.append(str); } } else if (reader.getStreamLevel() == startingLevel) { if (ch == delim) { break; } else if ((ch == 9) || (ch == 10) || (ch == 13)) { result.append(' '); } else { result.append(ch); } } else { result.append(ch); } } return result.toString(); }
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")); }
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"); } }