[Pkg-cli-libs-commits] [SCM] gdata-sharp branch, master, updated. debian/1.4.0.2-5-6-g16247e9
Chow Loong Jin
hyperair at ubuntu.com
Tue Feb 8 17:17:25 UTC 2011
The following commit has been merged in the master branch:
commit 16247e90a1c335741b85d79b028ec8879670cc8b
Author: Chow Loong Jin <hyperair at ubuntu.com>
Date: Wed Feb 9 01:12:23 2011 +0800
Fix remove-system-web-dep.patch
Git-Dch: Ignore
diff --git a/debian/patches/remove-system-web-dep.patch b/debian/patches/remove-system-web-dep.patch
index 544e4d2..2f4eed9 100644
--- a/debian/patches/remove-system-web-dep.patch
+++ b/debian/patches/remove-system-web-dep.patch
@@ -1,17 +1,17 @@
Index: gdata-sharp/src/core/HttpUtility.cs
===================================================================
---- gdata-sharp.orig/src/core/HttpUtility.cs 2011-02-08 02:36:27.513987192 +0800
-+++ gdata-sharp/src/core/HttpUtility.cs 2011-02-08 02:43:36.161609037 +0800
+--- gdata-sharp.orig/src/core/HttpUtility.cs 2011-02-09 01:07:07.780963167 +0800
++++ gdata-sharp/src/core/HttpUtility.cs 2011-02-09 01:10:36.859808030 +0800
@@ -1,7 +1,6 @@
-#if WindowsCE || PocketPC
-
//
// System.Web.HttpUtility
-+// Taken from http://github.com/mono/mono/tree/master/mcs/class/System.Web/System.Web.Util/
++// http://github.com/mono/mono/tree/master/mcs/class/System.Web/System.Web.Util/
//
// Authors:
// Patrik Torstensson (Patrik.Torstensson at labs2.com)
-@@ -37,11 +36,28 @@
+@@ -37,409 +36,436 @@
using System.IO;
using System.Security.Permissions;
using System.Text;
@@ -21,91 +21,670 @@ Index: gdata-sharp/src/core/HttpUtility.cs
+using System.Collections.Generic;
+#endif
+
-+namespace System.Web.Util
-+{
-+ class Helpers
-+ {
++namespace System.Web.Util {
++ class Helpers {
+ public static readonly CultureInfo InvariantCulture = CultureInfo.InvariantCulture;
+ }
+}
namespace System.Web {
-- public sealed class HttpUtility {
+#if !MONOTOUCH
+ // CAS - no InheritanceDemand here as the class is sealed
-+ [AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
++ [AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
+#endif
++
+ public sealed class HttpUtility {
-+ public sealed class HttpUtility {
#region Fields
-
+-
++
static Hashtable entities;
-@@ -339,20 +355,32 @@
- if (null == s)
+- static object lock_ = new object ();
+-
++ static object lock_ = new object();
++
+ #endregion // Fields
+-
++
+ static Hashtable Entities {
+ get {
+ lock (lock_) {
+ if (entities == null)
+- InitEntities ();
++ InitEntities();
+
+ return entities;
+ }
+ }
+ }
+-
++
+ #region Constructors
+
+- static void InitEntities ()
+- {
++ static void InitEntities() {
+ // Build the hash table of HTML entity references. This list comes
+ // from the HTML 4.01 W3C recommendation.
+- entities = new Hashtable ();
+- entities.Add ("nbsp", '\u00A0');
+- entities.Add ("iexcl", '\u00A1');
+- entities.Add ("cent", '\u00A2');
+- entities.Add ("pound", '\u00A3');
+- entities.Add ("curren", '\u00A4');
+- entities.Add ("yen", '\u00A5');
+- entities.Add ("brvbar", '\u00A6');
+- entities.Add ("sect", '\u00A7');
+- entities.Add ("uml", '\u00A8');
+- entities.Add ("copy", '\u00A9');
+- entities.Add ("ordf", '\u00AA');
+- entities.Add ("laquo", '\u00AB');
+- entities.Add ("not", '\u00AC');
+- entities.Add ("shy", '\u00AD');
+- entities.Add ("reg", '\u00AE');
+- entities.Add ("macr", '\u00AF');
+- entities.Add ("deg", '\u00B0');
+- entities.Add ("plusmn", '\u00B1');
+- entities.Add ("sup2", '\u00B2');
+- entities.Add ("sup3", '\u00B3');
+- entities.Add ("acute", '\u00B4');
+- entities.Add ("micro", '\u00B5');
+- entities.Add ("para", '\u00B6');
+- entities.Add ("middot", '\u00B7');
+- entities.Add ("cedil", '\u00B8');
+- entities.Add ("sup1", '\u00B9');
+- entities.Add ("ordm", '\u00BA');
+- entities.Add ("raquo", '\u00BB');
+- entities.Add ("frac14", '\u00BC');
+- entities.Add ("frac12", '\u00BD');
+- entities.Add ("frac34", '\u00BE');
+- entities.Add ("iquest", '\u00BF');
+- entities.Add ("Agrave", '\u00C0');
+- entities.Add ("Aacute", '\u00C1');
+- entities.Add ("Acirc", '\u00C2');
+- entities.Add ("Atilde", '\u00C3');
+- entities.Add ("Auml", '\u00C4');
+- entities.Add ("Aring", '\u00C5');
+- entities.Add ("AElig", '\u00C6');
+- entities.Add ("Ccedil", '\u00C7');
+- entities.Add ("Egrave", '\u00C8');
+- entities.Add ("Eacute", '\u00C9');
+- entities.Add ("Ecirc", '\u00CA');
+- entities.Add ("Euml", '\u00CB');
+- entities.Add ("Igrave", '\u00CC');
+- entities.Add ("Iacute", '\u00CD');
+- entities.Add ("Icirc", '\u00CE');
+- entities.Add ("Iuml", '\u00CF');
+- entities.Add ("ETH", '\u00D0');
+- entities.Add ("Ntilde", '\u00D1');
+- entities.Add ("Ograve", '\u00D2');
+- entities.Add ("Oacute", '\u00D3');
+- entities.Add ("Ocirc", '\u00D4');
+- entities.Add ("Otilde", '\u00D5');
+- entities.Add ("Ouml", '\u00D6');
+- entities.Add ("times", '\u00D7');
+- entities.Add ("Oslash", '\u00D8');
+- entities.Add ("Ugrave", '\u00D9');
+- entities.Add ("Uacute", '\u00DA');
+- entities.Add ("Ucirc", '\u00DB');
+- entities.Add ("Uuml", '\u00DC');
+- entities.Add ("Yacute", '\u00DD');
+- entities.Add ("THORN", '\u00DE');
+- entities.Add ("szlig", '\u00DF');
+- entities.Add ("agrave", '\u00E0');
+- entities.Add ("aacute", '\u00E1');
+- entities.Add ("acirc", '\u00E2');
+- entities.Add ("atilde", '\u00E3');
+- entities.Add ("auml", '\u00E4');
+- entities.Add ("aring", '\u00E5');
+- entities.Add ("aelig", '\u00E6');
+- entities.Add ("ccedil", '\u00E7');
+- entities.Add ("egrave", '\u00E8');
+- entities.Add ("eacute", '\u00E9');
+- entities.Add ("ecirc", '\u00EA');
+- entities.Add ("euml", '\u00EB');
+- entities.Add ("igrave", '\u00EC');
+- entities.Add ("iacute", '\u00ED');
+- entities.Add ("icirc", '\u00EE');
+- entities.Add ("iuml", '\u00EF');
+- entities.Add ("eth", '\u00F0');
+- entities.Add ("ntilde", '\u00F1');
+- entities.Add ("ograve", '\u00F2');
+- entities.Add ("oacute", '\u00F3');
+- entities.Add ("ocirc", '\u00F4');
+- entities.Add ("otilde", '\u00F5');
+- entities.Add ("ouml", '\u00F6');
+- entities.Add ("divide", '\u00F7');
+- entities.Add ("oslash", '\u00F8');
+- entities.Add ("ugrave", '\u00F9');
+- entities.Add ("uacute", '\u00FA');
+- entities.Add ("ucirc", '\u00FB');
+- entities.Add ("uuml", '\u00FC');
+- entities.Add ("yacute", '\u00FD');
+- entities.Add ("thorn", '\u00FE');
+- entities.Add ("yuml", '\u00FF');
+- entities.Add ("fnof", '\u0192');
+- entities.Add ("Alpha", '\u0391');
+- entities.Add ("Beta", '\u0392');
+- entities.Add ("Gamma", '\u0393');
+- entities.Add ("Delta", '\u0394');
+- entities.Add ("Epsilon", '\u0395');
+- entities.Add ("Zeta", '\u0396');
+- entities.Add ("Eta", '\u0397');
+- entities.Add ("Theta", '\u0398');
+- entities.Add ("Iota", '\u0399');
+- entities.Add ("Kappa", '\u039A');
+- entities.Add ("Lambda", '\u039B');
+- entities.Add ("Mu", '\u039C');
+- entities.Add ("Nu", '\u039D');
+- entities.Add ("Xi", '\u039E');
+- entities.Add ("Omicron", '\u039F');
+- entities.Add ("Pi", '\u03A0');
+- entities.Add ("Rho", '\u03A1');
+- entities.Add ("Sigma", '\u03A3');
+- entities.Add ("Tau", '\u03A4');
+- entities.Add ("Upsilon", '\u03A5');
+- entities.Add ("Phi", '\u03A6');
+- entities.Add ("Chi", '\u03A7');
+- entities.Add ("Psi", '\u03A8');
+- entities.Add ("Omega", '\u03A9');
+- entities.Add ("alpha", '\u03B1');
+- entities.Add ("beta", '\u03B2');
+- entities.Add ("gamma", '\u03B3');
+- entities.Add ("delta", '\u03B4');
+- entities.Add ("epsilon", '\u03B5');
+- entities.Add ("zeta", '\u03B6');
+- entities.Add ("eta", '\u03B7');
+- entities.Add ("theta", '\u03B8');
+- entities.Add ("iota", '\u03B9');
+- entities.Add ("kappa", '\u03BA');
+- entities.Add ("lambda", '\u03BB');
+- entities.Add ("mu", '\u03BC');
+- entities.Add ("nu", '\u03BD');
+- entities.Add ("xi", '\u03BE');
+- entities.Add ("omicron", '\u03BF');
+- entities.Add ("pi", '\u03C0');
+- entities.Add ("rho", '\u03C1');
+- entities.Add ("sigmaf", '\u03C2');
+- entities.Add ("sigma", '\u03C3');
+- entities.Add ("tau", '\u03C4');
+- entities.Add ("upsilon", '\u03C5');
+- entities.Add ("phi", '\u03C6');
+- entities.Add ("chi", '\u03C7');
+- entities.Add ("psi", '\u03C8');
+- entities.Add ("omega", '\u03C9');
+- entities.Add ("thetasym", '\u03D1');
+- entities.Add ("upsih", '\u03D2');
+- entities.Add ("piv", '\u03D6');
+- entities.Add ("bull", '\u2022');
+- entities.Add ("hellip", '\u2026');
+- entities.Add ("prime", '\u2032');
+- entities.Add ("Prime", '\u2033');
+- entities.Add ("oline", '\u203E');
+- entities.Add ("frasl", '\u2044');
+- entities.Add ("weierp", '\u2118');
+- entities.Add ("image", '\u2111');
+- entities.Add ("real", '\u211C');
+- entities.Add ("trade", '\u2122');
+- entities.Add ("alefsym", '\u2135');
+- entities.Add ("larr", '\u2190');
+- entities.Add ("uarr", '\u2191');
+- entities.Add ("rarr", '\u2192');
+- entities.Add ("darr", '\u2193');
+- entities.Add ("harr", '\u2194');
+- entities.Add ("crarr", '\u21B5');
+- entities.Add ("lArr", '\u21D0');
+- entities.Add ("uArr", '\u21D1');
+- entities.Add ("rArr", '\u21D2');
+- entities.Add ("dArr", '\u21D3');
+- entities.Add ("hArr", '\u21D4');
+- entities.Add ("forall", '\u2200');
+- entities.Add ("part", '\u2202');
+- entities.Add ("exist", '\u2203');
+- entities.Add ("empty", '\u2205');
+- entities.Add ("nabla", '\u2207');
+- entities.Add ("isin", '\u2208');
+- entities.Add ("notin", '\u2209');
+- entities.Add ("ni", '\u220B');
+- entities.Add ("prod", '\u220F');
+- entities.Add ("sum", '\u2211');
+- entities.Add ("minus", '\u2212');
+- entities.Add ("lowast", '\u2217');
+- entities.Add ("radic", '\u221A');
+- entities.Add ("prop", '\u221D');
+- entities.Add ("infin", '\u221E');
+- entities.Add ("ang", '\u2220');
+- entities.Add ("and", '\u2227');
+- entities.Add ("or", '\u2228');
+- entities.Add ("cap", '\u2229');
+- entities.Add ("cup", '\u222A');
+- entities.Add ("int", '\u222B');
+- entities.Add ("there4", '\u2234');
+- entities.Add ("sim", '\u223C');
+- entities.Add ("cong", '\u2245');
+- entities.Add ("asymp", '\u2248');
+- entities.Add ("ne", '\u2260');
+- entities.Add ("equiv", '\u2261');
+- entities.Add ("le", '\u2264');
+- entities.Add ("ge", '\u2265');
+- entities.Add ("sub", '\u2282');
+- entities.Add ("sup", '\u2283');
+- entities.Add ("nsub", '\u2284');
+- entities.Add ("sube", '\u2286');
+- entities.Add ("supe", '\u2287');
+- entities.Add ("oplus", '\u2295');
+- entities.Add ("otimes", '\u2297');
+- entities.Add ("perp", '\u22A5');
+- entities.Add ("sdot", '\u22C5');
+- entities.Add ("lceil", '\u2308');
+- entities.Add ("rceil", '\u2309');
+- entities.Add ("lfloor", '\u230A');
+- entities.Add ("rfloor", '\u230B');
+- entities.Add ("lang", '\u2329');
+- entities.Add ("rang", '\u232A');
+- entities.Add ("loz", '\u25CA');
+- entities.Add ("spades", '\u2660');
+- entities.Add ("clubs", '\u2663');
+- entities.Add ("hearts", '\u2665');
+- entities.Add ("diams", '\u2666');
+- entities.Add ("quot", '\u0022');
+- entities.Add ("amp", '\u0026');
+- entities.Add ("lt", '\u003C');
+- entities.Add ("gt", '\u003E');
+- entities.Add ("OElig", '\u0152');
+- entities.Add ("oelig", '\u0153');
+- entities.Add ("Scaron", '\u0160');
+- entities.Add ("scaron", '\u0161');
+- entities.Add ("Yuml", '\u0178');
+- entities.Add ("circ", '\u02C6');
+- entities.Add ("tilde", '\u02DC');
+- entities.Add ("ensp", '\u2002');
+- entities.Add ("emsp", '\u2003');
+- entities.Add ("thinsp", '\u2009');
+- entities.Add ("zwnj", '\u200C');
+- entities.Add ("zwj", '\u200D');
+- entities.Add ("lrm", '\u200E');
+- entities.Add ("rlm", '\u200F');
+- entities.Add ("ndash", '\u2013');
+- entities.Add ("mdash", '\u2014');
+- entities.Add ("lsquo", '\u2018');
+- entities.Add ("rsquo", '\u2019');
+- entities.Add ("sbquo", '\u201A');
+- entities.Add ("ldquo", '\u201C');
+- entities.Add ("rdquo", '\u201D');
+- entities.Add ("bdquo", '\u201E');
+- entities.Add ("dagger", '\u2020');
+- entities.Add ("Dagger", '\u2021');
+- entities.Add ("permil", '\u2030');
+- entities.Add ("lsaquo", '\u2039');
+- entities.Add ("rsaquo", '\u203A');
+- entities.Add ("euro", '\u20AC');
++ entities = new Hashtable();
++ entities.Add("nbsp", '\u00A0');
++ entities.Add("iexcl", '\u00A1');
++ entities.Add("cent", '\u00A2');
++ entities.Add("pound", '\u00A3');
++ entities.Add("curren", '\u00A4');
++ entities.Add("yen", '\u00A5');
++ entities.Add("brvbar", '\u00A6');
++ entities.Add("sect", '\u00A7');
++ entities.Add("uml", '\u00A8');
++ entities.Add("copy", '\u00A9');
++ entities.Add("ordf", '\u00AA');
++ entities.Add("laquo", '\u00AB');
++ entities.Add("not", '\u00AC');
++ entities.Add("shy", '\u00AD');
++ entities.Add("reg", '\u00AE');
++ entities.Add("macr", '\u00AF');
++ entities.Add("deg", '\u00B0');
++ entities.Add("plusmn", '\u00B1');
++ entities.Add("sup2", '\u00B2');
++ entities.Add("sup3", '\u00B3');
++ entities.Add("acute", '\u00B4');
++ entities.Add("micro", '\u00B5');
++ entities.Add("para", '\u00B6');
++ entities.Add("middot", '\u00B7');
++ entities.Add("cedil", '\u00B8');
++ entities.Add("sup1", '\u00B9');
++ entities.Add("ordm", '\u00BA');
++ entities.Add("raquo", '\u00BB');
++ entities.Add("frac14", '\u00BC');
++ entities.Add("frac12", '\u00BD');
++ entities.Add("frac34", '\u00BE');
++ entities.Add("iquest", '\u00BF');
++ entities.Add("Agrave", '\u00C0');
++ entities.Add("Aacute", '\u00C1');
++ entities.Add("Acirc", '\u00C2');
++ entities.Add("Atilde", '\u00C3');
++ entities.Add("Auml", '\u00C4');
++ entities.Add("Aring", '\u00C5');
++ entities.Add("AElig", '\u00C6');
++ entities.Add("Ccedil", '\u00C7');
++ entities.Add("Egrave", '\u00C8');
++ entities.Add("Eacute", '\u00C9');
++ entities.Add("Ecirc", '\u00CA');
++ entities.Add("Euml", '\u00CB');
++ entities.Add("Igrave", '\u00CC');
++ entities.Add("Iacute", '\u00CD');
++ entities.Add("Icirc", '\u00CE');
++ entities.Add("Iuml", '\u00CF');
++ entities.Add("ETH", '\u00D0');
++ entities.Add("Ntilde", '\u00D1');
++ entities.Add("Ograve", '\u00D2');
++ entities.Add("Oacute", '\u00D3');
++ entities.Add("Ocirc", '\u00D4');
++ entities.Add("Otilde", '\u00D5');
++ entities.Add("Ouml", '\u00D6');
++ entities.Add("times", '\u00D7');
++ entities.Add("Oslash", '\u00D8');
++ entities.Add("Ugrave", '\u00D9');
++ entities.Add("Uacute", '\u00DA');
++ entities.Add("Ucirc", '\u00DB');
++ entities.Add("Uuml", '\u00DC');
++ entities.Add("Yacute", '\u00DD');
++ entities.Add("THORN", '\u00DE');
++ entities.Add("szlig", '\u00DF');
++ entities.Add("agrave", '\u00E0');
++ entities.Add("aacute", '\u00E1');
++ entities.Add("acirc", '\u00E2');
++ entities.Add("atilde", '\u00E3');
++ entities.Add("auml", '\u00E4');
++ entities.Add("aring", '\u00E5');
++ entities.Add("aelig", '\u00E6');
++ entities.Add("ccedil", '\u00E7');
++ entities.Add("egrave", '\u00E8');
++ entities.Add("eacute", '\u00E9');
++ entities.Add("ecirc", '\u00EA');
++ entities.Add("euml", '\u00EB');
++ entities.Add("igrave", '\u00EC');
++ entities.Add("iacute", '\u00ED');
++ entities.Add("icirc", '\u00EE');
++ entities.Add("iuml", '\u00EF');
++ entities.Add("eth", '\u00F0');
++ entities.Add("ntilde", '\u00F1');
++ entities.Add("ograve", '\u00F2');
++ entities.Add("oacute", '\u00F3');
++ entities.Add("ocirc", '\u00F4');
++ entities.Add("otilde", '\u00F5');
++ entities.Add("ouml", '\u00F6');
++ entities.Add("divide", '\u00F7');
++ entities.Add("oslash", '\u00F8');
++ entities.Add("ugrave", '\u00F9');
++ entities.Add("uacute", '\u00FA');
++ entities.Add("ucirc", '\u00FB');
++ entities.Add("uuml", '\u00FC');
++ entities.Add("yacute", '\u00FD');
++ entities.Add("thorn", '\u00FE');
++ entities.Add("yuml", '\u00FF');
++ entities.Add("fnof", '\u0192');
++ entities.Add("Alpha", '\u0391');
++ entities.Add("Beta", '\u0392');
++ entities.Add("Gamma", '\u0393');
++ entities.Add("Delta", '\u0394');
++ entities.Add("Epsilon", '\u0395');
++ entities.Add("Zeta", '\u0396');
++ entities.Add("Eta", '\u0397');
++ entities.Add("Theta", '\u0398');
++ entities.Add("Iota", '\u0399');
++ entities.Add("Kappa", '\u039A');
++ entities.Add("Lambda", '\u039B');
++ entities.Add("Mu", '\u039C');
++ entities.Add("Nu", '\u039D');
++ entities.Add("Xi", '\u039E');
++ entities.Add("Omicron", '\u039F');
++ entities.Add("Pi", '\u03A0');
++ entities.Add("Rho", '\u03A1');
++ entities.Add("Sigma", '\u03A3');
++ entities.Add("Tau", '\u03A4');
++ entities.Add("Upsilon", '\u03A5');
++ entities.Add("Phi", '\u03A6');
++ entities.Add("Chi", '\u03A7');
++ entities.Add("Psi", '\u03A8');
++ entities.Add("Omega", '\u03A9');
++ entities.Add("alpha", '\u03B1');
++ entities.Add("beta", '\u03B2');
++ entities.Add("gamma", '\u03B3');
++ entities.Add("delta", '\u03B4');
++ entities.Add("epsilon", '\u03B5');
++ entities.Add("zeta", '\u03B6');
++ entities.Add("eta", '\u03B7');
++ entities.Add("theta", '\u03B8');
++ entities.Add("iota", '\u03B9');
++ entities.Add("kappa", '\u03BA');
++ entities.Add("lambda", '\u03BB');
++ entities.Add("mu", '\u03BC');
++ entities.Add("nu", '\u03BD');
++ entities.Add("xi", '\u03BE');
++ entities.Add("omicron", '\u03BF');
++ entities.Add("pi", '\u03C0');
++ entities.Add("rho", '\u03C1');
++ entities.Add("sigmaf", '\u03C2');
++ entities.Add("sigma", '\u03C3');
++ entities.Add("tau", '\u03C4');
++ entities.Add("upsilon", '\u03C5');
++ entities.Add("phi", '\u03C6');
++ entities.Add("chi", '\u03C7');
++ entities.Add("psi", '\u03C8');
++ entities.Add("omega", '\u03C9');
++ entities.Add("thetasym", '\u03D1');
++ entities.Add("upsih", '\u03D2');
++ entities.Add("piv", '\u03D6');
++ entities.Add("bull", '\u2022');
++ entities.Add("hellip", '\u2026');
++ entities.Add("prime", '\u2032');
++ entities.Add("Prime", '\u2033');
++ entities.Add("oline", '\u203E');
++ entities.Add("frasl", '\u2044');
++ entities.Add("weierp", '\u2118');
++ entities.Add("image", '\u2111');
++ entities.Add("real", '\u211C');
++ entities.Add("trade", '\u2122');
++ entities.Add("alefsym", '\u2135');
++ entities.Add("larr", '\u2190');
++ entities.Add("uarr", '\u2191');
++ entities.Add("rarr", '\u2192');
++ entities.Add("darr", '\u2193');
++ entities.Add("harr", '\u2194');
++ entities.Add("crarr", '\u21B5');
++ entities.Add("lArr", '\u21D0');
++ entities.Add("uArr", '\u21D1');
++ entities.Add("rArr", '\u21D2');
++ entities.Add("dArr", '\u21D3');
++ entities.Add("hArr", '\u21D4');
++ entities.Add("forall", '\u2200');
++ entities.Add("part", '\u2202');
++ entities.Add("exist", '\u2203');
++ entities.Add("empty", '\u2205');
++ entities.Add("nabla", '\u2207');
++ entities.Add("isin", '\u2208');
++ entities.Add("notin", '\u2209');
++ entities.Add("ni", '\u220B');
++ entities.Add("prod", '\u220F');
++ entities.Add("sum", '\u2211');
++ entities.Add("minus", '\u2212');
++ entities.Add("lowast", '\u2217');
++ entities.Add("radic", '\u221A');
++ entities.Add("prop", '\u221D');
++ entities.Add("infin", '\u221E');
++ entities.Add("ang", '\u2220');
++ entities.Add("and", '\u2227');
++ entities.Add("or", '\u2228');
++ entities.Add("cap", '\u2229');
++ entities.Add("cup", '\u222A');
++ entities.Add("int", '\u222B');
++ entities.Add("there4", '\u2234');
++ entities.Add("sim", '\u223C');
++ entities.Add("cong", '\u2245');
++ entities.Add("asymp", '\u2248');
++ entities.Add("ne", '\u2260');
++ entities.Add("equiv", '\u2261');
++ entities.Add("le", '\u2264');
++ entities.Add("ge", '\u2265');
++ entities.Add("sub", '\u2282');
++ entities.Add("sup", '\u2283');
++ entities.Add("nsub", '\u2284');
++ entities.Add("sube", '\u2286');
++ entities.Add("supe", '\u2287');
++ entities.Add("oplus", '\u2295');
++ entities.Add("otimes", '\u2297');
++ entities.Add("perp", '\u22A5');
++ entities.Add("sdot", '\u22C5');
++ entities.Add("lceil", '\u2308');
++ entities.Add("rceil", '\u2309');
++ entities.Add("lfloor", '\u230A');
++ entities.Add("rfloor", '\u230B');
++ entities.Add("lang", '\u2329');
++ entities.Add("rang", '\u232A');
++ entities.Add("loz", '\u25CA');
++ entities.Add("spades", '\u2660');
++ entities.Add("clubs", '\u2663');
++ entities.Add("hearts", '\u2665');
++ entities.Add("diams", '\u2666');
++ entities.Add("quot", '\u0022');
++ entities.Add("amp", '\u0026');
++ entities.Add("lt", '\u003C');
++ entities.Add("gt", '\u003E');
++ entities.Add("OElig", '\u0152');
++ entities.Add("oelig", '\u0153');
++ entities.Add("Scaron", '\u0160');
++ entities.Add("scaron", '\u0161');
++ entities.Add("Yuml", '\u0178');
++ entities.Add("circ", '\u02C6');
++ entities.Add("tilde", '\u02DC');
++ entities.Add("ensp", '\u2002');
++ entities.Add("emsp", '\u2003');
++ entities.Add("thinsp", '\u2009');
++ entities.Add("zwnj", '\u200C');
++ entities.Add("zwj", '\u200D');
++ entities.Add("lrm", '\u200E');
++ entities.Add("rlm", '\u200F');
++ entities.Add("ndash", '\u2013');
++ entities.Add("mdash", '\u2014');
++ entities.Add("lsquo", '\u2018');
++ entities.Add("rsquo", '\u2019');
++ entities.Add("sbquo", '\u201A');
++ entities.Add("ldquo", '\u201C');
++ entities.Add("rdquo", '\u201D');
++ entities.Add("bdquo", '\u201E');
++ entities.Add("dagger", '\u2020');
++ entities.Add("Dagger", '\u2021');
++ entities.Add("permil", '\u2030');
++ entities.Add("lsaquo", '\u2039');
++ entities.Add("rsaquo", '\u203A');
++ entities.Add("euro", '\u20AC');
+ }
+
+- public HttpUtility ()
+- {
++ public HttpUtility() {
+ }
+-
++
+ #endregion // Constructors
+-
++
+ #region Methods
+-
+- public static void HtmlAttributeEncode (string s, TextWriter output)
+- {
++
++ public static void HtmlAttributeEncode(string s, TextWriter output) {
+ output.Write(HtmlAttributeEncode(s));
+ }
+-
+- public static string HtmlAttributeEncode (string s)
+- {
+- if (null == s)
++
++ public static string HtmlAttributeEncode(string s) {
++ if (null == s) {
return null;
-
+-
- if (s.IndexOf ('&') == -1 && s.IndexOf ('"') == -1)
-+ bool needEncode = false;
-+ for (int i = 0; i < s.Length; i++) {
-+ if (s [i] == '&' || s [i] == '"' || s [i] == '<') {
-+ needEncode = true;
-+ break;
-+ }
+- return s;
+ }
-+
-+ if (!needEncode)
- return s;
- StringBuilder output = new StringBuilder ();
+- StringBuilder output = new StringBuilder ();
- foreach (char c in s)
- switch (c) {
-+ int len = s.Length;
-+ for (int i = 0; i < len; i++)
-+ switch (s [i]) {
- case '&' :
- output.Append ("&");
- break;
- case '"' :
- output.Append (""");
- break;
-+ case '<':
-+ output.Append ("<");
-+ break;
- default:
+- case '&' :
+- output.Append ("&");
+- break;
+- case '"' :
+- output.Append (""");
+- break;
+- default:
- output.Append (c);
-+ output.Append (s [i]);
++ bool needEncode = false;
++ for (int i = 0; i < s.Length; i++) {
++ if (s[i] == '&' || s[i] == '"' || s[i] == '<') {
++ needEncode = true;
break;
}
-
-@@ -364,11 +392,20 @@
+-
++ }
++
++ if (!needEncode) {
++ return s;
++ }
++
++ StringBuilder output = new StringBuilder();
++ int len = s.Length;
++ for (int i = 0; i < len; i++) {
++ switch (s[i]) {
++ case '&':
++ output.Append("&");
++ break;
++ case '"':
++ output.Append(""");
++ break;
++ case '<':
++ output.Append("<");
++ break;
++ default:
++ output.Append(s[i]);
++ break;
++ }
++ }
++
+ return output.ToString();
+ }
+-
+- public static string UrlDecode (string str)
+- {
++
++ public static string UrlDecode(string str) {
return UrlDecode(str, Encoding.UTF8);
}
-
+-
- private static char [] GetChars (MemoryStream b, Encoding e)
-+ static char [] GetChars (MemoryStream b, Encoding e)
- {
- return e.GetChars (b.GetBuffer (), 0, (int) b.Length);
+- {
+- return e.GetChars (b.GetBuffer (), 0, (int) b.Length);
++
++ static char[] GetChars(MemoryStream b, Encoding e) {
++ return e.GetChars(b.GetBuffer(), 0, (int)b.Length);
}
-+ static void WriteCharBytes (IList buf, char ch, Encoding e)
-+ {
+- public static string UrlDecode (string s, Encoding e)
+- {
+- if (null == s)
++ static void WriteCharBytes(IList buf, char ch, Encoding e) {
+ if (ch > 255) {
-+ foreach (byte b in e.GetBytes (new char[] { ch }))
-+ buf.Add (b);
++ foreach (byte b in e.GetBytes(new char[] { ch }))
++ buf.Add(b);
+ } else
-+ buf.Add ((byte)ch);
++ buf.Add((byte)ch);
+ }
-+
- public static string UrlDecode (string s, Encoding e)
- {
- if (null == s)
-@@ -376,57 +413,53 @@
++
++ public static string UrlDecode(string s, Encoding e) {
++ if (null == s)
+ return null;
- if (s.IndexOf ('%') == -1 && s.IndexOf ('+') == -1)
+- if (s.IndexOf ('%') == -1 && s.IndexOf ('+') == -1)
++ if (s.IndexOf('%') == -1 && s.IndexOf('+') == -1)
return s;
--
-+
+
if (e == null)
e = Encoding.UTF8;
-
@@ -114,42 +693,44 @@ Index: gdata-sharp/src/core/HttpUtility.cs
long len = s.Length;
- MemoryStream bytes = new MemoryStream ();
+#if NET_2_0
-+ var bytes = new List <byte> ();
++ var bytes = new List <byte>();
+#else
-+ ArrayList bytes = new ArrayList ();
++ ArrayList bytes = new ArrayList();
+#endif
int xchar;
-
-+ char ch;
-+
- for (int i = 0; i < len; i++) {
+- for (int i = 0; i < len; i++) {
- if (s [i] == '%' && i + 2 < len && s [i + 1] != '%') {
-+ ch = s [i];
-+ if (ch == '%' && i + 2 < len && s [i + 1] != '%') {
- if (s [i + 1] == 'u' && i + 5 < len) {
+- if (s [i + 1] == 'u' && i + 5 < len) {
- if (bytes.Length > 0) {
- output.Append (GetChars (bytes, e));
- bytes.SetLength (0);
- }
--
++ char ch;
+
+- xchar = GetChar (s, i + 2, 4);
++ for (int i = 0; i < len; i++) {
++ ch = s[i];
++ if (ch == '%' && i + 2 < len && s[i + 1] != '%') {
++ if (s[i + 1] == 'u' && i + 5 < len) {
+ // unicode hex sequence
- xchar = GetChar (s, i + 2, 4);
++ xchar = GetChar(s, i + 2, 4);
if (xchar != -1) {
- output.Append ((char) xchar);
-+ WriteCharBytes (bytes, (char)xchar, e);
++ WriteCharBytes(bytes, (char)xchar, e);
i += 5;
-- } else {
+ } else {
- output.Append ('%');
-- }
-+ } else
-+ WriteCharBytes (bytes, '%', e);
- } else if ((xchar = GetChar (s, i + 1, 2)) != -1) {
++ WriteCharBytes(bytes, '%', e);
+ }
+- } else if ((xchar = GetChar (s, i + 1, 2)) != -1) {
- bytes.WriteByte ((byte) xchar);
-+ WriteCharBytes (bytes, (char)xchar, e);
++ } else if ((xchar = GetChar(s, i + 1, 2)) != -1) {
++ WriteCharBytes(bytes, (char)xchar, e);
i += 2;
} else {
- output.Append ('%');
-+ WriteCharBytes (bytes, '%', e);
++ WriteCharBytes(bytes, '%', e);
}
continue;
}
@@ -169,62 +750,242 @@ Index: gdata-sharp/src/core/HttpUtility.cs
- if (bytes.Length > 0) {
- output.Append (GetChars (bytes, e));
+ if (ch == '+')
-+ WriteCharBytes (bytes, ' ', e);
++ WriteCharBytes(bytes, ' ', e);
+ else
-+ WriteCharBytes (bytes, ch, e);
++ WriteCharBytes(bytes, ch, e);
}
--
-+
+
+#if NET_2_0
+ byte[] buf = bytes.ToArray ();
+#else
-+ byte[] buf = (byte[])bytes.ToArray (typeof (byte));
++ byte[] buf = (byte[])bytes.ToArray(typeof(byte));
+#endif
++
bytes = null;
- return output.ToString ();
-+ return e.GetString (buf);
-+
++ return e.GetString(buf);
}
-
- public static string UrlDecode (byte [] bytes, Encoding e)
-@@ -437,7 +470,7 @@
- return UrlDecode (bytes, 0, bytes.Length, e);
+-
+- public static string UrlDecode (byte [] bytes, Encoding e)
+- {
++
++ public static string UrlDecode(byte[] bytes, Encoding e) {
+ if (bytes == null)
+ return null;
+
+- return UrlDecode (bytes, 0, bytes.Length, e);
++ return UrlDecode(bytes, 0, bytes.Length, e);
}
- private static int GetInt (byte b)
-+ static int GetInt (byte b)
- {
- char c = (char) b;
+- {
+- char c = (char) b;
++ static int GetInt(byte b) {
++ char c = (char)b;
if (c >= '0' && c <= '9')
-@@ -452,7 +485,7 @@
+ return c - '0';
+
+@@ -452,12 +478,11 @@
return -1;
}
- private static int GetChar (byte [] bytes, int offset, int length)
-+ static int GetChar (byte [] bytes, int offset, int length)
- {
+- {
++ static int GetChar(byte[] bytes, int offset, int length) {
int value = 0;
int end = length + offset;
-@@ -466,7 +499,7 @@
+ for (int i = offset; i < end; i++) {
+- int current = GetInt (bytes [i]);
++ int current = GetInt(bytes[i]);
+ if (current == -1)
+ return -1;
+ value = (value << 4) + current;
+@@ -466,16 +491,15 @@
return value;
}
- private static int GetChar (string str, int offset, int length)
-+ static int GetChar (string str, int offset, int length)
- {
+- {
++ static int GetChar(string str, int offset, int length) {
int val = 0;
int end = length + offset;
-@@ -602,8 +635,97 @@
- return result.ToArray ();
+ for (int i = offset; i < end; i++) {
+- char c = str [i];
++ char c = str[i];
+ if (c > 127)
+ return -1;
+
+- int current = GetInt ((byte) c);
++ int current = GetInt((byte)c);
+ if (current == -1)
+ return -1;
+ val = (val << 4) + current;
+@@ -483,98 +507,93 @@
+
+ return val;
+ }
+-
+- public static string UrlDecode (byte [] bytes, int offset, int count, Encoding e)
+- {
++
++ public static string UrlDecode(byte[] bytes, int offset, int count, Encoding e) {
+ if (bytes == null)
+ return null;
+ if (count == 0)
+ return String.Empty;
+
+ if (bytes == null)
+- throw new ArgumentNullException ("bytes");
++ throw new ArgumentNullException("bytes");
+
+ if (offset < 0 || offset > bytes.Length)
+- throw new ArgumentOutOfRangeException ("offset");
++ throw new ArgumentOutOfRangeException("offset");
+
+ if (count < 0 || offset + count > bytes.Length)
+- throw new ArgumentOutOfRangeException ("count");
++ throw new ArgumentOutOfRangeException("count");
+
+- StringBuilder output = new StringBuilder ();
+- MemoryStream acc = new MemoryStream ();
++ StringBuilder output = new StringBuilder();
++ MemoryStream acc = new MemoryStream();
+
+ int end = count + offset;
+ int xchar;
+ for (int i = offset; i < end; i++) {
+- if (bytes [i] == '%' && i + 2 < count && bytes [i + 1] != '%') {
+- if (bytes [i + 1] == (byte) 'u' && i + 5 < end) {
++ if (bytes[i] == '%' && i + 2 < count && bytes[i + 1] != '%') {
++ if (bytes[i + 1] == (byte)'u' && i + 5 < end) {
+ if (acc.Length > 0) {
+- output.Append (GetChars (acc, e));
+- acc.SetLength (0);
++ output.Append(GetChars(acc, e));
++ acc.SetLength(0);
+ }
+- xchar = GetChar (bytes, i + 2, 4);
++ xchar = GetChar(bytes, i + 2, 4);
+ if (xchar != -1) {
+- output.Append ((char) xchar);
++ output.Append((char)xchar);
+ i += 5;
+ continue;
+ }
+- } else if ((xchar = GetChar (bytes, i + 1, 2)) != -1) {
+- acc.WriteByte ((byte) xchar);
++ } else if ((xchar = GetChar(bytes, i + 1, 2)) != -1) {
++ acc.WriteByte((byte)xchar);
+ i += 2;
+ continue;
+ }
+ }
+
+ if (acc.Length > 0) {
+- output.Append (GetChars (acc, e));
+- acc.SetLength (0);
++ output.Append(GetChars(acc, e));
++ acc.SetLength(0);
+ }
+
+- if (bytes [i] == '+') {
+- output.Append (' ');
++ if (bytes[i] == '+') {
++ output.Append(' ');
+ } else {
+- output.Append ((char) bytes [i]);
++ output.Append((char)bytes[i]);
+ }
+ }
+
+ if (acc.Length > 0) {
+- output.Append (GetChars (acc, e));
++ output.Append(GetChars(acc, e));
+ }
+-
++
+ acc = null;
+- return output.ToString ();
++ return output.ToString();
+ }
+-
+- public static byte [] UrlDecodeToBytes (byte [] bytes)
+- {
++
++ public static byte[] UrlDecodeToBytes(byte[] bytes) {
+ if (bytes == null)
+ return null;
+
+- return UrlDecodeToBytes (bytes, 0, bytes.Length);
++ return UrlDecodeToBytes(bytes, 0, bytes.Length);
+ }
+
+- public static byte [] UrlDecodeToBytes (string str)
+- {
+- return UrlDecodeToBytes (str, Encoding.UTF8);
++ public static byte[] UrlDecodeToBytes(string str) {
++ return UrlDecodeToBytes(str, Encoding.UTF8);
+ }
+
+- public static byte [] UrlDecodeToBytes (string str, Encoding e)
+- {
++ public static byte[] UrlDecodeToBytes(string str, Encoding e) {
+ if (str == null)
+ return null;
+
+ if (e == null)
+- throw new ArgumentNullException ("e");
++ throw new ArgumentNullException("e");
+
+- return UrlDecodeToBytes (e.GetBytes (str));
++ return UrlDecodeToBytes(e.GetBytes(str));
}
-+ public static string UrlEncode(string str)
-+ {
+- public static byte [] UrlDecodeToBytes (byte [] bytes, int offset, int count)
+- {
++ public static byte[] UrlDecodeToBytes(byte[] bytes, int offset, int count) {
+ if (bytes == null)
+ return null;
+ if (count == 0)
+- return new byte [0];
++ return new byte[0];
+
+ int len = bytes.Length;
+ if (offset < 0 || offset >= len)
+@@ -583,87 +602,165 @@
+ if (count < 0 || offset > len - count)
+ throw new ArgumentOutOfRangeException("count");
+
+- MemoryStream result = new MemoryStream ();
++ MemoryStream result = new MemoryStream();
+ int end = offset + count;
+- for (int i = offset; i < end; i++){
+- char c = (char) bytes [i];
++ for (int i = offset; i < end; i++) {
++ char c = (char)bytes[i];
+ if (c == '+') {
+ c = ' ';
+ } else if (c == '%' && i < end - 2) {
+- int xchar = GetChar (bytes, i + 1, 2);
++ int xchar = GetChar(bytes, i + 1, 2);
+ if (xchar != -1) {
+- c = (char) xchar;
++ c = (char)xchar;
+ i += 2;
+ }
+ }
+- result.WriteByte ((byte) c);
++ result.WriteByte((byte)c);
++ }
++
++ return result.ToArray();
++ }
++
++ public static string UrlEncode(string str) {
+ return UrlEncode(str, Encoding.UTF8);
+ }
-+
-+ public static string UrlEncode (string s, Encoding Enc)
-+ {
++
++ public static string UrlEncode(string s, Encoding Enc) {
+ if (s == null)
+ return null;
+
@@ -234,212 +995,527 @@ Index: gdata-sharp/src/core/HttpUtility.cs
+ bool needEncode = false;
+ int len = s.Length;
+ for (int i = 0; i < len; i++) {
-+ char c = s [i];
++ char c = s[i];
+ if ((c < '0') || (c < 'A' && c > '9') || (c > 'Z' && c < 'a') || (c > 'z')) {
-+ if (NotEncoded (c))
++ if (NotEncoded(c))
+ continue;
+
+ needEncode = true;
+ break;
+ }
-+ }
-+
+ }
+
+- return result.ToArray ();
+ if (!needEncode)
+ return s;
+
+ // avoided GetByteCount call
-+ byte [] bytes = new byte[Enc.GetMaxByteCount(s.Length)];
-+ int realLen = Enc.GetBytes (s, 0, s.Length, bytes, 0);
-+ return Encoding.ASCII.GetString (UrlEncodeToBytes (bytes, 0, realLen));
++ byte[] bytes = new byte[Enc.GetMaxByteCount(s.Length)];
++ int realLen = Enc.GetBytes(s, 0, s.Length, bytes, 0);
++ return Encoding.ASCII.GetString(UrlEncodeToBytes(bytes, 0, realLen));
+ }
-+
-+ public static string UrlEncode (byte [] bytes)
-+ {
++
++ public static string UrlEncode(byte[] bytes) {
+ if (bytes == null)
+ return null;
+
+ if (bytes.Length == 0)
+ return "";
+
-+ return Encoding.ASCII.GetString (UrlEncodeToBytes (bytes, 0, bytes.Length));
++ return Encoding.ASCII.GetString(UrlEncodeToBytes(bytes, 0, bytes.Length));
+ }
+
-+ public static string UrlEncode (byte [] bytes, int offset, int count)
-+ {
++ public static string UrlEncode(byte[] bytes, int offset, int count) {
+ if (bytes == null)
+ return null;
+
+ if (bytes.Length == 0)
+ return "";
+
-+ return Encoding.ASCII.GetString (UrlEncodeToBytes (bytes, offset, count));
++ return Encoding.ASCII.GetString(UrlEncodeToBytes(bytes, offset, count));
+ }
+
-+ public static byte [] UrlEncodeToBytes (string str)
-+ {
-+ return UrlEncodeToBytes (str, Encoding.UTF8);
++ public static byte[] UrlEncodeToBytes(string str) {
++ return UrlEncodeToBytes(str, Encoding.UTF8);
+ }
+
-+ public static byte [] UrlEncodeToBytes (string str, Encoding e)
-+ {
++ public static byte[] UrlEncodeToBytes(string str, Encoding e) {
+ if (str == null)
+ return null;
+
+ if (str == "")
-+ return new byte [0];
++ return new byte[0];
+
-+ byte [] bytes = e.GetBytes (str);
-+ return UrlEncodeToBytes (bytes, 0, bytes.Length);
++ byte[] bytes = e.GetBytes(str);
++ return UrlEncodeToBytes(bytes, 0, bytes.Length);
+ }
+
-+ public static byte [] UrlEncodeToBytes (byte [] bytes)
-+ {
++ public static byte[] UrlEncodeToBytes(byte[] bytes) {
+ if (bytes == null)
+ return null;
+
+ if (bytes.Length == 0)
-+ return new byte [0];
++ return new byte[0];
+
-+ return UrlEncodeToBytes (bytes, 0, bytes.Length);
-+ }
-+
- static char [] hexChars = "0123456789abcdef".ToCharArray ();
++ return UrlEncodeToBytes(bytes, 0, bytes.Length);
+ }
+
+- static char [] hexChars = "0123456789abcdef".ToCharArray ();
- const string notEncoded = "!'()*-._";
-+
-+ static bool NotEncoded (char c)
-+ {
++ static char[] hexChars = "0123456789abcdef".ToCharArray();
+
+- static void UrlEncodeChar (char c, Stream result, bool isUnicode) {
++ static bool NotEncoded(char c) {
+ return (c == '!' || c == '\'' || c == '(' || c == ')' || c == '*' || c == '-' || c == '.' || c == '_');
+ }
-
- static void UrlEncodeChar (char c, Stream result, bool isUnicode) {
++
++ static void UrlEncodeChar(char c, Stream result, bool isUnicode) {
if (c > 255) {
-@@ -626,7 +748,7 @@
+ //FIXME: what happens when there is an internal error?
+ //if (!isUnicode)
+ // throw new ArgumentOutOfRangeException ("c", c, "c must be less than 256");
+ int idx;
+- int i = (int) c;
++ int i = (int)c;
+
+- result.WriteByte ((byte)'%');
+- result.WriteByte ((byte)'u');
++ result.WriteByte((byte)'%');
++ result.WriteByte((byte)'u');
+ idx = i >> 12;
+- result.WriteByte ((byte)hexChars [idx]);
++ result.WriteByte((byte)hexChars[idx]);
+ idx = (i >> 8) & 0x0F;
+- result.WriteByte ((byte)hexChars [idx]);
++ result.WriteByte((byte)hexChars[idx]);
+ idx = (i >> 4) & 0x0F;
+- result.WriteByte ((byte)hexChars [idx]);
++ result.WriteByte((byte)hexChars[idx]);
+ idx = i & 0x0F;
+- result.WriteByte ((byte)hexChars [idx]);
++ result.WriteByte((byte)hexChars[idx]);
return;
}
-
+-
- if (c>' ' && notEncoded.IndexOf (c)!=-1) {
-+ if (c > ' ' && NotEncoded (c)) {
- result.WriteByte ((byte)c);
+- result.WriteByte ((byte)c);
++
++ if (c > ' ' && NotEncoded(c)) {
++ result.WriteByte((byte)c);
+ return;
+ }
+- if (c==' ') {
+- result.WriteByte ((byte)'+');
++ if (c == ' ') {
++ result.WriteByte((byte)'+');
return;
}
-@@ -679,6 +801,13 @@
+- if ( (c < '0') ||
++ if ((c < '0') ||
+ (c < 'A' && c > '9') ||
+ (c > 'Z' && c < 'a') ||
+ (c > 'z')) {
+ if (isUnicode && c > 127) {
+- result.WriteByte ((byte)'%');
+- result.WriteByte ((byte)'u');
+- result.WriteByte ((byte)'0');
+- result.WriteByte ((byte)'0');
+- }
+- else
+- result.WriteByte ((byte)'%');
+-
+- int idx = ((int) c) >> 4;
+- result.WriteByte ((byte)hexChars [idx]);
+- idx = ((int) c) & 0x0F;
+- result.WriteByte ((byte)hexChars [idx]);
+- }
+- else
+- result.WriteByte ((byte)c);
++ result.WriteByte((byte)'%');
++ result.WriteByte((byte)'u');
++ result.WriteByte((byte)'0');
++ result.WriteByte((byte)'0');
++ } else
++ result.WriteByte((byte)'%');
++
++ int idx = ((int)c) >> 4;
++ result.WriteByte((byte)hexChars[idx]);
++ idx = ((int)c) & 0x0F;
++ result.WriteByte((byte)hexChars[idx]);
++ } else
++ result.WriteByte((byte)c);
+ }
+
+- public static byte [] UrlEncodeToBytes (byte [] bytes, int offset, int count)
+- {
++ public static byte[] UrlEncodeToBytes(byte[] bytes, int offset, int count) {
+ if (bytes == null)
+ return null;
+
+ int len = bytes.Length;
+ if (len == 0)
+- return new byte [0];
++ return new byte[0];
+
+ if (offset < 0 || offset >= len)
+ throw new ArgumentOutOfRangeException("offset");
+@@ -671,28 +768,33 @@
+ if (count < 0 || count > len - offset)
+ throw new ArgumentOutOfRangeException("count");
+
+- MemoryStream result = new MemoryStream (count);
++ MemoryStream result = new MemoryStream(count);
+ int end = offset + count;
+ for (int i = offset; i < end; i++)
+- UrlEncodeChar ((char)bytes [i], result, false);
++ UrlEncodeChar((char)bytes[i], result, false);
+
return result.ToArray();
}
-+ public static string UrlEncodeUnicode (string str)
-+ {
++ public static string UrlEncodeUnicode(string str) {
+ if (str == null)
+ return null;
-+
-+ return Encoding.ASCII.GetString (UrlEncodeUnicodeToBytes (str));
+
+- public static byte [] UrlEncodeUnicodeToBytes (string str)
+- {
++ return Encoding.ASCII.GetString(UrlEncodeUnicodeToBytes(str));
+ }
++
++ public static byte[] UrlEncodeUnicodeToBytes(string str) {
+ if (str == null)
+ return null;
- public static byte [] UrlEncodeUnicodeToBytes (string str)
- {
-@@ -734,7 +863,7 @@
+ if (str == "")
+- return new byte [0];
++ return new byte[0];
+
+- MemoryStream result = new MemoryStream (str.Length);
+- foreach (char c in str){
+- UrlEncodeChar (c, result, true);
++ MemoryStream result = new MemoryStream(str.Length);
++ foreach (char c in str) {
++ UrlEncodeChar(c, result, true);
+ }
+- return result.ToArray ();
++ return result.ToArray();
+ }
+
+ /// <summary>
+@@ -700,16 +802,15 @@
+ /// </summary>
+ /// <param name="s">The HTML string to decode. </param>
+ /// <returns>The decoded text.</returns>
+- public static string HtmlDecode (string s)
+- {
++ public static string HtmlDecode(string s) {
+ if (s == null)
+- throw new ArgumentNullException ("s");
++ throw new ArgumentNullException("s");
+
+- if (s.IndexOf ('&') == -1)
++ if (s.IndexOf('&') == -1)
+ return s;
+
+- StringBuilder entity = new StringBuilder ();
+- StringBuilder output = new StringBuilder ();
++ StringBuilder entity = new StringBuilder();
++ StringBuilder output = new StringBuilder();
+ int len = s.Length;
+ // 0 -> nothing,
+ // 1 -> right after '&'
+@@ -718,15 +819,15 @@
+ int state = 0;
+ int number = 0;
+ bool have_trailing_digits = false;
+-
++
+ for (int i = 0; i < len; i++) {
+- char c = s [i];
++ char c = s[i];
+ if (state == 0) {
+ if (c == '&') {
+- entity.Append (c);
++ entity.Append(c);
+ state = 1;
+ } else {
+- output.Append (c);
++ output.Append(c);
+ }
+ continue;
+ }
+@@ -734,21 +835,21 @@
if (c == '&') {
state = 1;
if (have_trailing_digits) {
- entity.Append (number.ToString (CultureInfo.InvariantCulture));
-+ entity.Append (number.ToString (Helpers.InvariantCulture));
++ entity.Append(number.ToString(Helpers.InvariantCulture));
have_trailing_digits = false;
}
-@@ -774,7 +903,7 @@
+- output.Append (entity.ToString ());
++ output.Append(entity.ToString());
+ entity.Length = 0;
+- entity.Append ('&');
++ entity.Append('&');
+ continue;
+ }
+
+ if (state == 1) {
+ if (c == ';') {
+ state = 0;
+- output.Append (entity.ToString ());
+- output.Append (c);
++ output.Append(entity.ToString());
++ output.Append(c);
+ entity.Length = 0;
+ } else {
+ number = 0;
+@@ -757,119 +858,133 @@
+ } else {
+ state = 3;
+ }
+- entity.Append (c);
++ entity.Append(c);
+ }
+ } else if (state == 2) {
+- entity.Append (c);
++ entity.Append(c);
+ if (c == ';') {
+- string key = entity.ToString ();
+- if (key.Length > 1 && Entities.ContainsKey (key.Substring (1, key.Length - 2)))
+- key = Entities [key.Substring (1, key.Length - 2)].ToString ();
++ string key = entity.ToString();
++ if (key.Length > 1 && Entities.ContainsKey(key.Substring(1, key.Length - 2)))
++ key = Entities[key.Substring(1, key.Length - 2)].ToString();
+
+- output.Append (key);
++ output.Append(key);
+ state = 0;
+ entity.Length = 0;
+ }
+ } else if (state == 3) {
if (c == ';') {
if (number > 65535) {
- output.Append ("&#");
+- output.Append ("&#");
- output.Append (number.ToString (CultureInfo.InvariantCulture));
-+ output.Append (number.ToString (Helpers.InvariantCulture));
- output.Append (";");
+- output.Append (";");
++ output.Append("&#");
++ output.Append(number.ToString(Helpers.InvariantCulture));
++ output.Append(";");
} else {
- output.Append ((char) number);
-@@ -788,7 +917,7 @@
+- output.Append ((char) number);
++ output.Append((char)number);
+ }
+ state = 0;
+ entity.Length = 0;
+ have_trailing_digits = false;
+- } else if (Char.IsDigit (c)) {
+- number = number * 10 + ((int) c - '0');
++ } else if (Char.IsDigit(c)) {
++ number = number * 10 + ((int)c - '0');
+ have_trailing_digits = true;
} else {
state = 2;
if (have_trailing_digits) {
- entity.Append (number.ToString (CultureInfo.InvariantCulture));
-+ entity.Append (number.ToString (Helpers.InvariantCulture));
++ entity.Append(number.ToString(Helpers.InvariantCulture));
have_trailing_digits = false;
}
- entity.Append (c);
-@@ -799,7 +928,7 @@
+- entity.Append (c);
++ entity.Append(c);
+ }
+ }
+ }
+
if (entity.Length > 0) {
- output.Append (entity.ToString ());
+- output.Append (entity.ToString ());
++ output.Append(entity.ToString());
} else if (have_trailing_digits) {
- output.Append (number.ToString (CultureInfo.InvariantCulture));
-+ output.Append (number.ToString (Helpers.InvariantCulture));
++ output.Append(number.ToString(Helpers.InvariantCulture));
}
- return output.ToString ();
+- return output.ToString ();
++ return output.ToString();
}
-@@ -825,10 +954,23 @@
+-
++
+ /// <summary>
+ /// Decodes an HTML-encoded string and sends the resulting output to a TextWriter output stream.
+ /// </summary>
+ /// <param name="s">The HTML string to decode</param>
+ /// <param name="output">The TextWriter output stream containing the decoded string. </param>
+- public static void HtmlDecode(string s, TextWriter output)
+- {
++ public static void HtmlDecode(string s, TextWriter output) {
+ if (s != null)
+- output.Write (HtmlDecode (s));
++ output.Write(HtmlDecode(s));
+ }
+-
++
+ /// <summary>
+ /// HTML-encodes a string and returns the encoded string.
+ /// </summary>
+ /// <param name="s">The text string to encode. </param>
+ /// <returns>The HTML-encoded text.</returns>
+- public static string HtmlEncode (string s)
+- {
++ public static string HtmlEncode(string s) {
if (s == null)
return null;
+- StringBuilder output = new StringBuilder ();
+-
+- foreach (char c in s)
+- switch (c) {
+- case '&' :
+- output.Append ("&");
+- break;
+- case '>' :
+- output.Append (">");
+- break;
+- case '<' :
+- output.Append ("<");
+- break;
+- case '"' :
+- output.Append (""");
+- break;
+- default:
+- // MS starts encoding with &# from 160 and stops at 255.
+- // We don't do that. One reason is the 65308/65310 unicode
+- // characters that look like '<' and '>'.
+- if (c > 159) {
+- output.Append ("&#");
+- output.Append (((int) c).ToString (CultureInfo.InvariantCulture));
+- output.Append (";");
+- } else {
+- output.Append (c);
+- }
+ bool needEncode = false;
+ for (int i = 0; i < s.Length; i++) {
-+ char c = s [i];
++ char c = s[i];
+ if (c == '&' || c == '"' || c == '<' || c == '>' || c > 159) {
+ needEncode = true;
-+ break;
-+ }
+ break;
+ }
+- return output.ToString ();
+ }
+
+ if (!needEncode)
+ return s;
+
- StringBuilder output = new StringBuilder ();
-
-- foreach (char c in s)
-- switch (c) {
++ StringBuilder output = new StringBuilder();
++
+ int len = s.Length;
-+ for (int i = 0; i < len; i++)
-+ switch (s [i]) {
- case '&' :
- output.Append ("&");
- break;
-@@ -845,12 +987,16 @@
- // MS starts encoding with &# from 160 and stops at 255.
- // We don't do that. One reason is the 65308/65310 unicode
- // characters that look like '<' and '>'.
-- if (c > 159) {
++ for (int i = 0; i < len; i++)
++ switch (s[i]) {
++ case '&':
++ output.Append("&");
++ break;
++ case '>':
++ output.Append(">");
++ break;
++ case '<':
++ output.Append("<");
++ break;
++ case '"':
++ output.Append(""");
++ break;
++ default:
++ // MS starts encoding with &# from 160 and stops at 255.
++ // We don't do that. One reason is the 65308/65310 unicode
++ // characters that look like '<' and '>'.
+#if TARGET_JVM
-+ if (s [i] > 159 && s [i] < 256) {
++ if (s [i] > 159 && s [i] < 256) {
+#else
-+ if (s [i] > 159) {
++ if (s[i] > 159) {
+#endif
- output.Append ("&#");
-- output.Append (((int) c).ToString (CultureInfo.InvariantCulture));
-+ output.Append (((int) s [i]).ToString (Helpers.InvariantCulture));
- output.Append (";");
- } else {
-- output.Append (c);
-+ output.Append (s [i]);
- }
- break;
- }
-@@ -883,7 +1029,11 @@
++ output.Append("&#");
++ output.Append(((int)s[i]).ToString(Helpers.InvariantCulture));
++ output.Append(";");
++ } else {
++ output.Append(s[i]);
++ }
++ break;
++ }
++ return output.ToString();
+ }
+-
++
+ /// <summary>
+ /// HTML-encodes a string and sends the resulting output to a TextWriter output stream.
+ /// </summary>
+ /// <param name="s">The string to encode. </param>
+ /// <param name="output">The TextWriter output stream containing the encoded string. </param>
+- public static void HtmlEncode(string s, TextWriter output)
+- {
++ public static void HtmlEncode(string s, TextWriter output) {
+ if (s != null)
+- output.Write (HtmlEncode (s));
++ output.Write(HtmlEncode(s));
+ }
+
+ #if NET_1_1
+- public static string UrlPathEncode (string s)
++ public static string UrlPathEncode(string s)
+ {
+ if (s == null || s.Length == 0)
+ return s;
+@@ -877,93 +992,122 @@
+ MemoryStream result = new MemoryStream ();
+ int length = s.Length;
+ for (int i = 0; i < length; i++) {
+- UrlPathEncodeChar (s [i], result);
++ UrlPathEncodeChar(s [i], result);
+ }
+- return Encoding.ASCII.GetString (result.ToArray ());
++ return Encoding.ASCII.GetString(result.ToArray ());
}
- static void UrlPathEncodeChar (char c, Stream result) {
+- static void UrlPathEncodeChar (char c, Stream result) {
++ static void UrlPathEncodeChar(char c, Stream result) {
+#if NET_2_0
+ if (c < 33 || c > 126) {
+#else
if (c > 127) {
+- byte [] bIn = Encoding.UTF8.GetBytes (c.ToString ());
+#endif
- byte [] bIn = Encoding.UTF8.GetBytes (c.ToString ());
++ byte [] bIn = Encoding.UTF8.GetBytes(c.ToString());
for (int i = 0; i < bIn.Length; i++) {
- result.WriteByte ((byte) '%');
-@@ -904,6 +1054,23 @@
+- result.WriteByte ((byte) '%');
++ result.WriteByte((byte) '%');
+ int idx = ((int) bIn [i]) >> 4;
+- result.WriteByte ((byte) hexChars [idx]);
++ result.WriteByte((byte) hexChars [idx]);
+ idx = ((int) bIn [i]) & 0x0F;
+- result.WriteByte ((byte) hexChars [idx]);
++ result.WriteByte((byte) hexChars [idx]);
+ }
+ }
+ else if (c == ' ') {
+- result.WriteByte ((byte) '%');
+- result.WriteByte ((byte) '2');
+- result.WriteByte ((byte) '0');
++ result.WriteByte((byte) '%');
++ result.WriteByte((byte) '2');
++ result.WriteByte((byte) '0');
+ }
+ else
+- result.WriteByte ((byte) c);
++ result.WriteByte((byte) c);
+ }
#endif
#if NET_2_0
+- public static NameValueCollection ParseQueryString (string query)
+ class HttpQSCollection : NameValueCollection {
+ public override string ToString ()
+ {
+ int count = Count;
+ if (count == 0)
+ return "";
++
+ StringBuilder sb = new StringBuilder ();
+ string [] keys = AllKeys;
+ for (int i = 0; i < count; i++) {
@@ -451,23 +1527,43 @@ Index: gdata-sharp/src/core/HttpUtility.cs
+ }
+ }
+
- public static NameValueCollection ParseQueryString (string query)
++ public static NameValueCollection ParseQueryString(string query)
+ {
+- return ParseQueryString (query, Encoding.UTF8);
++ return ParseQueryString(query, Encoding.UTF8);
+ }
+
+- public static NameValueCollection ParseQueryString (string query, Encoding encoding)
++ public static NameValueCollection ParseQueryString(string query, Encoding encoding)
{
- return ParseQueryString (query, Encoding.UTF8);
-@@ -920,7 +1087,7 @@
+ if (query == null)
+- throw new ArgumentNullException ("query");
++ throw new ArgumentNullException("query");
+ if (encoding == null)
+- throw new ArgumentNullException ("encoding");
++ throw new ArgumentNullException("encoding");
+ if (query.Length == 0 || (query.Length == 1 && query[0] == '?'))
+- return new NameValueCollection ();
++ return new NameValueCollection();
if (query[0] == '?')
- query = query.Substring (1);
+- query = query.Substring (1);
++ query = query.Substring(1);
- NameValueCollection result = new NameValueCollection ();
-+ NameValueCollection result = new HttpQSCollection ();
- ParseQueryString (query, encoding, result);
+- ParseQueryString (query, encoding, result);
++ NameValueCollection result = new HttpQSCollection();
++ ParseQueryString(query, encoding, result);
return result;
}
-@@ -931,39 +1098,48 @@
+ #endif
+
+- internal static void ParseQueryString (string query, Encoding encoding, NameValueCollection result)
+- {
++ internal static void ParseQueryString(string query, Encoding encoding, NameValueCollection result) {
if (query.Length == 0)
return;
-+ string decoded = HtmlDecode (query);
++ string decoded = HtmlDecode(query);
+ int decodedLength = decoded.Length;
int namePos = 0;
- while (namePos <= query.Length) {
@@ -477,10 +1573,10 @@ Index: gdata-sharp/src/core/HttpUtility.cs
- for (int q = namePos; q < query.Length; q++) {
- if (valuePos == -1 && query[q] == '=') {
+ for (int q = namePos; q < decodedLength; q++) {
-+ if (valuePos == -1 && decoded [q] == '=') {
++ if (valuePos == -1 && decoded[q] == '=') {
valuePos = q + 1;
- } else if (query[q] == '&') {
-+ } else if (decoded [q] == '&') {
++ } else if (decoded[q] == '&') {
valueEnd = q;
break;
}
@@ -488,17 +1584,17 @@ Index: gdata-sharp/src/core/HttpUtility.cs
+ if (first) {
+ first = false;
-+ if (decoded [namePos] == '?')
++ if (decoded[namePos] == '?')
+ namePos++;
+ }
-+
++
string name, value;
if (valuePos == -1) {
name = null;
valuePos = namePos;
} else {
- name = UrlDecode (query.Substring (namePos, valuePos - namePos - 1), encoding);
-+ name = UrlDecode (decoded.Substring (namePos, valuePos - namePos - 1), encoding);
++ name = UrlDecode(decoded.Substring(namePos, valuePos - namePos - 1), encoding);
}
if (valueEnd < 0) {
namePos = -1;
@@ -508,10 +1604,11 @@ Index: gdata-sharp/src/core/HttpUtility.cs
namePos = valueEnd + 1;
}
- value = UrlDecode (query.Substring (valuePos, valueEnd - valuePos), encoding);
-+ value = UrlDecode (decoded.Substring (valuePos, valueEnd - valuePos), encoding);
++ value = UrlDecode(decoded.Substring(valuePos, valueEnd - valuePos), encoding);
- result.Add (name, value);
+- result.Add (name, value);
- if (namePos == -1) break;
++ result.Add(name, value);
+ if (namePos == -1)
+ break;
}
@@ -519,12 +1616,43 @@ Index: gdata-sharp/src/core/HttpUtility.cs
#endregion // Methods
}
}
-
+-
-#endif
+Index: gdata-sharp/src/gapps/orgmanagementservice.cs
+===================================================================
+--- gdata-sharp.orig/src/gapps/orgmanagementservice.cs 2011-02-09 01:07:07.797629742 +0800
++++ gdata-sharp/src/gapps/orgmanagementservice.cs 2011-02-09 01:07:09.454287263 +0800
+@@ -98,7 +98,7 @@
+ {
+ String uri = String.Format("{0}/{1}?get=children&orgUnitPath={2}",
+ AppsOrganizationNameTable.AppsOrgUnitBaseFeedUri, customerId,
+- HttpUtility.UrlPathEncode(orgUnitPath));
++ HttpUtility.UrlEncode(orgUnitPath));
+ return QueryExtendedFeed(new Uri(uri), true);
+ }
+
+@@ -271,7 +271,7 @@
+ {
+ String uri = String.Format("{0}/{1}?get=children&orgUnitPath={2}",
+ AppsOrganizationNameTable.AppsOrgUserBaseFeedUri, customerId,
+- HttpUtility.UrlPathEncode(orgUnitPath));
++ HttpUtility.UrlEncode(orgUnitPath));
+ return QueryExtendedFeed(new Uri(uri), true);
+ }
+
+@@ -286,7 +286,7 @@
+ {
+ String uri = String.Format("{0}/{1}?get=children&orgUnitPath={2}",
+ AppsOrganizationNameTable.AppsOrgUserBaseFeedUri, customerId,
+- HttpUtility.UrlPathEncode(orgUnitPath));
++ HttpUtility.UrlEncode(orgUnitPath));
+ return QueryExtendedFeed(new Uri(uri), false);
+ }
+ }
Index: gdata-sharp/Makefile
===================================================================
---- gdata-sharp.orig/Makefile 2011-02-08 02:36:27.500653935 +0800
-+++ gdata-sharp/Makefile 2011-02-08 02:43:36.161609037 +0800
+--- gdata-sharp.orig/Makefile 2011-02-09 01:07:07.767629907 +0800
++++ gdata-sharp/Makefile 2011-02-09 01:09:33.846823071 +0800
@@ -36,7 +36,7 @@
UNINSTALLLIBS = $(basename $(ALLLIBS))
--
gdata-sharp
More information about the Pkg-cli-libs-commits
mailing list