[Test]
public void AgtB ()
{
- Assertion.Assert(A > B);
+ Assert.IsTrue(A > B);
}
[Test]
public void ANotLtB ()
{
- Assertion.Assert(!(A < B));
+ Assert.IsTrue(!(A < B));
}
[Test]
public void BNotGtA ()
{
- Assertion.Assert(!(B > A));
+ Assert.IsTrue(!(B > A));
}
[Test]
public void AltB ()
{
- Assertion.Assert(B < A);
+ Assert.IsTrue(B < A);
}
[Test]
public void AeqA ()
{
- Assertion.Assert(A == A);
+ Assert.AreEqual(A, A);
}
[Test]
public void BeqB ()
{
- Assertion.Assert(B == B);
+ Assert.AreEqual(B, B);
}
[Test]
public void AneqB ()
{
- Assertion.Assert(A != B);
+ Assert.AreNotEqual(A, B);
}
[Test]
public void BneqA ()
{
- Assertion.Assert(B != A);
+ Assert.AreNotEqual(B, A);
}
#endregion
for (int i = 0; i < 5; i++) {
ContextData ctx = new ContextData (128, (uint)r.Next (int.MinValue, int.MaxValue));
BigInteger p = GenerateNewPrime (128, ctx);
- Assertion.Assert (p.TestBit (1));
+ Assert.IsTrue (p.TestBit (1));
uint d = ctx.testData;
for (uint j = 128 - 2; d > 0; j--, d >>= 1)
Assertion.AssertEquals ((d&1) == 1, p.TestBit (j));
private string WriteFile ()
{
- string filename = "helloworld_signed.exe";
+ string filename = Path.Combine (Path.GetTempPath (), "helloworld_signed.exe");
try {
if (File.Exists (filename)) {
File.Delete (filename);
Assert (msg, a);
}
- private const string testfile = "test.pvk";
+ string testfile;
+
+ [TestFixtureSetUp]
+ public void FixtureSetup ()
+ {
+ testfile = Path.Combine (Path.GetTempPath (), "test.pvk");
+ }
[TearDown]
public void TearDown ()
0x77, 0xEF, 0xEC, 0x17, 0x92, 0xC7, 0xD6, 0xCD, 0xE1, 0x2A, 0x2E, 0xE7,
0xF3, 0xED, 0x7F, 0x66, 0x86, 0x31, 0x00 };
- private const string testfile = "test.spc";
+ string testfile;
+
+ [TestFixtureSetUp]
+ public void FixtureSetup ()
+ {
+ testfile = Path.Combine (Path.GetTempPath (), "test.spc");
+ }
[TearDown]
public void TearDown ()
if (unicode) {
data = Encoding.Unicode.GetBytes (s);
} else if (pem) {
- string b64pem = "-----BEGIN PKCS7-----\n" + s + "\n-----END PKCS7-----";
- data = Encoding.ASCII.GetBytes (b64pem);
- using (FileStream fs = File.Create ("bad.pem")) {
- fs.Write (data, 0, data.Length);
- }
+ //string b64pem = "-----BEGIN PKCS7-----\n" + s + "\n-----END PKCS7-----";
+ //data = Encoding.ASCII.GetBytes (b64pem);
+ //using (FileStream fs = File.Create ("bad.pem")) {
+ // fs.Write (data, 0, data.Length);
+ //}
} else {
data = Encoding.ASCII.GetBytes (s);
}
AssertEquals ("key.PublicKeyToken", sn1.PublicKeyToken, sn2.PublicKeyToken);
}
- private const string Signed = "hellosigned.exe";
- private const string Delay = "hellodelay.exe";
+ string Signed;
+ string Delay;
private StrongName sn;
private static byte[] signedData = {
0x4D, 0x5A, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
[SetUp]
public void SetUp ()
{
+ Signed = Path.Combine (Path.GetTempPath (), "hellosigned.exe");
+ Delay = Path.Combine (Path.GetTempPath (), "hellodelay.exe");
+
sn = new StrongName (key);
// write hellosigned.exe to disk
FileStream fs = File.OpenWrite (Signed);
fs.Write (signedData, 0, signedData.Length);
fs.Close ();
+
+
// write hellodelay.exe to disk
fs = File.OpenWrite (Delay);
fs.Write (delayData, 0, delayData.Length);
client.SendAsync (request, HttpCompletionOption.ResponseContentRead).Wait (WaitTimeout);
Assert.Fail ("#2");
} catch (AggregateException e) {
- Assert.IsInstanceOfType (typeof (HttpRequestException), e.InnerException, "#3");
+ Assert.IsTrue (e.InnerException is HttpRequestException, "#3");
}
} finally {
client.GetByteArrayAsync (LocalServer).Wait (WaitTimeout);
Assert.Fail ("#1");
} catch (AggregateException e) {
- Assert.IsInstanceOfType (typeof (HttpRequestException), e.InnerException, "#2");
+ Assert.IsTrue (e.InnerException is HttpRequestException , "#2");
}
} finally {
listener.Close ();
client.GetStringAsync (LocalServer).Wait (WaitTimeout);
Assert.Fail ("#1");
} catch (AggregateException e) {
- Assert.IsInstanceOfType (typeof (HttpRequestException), e.InnerException, "#2");
+ Assert.IsTrue (e.InnerException is HttpRequestException, "#2");
}
} finally {
listener.Abort ();
Assert.IsTrue (sc.LoadIntoBufferAsync (50).Wait (200));
Assert.Fail ("#1");
} catch (AggregateException e) {
- Assert.IsInstanceOfType (typeof (HttpRequestException), e.InnerException, "#2");
+ Assert.IsTrue (e.InnerException is HttpRequestException, "#2");
}
}
var s = new StringContent ("aaa", null, "multipart/*");
Assert.AreEqual ("Content-Type: multipart/*; charset=utf-8\r\n", s.Headers.ToString ());
-
+#if !MOBILE
s = new StringContent ("aaa", Encoding.GetEncoding (852), "multipart/*");
Assert.AreEqual ("Content-Type: multipart/*; charset=ibm852\r\n", s.Headers.ToString ());
+#endif
}
[Test]
void WriteValue (StringBuilder output, float value)
{
- StringBuilderExtensions.AppendCount (output, maxJsonLength, value.ToString ("r"));
+ StringBuilderExtensions.AppendCount (output, maxJsonLength, value.ToString ("r", CultureInfo.InvariantCulture));
}
void WriteValue (StringBuilder output, double value)
{
- StringBuilderExtensions.AppendCount (output, maxJsonLength, value.ToString ("r"));
+ StringBuilderExtensions.AppendCount (output, maxJsonLength, value.ToString ("r", CultureInfo.InvariantCulture));
}
void WriteValue (StringBuilder output, Guid value)
}
[Test]
+ [Category ("MobileNotWorking")]
public void TestSimpleMutualImport ()
{
XmlReader r = new XmlTextReader ("Test/XmlFiles/xsd/inter-inc-1.xsd");
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
-#if NET_2_0
+#if !MOBILE
using System;
using System.CodeDom;
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
-#if NET_2_0
+#if !MOBILE
using System;
using System.CodeDom;
// (C) 2005 Novell
//
+#if !MOBILE
+
using System;
using System.Collections;
using System.Globalization;
}
}
}
+
+#endif
\ No newline at end of file
// (C) 2006 Novell
//
+#if !MOBILE
+
using System;
using System.CodeDom;
using System.CodeDom.Compiler;
}
}
}
+
+#endif
[Test]
#if NET_2_0
[Category ("NotWorking")] // support for XmlSchemaProvider is not implemented
-#else
- [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
#endif
public void ExportXmlSerializable_SchemaProvider1 () {
- XmlSchemas schemas = schemas = Export (typeof (PrimitiveSchemaProvider));
+ XmlSchemas schemas = Export (typeof (PrimitiveSchemaProvider));
Assert.AreEqual (1, schemas.Count, "#1");
StringWriter sw = new StringWriter ();
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
+#if !MOBILE
using Microsoft.CSharp;
-
+#endif
using NUnit.Framework;
using MonoTests.System.Xml.TestClasses;
Assert.AreEqual ("UInt16", map.TypeName, "#6");
}
+#if !MOBILE
+
[Test]
public void ImportTypeMapping_EnumSimpleContent ()
{
return null;
}
- private static XmlSchemas ExportType (Type type)
- {
- XmlReflectionImporter ri = new XmlReflectionImporter ("NS" + type.Name);
- XmlSchemas schemas = new XmlSchemas ();
- XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
- XmlTypeMapping tm = ri.ImportTypeMapping (type);
- sx.ExportTypeMapping (tm);
- return schemas;
- }
-
- private static ArrayList GetXmlQualifiedNames (XmlSchemas schemas)
- {
- ArrayList qnames = new ArrayList ();
-
- foreach (XmlSchema schema in schemas) {
- if (!schema.IsCompiled) schema.Compile (null);
- foreach (XmlSchemaObject ob in schema.Items)
- if (ob is XmlSchemaElement)
- qnames.Add (((XmlSchemaElement) ob).QualifiedName);
- }
-
- return qnames;
- }
-
[Test]
[ExpectedException (typeof (InvalidOperationException))]
public void ImportTypeMappingNonExistent ()
xss.Add (XmlSchema.Read (new XmlTextReader (new StringReader (xsd)), null));
return new XmlSchemaImporter (xss);
}
+
+#endif
+
+ private static ArrayList GetXmlQualifiedNames (XmlSchemas schemas)
+ {
+ ArrayList qnames = new ArrayList ();
+
+ foreach (XmlSchema schema in schemas) {
+ if (!schema.IsCompiled) schema.Compile (null);
+ foreach (XmlSchemaObject ob in schema.Items)
+ if (ob is XmlSchemaElement)
+ qnames.Add (((XmlSchemaElement) ob).QualifiedName);
+ }
+
+ return qnames;
+ }
+
+ private static XmlSchemas ExportType (Type type)
+ {
+ XmlReflectionImporter ri = new XmlReflectionImporter ("NS" + type.Name);
+ XmlSchemas schemas = new XmlSchemas ();
+ XmlSchemaExporter sx = new XmlSchemaExporter (schemas);
+ XmlTypeMapping tm = ri.ImportTypeMapping (type);
+ sx.ExportTypeMapping (tm);
+ return schemas;
+ }
}
}
ser.Deserialize (new XmlTextReader (xml, XmlNodeType.Document, null));
}
-#if NET_2_0
-#if !TARGET_JVM
+#if !TARGET_JVM && !MOBILE
[Test]
public void GenerateSerializerGenerics ()
{
Assert.AreEqual (TestEnumWithNulls.bb, w.nenum.Value);
Assert.AreEqual (t, w.ndate.Value);
}
-#endif
[Test]
public void SerializeBase64Binary()
[TestFixture]\r
public class XmlDocumentEventTests\r
{\r
- public static void Main ()\r
- {\r
- new XmlDocumentEventTests ().InsertingOrder ();\r
- }\r
-\r
private StringBuilder eventLogBuilder = new StringBuilder ();\r
\r
private XmlDocument GetEventDocument ()\r
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
+#if !MOBILE
+
using NUnit.Framework;
using System;
}
}
}
+
+#endif
\ No newline at end of file
// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
//
+#if !MOBILE
+
using System;
using System.Collections;
using System.IO;
}
}
+#endif
\r
#if NET_4_5\r
[Test]\r
- [Category("Async")]\r
public void TestAsync ()\r
{\r
var loc = Assembly.GetExecutingAssembly ().Location;\r
Uri resolved = resolver.ResolveUri (null, loc);\r
Assert.AreEqual ("file", resolved.Scheme);\r
var task = resolver.GetEntityAsync (resolved, null, typeof (Stream));\r
- Assert.That (task.Wait (3000));\r
- Assert.IsInstanceOfType (typeof (Stream), task.Result);\r
+ Assert.IsTrue (task.Wait (3000));\r
+ Assert.IsTrue (task.Result is Stream);\r
}\r
\r
[Test]\r
- [Category("Async")]\r
public void TestAsyncError ()\r
{\r
var loc = Assembly.GetExecutingAssembly ().Location;\r
} catch (Exception ex) {\r
if (ex is AggregateException)\r
ex = ((AggregateException) ex).InnerException;\r
- Assert.IsInstanceOfType (typeof (XmlException), ex);\r
+ Assert.IsTrue (ex is XmlException);\r
}\r
}\r
#endif\r
}
[Test]
+ [Category ("MobileNotWorking")]
public void EncodingTest ()
{
// For Stream it makes sense
Assert.IsNotNull ((double?) new XAttribute (m), "m:double?:null");
Assert.AreEqual (double.NegativeInfinity, ((double?) new XAttribute (m)).Value, "m:double?:value");
Assert.IsNotNull ((double?) new XAttribute (n), "n:double?:null");
- Assert.IsNaN (((double?) new XAttribute (n)).Value, "n:double?:value");
+ Assert.AreEqual (double.NaN, ((double?) new XAttribute (n)).Value, "n:double?:value");
Assert.IsNotNull ((float?) new XAttribute (a), "a:float?:null");
Assert.AreEqual (7f, ((float?) new XAttribute (a)).Value, "a:float?:value");
Assert.IsNotNull ((float?) new XAttribute (b), "b:float?:null");
Assert.IsNotNull ((float?) new XAttribute (m), "m:float?:null");
Assert.AreEqual (float.NegativeInfinity, ((float?) new XAttribute (m)).Value, "m:float?:value");
Assert.IsNotNull ((float?) new XAttribute (n), "n:float?:null");
- Assert.IsNaN (((float?) new XAttribute (n)).Value, "n:float?:value");
+ Assert.AreEqual (float.NaN, ((float?) new XAttribute (n)).Value, "n:float?:value");
AssertThrows<FormatException> (() => { Guid? z = (Guid?) new XAttribute (a); }, "a:Guid?");
AssertThrows<FormatException> (() => { Guid? z = (Guid?) new XAttribute (b); }, "b:Guid?");
AssertThrows<FormatException> (() => { Guid? z = (Guid?) new XAttribute (c); }, "c:Guid?");
Assert.AreEqual (double.PositiveInfinity, (double) new XAttribute (i), "i:double");
Assert.AreEqual (double.NegativeInfinity, (double) new XAttribute (M), "M:double");
Assert.AreEqual (double.NegativeInfinity, (double) new XAttribute (m), "m:double");
- Assert.IsNaN (((double) new XAttribute (n)), "n:double");
+ Assert.AreEqual (double.NaN, ((double) new XAttribute (n)), "n:double");
Assert.AreEqual (7f, (float) new XAttribute (a), "a:float");
Assert.AreEqual (42f, (float) new XAttribute (b), "b:float");
Assert.AreEqual (123f, (float) new XAttribute (c), "c:float");
Assert.AreEqual (float.PositiveInfinity, (float) new XAttribute (i), "i:float");
Assert.AreEqual (float.NegativeInfinity, (float) new XAttribute (M), "M:float");
Assert.AreEqual (float.NegativeInfinity, (float) new XAttribute (m), "m:float");
- Assert.IsNaN (((float) new XAttribute (n)), "n:float");
+ Assert.AreEqual (float.NaN, ((float) new XAttribute (n)), "n:float");
AssertThrows<FormatException> (() => { Guid z = (Guid) new XAttribute (a); }, "a:Guid");
AssertThrows<FormatException> (() => { Guid z = (Guid) new XAttribute (b); }, "b:Guid");
AssertThrows<FormatException> (() => { Guid z = (Guid) new XAttribute (c); }, "c:Guid");
Assert.IsNotNull ((double?) new XElement (m), "m:double?:null");
Assert.AreEqual (double.NegativeInfinity, ((double?) new XElement (m)).Value, "m:double?:value");
Assert.IsNotNull ((double?) new XElement (n), "n:double?:null");
- Assert.IsNaN (((double?) new XElement (n)).Value, "n:double?:value");
+ Assert.AreEqual (double.NaN, ((double?) new XElement (n)).Value, "n:double?:value");
Assert.IsNotNull ((float?) new XElement (a), "a:float?:null");
Assert.AreEqual (7f, ((float?) new XElement (a)).Value, "a:float?:value");
Assert.IsNotNull ((float?) new XElement (b), "b:float?:null");
Assert.IsNotNull ((float?) new XElement (m), "m:float?:null");
Assert.AreEqual (float.NegativeInfinity, ((float?) new XElement (m)).Value, "m:float?:value");
Assert.IsNotNull ((float?) new XElement (n), "n:float?:null");
- Assert.IsNaN (((float?) new XElement (n)).Value, "n:float?:value");
+ Assert.AreEqual (float.NaN, ((float?) new XElement (n)).Value, "n:float?:value");
AssertThrows<FormatException> (() => { Guid? z = (Guid?) new XElement (a); }, "a:Guid?");
AssertThrows<FormatException> (() => { Guid? z = (Guid?) new XElement (b); }, "b:Guid?");
AssertThrows<FormatException> (() => { Guid? z = (Guid?) new XElement (c); }, "c:Guid?");
Assert.AreEqual (double.PositiveInfinity, (double) new XElement (i), "i:double");
Assert.AreEqual (double.NegativeInfinity, (double) new XElement (M), "M:double");
Assert.AreEqual (double.NegativeInfinity, (double) new XElement (m), "m:double");
- Assert.IsNaN (((double) new XElement (n)), "n:double");
+ Assert.AreEqual (double.NaN, ((double) new XElement (n)), "n:double");
Assert.AreEqual (7f, (float) new XElement (a), "a:float");
Assert.AreEqual (42f, (float) new XElement (b), "b:float");
Assert.AreEqual (13f, (float) new XElement (c), "c:float");
Assert.AreEqual (float.PositiveInfinity, (float) new XElement (i), "i:float");
Assert.AreEqual (float.NegativeInfinity, (float) new XElement (M), "M:float");
Assert.AreEqual (float.NegativeInfinity, (float) new XElement (m), "m:float");
- Assert.IsNaN (((float) new XElement (n)), "n:float");
+ Assert.AreEqual (float.NaN, ((float) new XElement (n)), "n:float");
AssertThrows<FormatException> (() => { Guid z = (Guid) new XElement (a); }, "a:Guid");
AssertThrows<FormatException> (() => { Guid z = (Guid) new XElement (b); }, "b:Guid");
AssertThrows<FormatException> (() => { Guid z = (Guid) new XElement (c); }, "c:Guid");
// (C) Stefan Prutianu
//
+#if !MOBILE
+
using NUnit.Framework;
using System;
using System.Xml;
}
}
+
+#endif
\ No newline at end of file
--- /dev/null
+//
+// ReadOnlyDictionary.cs
+//
+// Authors:
+// Martin Baulig <martin.baulig@xamarin.com>
+// Marek Safar (marek.safar@gmail.com)
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#if NET_4_5
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace System.Collections.ObjectModel {
+
+ [Serializable]
+ [DebuggerDisplay ("Count={Count}")]
+ [DebuggerTypeProxy (typeof (CollectionDebuggerView<,>))]
+ public class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary,
+ IReadOnlyDictionary<TKey, TValue>
+ {
+ readonly IDictionary<TKey, TValue> inner;
+
+ public ReadOnlyDictionary (IDictionary<TKey, TValue> dictionary)
+ {
+ if (dictionary == null)
+ throw new ArgumentNullException ("dictionary");
+
+ this.inner = dictionary;
+ }
+
+ protected IDictionary<TKey, TValue> Dictionary {
+ get {
+ return inner;
+ }
+ }
+
+ public bool ContainsKey (TKey key)
+ {
+ return inner.ContainsKey (key);
+ }
+
+ public bool TryGetValue (TKey key, out TValue value)
+ {
+ return inner.TryGetValue (key, out value);
+ }
+
+ public TValue this [TKey key] {
+ get {
+ return inner [key];
+ }
+ }
+
+ public KeyCollection Keys {
+ get {
+ return new KeyCollection (inner.Keys);
+ }
+ }
+
+ public ValueCollection Values {
+ get {
+ return new ValueCollection (inner.Values);
+ }
+ }
+
+ #region IEnumerable<KeyValuePair<TKey, TValue>> implementation
+ public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator ()
+ {
+ return inner.GetEnumerator ();
+ }
+ #endregion
+ #region IEnumerable implementation
+ IEnumerator IEnumerable.GetEnumerator ()
+ {
+ return inner.GetEnumerator ();
+ }
+ #endregion
+
+ #region IDictionary<TKey, TValue> implementation
+
+ void IDictionary<TKey, TValue>.Add (TKey key, TValue value)
+ {
+ throw new NotSupportedException ();
+ }
+
+ bool IDictionary<TKey, TValue>.Remove (TKey key)
+ {
+ throw new NotSupportedException ();
+ }
+
+ TValue IDictionary<TKey, TValue>.this [TKey key] {
+ get {
+ return inner [key];
+ }
+ set {
+ throw new NotSupportedException ();
+ }
+ }
+
+ ICollection<TKey> IDictionary<TKey, TValue>.Keys {
+ get {
+ return Keys;
+ }
+ }
+
+ ICollection<TValue> IDictionary<TKey, TValue>.Values {
+ get {
+ return Values;
+ }
+ }
+
+ #endregion
+
+ #region IDictionary implementation
+
+ void IDictionary.Add (object key, object value)
+ {
+ throw new NotSupportedException ();
+ }
+
+ void IDictionary.Clear ()
+ {
+ throw new NotSupportedException ();
+ }
+
+ bool IDictionary.Contains (object key)
+ {
+ return ((IDictionary)inner).Contains (key);
+ }
+
+ IDictionaryEnumerator IDictionary.GetEnumerator ()
+ {
+ return ((IDictionary)inner).GetEnumerator ();
+ }
+
+ void IDictionary.Remove (object key)
+ {
+ throw new NotSupportedException ();
+ }
+
+ bool IDictionary.IsFixedSize {
+ get {
+ return true;
+ }
+ }
+
+ bool IDictionary.IsReadOnly {
+ get {
+ return true;
+ }
+ }
+
+ object IDictionary.this [object key] {
+ get {
+ return ((IDictionary)inner)[key];
+ }
+ set {
+ throw new NotSupportedException ();
+ }
+ }
+
+ ICollection IDictionary.Keys {
+ get {
+ return Keys;
+ }
+ }
+
+ ICollection IDictionary.Values {
+ get {
+ return Values;
+ }
+ }
+
+ #endregion
+
+ #region ICollection implementation
+
+ void ICollection.CopyTo (Array array, int index)
+ {
+ ((ICollection)inner).CopyTo (array, index);
+ }
+
+ #endregion
+
+ #region ICollection<KeyValuePair<TKey, TValue>> implementation
+
+ void ICollection<KeyValuePair<TKey, TValue>>.Add (KeyValuePair<TKey, TValue> item)
+ {
+ throw new NotSupportedException ();
+ }
+
+ void ICollection<KeyValuePair<TKey, TValue>>.Clear ()
+ {
+ throw new NotSupportedException ();
+ }
+
+ bool ICollection<KeyValuePair<TKey, TValue>>.Contains (KeyValuePair<TKey, TValue> item)
+ {
+ return ((ICollection<KeyValuePair<TKey, TValue>>)inner).Contains (item);
+ }
+
+ void ICollection<KeyValuePair<TKey, TValue>>.CopyTo (KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+ {
+ ((ICollection<KeyValuePair<TKey, TValue>>)inner).CopyTo (array, arrayIndex);
+ }
+
+ bool ICollection<KeyValuePair<TKey, TValue>>.Remove (KeyValuePair<TKey, TValue> item)
+ {
+ throw new NotSupportedException ();
+ }
+
+ bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly {
+ get {
+ return true;
+ }
+ }
+
+ #endregion
+
+ #region ICollection implementation
+
+ public int Count {
+ get {
+ return inner.Count;
+ }
+ }
+
+ bool ICollection.IsSynchronized {
+ get {
+ return false;
+ }
+ }
+
+ object ICollection.SyncRoot {
+ get {
+ throw new NotSupportedException ();
+ }
+ }
+
+ #endregion
+
+ IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys {
+ get {
+ return Keys;
+ }
+ }
+
+ IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values {
+ get {
+ return Values;
+ }
+ }
+
+ [Serializable]
+ [DebuggerDisplay ("Count={Count}")]
+ [DebuggerTypeProxy (typeof (CollectionDebuggerView<,>))]
+ public sealed class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, ICollection, IEnumerable
+ {
+ readonly ICollection<TKey> collection;
+
+ internal KeyCollection (ICollection<TKey> collection)
+ {
+ this.collection = collection;
+ }
+
+ public void CopyTo (TKey [] array, int arrayIndex)
+ {
+ collection.CopyTo (array, arrayIndex);
+ }
+
+ public IEnumerator<TKey> GetEnumerator ()
+ {
+ return collection.GetEnumerator ();
+ }
+
+ void ICollection<TKey>.Add (TKey item)
+ {
+ throw new NotSupportedException ("this is a read-only collection");
+ }
+
+ void ICollection<TKey>.Clear ()
+ {
+ throw new NotSupportedException ("this is a read-only collection");
+ }
+
+ bool ICollection<TKey>.Contains (TKey item)
+ {
+ return collection.Contains (item);
+ }
+
+ bool ICollection<TKey>.Remove (TKey item)
+ {
+ throw new NotSupportedException ("this is a read-only collection");
+ }
+
+ void ICollection.CopyTo (Array array, int index)
+ {
+ var target = array as TKey [];
+ if (target != null) {
+ CopyTo (target, index);
+ return;
+ }
+
+ throw new NotImplementedException ();
+ }
+
+ IEnumerator IEnumerable.GetEnumerator ()
+ {
+ return collection.GetEnumerator ();
+ }
+
+ public int Count {
+ get {
+ return collection.Count;
+ }
+ }
+
+ bool ICollection<TKey>.IsReadOnly {
+ get {
+ return true;
+ }
+ }
+
+ bool ICollection.IsSynchronized {
+ get {
+ return false;
+ }
+ }
+
+ object ICollection.SyncRoot {
+ get {
+ throw new NotImplementedException ();
+ }
+ }
+ }
+
+ [Serializable]
+ [DebuggerDisplay ("Count={Count}")]
+ [DebuggerTypeProxy (typeof (CollectionDebuggerView<,>))]
+ public sealed class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, ICollection, IEnumerable
+ {
+ readonly ICollection<TValue> collection;
+
+ internal ValueCollection (ICollection<TValue> collection)
+ {
+ this.collection = collection;
+ }
+
+ public void CopyTo (TValue [] array, int arrayIndex)
+ {
+ collection.CopyTo (array, arrayIndex);
+ }
+
+ public IEnumerator<TValue> GetEnumerator ()
+ {
+ return collection.GetEnumerator ();
+ }
+
+ void ICollection<TValue>.Add (TValue item)
+ {
+ throw new NotSupportedException ("this is a read-only collection");
+ }
+
+ void ICollection<TValue>.Clear ()
+ {
+ throw new NotSupportedException ("this is a read-only collection");
+ }
+
+ bool ICollection<TValue>.Contains (TValue item)
+ {
+ return collection.Contains (item);
+ }
+
+ bool ICollection<TValue>.Remove (TValue item)
+ {
+ throw new NotSupportedException ("this is a read-only collection");
+ }
+
+ void ICollection.CopyTo (Array array, int index)
+ {
+ var target = array as TValue [];
+ if (target != null) {
+ CopyTo (target, index);
+ return;
+ }
+
+ throw new NotImplementedException ();
+ }
+
+ IEnumerator IEnumerable.GetEnumerator ()
+ {
+ return collection.GetEnumerator ();
+ }
+
+ public int Count {
+ get {
+ return collection.Count;
+ }
+ }
+
+ bool ICollection<TValue>.IsReadOnly {
+ get {
+ return true;
+ }
+ }
+
+ bool ICollection.IsSynchronized {
+ get {
+ return false;
+ }
+ }
+
+ object ICollection.SyncRoot {
+ get {
+ throw new NotImplementedException ();
+ }
+ }
+ }
+ }
+}
+#endif
+
if (l >= 2 && DirectorySeparatorChar == '\\' && ret [l - 1] == VolumeSeparatorChar)
return ret + DirectorySeparatorChar;
+ else if (l == 1 && DirectorySeparatorChar == '\\' && path.Length >= 2 && path [nLast] == VolumeSeparatorChar)
+ return ret + VolumeSeparatorChar;
else {
//
// Important: do not use CanonicalizePath here, use
out int bytesUsed, out int charsUsed, out bool completed)
{
CheckArguments (bytes, byteIndex, byteCount);
- CheckArguments (chars, charIndex);
+ if (chars == null)
+ throw new ArgumentNullException ("chars");
+ if (charIndex < 0)
+ throw new ArgumentOutOfRangeException ("charIndex");
if (charCount < 0 || chars.Length < charIndex + charCount)
throw new ArgumentOutOfRangeException ("charCount");
{
if (chars == null)
throw new ArgumentNullException ("chars");
- if (charIndex < 0 || chars.Length <= charIndex)
+ if (charIndex < 0 || chars.Length < charIndex)
throw new ArgumentOutOfRangeException ("charIndex");
}
{
if (bytes == null)
throw new ArgumentNullException ("bytes");
- if (byteIndex < 0 || bytes.Length <= byteIndex)
+ if (byteIndex < 0)
throw new ArgumentOutOfRangeException ("byteIndex");
if (byteCount < 0 || bytes.Length < byteIndex + byteCount)
throw new ArgumentOutOfRangeException ("byteCount");
throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_Array"));
}
- if (charIndex == chars.Length)
+ if (charIndex == chars.Length && byteCount == 0)
return 0;
fixed (char* cptr = chars) {
if (leftOverCount == 0) {
int end = byteIndex + byteCount;
for (; byteIndex < end; posn++, byteIndex++, byteCount--) {
- if (bytes [byteIndex] < 0x80)
+ if (bytes [byteIndex] < 0x80) {
+ if (posn >= length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "chars");
+ }
chars [posn] = (char) bytes [byteIndex];
- else
+ } else {
break;
+ }
}
}
Assert.AreEqual (@"C:\dir", Path.GetDirectoryName (@"C:\dir\"), "#B5");
Assert.AreEqual (@"C:\dir", Path.GetDirectoryName (@"C:\dir\dir"), "#B6");
Assert.AreEqual (@"C:\dir\dir", Path.GetDirectoryName (@"C:\dir\dir\"), "#B7");
+ Assert.AreEqual (@"C:", Path.GetDirectoryName (@"C:foo.txt"), "#B8");
+ Assert.AreEqual (@"C:dir", Path.GetDirectoryName (@"C:dir\"), "#B9");
Assert.AreEqual ("\\foo\\bar", Path.GetDirectoryName ("/foo//bar/dingus"), "#C1");
Assert.AreEqual ("foo\\bar", Path.GetDirectoryName ("foo/bar/"), "#C2");
}
}
#endif
+
+ [Test]
+ public void Bug10789 ()
+ {
+ byte[] bytes = new byte[100];
+ char[] chars = new char[100];
+
+ Decoder conv = Encoding.UTF8.GetDecoder ();
+ int charsUsed, bytesUsed;
+ bool completed;
+
+ conv.Convert (bytes, 0, 0, chars, 100, 0, false, out bytesUsed, out charsUsed, out completed);
+
+ Assert.IsTrue (completed, "#1");
+ Assert.AreEqual (0, charsUsed, "#2");
+ Assert.AreEqual (0, bytesUsed, "#3");
+ }
}
}
}
}
#endif
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void Bug10788()
+ {
+ byte[] bytes = new byte[4096];
+ char[] chars = new char[10];
+
+ Encoding.UTF8.GetDecoder ().GetChars (bytes, 0, 4096, chars, 9, false);
+ }
+
+ [Test]
+ public void Bug10789()
+ {
+ byte[] bytes = new byte[4096];
+ char[] chars = new char[10];
+
+ try {
+ Encoding.UTF8.GetDecoder ().GetChars (bytes, 0, 1, chars, 10, false);
+ Assert.Fail ("ArgumentException is expected #1");
+ } catch (ArgumentException) {
+ }
+
+ try {
+ Encoding.UTF8.GetDecoder ().GetChars (bytes, 0, 1, chars, 11, false);
+ Assert.Fail ("ArgumentOutOfRangeException is expected #2");
+ } catch (ArgumentOutOfRangeException) {
+ }
+
+ int charactersWritten = Encoding.UTF8.GetDecoder ().GetChars (bytes, 0, 0, chars, 10, false);
+ Assert.AreEqual (0, charactersWritten, "#3");
+ }
}
}
System.Collections.ObjectModel/Collection.cs
System.Collections.ObjectModel/KeyedCollection.cs
System.Collections.ObjectModel/ReadOnlyCollection.cs
+System.Collections.ObjectModel/ReadOnlyDictionary.cs
System/Action.cs
System/ArraySegment.cs
System/Comparison.cs
internal readonly HoistedLocals Parent;
// A mapping of hoisted variables to their indexes in the array
- internal readonly ReadOnlyDictionary<Expression, int> Indexes;
+ internal readonly System.Dynamic.Utils.ReadOnlyDictionary<Expression, int> Indexes;
// The variables, in the order they appear in the array
internal readonly ReadOnlyCollection<ParameterExpression> Variables;
SelfVariable = Expression.Variable(typeof(object[]), null);
Parent = parent;
Variables = vars;
- Indexes = new ReadOnlyDictionary<Expression, int>(indexes);
+ Indexes = new System.Dynamic.Utils.ReadOnlyDictionary<Expression, int>(indexes);
}
internal ParameterExpression ParentVariable {
gconstpointer wrapper;
gconstpointer trampoline;
MonoMethodSignature *sig;
+ const char *c_symbol;
} MonoJitICallInfo;
typedef struct {
MonoJitICallInfo *
mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save) MONO_INTERNAL;
+MonoJitICallInfo *
+mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, const char *c_symbol) MONO_INTERNAL;
+
void
mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper) MONO_INTERNAL;
GHashTable*
mono_get_jit_icall_info (void) MONO_INTERNAL;
+const char*
+mono_lookup_jit_icall_symbol (const char *name) MONO_INTERNAL;
+
gboolean
mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data) MONO_INTERNAL;
MONO_ARCH_SAVE_REGS;
#ifndef DISABLE_REMOTING
- if (obj->vtable->klass == mono_defaults.transparent_proxy_class)
+ if (obj->vtable->klass != mono_defaults.transparent_proxy_class)
return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg);
else
#endif
return jit_icall_hash_name;
}
+/*
+ * mono_lookup_jit_icall_symbol:
+ *
+ * Given the jit icall NAME, returns its C symbol if possible, or NULL.
+ */
+const char*
+mono_lookup_jit_icall_symbol (const char *name)
+{
+ MonoJitICallInfo *info;
+ const char *res = NULL;
+
+ mono_loader_lock ();
+ info = g_hash_table_lookup (jit_icall_hash_name, name);
+ if (info)
+ res = info->c_symbol;
+ mono_loader_unlock ();
+ return res;
+}
+
void
mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper)
{
}
MonoJitICallInfo *
-mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
+mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, const char *c_symbol)
{
MonoJitICallInfo *info;
info->name = name;
info->func = func;
info->sig = sig;
+ info->c_symbol = c_symbol;
if (is_save) {
info->wrapper = func;
mono_loader_unlock ();
return info;
}
+
+MonoJitICallInfo *
+mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
+{
+ return mono_register_jit_icall_full (func, name, sig, is_save, NULL);
+}
+
mb->method->save_lmf = 1;
-#ifndef DISABLE_JIT
/*
* In AOT mode and embedding scenarios, it is possible that the icall is not
* registered in the runtime doing the AOT compilation.
*/
if (!piinfo->addr && !aot) {
+#ifndef DISABLE_JIT
mono_mb_emit_exception (mb, exc_class, exc_arg);
+#endif
csig = signature_dup (method->klass->image, sig);
csig->pinvoke = 0;
res = mono_mb_create_and_cache (cache, method,
mb, csig, csig->param_count + 16);
mono_mb_free (mb);
+
+ info = mono_wrapper_info_create (res, WRAPPER_SUBTYPE_NONE);
+ info->d.managed_to_native.method = method;
+ mono_marshal_set_wrapper_info (res, info);
+
return res;
}
-#endif
/* internal calls: we simply push all arguments and call the method (no conversions) */
if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
char *plt_symbol;
GHashTable *method_label_hash;
const char *temp_prefix;
+ const char *user_symbol_prefix;
const char *llvm_label_prefix;
guint32 label_generator;
gboolean llvm;
* symbols.
*/
acfg->llvm_label_prefix = "";
+ acfg->user_symbol_prefix = "";
#ifdef TARGET_ARM
if (acfg->aot_opts.mtriple && strstr (acfg->aot_opts.mtriple, "darwin")) {
#endif
#ifdef TARGET_MACH
+ acfg->user_symbol_prefix = "_";
acfg->llvm_label_prefix = "_";
acfg->need_no_dead_strip = TRUE;
#endif
* calling code.
*/
static void
-arch_emit_direct_call (MonoAotCompile *acfg, const char *target, int *call_size)
+arch_emit_direct_call (MonoAotCompile *acfg, const char *target, gboolean external, int *call_size)
{
#if defined(TARGET_X86) || defined(TARGET_AMD64)
/* Need to make sure this is exactly 5 bytes long */
- if (FALSE && !acfg->use_bin_writer) {
+ if (external && !acfg->use_bin_writer) {
img_writer_emit_unset_mode (acfg->w);
fprintf (acfg->fp, "call %s\n", target);
} else {
GPtrArray *patches;
MonoJumpInfo *patch_info;
MonoMethodHeader *header;
- gboolean skip, direct_call;
+ gboolean skip, direct_call, external_call;
guint32 got_slot;
const char *direct_call_target;
const char *direct_pinvoke;
* the same assembly and requires no initialization.
*/
direct_call = FALSE;
+ external_call = FALSE;
if ((patch_info->type == MONO_PATCH_INFO_METHOD) && (patch_info->data.method->klass->image == acfg->image)) {
if (!got_only && is_direct_callable (acfg, method, patch_info)) {
MonoCompile *callee_cfg = g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
else
direct_pinvoke = get_pinvoke_import (acfg, patch_info->data.method);
if (direct_pinvoke) {
- const char*prefix;
-#if defined(TARGET_MACH)
- prefix = "_";
-#else
- prefix = "";
-#endif
direct_call = TRUE;
g_assert (strlen (direct_pinvoke) < 1000);
- direct_call_target = g_strdup_printf ("%s%s", prefix, direct_pinvoke);
+ direct_call_target = g_strdup_printf ("%s%s", acfg->user_symbol_prefix, direct_pinvoke);
}
}
+ } else if (patch_info->type == MONO_PATCH_INFO_INTERNAL_METHOD) {
+ const char *sym = mono_lookup_jit_icall_symbol (patch_info->data.name);
+ if (sym && acfg->aot_opts.direct_icalls) {
+ direct_call = TRUE;
+ external_call = TRUE;
+ g_assert (strlen (sym) < 1000);
+ direct_call_target = g_strdup_printf ("%s%s", acfg->user_symbol_prefix, sym);
+ }
}
if (direct_call) {
if (direct_call) {
int call_size;
- arch_emit_direct_call (acfg, direct_call_target, &call_size);
+ arch_emit_direct_call (acfg, direct_call_target, external_call, &call_size);
i += call_size - 1;
} else {
int code_size;
encode_value (get_image_index (acfg, patch_info->data.image), p, &p);
break;
case MONO_PATCH_INFO_MSCORLIB_GOT_ADDR:
+ case MONO_PATCH_INFO_JIT_TLS_ID:
case MONO_PATCH_INFO_GC_CARD_TABLE_ADDR:
case MONO_PATCH_INFO_CASTCLASS_CACHE:
break;
ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoAotCompile));
ji->type = MONO_PATCH_INFO_GC_CARD_TABLE_ADDR;
get_got_offset (acfg, ji);
+
+ ji = mono_mempool_alloc0 (acfg->mempool, sizeof (MonoAotCompile));
+ ji->type = MONO_PATCH_INFO_JIT_TLS_ID;
+ get_got_offset (acfg, ji);
}
TV_GETTIME (atv);
case MONO_PATCH_INFO_MONITOR_EXIT:
case MONO_PATCH_INFO_GC_CARD_TABLE_ADDR:
case MONO_PATCH_INFO_CASTCLASS_CACHE:
+ case MONO_PATCH_INFO_JIT_TLS_ID:
break;
case MONO_PATCH_INFO_RGCTX_FETCH: {
gboolean res;
{
asm_writer_emit_unset_mode (acfg);
#if ((defined(__ppc__) || defined(TARGET_X86)) && defined(TARGET_ASM_APPLE)) || (defined(HOST_WIN32) && !defined(MONO_CROSS_COMPILE))
- // mach-o always uses a '_' prefix.
- fprintf (acfg->fp, "\t.globl _%s\n", name);
+ if (name[0] != '_')
+ // mach-o always uses a '_' prefix.
+ fprintf (acfg->fp, "\t.globl _%s\n", name);
+ else
+ fprintf (acfg->fp, "\t.globl %s\n", name);
#else
fprintf (acfg->fp, "\t.globl %s\n", name);
#endif
if (lmf_addr_tls_offset != -1) {
get_lmf_fast = TRUE;
- mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
+ mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
(gpointer)"__aeabi_read_tp");
code = emit_call_seq (cfg, code);
get_lmf_fast = TRUE;
}
#endif
+
+#ifdef TARGET_IOS
+ if (cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
+ int lmf_offset;
+
+ /* Inline mono_get_lmf_addr () */
+ /* jit_tls = pthread_getspecific (mono_jit_tls_id); lmf_addr = &jit_tls->lmf; */
+
+ /* Load mono_jit_tls_id */
+ /* OP_AOTCONST */
+ mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_JIT_TLS_ID, NULL);
+ ARM_LDR_IMM (code, ARMREG_R0, ARMREG_PC, 0);
+ ARM_B (code, 0);
+ *(gpointer*)code = NULL;
+ code += 4;
+ ARM_LDR_REG_REG (code, ARMREG_R0, ARMREG_PC, ARMREG_R0);
+ /* call pthread_getspecific () */
+ mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
+ (gpointer)"pthread_getspecific");
+ code = emit_call_seq (cfg, code);
+ /* lmf_addr = &jit_tls->lmf */
+ lmf_offset = G_STRUCT_OFFSET (MonoJitTlsData, lmf);
+ g_assert (arm_is_imm8 (lmf_offset));
+ ARM_ADD_REG_IMM (code, ARMREG_R0, ARMREG_R0, lmf_offset, 0);
+
+ get_lmf_fast = TRUE;
+ }
+#endif
+
if (!get_lmf_fast) {
mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
- (gpointer)"mono_get_lmf_addr");
+ (gpointer)"mono_get_lmf_addr");
code = emit_call_seq (cfg, code);
}
/* we build the MonoLMF structure on the stack - see mini-arm.h */
emul_opcode_hit_cache [opcode >> (EMUL_HIT_SHIFT + 3)] |= (1 << (opcode & EMUL_HIT_MASK));
}
+/*
+ * For JIT icalls implemented in C.
+ * NAME should be the same as the name of the C function whose address is FUNC.
+ */
static void
register_icall (gpointer func, const char *name, const char *sigstr, gboolean save)
{
MonoMethodSignature *sig;
+ if (sigstr)
+ sig = mono_create_icall_signature (sigstr);
+ else
+ sig = NULL;
+
+ mono_register_jit_icall_full (func, name, sig, save, save ? name : NULL);
+}
+
+static void
+register_dyn_icall (gpointer func, const char *name, const char *sigstr, gboolean save)
+{
+ MonoMethodSignature *sig;
+
if (sigstr)
sig = mono_create_icall_signature (sigstr);
else
#else
MonoJitTlsData *jit_tls;
- if ((jit_tls = mono_native_tls_get_value (mono_jit_tls_id)))
+ jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ if (G_LIKELY (jit_tls))
return &jit_tls->lmf;
/*
target = mono_domain_alloc0 (domain, sizeof (gpointer));
break;
}
+ case MONO_PATCH_INFO_JIT_TLS_ID: {
+ target = (gpointer)mono_jit_tls_id;
+ break;
+ }
default:
g_assert_not_reached ();
}
register_icall (mono_jit_set_domain, "mono_jit_set_domain", "void ptr", TRUE);
register_icall (mono_domain_get, "mono_domain_get", "ptr", TRUE);
- register_icall (mono_get_throw_exception (), "mono_arch_throw_exception", "void object", TRUE);
- register_icall (mono_get_rethrow_exception (), "mono_arch_rethrow_exception", "void object", TRUE);
- register_icall (mono_get_throw_corlib_exception (), "mono_arch_throw_corlib_exception",
- "void ptr", TRUE);
+ register_dyn_icall (mono_get_throw_exception (), "mono_arch_throw_exception", "void object", TRUE);
+ register_dyn_icall (mono_get_rethrow_exception (), "mono_arch_rethrow_exception", "void object", TRUE);
+ register_dyn_icall (mono_get_throw_corlib_exception (), "mono_arch_throw_corlib_exception", "void ptr", TRUE);
register_icall (mono_thread_get_undeniable_exception, "mono_thread_get_undeniable_exception", "object", FALSE);
register_icall (mono_thread_interruption_checkpoint, "mono_thread_interruption_checkpoint", "void", FALSE);
register_icall (mono_thread_force_interruption_checkpoint, "mono_thread_force_interruption_checkpoint", "void", FALSE);
"ptr ptr ptr ptr", FALSE);
register_icall (mono_get_special_static_data, "mono_get_special_static_data", "ptr int", FALSE);
register_icall (mono_ldstr, "mono_ldstr", "object ptr ptr int32", FALSE);
- register_icall (mono_helper_stelem_ref_check, "helper_stelem_ref_check", "void object object", FALSE);
+ register_icall (mono_helper_stelem_ref_check, "mono_helper_stelem_ref_check", "void object object", FALSE);
register_icall (mono_object_new, "mono_object_new", "object ptr ptr", FALSE);
register_icall (mono_object_new_specific, "mono_object_new_specific", "object ptr", FALSE);
register_icall (mono_array_new, "mono_array_new", "object ptr ptr int32", FALSE);
register_icall (mono_ldftn, "mono_ldftn", "ptr ptr", FALSE);
register_icall (mono_ldvirtfn, "mono_ldvirtfn", "ptr object ptr", FALSE);
register_icall (mono_ldvirtfn_gshared, "mono_ldvirtfn_gshared", "ptr object ptr", FALSE);
- register_icall (mono_helper_compile_generic_method, "compile_generic_method", "ptr object ptr ptr", FALSE);
- register_icall (mono_helper_ldstr, "helper_ldstr", "object ptr int", FALSE);
- register_icall (mono_helper_ldstr_mscorlib, "helper_ldstr_mscorlib", "object int", FALSE);
- register_icall (mono_helper_newobj_mscorlib, "helper_newobj_mscorlib", "object int", FALSE);
+ register_icall (mono_helper_compile_generic_method, "mono_helper_compile_generic_method", "ptr object ptr ptr", FALSE);
+ register_icall (mono_helper_ldstr, "mono_helper_ldstr", "object ptr int", FALSE);
+ register_icall (mono_helper_ldstr_mscorlib, "mono_helper_ldstr_mscorlib", "object int", FALSE);
+ register_icall (mono_helper_newobj_mscorlib, "mono_helper_newobj_mscorlib", "object int", FALSE);
register_icall (mono_value_copy, "mono_value_copy", "void ptr ptr ptr", FALSE);
register_icall (mono_object_castclass, "mono_object_castclass", "object object ptr", FALSE);
register_icall (mono_break, "mono_break", NULL, TRUE);
register_icall (mono_object_isinst_with_cache, "mono_object_isinst_with_cache", "object object ptr ptr", FALSE);
register_icall (mono_debugger_agent_user_break, "mono_debugger_agent_user_break", "void", FALSE);
+#endif
+#ifdef TARGET_IOS
+ register_icall (pthread_getspecific, "pthread_getspecific", NULL, TRUE);
#endif
mono_generic_sharing_init ();
PATCH_INFO(CASTCLASS_CACHE, "castclass_cache")
PATCH_INFO(SIGNATURE, "signature")
PATCH_INFO(GSHAREDVT_CALL, "gsharedvt_call")
+PATCH_INFO(JIT_TLS_ID, "jit_tls_id")
PATCH_INFO(NONE, "none")
+
{C5639B3F-288A-4A4B-A4A5-C0D85834221D}.Debug_SGen|x64.Build.0 = Debug|x64\r
{C5639B3F-288A-4A4B-A4A5-C0D85834221D}.Debug|Win32.ActiveCfg = Debug|Win32\r
{C5639B3F-288A-4A4B-A4A5-C0D85834221D}.Debug|x64.ActiveCfg = Debug|x64\r
- {C5639B3F-288A-4A4B-A4A5-C0D85834221D}.Debug|x64.Build.0 = Debug|x64\r
{C5639B3F-288A-4A4B-A4A5-C0D85834221D}.Release_SGen|Win32.ActiveCfg = Release|Win32\r
{C5639B3F-288A-4A4B-A4A5-C0D85834221D}.Release_SGen|x64.ActiveCfg = Release|x64\r
{C5639B3F-288A-4A4B-A4A5-C0D85834221D}.Release|Win32.ActiveCfg = Release|Win32\r
{6FDE4E5E-57D0-432F-A987-6C226A7827E4}.Debug_SGen|x64.Build.0 = Debug|x64\r
{6FDE4E5E-57D0-432F-A987-6C226A7827E4}.Debug|Win32.ActiveCfg = Debug|Win32\r
{6FDE4E5E-57D0-432F-A987-6C226A7827E4}.Debug|x64.ActiveCfg = Debug|x64\r
- {6FDE4E5E-57D0-432F-A987-6C226A7827E4}.Debug|x64.Build.0 = Debug|x64\r
{6FDE4E5E-57D0-432F-A987-6C226A7827E4}.Release_SGen|Win32.ActiveCfg = Release|Win32\r
{6FDE4E5E-57D0-432F-A987-6C226A7827E4}.Release_SGen|x64.ActiveCfg = Release|x64\r
{6FDE4E5E-57D0-432F-A987-6C226A7827E4}.Release|Win32.ActiveCfg = Release|Win32\r
{37F50E5A-4818-46CF-81FE-4BB06DE5D42E}.Debug_SGen|x64.Build.0 = Debug|x64\r
{37F50E5A-4818-46CF-81FE-4BB06DE5D42E}.Debug|Win32.ActiveCfg = Debug|Win32\r
{37F50E5A-4818-46CF-81FE-4BB06DE5D42E}.Debug|x64.ActiveCfg = Debug|x64\r
- {37F50E5A-4818-46CF-81FE-4BB06DE5D42E}.Debug|x64.Build.0 = Debug|x64\r
{37F50E5A-4818-46CF-81FE-4BB06DE5D42E}.Release_SGen|Win32.ActiveCfg = Release|Win32\r
{37F50E5A-4818-46CF-81FE-4BB06DE5D42E}.Release_SGen|x64.ActiveCfg = Release|x64\r
{37F50E5A-4818-46CF-81FE-4BB06DE5D42E}.Release|Win32.ActiveCfg = Release|Win32\r
{84C7DB50-D6F8-4C47-B22C-6BB203AEB4D3}.Debug_SGen|x64.Build.0 = Debug|x64\r
{84C7DB50-D6F8-4C47-B22C-6BB203AEB4D3}.Debug|Win32.ActiveCfg = Debug|Win32\r
{84C7DB50-D6F8-4C47-B22C-6BB203AEB4D3}.Debug|x64.ActiveCfg = Debug|x64\r
- {84C7DB50-D6F8-4C47-B22C-6BB203AEB4D3}.Debug|x64.Build.0 = Debug|x64\r
{84C7DB50-D6F8-4C47-B22C-6BB203AEB4D3}.Release_SGen|Win32.ActiveCfg = Release|Win32\r
{84C7DB50-D6F8-4C47-B22C-6BB203AEB4D3}.Release_SGen|x64.ActiveCfg = Release|x64\r
{84C7DB50-D6F8-4C47-B22C-6BB203AEB4D3}.Release|Win32.ActiveCfg = Release|Win32\r
{8F90007F-8019-4191-8808-891E4762D958}.Debug_SGen|x64.Build.0 = Debug|x64\r
{8F90007F-8019-4191-8808-891E4762D958}.Debug|Win32.ActiveCfg = Debug|Win32\r
{8F90007F-8019-4191-8808-891E4762D958}.Debug|x64.ActiveCfg = Debug|x64\r
- {8F90007F-8019-4191-8808-891E4762D958}.Debug|x64.Build.0 = Debug|x64\r
{8F90007F-8019-4191-8808-891E4762D958}.Release_SGen|Win32.ActiveCfg = Release|Win32\r
{8F90007F-8019-4191-8808-891E4762D958}.Release_SGen|x64.ActiveCfg = Release|x64\r
{8F90007F-8019-4191-8808-891E4762D958}.Release_SGen|x64.Build.0 = Release|x64\r
{8F90007F-8019-4191-8808-891E4762D958}.Release|Win32.ActiveCfg = Release|Win32\r
{8F90007F-8019-4191-8808-891E4762D958}.Release|x64.ActiveCfg = Release|x64\r
- {8F90007F-8019-4191-8808-891E4762D958}.Release|x64.Build.0 = Release|x64\r
{CA2A69D6-3B9D-45A5-8BF7-4E242E683122}.Debug_SGen|Win32.ActiveCfg = Debug|Win32\r
{CA2A69D6-3B9D-45A5-8BF7-4E242E683122}.Debug_SGen|x64.ActiveCfg = Debug|x64\r
{CA2A69D6-3B9D-45A5-8BF7-4E242E683122}.Debug_SGen|x64.Build.0 = Debug|x64\r
{CA2A69D6-3B9D-45A5-8BF7-4E242E683122}.Debug|Win32.ActiveCfg = Debug|Win32\r
{CA2A69D6-3B9D-45A5-8BF7-4E242E683122}.Debug|x64.ActiveCfg = Debug|x64\r
- {CA2A69D6-3B9D-45A5-8BF7-4E242E683122}.Debug|x64.Build.0 = Debug|x64\r
{CA2A69D6-3B9D-45A5-8BF7-4E242E683122}.Release_SGen|Win32.ActiveCfg = Release|Win32\r
{CA2A69D6-3B9D-45A5-8BF7-4E242E683122}.Release_SGen|x64.ActiveCfg = Release|x64\r
{CA2A69D6-3B9D-45A5-8BF7-4E242E683122}.Release|Win32.ActiveCfg = Release|Win32\r
{C2EB666E-9146-4B7A-85F6-25F9EA313770}.Debug_SGen|x64.Build.0 = Debug|x64\r
{C2EB666E-9146-4B7A-85F6-25F9EA313770}.Debug|Win32.ActiveCfg = Debug|Win32\r
{C2EB666E-9146-4B7A-85F6-25F9EA313770}.Debug|x64.ActiveCfg = Debug|x64\r
- {C2EB666E-9146-4B7A-85F6-25F9EA313770}.Debug|x64.Build.0 = Debug|x64\r
{C2EB666E-9146-4B7A-85F6-25F9EA313770}.Release_SGen|Win32.ActiveCfg = Release|Win32\r
{C2EB666E-9146-4B7A-85F6-25F9EA313770}.Release_SGen|x64.ActiveCfg = Release|x64\r
{C2EB666E-9146-4B7A-85F6-25F9EA313770}.Release|Win32.ActiveCfg = Release|Win32\r
{80A0620A-3478-4E1A-AA7C-0D2387B892AB}.Debug_SGen|x64.Build.0 = Debug|x64\r
{80A0620A-3478-4E1A-AA7C-0D2387B892AB}.Debug|Win32.ActiveCfg = Debug|Win32\r
{80A0620A-3478-4E1A-AA7C-0D2387B892AB}.Debug|x64.ActiveCfg = Debug|x64\r
- {80A0620A-3478-4E1A-AA7C-0D2387B892AB}.Debug|x64.Build.0 = Debug|x64\r
{80A0620A-3478-4E1A-AA7C-0D2387B892AB}.Release_SGen|Win32.ActiveCfg = Release|Win32\r
{80A0620A-3478-4E1A-AA7C-0D2387B892AB}.Release_SGen|x64.ActiveCfg = Release|x64\r
{80A0620A-3478-4E1A-AA7C-0D2387B892AB}.Release|Win32.ActiveCfg = Release|Win32\r
{8FC2B0C8-51AD-49DF-851F-5D01A77A75E4}.Debug_SGen|x64.Build.0 = Debug|x64\r
{8FC2B0C8-51AD-49DF-851F-5D01A77A75E4}.Debug|Win32.ActiveCfg = Debug|Win32\r
{8FC2B0C8-51AD-49DF-851F-5D01A77A75E4}.Debug|Win32.Build.0 = Debug|Win32\r
- {8FC2B0C8-51AD-49DF-851F-5D01A77A75E4}.Debug|x64.ActiveCfg = Debug|Win32\r
+ {8FC2B0C8-51AD-49DF-851F-5D01A77A75E4}.Debug|x64.ActiveCfg = Debug|x64\r
+ {8FC2B0C8-51AD-49DF-851F-5D01A77A75E4}.Debug|x64.Build.0 = Debug|x64\r
{8FC2B0C8-51AD-49DF-851F-5D01A77A75E4}.Release_SGen|Win32.ActiveCfg = Release|Win32\r
{8FC2B0C8-51AD-49DF-851F-5D01A77A75E4}.Release_SGen|Win32.Build.0 = Release|Win32\r
{8FC2B0C8-51AD-49DF-851F-5D01A77A75E4}.Release_SGen|x64.ActiveCfg = Release|x64\r
{C36612BD-22D3-4B95-85E2-7FDC4FC5D739}.Debug_SGen|x64.Build.0 = Debug_SGen|x64\r
{C36612BD-22D3-4B95-85E2-7FDC4FC5D739}.Debug|Win32.ActiveCfg = Debug|Win32\r
{C36612BD-22D3-4B95-85E2-7FDC4FC5D739}.Debug|Win32.Build.0 = Debug|Win32\r
- {C36612BD-22D3-4B95-85E2-7FDC4FC5D739}.Debug|x64.ActiveCfg = Debug|Win32\r
+ {C36612BD-22D3-4B95-85E2-7FDC4FC5D739}.Debug|x64.ActiveCfg = Debug|x64\r
+ {C36612BD-22D3-4B95-85E2-7FDC4FC5D739}.Debug|x64.Build.0 = Debug|x64\r
{C36612BD-22D3-4B95-85E2-7FDC4FC5D739}.Release_SGen|Win32.ActiveCfg = Release_SGen|Win32\r
{C36612BD-22D3-4B95-85E2-7FDC4FC5D739}.Release_SGen|Win32.Build.0 = Release_SGen|Win32\r
{C36612BD-22D3-4B95-85E2-7FDC4FC5D739}.Release_SGen|x64.ActiveCfg = Release_SGen|x64\r
projects / mono.git / commitdiff