/**

     * This method ensures that the output String has only valid XML unicode characters as specified by the

     * XML 1.0 standard. For reference, please see the

     * standard. This method will return an empty String if the input is null or empty.

     *

     * @author Donoiu Cristian, GPL

     * @param  The String whose non-valid characters we want to remove.

     * @return The in String, stripped of non-valid characters.

     */

    public static String removeInvalidXMLCharacters(String s) {

        StringBuilder out = new StringBuilder();                // Used to hold the output.

    	int codePoint;                                          // Used to reference the current character.

    	//String ss = "\ud801\udc00";                           // This is actualy one unicode character, represented by two code units!!!.

    	//System.out.println(ss.codePointCount(0, ss.length()));// See: 1

		int i=0;

    	while(i<s.length()) {

    		System.out.println("i=" + i);

    		codePoint = s.codePointAt(i);                       // This is the unicode code of the character.

			if ((codePoint == 0x9) ||          				    // Consider testing larger ranges first to improve speed. 

					(codePoint == 0xA) ||

					(codePoint == 0xD) ||

					((codePoint >= 0x20) && (codePoint <= 0xD7FF)) ||

					((codePoint >= 0xE000) && (codePoint <= 0xFFFD)) ||

					((codePoint >= 0x10000) && (codePoint <= 0x10FFFF))) {

				out.append(Character.toChars(codePoint));

			}				

			i+= Character.charCount(codePoint);                 // Increment with the number of code units(java chars) needed to represent a Unicode char.  

    	}

    	return out.toString();

    } 

        public static string stripNonValidXMLCharacters(string s)

        {

            StringBuilder _validXML = new StringBuilder(s.Length, s.Length); // Used to hold the output.

            char current; // Used to reference the current character.

            char[] charArray = s.ToCharArray();



            if (string.IsNullOrEmpty(s)) return string.Empty; // vacancy test.



            for (int i = 0; i < charArray.Length; i++)

            {

                current = charArray[i]; // NOTE: No IndexOutOfBoundsException caught here; it should not happen.

                if ((current == 0x9) ||

                    (current == 0xA) ||

                    (current == 0xD) ||

                    ((current >= 0x20) && (current <= 0xD7FF)) ||

                    ((current >= 0xE000) && (current <= 0xFFFD)) ||

                    ((current >= 0x10000) && (current <= 0x10FFFF)))

                    _validXML.Append(current);

            }

            return _validXML.ToString();

function strip_invalid_xml_chars2( $in )

{



$out = "";



$length = strlen($in);



for ( $i = 0; $i < $length; $i++)

{



$current = ord($in{$i});



if ( ($current == 0x9) || ($current == 0xA) || ($current == 0xD) || (($current >= 0x20) && ($current <= 0xD7FF)) || (($current >= 0xE000) && ($current <= 0xFFFD)) || (($current >= 0x10000) && ($current <= 0x10FFFF)))

{

        $out .= chr($current);

}

else

{

        $out .= " ";

}





}



return $out;





}

public String stripNonValidXMLCharacters(String in) {

	StringBuffer out = new StringBuffer(); // Used to hold the output.

	char current; // Used to reference the current character.



	if (in == null || ("".equals(in))) {

	    return "";

	} // vacancy test.

	for (int i = 0; i < in.length(); i++) {

	    current = in.charAt(i); // NOTE: No IndexOutOfBoundsException caught here; it should not happen.  

	    if ((current == 0x9) ||

		    (current == 0xA) ||

		    (current == 0xD) ||

		    ((current >= 0x20) && (current <= 0xD7FF)) ||

		    ((current >= 0xE000) && (current <= 0xFFFD)) ||

		    ((current >= 0x10000) && (current <= 0x10FFFF))) {

		out.append(current);

	    } else {

		out.append("_");

	    }

	}



	return out.toString();

    }

function ValidXmlString(Value :  wideString) : WideString;

var

  NewLen,

  idx     : integer;

  CurChar : word;

begin

  // initialize

  Result := '';

  NewLen := 0;

 

  // check for empty string

  if Length(Value) = 0 then

     exit;

 

  // init length of result

  Result := stringofchar(' ',length(Value));

 

  // loop and check valid xml characters

  for idx := 1 to length(Value) do

  begin

    CurChar := ord(Value[idx]);

    if (CurChar   = $9)     or  (CurChar =  $A)       or (CurChar = $D) or

       ((CurChar >= $20)    and (CurChar <= $D7FF))   or

       ((CurChar >= $E000)  and (CurChar <= $FFFD))   or

       ((CurChar >= $10000) and (CurChar <= $10FFFF)) then

    begin

       inc(NewLen);

       Result[NewLen] := Value[idx];

    end;

  end;

 

  // adjust size of result

  Result := copy(Result,1,NewLen);

end; // ValidXmlString

function stripNonValidXMLCharacters(in)

{

    var current;

    var out = "";



    for (var i = 0; i < in.length; i++)

    {

        current = in.charCodeAt(i);



        if ((current == 0x9) ||

            (current == 0xA) ||

            (current == 0xD) ||

            ((current >= 0x20) && (current <= 0xD7FF)) ||

            ((current >= 0xE000) && (current <= 0xFFFD)) ||

            ((current >= 0x10000) && (current <= 0x10FFFF)))

            out += in.charAt(i);

    }

    

    return out;

}

class ValidXmlChar(chr:Char) { 

    def isValidXmlChr() = { 

        ((chr == 0x9) || 

         (chr == 0xA) || 

         (chr == 0xD) || 

         ((chr >= 0x20) && (chr <= 0xD7FF)) || 

         ((chr >= 0xE000) && (chr <= 0xFFFD)) || 

         ((chr >= 0x10000) && (chr <= 0x10FFFF))) 

    } 

} 

 

object ValidXmlChar { 

    implicit def char2ValidXMLChar(chr:Char) = new ValidXmlChar(chr) 

} 

 

import ValidXmlChar.{_} 

 

object Main { 

 

    def main(args: Array[String]) :Unit = { 

        // Assuming args(0) is a string you want to clean 

        println(stripNonValidXMLCharacters(args(0))) 

    } 

 

    def stripNonValidXMLCharacters(s:String) = { 

        val sb = new StringBuffer() 

        s.filter(_.isValidXmlChr).foreach(sb.append(_)) 

        sb 

    } 

 

}