rename all jvm-only files to jvm.cs

svn path=/trunk/mcs/; revision=67540

mcs/class/System/System.Diagnostics/Debugger.jvm.cs

@@ -0,0 +1,94 @@
+//
+// System.Diagnostics.Debugger.cs
+//
+// Author:
+//	John R. Hicks ([email protected])
+//
+// (C) 2001
+//
+using System;
+
+namespace System.Diagnostics
+{
+	/// <summary>
+	/// Enables communication with a debugger.
+	/// </summary>
+	[MonoTODO]
+	public sealed class Debugger
+	{
+		private static bool isAttached;
+		
+		/// <summary>
+		/// Represents the default category of a message with a constant.
+		/// </summary>
+		public static readonly string DefaultCategory = "";
+		
+		/// <summary>
+		/// Returns a Boolean indicating whether a debugger is attached to a process.
+		/// </summary>
+		/// <value>
+		/// true if debugger is attached; otherwise, false.
+		/// </value>
+		public static bool IsAttached
+		{
+			get
+			{
+				return isAttached;
+			}
+		}
+		
+		/// <summary>
+		/// Causes a breakpoint to be signaled to an attached debugger.
+		/// </summary>
+		[MonoTODO]
+		public static void Break()
+		{
+			throw new NotImplementedException();
+		}
+		
+		/// <summary>
+		/// Checks to see if logging is enabled by an attached debugger.
+		/// </summary>
+		[MonoTODO]
+		public static bool IsLogging()
+		{
+			// Return false. DefaultTraceListener invokes this method, so throwing
+			// a NotImplementedException wouldn't be appropriate.
+      return false;
+
+		}
+		
+		/// <summary>
+		/// Launches and attaches a debugger to the process.
+		/// </summary>
+		[MonoTODO]
+		public static bool Launch()
+		{
+			throw new NotImplementedException();
+		}
+		
+		/// <summary>
+		/// Posts a message for the attached debugger.
+		/// </summary>
+		/// <param name="level">
+		/// A description of the importance of this message
+		/// </param>
+		/// <param name="category">
+		/// A string describing the category of this message.
+		/// </param>
+		/// <param name="message">
+		/// A string representing the message to show.
+		/// </param>
+		[MonoTODO]
+		public static void Log(int level, string category, string message)
+		{
+			// Do nothing. DefaultTraceListener invokes this method, so throwing
+			// a NotImplementedException wouldn't be appropriate.
+		}
+		
+		public Debugger()
+		{
+			isAttached = false;
+		}
+	}
+}

mcs/class/System/System.Diagnostics/StackFrame.jvm.cs

@@ -0,0 +1,347 @@
+//
+// System.Diagnostics.StackFrame.cs
+//
+// Author:
+//      Alexander Klyubin ([email protected])
+//      Dietmar Maurer ([email protected])
+//
+// (C) 2001
+//
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace System.Diagnostics {
+        /// <summary>
+        ///   Stack frame.
+        /// </summary>
+
+	[Serializable]
+        public class StackFrame {
+                /// <value>
+                ///   Constant returned when the native or IL offset is unknown.
+                /// </value>
+                public const int OFFSET_UNKNOWN = -1;
+                
+                /// <value>
+                ///   Offset from the start of the IL code for the method
+                ///   being executed.
+                /// </value>
+                private int ilOffset = OFFSET_UNKNOWN;
+                
+                /// <value>
+                ///   Offset from the start of the native code for the method
+                ///   being executed.
+                /// </value>
+                private int nativeOffset = OFFSET_UNKNOWN;
+
+                /// <value>
+                ///   Method associated with this stack frame.
+                /// </value>
+                private MethodBase methodBase;
+                
+                /// <value>
+                ///   File name.
+                /// </value>
+                private string fileName;
+                
+                /// <value>
+                ///   Line number.
+                /// </value>
+                private int lineNumber;
+                
+                /// <value>
+                ///   Column number.
+                /// </value>
+                private int columnNumber;
+#if TARGET_JVM
+		static bool get_frame_info (int skip, bool needFileInfo, out MethodBase method,
+			out int iloffset, out int native_offset,
+			out string file, out int line, out int column)
+		{
+			native_offset = 0;
+			line = 0;
+			column = 0;
+			file = "";
+			iloffset = 0;
+			method = null;
+			return false;
+		}
+#else
+		[MethodImplAttribute(MethodImplOptions.InternalCall)]
+		extern static bool get_frame_info (int skip, bool needFileInfo, out MethodBase method,
+						   out int iloffset, out int native_offset,
+						   out string file, out int line, out int column);
+#endif
+		/// <summary>
+                ///   Initializes a new StackFrame object corresponding to the
+                ///   active stack frame.
+                /// </summary>
+                public StackFrame() 
+				{
+			get_frame_info (2, false, out methodBase, out ilOffset,
+					out nativeOffset, out fileName, out lineNumber,
+					out columnNumber);			
+                }
+                
+                /// <summary>
+                ///   Initializes a new StackFrame object corresponding to the
+                ///   active stack frame.
+                /// </summary>
+                /// <param name="needFileInfo">
+                ///   TODO:
+                /// </param>
+                public StackFrame(bool needFileInfo) : this() {
+			get_frame_info (2, needFileInfo, out methodBase, out ilOffset,
+					out nativeOffset, out fileName, out lineNumber,
+					out columnNumber);			
+                }
+                
+                /// <summary>
+                ///   Initializes a new StackFrame object corresponding to the
+                ///   active stack frame.
+                /// </summary>
+                /// <param name="skipFrames">
+                ///   The number of frames up the stack to skip.
+                /// </param>
+                public StackFrame(int skipFrames) {
+			get_frame_info (skipFrames + 2, false, out methodBase, out ilOffset,
+					out nativeOffset, out fileName, out lineNumber,
+					out columnNumber);			
+                }
+                
+                /// <summary>
+                ///   Initializes a new StackFrame object corresponding to the
+                ///   active stack frame.
+                /// </summary>
+                /// <param name="skipFrames">
+                ///   The number of frames up the stack to skip.
+                /// </param>
+                /// <param name="needFileInfo">
+                ///   TODO:
+                /// </param>
+                public StackFrame(int skipFrames, bool needFileInfo) {
+			get_frame_info (skipFrames + 2, needFileInfo, out methodBase, out ilOffset,
+					out nativeOffset, out fileName, out lineNumber,
+					out columnNumber);
+                }
+                
+                /// <summary>
+                ///   Constructs a fake stack frame that just contains the
+                ///   given file name and line number. Use this constructor
+                ///   when you do not want to use the debugger's line mapping
+                ///   logic.
+                /// </summary>
+                /// <param name="fileName">
+                ///   The given file name.
+                /// </param>
+                /// <param name="lineNumber">
+                ///   The line number in the specified file.
+                /// </param>
+				// LAMESPEC: According to the MSDN docs, this creates a
+				// fake stack frame. But MS fills out the frame info as well
+                public StackFrame(string fileName, int lineNumber) {
+					get_frame_info (2, false, out methodBase, out ilOffset,
+									out nativeOffset, out fileName, out lineNumber,
+									out columnNumber);
+					this.fileName = fileName;
+					this.lineNumber = lineNumber;
+					this.columnNumber = 0;
+				}
+                
+                /// <summary>
+                ///   Constructs a fake stack frame that just contains the
+                ///   given file name and line number. Use this constructor
+                ///   when you do not want to use the debugger's line mapping
+                ///   logic.
+                /// </summary>
+                /// <param name="fileName">
+                ///   The given file name.
+                /// </param>
+                /// <param name="lineNumber">
+                ///   The line number in the specified file.
+                /// </param>
+                /// <param name="colNumber">
+                ///   The column number in the specified file.
+                /// </param>
+				// LAMESPEC: According to the MSDN docs, this creates a
+				// fake stack frame. But MS fills out the frame info as well
+                public StackFrame(string fileName,
+                                  int lineNumber,
+                                  int colNumber) {
+					get_frame_info (2, false, out methodBase, out ilOffset,
+									out nativeOffset, out fileName, out lineNumber,
+									out columnNumber);
+					this.fileName = fileName;
+					this.lineNumber = lineNumber;
+					this.columnNumber = colNumber;
+                }
+                                  
+                              
+                /// <summary>
+                ///   Gets the line number in the file containing the code
+                ///   being executed. This information is typically extracted
+                ///   from the debugging symbols for the executable.
+                /// </summary>
+                /// <returns>
+                ///   The file line number or zero if it cannot be determined.
+                /// </returns>
+                public virtual int GetFileLineNumber()
+                {
+                        return lineNumber;
+                }
+                
+                /// <summary>
+                ///   Gets the column number in the file containing the code
+                ///   being executed. This information is typically extracted
+                ///   from the debugging symbols for the executable.
+                /// </summary>
+                /// <returns>
+                ///   The file column number or zero if it cannot be determined.
+                /// </returns>
+                public virtual int GetFileColumnNumber()
+                {
+                        return columnNumber;
+                }
+                
+                /// <summary>
+                ///   Gets the file name containing the code being executed.
+                ///   This information is typically extracted from the
+                ///   debugging symbols for the executable.
+                /// </summary>
+                /// <returns>
+                ///   The file name or null if it cannot be determined.
+                /// </returns> 
+                public virtual string GetFileName()
+                {
+                        return fileName;
+                }
+                
+                /// <summary>
+                ///   Gets the offset from the start of the IL code for the
+                ///   method being executed. This offset may be approximate
+                ///   depending on whether the JIT compiler is generating
+                ///   debugging code or not.
+                /// </summary>
+                /// <returns>
+                ///   The offset from the start of the IL code for the method
+                ///   being executed.
+                /// </returns>
+                public virtual int GetILOffset()
+                {
+                        return ilOffset;
+                }
+                
+                /// <summary>
+                ///   Gets the method in which the frame is executing.
+                /// </summary>
+                /// <returns>
+                ///   The method the frame is executing in.
+                /// </returns>
+                public virtual MethodBase GetMethod()
+                {
+                        return methodBase;
+                }
+                
+                /// <summary>
+                ///   Gets the offset from the start of the native
+                ///   (JIT-compiled) code for the method being executed.
+                /// </summary>
+                /// <returns>
+                ///   The offset from the start of the native (JIT-compiled)
+                ///   code or the method being executed.
+                /// </returns>
+                public virtual int GetNativeOffset()
+                {
+                        return nativeOffset;                        
+                }
+                
+                /// <summary>
+                ///   Builds a readable representation of the stack frame.
+                /// </summary>
+                /// <returns>
+                ///   A readable representation of the stack frame.
+                /// </returns>
+                public override string ToString() {
+                        string methodNameString =
+                                (GetMethod() == null)
+                                        ? "<unknown method>"
+                                          : GetMethod().Name;
+                        string offsetString =
+                                (GetILOffset() == OFFSET_UNKNOWN)
+                                        ? "<unknown offset>"
+                                          : "offset " + GetILOffset();
+                        string fileNameString =
+                                (GetFileName() == null)
+                                        ? "<filename unknown>" : GetFileName();
+                        return methodNameString + " at " + offsetString
+                                + " in file:line:column " + fileNameString
+                                + ":" + GetFileLineNumber()
+                                + ":" + GetFileColumnNumber();
+                }
+                
+                public override bool Equals(Object obj) {
+                        if ((obj == null) || (!(obj is StackFrame))) {
+                                return false;
+                        }
+                        
+                        StackFrame rhs = (StackFrame) obj;
+                        
+                        if (!ObjectsEqual(GetMethod(), rhs.GetMethod())) {
+                                return false;
+                        }
+                        
+                        if (!ObjectsEqual(GetFileName(), rhs.GetFileName())) {
+                                return false;
+                        }
+                        
+                        if (GetFileLineNumber() != rhs.GetFileLineNumber()) {
+                                return false;
+                        }
+                        
+                        if (GetFileColumnNumber() != rhs.GetFileColumnNumber()) {
+                                return false;
+                        }
+                        
+                        if (GetILOffset() != rhs.GetILOffset()) {
+                                return false;
+                        }
+                        
+                        if (GetNativeOffset() != rhs.GetNativeOffset()) {
+                                return false;
+                        }
+                        
+                        return true;
+                        
+                }
+                
+                public override int GetHashCode() {
+                        return GetFileLineNumber();
+                }
+                
+                /// <summary>
+                ///   Checks whether two objects are equal.
+                ///   The objects are assumed equal if and only if either
+                ///   both of the references are <code>null</code> or they
+                ///   equal via <code>Equals</code> method.
+                /// </summary>
+                /// <param name="obj1">
+                ///   First object.
+                /// </param>
+                /// <param name="obj2">
+                ///   Second object.
+                /// </param>
+                /// <returns>
+                ///   <code>true</code> if the two objects are equal,
+                ///   </code>false</code> otherwise.
+                /// </returns>
+                private static bool ObjectsEqual(Object obj1, Object obj2) {
+                        if (obj1 == null) {
+                                return (obj2 == null);
+                        } else {
+                                return obj1.Equals(obj2);
+                        }
+                }
+         }
+}

mcs/class/System/System.Diagnostics/StackTrace.jvm.cs

@@ -0,0 +1,287 @@
+//
+// System.Diagnostics.StackTrace.cs
+//
+// Author:
+//      Alexander Klyubin ([email protected])
+//      Dietmar Maurer ([email protected])
+//
+// (C) 2001
+//
+
+using System;
+using System.Reflection;
+using System.Threading;
+using System.Runtime.CompilerServices;
+using System.Collections;
+
+namespace System.Diagnostics {
+        /// <summary>
+        ///   Stack trace.
+        ///   TODO: more information.
+        /// </summary>
+        [Serializable]
+	public class StackTrace {
+                /// <value>
+                ///   Uses a constant to define the number of methods that are
+                ///   to be omitted from the stack trace.
+                /// </value>
+                public const int METHODS_TO_SKIP = 0;
+                
+                /// <value>
+                ///   Frames. First frame is the last stack frame pushed.
+                /// </value>
+                private StackFrame[] frames;
+
+                /// <summary>
+                ///   Initializes a new instance of the StackTrace class.
+                /// </summary>
+		[MonoTODO]
+                public StackTrace() {
+			init_frames (METHODS_TO_SKIP, false);
+		}
+                
+                /// <summary>
+                ///   Initializes a new instance of the StackTrace class.
+                /// </summary>
+                /// <param name="needFileInfo">
+                ///   TODO:
+                /// </param>
+                public StackTrace(bool needFileInfo) {
+			init_frames (METHODS_TO_SKIP, needFileInfo);
+		}
+
+                /// <summary>
+                ///   Initializes a new instance of the StackTrace class
+                ///   from the current location, in a caller's frame.
+                /// </summary>
+                /// <param name="skipFrames">
+                ///   The number of frames up the stack to start the trace
+                ///   from.
+                /// </param>
+                public StackTrace(int skipFrames) {
+			init_frames (skipFrames, false);
+		}
+
+		/// <summary>
+                ///   Initializes a new instance of the StackTrace class
+                ///   from the current location, in a caller's frame.
+                /// </summary>
+                /// <param name="skipFrames">
+                ///   The number of frames up the stack to start the trace
+                ///   from.
+                /// </param>
+                /// <param name="needFileInfo">
+                ///   TODO:
+                /// </param>
+                public StackTrace(int skipFrames, bool needFileInfo) {
+			init_frames (skipFrames, needFileInfo);
+		}
+
+		void init_frames (int skipFrames, bool needFileInfo)
+		{
+			StackFrame sf;
+			ArrayList al = new ArrayList ();
+
+			skipFrames += 2;
+			
+			while ((sf = new StackFrame (skipFrames, needFileInfo)) != null &&
+			       sf.GetMethod () != null) {
+				
+				al.Add (sf);
+				skipFrames++;
+			};
+
+                        frames = (StackFrame [])al.ToArray (typeof (StackFrame));
+		}
+#if TARGET_JVM
+		static StackFrame [] get_trace (Exception e, int skipFrames, bool needFileInfo)
+		{
+			return null;
+		}
+#else
+		[MethodImplAttribute(MethodImplOptions.InternalCall)]
+		extern static StackFrame [] get_trace (Exception e, int skipFrames, bool needFileInfo);
+#endif
+		/// <summary>
+                ///   Initializes a new instance of the StackTrace class.
+                /// </summary>
+                /// <param name="e">
+                ///   TODO:
+                /// </param>
+                public StackTrace(Exception e) 
+				{
+                        frames = get_trace (e, METHODS_TO_SKIP, false);
+                }
+                                
+                /// <summary>
+                ///   Initializes a new instance of the StackTrace class,
+                ///   using the provided exception object. The resulting stack
+                ///   trace describes the stack at the time of the exception.
+                /// </summary>
+                /// <param name="e">
+                ///   TODO:
+                /// </param>
+                /// <param name="needFileInfo">
+                ///   TODO:
+                /// </param>
+                public StackTrace(Exception e, bool needFileInfo) {
+                        frames = get_trace (e, METHODS_TO_SKIP, needFileInfo);
+		}
+                
+                /// <summary>
+                ///   Initializes a new instance of the StackTrace class,
+                ///   using the provided exception object. The resulting stack
+                ///   trace describes the stack at the time of the exception.
+                /// </summary>
+                /// <param name="e">
+                ///   Exception.
+                /// </param>
+                /// <param name="skipFrames">
+                ///   The number of frames up the stack to start the trace
+                ///   from.
+                /// </param>
+                public StackTrace(Exception e, int skipFrames) {
+                        frames = get_trace (e, skipFrames, false);
+                }
+                
+                /// <summary>
+                ///   Initializes a new instance of the StackTrace class,
+                ///   using the provided exception object. The resulting stack
+                ///   trace describes the stack at the time of the exception.
+                /// </summary>
+                /// <param name="e">
+                ///   Exception.
+                /// </param>
+                /// <param name="skipFrames">
+                ///   The number of frames up the stack to start the trace
+                ///   from.
+                /// </param>
+                /// <param name="needFileInfo">
+                ///   TODO:
+                /// </param>
+                public StackTrace(Exception e, int skipFrames, bool needFileInfo) {
+                        frames = get_trace (e, skipFrames, needFileInfo);
+		}
+                              
+                /// <summary>
+                ///   Initializes a new instance of the StackTrace class
+                ///   containing a single frame.
+                /// </summary>
+                /// <param name="frame">
+                ///   The frame that the StackTrace object should contain.
+                /// </param>
+                public StackTrace(StackFrame frame) {
+                        this.frames = new StackFrame[1];
+                        this.frames[0] = frame;
+                }
+                               
+                /// <summary>
+                ///   Initializes a new instance of the StackTrace class.
+                /// </summary>
+                /// <param name="targetThread">
+                ///   TODO:
+                /// </param>
+                /// <param name="needFileInfo">
+                ///   TODO:
+                /// </param>
+		[MonoTODO]
+                public StackTrace(Thread targetThread, bool needFileInfo) {
+                        throw new NotImplementedException();
+                }
+               
+                /// <summary>
+                ///   Holds the number of frames in the stack trace.
+                /// </summary>
+                public virtual int FrameCount {
+                        get {
+                                return (frames == null) ? 0 : frames.Length;
+                        }
+                }             
+                              
+                /// <summary>
+                ///   Gets the specified stack frame.
+                /// </summary>
+                /// <param name="index">
+                ///   The index of the stack frame requested.
+                /// </param>
+                /// <returns>
+                ///   The specified stack frame. Returns <code>null</code> if
+                ///   frame with specified index does not exist in this stack
+                ///   trace.
+                /// </returns>
+                /// <remarks>
+                ///   Stack frames are numbered starting at zero, which is the
+                ///   last stack frame pushed.
+                /// </remarks>
+                public virtual StackFrame GetFrame(int index) {
+                        if ((index < 0) || (index >= FrameCount)) {
+                                return null;
+                        }
+                        
+                        return frames[index];
+                }              
+                
+                /// <summary>
+                ///   Builds a readable representation of the stack trace.
+                /// </summary>
+                /// <returns>
+                ///   A readable representation of the stack trace.
+                /// </returns>
+                public override string ToString() {
+                        string result = "";
+                        for (int i = 0; i < FrameCount; i++) {
+                                StackFrame frame = GetFrame(i);
+                                result += "\n\tat " + FrameToString(frame);
+                        }
+                        
+                        return result;
+                }
+                
+                public override bool Equals(Object obj) {
+                        if ((obj == null) || (!(obj is StackTrace))) {
+                                return false;
+                        }
+                        
+                        StackTrace rhs = (StackTrace) obj;
+                        
+                        if (FrameCount != rhs.FrameCount) {
+                                return false;
+                        }
+                        
+                        for (int i = 0; i < FrameCount; i++) {
+                                if (!GetFrame(i).Equals(rhs.GetFrame(i))) {
+                                        return false;
+                                }
+                        }
+                        
+                        return true;
+                }
+                
+                public override int GetHashCode() {
+                        return FrameCount;
+                }
+                
+                /// <summary>
+                ///   Converts single stack frame to string to be used in
+                ///   ToString method.
+                /// </summary>
+                /// <param name="frame">
+                ///   Frame to convert.
+                /// </param>
+                /// <returns>
+                ///   A readable representation of stack frame for using
+                ///   ToString.
+                /// </returns>
+                private static String FrameToString(StackFrame frame) {
+			MethodBase method = frame.GetMethod();
+                        if (method != null) {
+                                // Method information available
+                                return  method.DeclaringType.FullName
+                                        + "." + method.Name + "()";
+                        } else {
+                                // Method information not available
+                                return "<unknown method>";
+                        }
+                }
+        }
+}

mcs/class/System/System20.vmwcsproj

@@ -1,4 +1,4 @@
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug_Java</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -143,7 +143,7 @@
   -->
   <ProjectExtensions>
     <VisualStudio>
-      <UserProperties REFS-JarPath-apache_http_client="..\lib\apache_http_client.jar" REFS-JarPath-system-configuration="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jgac\vmw4j2ee_110\System.Configuration.jar" REFS-JarPath-rt="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jre5\lib\rt.jar" REFS-JarPath-mscorlib="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jgac\vmw4j2ee_110\mscorlib.jar" REFS-JarPath-j2se-helpers="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jgac\vmw4j2ee_110\J2SE.Helpers.jar" REFS-JarPath-system-xml="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jgac\vmw4j2ee_110\System.Xml.jar" />
+      <UserProperties REFS-JarPath-system-xml="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jgac\vmw4j2ee_110\System.Xml.jar" REFS-JarPath-j2se-helpers="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jgac\vmw4j2ee_110\J2SE.Helpers.jar" REFS-JarPath-mscorlib="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jgac\vmw4j2ee_110\mscorlib.jar" REFS-JarPath-rt="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jre5\lib\rt.jar" REFS-JarPath-system-configuration="..\..\..\..\..\Program Files\Mainsoft\Visual MainWin for J2EE V2\jgac\vmw4j2ee_110\System.Configuration.jar" REFS-JarPath-apache_http_client="..\lib\apache_http_client.jar" />
     </VisualStudio>
   </ProjectExtensions>
   <ItemGroup>
@@ -547,12 +547,15 @@
     <Compile Include="System.Diagnostics\Debug.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="System.Diagnostics\Debugger.jvm.cs" />
     <Compile Include="System.Diagnostics\DefaultTraceListener.cs">
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="System.Diagnostics\DiagnosticsConfigurationHandler.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="System.Diagnostics\StackFrame.jvm.cs" />
+    <Compile Include="System.Diagnostics\StackTrace.jvm.cs" />
     <Compile Include="System.Diagnostics\Trace.cs">
       <SubType>Code</SubType>
     </Compile>
@@ -699,10 +702,10 @@
     <Compile Include="System.Net.Security\SslPolicyErrors.cs" />
     <Compile Include="System.Net.Security\SslStream.cs" />
     <Compile Include="System.Net.Sockets\AddressFamily.cs" />
-    <Compile Include="System.Net.Sockets\GHSocket.cs" />
-    <Compile Include="System.Net.Sockets\GHSocketFactory.cs" />
-    <Compile Include="System.Net.Sockets\GHStreamSocket.cs" />
-    <Compile Include="System.Net.Sockets\GHStreamSocketSSL.cs" />
+    <Compile Include="System.Net.Sockets\GHSocket.jvm.cs" />
+    <Compile Include="System.Net.Sockets\GHSocketFactory.jvm.cs" />
+    <Compile Include="System.Net.Sockets\GHStreamSocket.jvm.cs" />
+    <Compile Include="System.Net.Sockets\GHStreamSocketSSL.jvm.cs" />
     <Compile Include="System.Net.Sockets\IPv6MulticastOption.cs" />
     <Compile Include="System.Net.Sockets\LingerOption.cs" />
     <Compile Include="System.Net.Sockets\MulticastOption.cs" />
@@ -775,11 +778,11 @@
     <Compile Include="System.Net\HttpListenerPrefixCollection.cs" />
     <Compile Include="System.Net\HttpListenerRequest.cs" />
     <Compile Include="System.Net\HttpListenerResponse.cs" />
-    <Compile Include="System.Net\HttpProvider.cs" />
+    <Compile Include="System.Net\HttpProvider.jvm.cs" />
     <Compile Include="System.Net\HttpRequestCreator.cs" />
     <Compile Include="System.Net\HttpRequestHeader.cs" />
     <Compile Include="System.Net\HttpResponseHeader.cs" />
-    <Compile Include="System.Net\HttpStateCache.cs" />
+    <Compile Include="System.Net\HttpStateCache.jvm.cs" />
     <Compile Include="System.Net\HttpStatusCode.cs" />
     <Compile Include="System.Net\HttpStreamAsyncResult.cs" />
     <Compile Include="System.Net\HttpUtility.cs" />
@@ -828,7 +831,7 @@
     <Compile Include="System.Net\UploadStringCompletedEventHandler.cs" />
     <Compile Include="System.Net\UploadValuesCompletedEventArgs.cs" />
     <Compile Include="System.Net\UploadValuesCompletedEventHandler.cs" />
-    <Compile Include="System.Net\VMWHttpProvider.cs" />
+    <Compile Include="System.Net\VMWHttpProvider.jvm.cs" />
     <Compile Include="System.Net\WebAsyncResult.cs" />
     <Compile Include="System.Net\WebClient.cs" />
     <Compile Include="System.Net\WebConnectionData.cs" />