Remove non ASCII characters from source files

Our native files were more or less encoded in Windows-1252, which
causes problems when we try to compile them on machines where the
current codepage can't represent everything that Windows-1252
can. With this conversion I just moved characters to their ASCII
counterparts (e.g. no smart quotes, the section marker glyph is now
"Section"). There were two places where I couldn't do the straight
forward thing, in object.h we wanted to insert the Per Mille symbol in
a comment so instead I just spelled out the Unicode codepoint. In
morph.cpp, there was a comment pointing to a paper by Torbjörn
Granlund (note the diaeresis above the second o).  In this case,
unfortuntely I had to just drop the diaeresis.  However, searching for
"Torbjorn Granlund" will lead you to the right person.

Fixes #49

20 files changed, 35 insertions, 35 deletions

diff --git a/src/vm/assembly.hpp b/src/vm/assembly.hpp
index 6493b0b1d1..812efb3c2b 100644
--- a/src/vm/assembly.hpp
+++ b/src/vm/assembly.hpp
@@ -898,7 +898,7 @@ public:
     // Checks to see if an assembly has friend access to a particular member.
     //
     // Arguments:
-    //    pAccessingAssembly – the assembly requesting friend access
+    //    pAccessingAssembly - the assembly requesting friend access
     //    pMember            - the member that is attempting to be accessed
     //
     // Return Value:
diff --git a/src/vm/callhelpers.h b/src/vm/callhelpers.h
index 07dbf3505f..497835f6d5 100644
--- a/src/vm/callhelpers.h
+++ b/src/vm/callhelpers.h
@@ -568,7 +568,7 @@ enum DispatchCallSimpleFlags
 // such as END_DOMAIN_TRANSITION or EX_CATCH. Catching exceptions in the managed code is properly instrumented and
 // does not need this notification.
 //
-// The notification is what enables both the managed ‘unhandled exception’ dialog and the ‘user unhandled’ dialog when 
+// The notification is what enables both the managed 'unhandled exception' dialog and the 'user unhandled' dialog when 
 // JMC is turned on. Many things that VS puts up the unhandled exception dialog for are actually cases where the native
 // exception was caught, for example catching exceptions at the thread base. JMC requires further accuracy - in that case
 // VS is checking to see if an exception escaped particular ranges of managed code frames.
diff --git a/src/vm/ceeload.cpp b/src/vm/ceeload.cpp
index e0fadaf58d..4fd1fdf009 100644
--- a/src/vm/ceeload.cpp
+++ b/src/vm/ceeload.cpp
@@ -10736,7 +10736,7 @@ void Module::PlaceMethod(DataImage *image, MethodDesc *pMD, DWORD profilingFlags
        }
 #endif // FEATURE_COMINTEROP
 
-        // Stubs-as-IL have writeable signatures sometimes, so can’t place them
+        // Stubs-as-IL have writeable signatures sometimes, so can't place them
         // into read-only section. We should not get here for stubs-as-il anyway,
         // but we will filter them out just to be sure.
         if (pMD->HasStoredSig() && !pMD->IsILStub())
diff --git a/src/vm/clrex.cpp b/src/vm/clrex.cpp
index 6fe52e53b3..24ca7f05f1 100644
--- a/src/vm/clrex.cpp
+++ b/src/vm/clrex.cpp
@@ -2477,7 +2477,7 @@ ObjrefException::ObjrefException(OBJECTREF throwable)
 // --------------------------------------------------------------------------------------------------------------------------------------
 // ObjrefException and CLRLastThrownObjectException are never set as inner exception for an internal CLR exception.
 // As a result, if we invoke DomainBoundClone against an exception, it will never reach these implementations.
-// If someone does set them as inner, it will trigger contract violation – which is valid and should be fixed by whoever
+// If someone does set them as inner, it will trigger contract violation - which is valid and should be fixed by whoever
 // set them as inner since Exception::DomainBoundClone is implemented in utilcode that has to work outside the context of CLR and thus,
 // should never trigger GC. This is also why GC_TRIGGERS is not supported in utilcode (refer to its definition in contracts.h).
 // --------------------------------------------------------------------------------------------------------------------------------------
diff --git a/src/vm/clsload.cpp b/src/vm/clsload.cpp
index 1aa6f23e8c..8d5fae5c2d 100644
--- a/src/vm/clsload.cpp
+++ b/src/vm/clsload.cpp
@@ -6364,7 +6364,7 @@ BOOL ClassLoader::CheckAccessMember(                // TRUE if access is allowed
 //
 // The second part:
 //
-//              For verifiable code (see §8.8), there is an additional
+//              For verifiable code (see Section 8.8), there is an additional
 //              requirement that can require a runtime check: the reference
 //              shall be made through an item whose exact type supports
 //              the exact type of the referent. That is, the item whose
diff --git a/src/vm/eehash.inl b/src/vm/eehash.inl
index 98c6bfd86b..6a09b29344 100644
--- a/src/vm/eehash.inl
+++ b/src/vm/eehash.inl
@@ -80,7 +80,7 @@ void EEHashTableBase<KeyType, Helper, bDefaultCopyIsDeep>::ClearHashTable()
     
     // Transition to COOP mode. This is need because EEHashTable is lock free and it can be read 
     // from multiple threads without taking locks. On rehash, you want to get rid of the old copy 
-    // of table. You can only get rid of it once nobody is using it. That’s a problem because 
+    // of table. You can only get rid of it once nobody is using it. That's a problem because 
     // there is no lock to tell when the last reader stopped using the old copy of the table.
     // The solution to this problem is to access the table in cooperative mode, and to get rid of 
     // the old copy of the table when we are suspended for GC. When we are suspended for GC, 
@@ -126,7 +126,7 @@ void EEHashTableBase<KeyType, Helper, bDefaultCopyIsDeep>::EmptyHashTable()
     
     // Transition to COOP mode. This is need because EEHashTable is lock free and it can be read 
     // from multiple threads without taking locks. On rehash, you want to get rid of the old copy 
-    // of table. You can only get rid of it once nobody is using it. That’s a problem because 
+    // of table. You can only get rid of it once nobody is using it. That's a problem because 
     // there is no lock to tell when the last reader stopped using the old copy of the table.
     // The solution to this problem is to access the table in cooperative mode, and to get rid of 
     // the old copy of the table when we are suspended for GC. When we are suspended for GC, 
@@ -237,7 +237,7 @@ void EEHashTableBase<KeyType, Helper, bDefaultCopyIsDeep>::InsertValue(KeyType p
     
     // Transition to COOP mode. This is need because EEHashTable is lock free and it can be read 
     // from multiple threads without taking locks. On rehash, you want to get rid of the old copy 
-    // of table. You can only get rid of it once nobody is using it. That’s a problem because 
+    // of table. You can only get rid of it once nobody is using it. That's a problem because 
     // there is no lock to tell when the last reader stopped using the old copy of the table.
     // The solution to this problem is to access the table in cooperative mode, and to get rid of 
     // the old copy of the table when we are suspended for GC. When we are suspended for GC, 
@@ -291,7 +291,7 @@ void EEHashTableBase<KeyType, Helper, bDefaultCopyIsDeep>::InsertKeyAsValue(KeyT
     
     // Transition to COOP mode. This is need because EEHashTable is lock free and it can be read 
     // from multiple threads without taking locks. On rehash, you want to get rid of the old copy 
-    // of table. You can only get rid of it once nobody is using it. That’s a problem because 
+    // of table. You can only get rid of it once nobody is using it. That's a problem because 
     // there is no lock to tell when the last reader stopped using the old copy of the table.
     // The solution to this problem is to access the table in cooperative mode, and to get rid of 
     // the old copy of the table when we are suspended for GC. When we are suspended for GC, 
@@ -543,7 +543,7 @@ EEHashEntry_t *EEHashTableBase<KeyType, Helper, bDefaultCopyIsDeep>::FindItem(Ke
 
     // Transition to COOP mode. This is need because EEHashTable is lock free and it can be read 
     // from multiple threads without taking locks. On rehash, you want to get rid of the old copy 
-    // of table. You can only get rid of it once nobody is using it. That’s a problem because 
+    // of table. You can only get rid of it once nobody is using it. That's a problem because 
     // there is no lock to tell when the last reader stopped using the old copy of the table.
     // The solution to this problem is to access the table in cooperative mode, and to get rid of 
     // the old copy of the table when we are suspended for GC. When we are suspended for GC, 
diff --git a/src/vm/eetoprofinterfaceimpl.h b/src/vm/eetoprofinterfaceimpl.h
index 039bdf8ae2..3de355549d 100644
--- a/src/vm/eetoprofinterfaceimpl.h
+++ b/src/vm/eetoprofinterfaceimpl.h
@@ -655,7 +655,7 @@ private:
 
     // ELT3 no long keeps track of FunctionID of current managed method.  Therefore, a hash table of bookkeeping 
     // the mapping from FunctionID to clientID is needed to build up ELT2 on top of ELT3.  When ELT2 (slow-path 
-    // or fast-path) is registered by the profiler and the profiler’s IDFunctionMapper requests to hook up the 
+    // or fast-path) is registered by the profiler and the profiler's IDFunctionMapper requests to hook up the 
     // function being loading, the clientID returned by FunctionIDMapper will be saved as the value to be looked 
     // up by the corresponding FunctionID in the hash table.  FunctionIDs can be recycled after an app domain
     // that contains the function bodies is unloaded so this hash table needs to replace the existing FunctionID 
diff --git a/src/vm/eventtrace.cpp b/src/vm/eventtrace.cpp
index faf8a60c2f..9983ad11e9 100644
--- a/src/vm/eventtrace.cpp
+++ b/src/vm/eventtrace.cpp
@@ -2205,8 +2205,8 @@ public:
     // node. Edges are reported in bulk, separately from Nodes, but it is expected that
     // the consumer read the Node and Edge streams together. One takes the first node
     // from the Node stream, and then reads EdgeCount entries in the Edge stream, telling
-    // you all of that Node’s targets. Then, one takes the next node in the Node stream,
-    // and reads the next entries in the Edge stream (using this Node’s EdgeCount to
+    // you all of that Node's targets. Then, one takes the next node in the Node stream,
+    // and reads the next entries in the Edge stream (using this Node's EdgeCount to
     // determine how many) to find all of its targets. This continues on until the Node
     // and Edge streams have been fully read.
     // 
diff --git a/src/vm/generics.h b/src/vm/generics.h
index 93d0e583d0..ac267e3b70 100644
--- a/src/vm/generics.h
+++ b/src/vm/generics.h
@@ -26,7 +26,7 @@ class DictionaryEntryLayout;
 // Generics helper functions
 namespace Generics
 {
-    // Part of the recursive inheritance graph as defined by ECMA part.II §9.2.
+    // Part of the recursive inheritance graph as defined by ECMA part.II Section 9.2.
     // 
     // code:MethodTable.DoFullyLoad and code:TypeDesc.DoFullyLoad declare local variable of
     // this type and initialize it with:
diff --git a/src/vm/i386/gmsx86.cpp b/src/vm/i386/gmsx86.cpp
index 3bc9002211..6badea0af9 100644
--- a/src/vm/i386/gmsx86.cpp
+++ b/src/vm/i386/gmsx86.cpp
@@ -309,8 +309,8 @@ static bool shouldEnterCall(PTR_BYTE ip) {
 
 /***************************************************************/
 // A fundamental requirement of managed code is that we need to be able to enumerate all GC references on the
-// stack at GC time. To do this we need to be able to ‘crawl’ the stack. We know how to do this in JIT
-// compiled code (it generates additional information like the frame size etc), but we don’t know how to do
+// stack at GC time. To do this we need to be able to 'crawl' the stack. We know how to do this in JIT
+// compiled code (it generates additional information like the frame size etc), but we don't know how to do
 // this for unmanaged code. For PINVOKE calls, we leave a pointer to the transition boundary between managed
 // and unmanaged code and we simply ignore the lower part of the stack. However setting up this transition is
 // a bit expensive (1-2 dozen instructions), and while that is acceptable for PINVOKE, it is not acceptable
@@ -319,15 +319,15 @@ static bool shouldEnterCall(PTR_BYTE ip) {
 // To get around this, for transitions into the runtime (which we call FCALLS), we DEFER setting up the
 // boundary variables (what we call the transition frame), until we actually need it (we will do an operation
 // that might cause a GC). This allow us to handle the common case (where we might find the thing in a cache,
-// or be service the ‘new’ from a allocation quantum), and only pay the cost of setting up the transition
+// or be service the 'new' from a allocation quantum), and only pay the cost of setting up the transition
 // frame when it will actually be used.
 //
 // The problem is that in order to set up a transition frame we need to be able to find ALL REGISTERS AT THE
 // TIME THE TRANSITION TO UNMANAGED CODE WAS MADE (because we might need to update them if they have GC
 // references). Because we have executed ordinary C++ code (which might spill the registers to the stack at
-// any time), we have a problem. LazyMachState is our ‘solution’ to this problem. We take advantage of the
+// any time), we have a problem. LazyMachState is our 'solution' to this problem. We take advantage of the
 // fact that the C++ code MUST RESTORE the register before returning. Thus we simulate the execution from the
-// current location to the return and ‘watch’ where the registers got restored from. This is what
+// current location to the return and 'watch' where the registers got restored from. This is what
 // unwindLazyState does (determine what the registers would be IF you had never executed and unmanaged C++
 // code).
 // 
diff --git a/src/vm/interoputil.cpp b/src/vm/interoputil.cpp
index 682bf53218..b1943bc13a 100644
--- a/src/vm/interoputil.cpp
+++ b/src/vm/interoputil.cpp
@@ -4044,7 +4044,7 @@ BOOL MethodNeedsReverseComStub(MethodDesc *pMD)
             {
                 //
                 // However, we do need CCWs for internal interfaces that define protected members of inheritable classes
-                // (for example, Windows.UI.Xaml.Application implements both IApplication, which we don’t need 
+                // (for example, Windows.UI.Xaml.Application implements both IApplication, which we don't need 
                 // a CCW for and IApplicationOverrides, which we do need).
                 //
                 if (!pMT->GetWriteableData()->IsOverridingInterface())
diff --git a/src/vm/method.cpp b/src/vm/method.cpp
index 2dc699e534..2295502d16 100644
--- a/src/vm/method.cpp
+++ b/src/vm/method.cpp
@@ -3047,7 +3047,7 @@ void MethodDesc::Save(DataImage *image)
                 // Store signatures that doesn't need restore into a read only section.
                 DataImage::ItemKind sigItemKind = DataImage::ITEM_STORED_METHOD_SIG_READONLY;
                 // Place the signatures for stubs-as-il into hot/cold or writeable section
-                // here since Module::Arrange won’t place them for us.
+                // here since Module::Arrange won't place them for us.
                 if (IsILStub())
                 {
                     PTR_DynamicMethodDesc pDynamicMD = AsDynamicMethodDesc();
diff --git a/src/vm/methodtable.cpp b/src/vm/methodtable.cpp
index 781b946e6d..0d95a9c884 100644
--- a/src/vm/methodtable.cpp
+++ b/src/vm/methodtable.cpp
@@ -4720,7 +4720,7 @@ void MethodTable::DoFullyLoad(Generics::RecursionGraph * const pVisited,  const
         else if (level == CLASS_DEPENDENCIES_LOADED && HasInstantiation())
         {
             // This is a typical instantiation of a generic type. When attaining CLASS_DEPENDENCIES_LOADED, the
-            // recursive inheritance graph (ECMA part.II §9.2) will be constructed and checked for "expanding
+            // recursive inheritance graph (ECMA part.II Section 9.2) will be constructed and checked for "expanding
             // cycles" to detect infinite recursion, e.g. A<T> : B<A<A<T>>>.
             // 
             // The dependencies loaded by this method (parent type, implemented interfaces, generic arguments)
diff --git a/src/vm/mlinfo.cpp b/src/vm/mlinfo.cpp
index 107841218e..78bc3e0a54 100644
--- a/src/vm/mlinfo.cpp
+++ b/src/vm/mlinfo.cpp
@@ -2904,7 +2904,7 @@ MarshalInfo::MarshalInfo(Module* pModule,
 lExit:
 #ifdef FEATURE_COMINTEROP
 #ifdef FEATURE_CORECLR
-//Field scenario is not blocked here because we don’t want to block loading structs that 
+//Field scenario is not blocked here because we don't want to block loading structs that 
 //have the types which we are blocking, but never pass it to Interop.
 
     if (AppX::IsAppXProcess() && ms != MarshalInfo::MARSHAL_SCENARIO_FIELD)
diff --git a/src/vm/object.h b/src/vm/object.h
index 95f7fa0c64..009e505cea 100644
--- a/src/vm/object.h
+++ b/src/vm/object.h
@@ -1939,7 +1939,7 @@ public:
         /* 0x0c0 */ STRINGREF sPositiveInfinity        ; // + Infinity
         /* 0x0c8 */ STRINGREF sNegativeInfinity        ; // - Infinity
         /* 0x0d0 */ STRINGREF sPercent                 ; // Percent (%) symbol
-        /* 0x0d8 */ STRINGREF sPerMille                ; // PerMille (‰) symbol
+        /* 0x0d8 */ STRINGREF sPerMille                ; // PerMille (U+2030) symbol
         /* 0x0e0 */ STRINGREF sCurrency                ; // (user can override) local monetary symbol
         /* 0x0e8 */ STRINGREF sIntlMonetarySymbol      ; // international monetary symbol (RegionInfo)
         /* 0x0f0 */ STRINGREF sEnglishCurrency         ; // English name for this currency
diff --git a/src/vm/profattach.h b/src/vm/profattach.h
index 8811479e09..be96e23a93 100644
--- a/src/vm/profattach.h
+++ b/src/vm/profattach.h
@@ -122,13 +122,13 @@ public:
     // customize its response for the format expected by the trigger.
     VersionBlock    m_triggerVersion;
 
-    // The GUID of the profiler’s COM object to load
+    // The GUID of the profiler's COM object to load
     CLSID           m_clsidProfiler;
 
-    // The path to the profiler’s COM object to load
+    // The path to the profiler's COM object to load
     WCHAR           m_wszProfilerPath[MAX_PATH];
 
-    // Client data is custom data that the profiler’s
+    // Client data is custom data that the profiler's
     // trigger-process wishes to copy into this process.
     // Profiler authors will typically use this as a way to
     // communicate to the profiler DLL what options the profiler
diff --git a/src/vm/proftoeeinterfaceimpl.cpp b/src/vm/proftoeeinterfaceimpl.cpp
index b12185c6e8..ea32a0dfa8 100644
--- a/src/vm/proftoeeinterfaceimpl.cpp
+++ b/src/vm/proftoeeinterfaceimpl.cpp
@@ -86,12 +86,12 @@
 //             startup). This will also allow the SetEnterLeaveFunctionHooks(2) info
 //             functions to be called outside of Initialize(). If a profiler later
 //             attaches and calls these functions, then the slow-path wrapper will call
-//             into the profiler’s ELT hooks.
+//             into the profiler's ELT hooks.
 //    * COMPLUS_TestOnlyEnableObjectAllocatedHook:
 //         * If nonzero, then on startup the runtime will act as if a profiler was loaded
 //             on startup and requested ObjectAllocated callback (even if no profiler is loaded
 //             on startup). If a profiler later attaches and calls these functions, then the 
-//             ObjectAllocated notifications will call into the profiler’s ObjectAllocated callback.
+//             ObjectAllocated notifications will call into the profiler's ObjectAllocated callback.
 //    * COMPLUS_TestOnlyEnableICorProfilerInfo:
 //         * If nonzero, then attaching profilers allows to call ICorProfilerInfo inteface, 
 //             which would otherwise be disallowed for attaching profilers
@@ -5395,7 +5395,7 @@ HRESULT ProfToEEInterfaceImpl::GetClassFromTokenAndTypeArgs(ModuleID moduleID,
         if (GetThreadNULLOk() == NULL)
         {
             // Type system will try to validate as part of its contract if the current 
-            // AppDomain returned by GetAppDomain can load types in specified module’s 
+            // AppDomain returned by GetAppDomain can load types in specified module's 
             // assembly.   On a non-EE thread it results in an AV in a check build 
             // since the type system tries to dereference NULL returned by GetAppDomain.  
             // More importantly, loading a type on a non-EE thread is not allowed.
diff --git a/src/vm/runtimehandles.cpp b/src/vm/runtimehandles.cpp
index e5cc503eae..b2848225d5 100644
--- a/src/vm/runtimehandles.cpp
+++ b/src/vm/runtimehandles.cpp
@@ -1900,11 +1900,11 @@ void QCALLTYPE RuntimeTypeHandle::GetTypeByName(LPCWSTR pwzClassName, BOOL bThro
         OBJECTREF keepAlive = NULL;
 
         // BEGIN_QCALL/END_QCALL define try/catch scopes for potential exceptions thrown when bThrowOnError is enabled.
-        // Originally, in case of an exception the GCFrame was removed from the Thread’s Frame chain in the catch block, in UnwindAndContinueRethrowHelperInsideCatch.
+        // Originally, in case of an exception the GCFrame was removed from the Thread's Frame chain in the catch block, in UnwindAndContinueRethrowHelperInsideCatch.
         // However, the catch block declared some local variables that overlapped the location of the now out of scope GCFrame and OBJECTREF, therefore corrupting
         // those values. Having the GCX_COOP/GCX_PREEMP switching GC modes, allowed a situation where in case of an exception, the thread would wait for a GC to complete
-        // while still having the GCFrame in the Thread’s Frame chain, but with a corrupt OBJECTREF due to stack location reuse in the catch block.
-        // The solution is to force the removal of GCFrame (and the Frames above) from the Thread’s Frame chain before entering the catch block, at the time of 
+        // while still having the GCFrame in the Thread's Frame chain, but with a corrupt OBJECTREF due to stack location reuse in the catch block.
+        // The solution is to force the removal of GCFrame (and the Frames above) from the Thread's Frame chain before entering the catch block, at the time of 
         // FrameWithCookieHolder's destruction.
         GCPROTECT_HOLDER(keepAlive);
 
diff --git a/src/vm/securitytransparentassembly.cpp b/src/vm/securitytransparentassembly.cpp
index 24a56398ad..2a3ac4e493 100644
--- a/src/vm/securitytransparentassembly.cpp
+++ b/src/vm/securitytransparentassembly.cpp
@@ -643,7 +643,7 @@ bool SecurityTransparent::SecurityCalloutQuickCheck(MethodDesc *pCallerMD)
     CONTRACTL_END;
 
     // In coreclr, we modified the logic in the callout to also do some transparency method access checks
-    // These checks need to happen regardless of trust level and we shouldn’t be bailing out early 
+    // These checks need to happen regardless of trust level and we shouldn't be bailing out early 
     // just because we happen to be in Full Trust
 #ifndef FEATURE_CORECLR
     // See if we need to process this callout for real, or if we can bail out early before setting up a HMF,
diff --git a/src/vm/stackwalk.cpp b/src/vm/stackwalk.cpp
index 72b9e3ccac..eb12aea750 100644
--- a/src/vm/stackwalk.cpp
+++ b/src/vm/stackwalk.cpp
@@ -1968,7 +1968,7 @@ ProcessFuncletsForGCReporting:
                                     
                                     if (!m_fDidFuncletReportGCReferences)
                                     {
-                                        // we have reached the parent frame of the funclet which didn’t report roots since it was already unwound.
+                                        // we have reached the parent frame of the funclet which didn't report roots since it was already unwound.
                                         // check if the parent frame of the funclet is also handling an exception. if it is, then we will need to
                                         // report roots for it since the catch handler may use references inside it.