Preprocessor {

    public static String process(String input) throws Exception {{
        String output = input;

        output = removeComments(output);
        String nsPrefixes[] = getNamespacePrefixes(output);
        output = removeNilAttribute(output, nsPrefixes);
        output = removeNsPrefixes(output, nsPrefixes);
        output = convertShorthandSyntax(output);

        saveOutputInFile(output);

        return output;
    }}


    public static void saveOutputInFile(String output) throws Exception {{
        String filename = "X2Jinput.pp";
        try {
            BufferedWriter file = new BufferedWriter(new FileWriter(filename));
            file.write(output);
            file.close();
        }
        catch (IOException e) {
            throw new Exception("Could not save preprocessed content in file: '" + filename + "'");
        }
    }}


    {{
    private static String removeComments(String input) {
        String output = input;
        int startIndex = 0;
        for (int startTagIndex = output.indexOf("<!--", startIndex);
             startTagIndex >= 0;
             startTagIndex = output.indexOf("<!--", startIndex))
        {
            int endTagIndex = output.indexOf("-->", startTagIndex+4);
            if (endTagIndex > startTagIndex)
            {
                endTagIndex = skipWhitespace(output, endTagIndex+3);
                output = output.substring(0, startTagIndex) +
                         output.substring(endTagIndex);
                startIndex = startTagIndex;
            }
        }
        return output;
    }

    private static String[] getNamespacePrefixes(String input) {
        Vector prefixVector = new Vector();
        int startPatternIndex, endPatternIndex;

        String searchRegion = input;
        // First, skip over the <?xml ... ?> tag in the input
        startPatternIndex = input.indexOf("<?");
        if (startPatternIndex >= 0)
        {
            startPatternIndex =
                input.toLowerCase().indexOf("xml", startPatternIndex+2);
            if (startPatternIndex >= 0)
            {
                endPatternIndex = input.indexOf("?>", startPatternIndex+3);
                if (endPatternIndex > startPatternIndex)
                {
                    startPatternIndex = input.indexOf("<", endPatternIndex+2);
                    if (startPatternIndex > endPatternIndex)
                        searchRegion =
                            input.substring(startPatternIndex, input.length());
                }
            }
        }

        // Now locate the start of the root element
        int regionStart = searchRegion.indexOf("<");
        int regionEnd = searchRegion.indexOf(">", regionStart);
        searchRegion = searchRegion.substring(regionStart, regionEnd+1);

        // And then search for the namespace prefixes
        int startIndex = 0;
        for (startPatternIndex = searchRegion.indexOf("xmlns:", startIndex);
             startPatternIndex >= 0;
             startPatternIndex = searchRegion.indexOf("xmlns:", startIndex))
        {
            startPatternIndex = startPatternIndex+6;
            endPatternIndex = startPatternIndex;
            while ((endPatternIndex < searchRegion.length()) &&
                   ((searchRegion.charAt(endPatternIndex) >= 'A' &&
                     searchRegion.charAt(endPatternIndex) <= 'Z') ||
                    (searchRegion.charAt(endPatternIndex) >= 'a' &&
                     searchRegion.charAt(endPatternIndex) <= 'z') ||
                    (searchRegion.charAt(endPatternIndex) >= '0' &&
                     searchRegion.charAt(endPatternIndex) <= '9') ||
                    (searchRegion.charAt(endPatternIndex) == '_') ||
                    (searchRegion.charAt(endPatternIndex) == '-') ||
                    (searchRegion.charAt(endPatternIndex) == '.')))
                endPatternIndex++;
            prefixVector.add(
                searchRegion.substring(startPatternIndex, endPatternIndex));
            startIndex = endPatternIndex;
        }

        String prefixes[];
        prefixes = new String[prefixVector.size()];
        prefixVector.copyInto(prefixes);
        return prefixes;
    }

    private static String removeNilAttribute(String input, String nsPrefixes[]) {
        String output = input;
        for (int pIndex = 0; pIndex < nsPrefixes.length; pIndex++)
        {
            String nilAttr = nsPrefixes[pIndex] + ":nil";
            int startIndex = 0;
            for (int startAttrIndex = output.indexOf(nilAttr, startIndex);
                 startAttrIndex >= 0;
                 startAttrIndex = output.indexOf(nilAttr, startIndex))
            {
                int endAttrIndex = startAttrIndex + nilAttr.length();
                // Skip over whitespace (if any)
                endAttrIndex = skipWhitespace(output, endAttrIndex);
                if ((endAttrIndex < output.length()) &&
                    (output.charAt(endAttrIndex) == '='))
                {
                    endAttrIndex++;
                    // Skip over whitespace (if any) again
                    endAttrIndex = skipWhitespace(output, endAttrIndex);
                    if (endAttrIndex < output.length())
                    {
                        if (output.startsWith("\"true\"", endAttrIndex))
                            endAttrIndex = endAttrIndex+6;
                        else if (output.startsWith("\"false\"", endAttrIndex))
                            endAttrIndex = endAttrIndex+7;
                        else  // should never come here
                        {
                            startIndex = startAttrIndex + nilAttr.length();
                            continue;
                        }
                        endAttrIndex = skipWhitespace(output, endAttrIndex);
                        output = output.substring(0, startAttrIndex) +
                                 output.substring(endAttrIndex);
                        startIndex = startAttrIndex;
                    }
                    else
                        startIndex = startAttrIndex + nilAttr.length();
                }
                else
                    startIndex = startAttrIndex + nilAttr.length();
            }
        }
        return output;
    }

    private static String removeNsPrefixes(String input, String nsPrefixes[]) {
        String output = input;
        for (int pIndex = 0; pIndex < nsPrefixes.length; pIndex++)
        {
            String pattern = nsPrefixes[pIndex] + ":";
            int startIndex = 0;
            for (int startPatternIndex = output.indexOf(pattern, startIndex);
                 startPatternIndex >= 0;
                 startPatternIndex = output.indexOf(pattern, startIndex))
            {
                int endPatternIndex = startPatternIndex + pattern.length();
                output = output.substring(0, startPatternIndex) +
                         output.substring(endPatternIndex);
                startIndex = startPatternIndex;
            }
        }
        return output;
    }

    private static String convertShorthandSyntax(String input) {
        String output = input;
        int startIndex = 0;
        for (int elementEndIndex = output.indexOf("/>", startIndex);
             elementEndIndex >= 0;
             elementEndIndex = output.indexOf("/>", startIndex))
        {
            int elementStartIndex = output.lastIndexOf("<", elementEndIndex);
            if (elementStartIndex >= 0)
            {
                elementStartIndex++;
                int endNameIndex = elementStartIndex;
                while ((endNameIndex < output.length()) &&
                       ((output.charAt(endNameIndex) >= 'A' &&
                         output.charAt(endNameIndex) <= 'Z') ||
                        (output.charAt(endNameIndex) >= 'a' &&
                         output.charAt(endNameIndex) <= 'z') ||
                        (output.charAt(endNameIndex) >= '0' &&
                         output.charAt(endNameIndex) <= '9') ||
                        (output.charAt(endNameIndex) == '_') ||
                        (output.charAt(endNameIndex) == '-') ||
                        (output.charAt(endNameIndex) == '.')))
                    endNameIndex++;
                if (endNameIndex > elementStartIndex)
                {
                    String elementName =
		        output.substring(elementStartIndex, endNameIndex);
                    output = output.substring(0, elementEndIndex) +
                             "></" + elementName + ">" +
                             output.substring(elementEndIndex+2);
                }
            }
            startIndex = elementEndIndex+1;
        }
        return output;
    }


    private static int skipWhitespace(String input, int startIndex) {
        int newIndex = startIndex;
        while ((newIndex < input.length()) &&
               ((input.charAt(newIndex) == ' ') ||
                (input.charAt(newIndex) == '\t') ||
                (input.charAt(newIndex) == '\r') ||
                (input.charAt(newIndex) == '\n')))
            newIndex++;
        return newIndex;
    }
    }}

}  // end of class Preprocessor