Extra tests for assembly name parser.

src/coreclr/binder/inc/assemblyidentity.hpp

@@ -30,12 +30,9 @@ namespace BINDER_SPACE
             IDENTITY_FLAG_PUBLIC_KEY_TOKEN       = 0x004,
             IDENTITY_FLAG_PUBLIC_KEY             = 0x008,
             IDENTITY_FLAG_CULTURE                = 0x010,
-            IDENTITY_FLAG_LANGUAGE               = 0x020,
             IDENTITY_FLAG_PROCESSOR_ARCHITECTURE = 0x040,
             IDENTITY_FLAG_RETARGETABLE           = 0x080,
             IDENTITY_FLAG_PUBLIC_KEY_TOKEN_NULL  = 0x100,
-            IDENTITY_FLAG_CUSTOM                 = 0x200,
-            IDENTITY_FLAG_CUSTOM_NULL            = 0x400,
             IDENTITY_FLAG_CONTENT_TYPE           = 0x800,
             IDENTITY_FLAG_FULL_NAME              = (IDENTITY_FLAG_SIMPLE_NAME |
                                                     IDENTITY_FLAG_VERSION)
@@ -50,7 +47,6 @@ namespace BINDER_SPACE
             // Need to pre-populate SBuffers because of bogus asserts
             static const BYTE byteArr[] = { 0 };
             m_publicKeyOrTokenBLOB.SetImmutable(byteArr, sizeof(byteArr));
-            m_customBLOB.SetImmutable(byteArr, sizeof(byteArr));
         }
         ~AssemblyIdentity()
         {
@@ -83,7 +79,6 @@ namespace BINDER_SPACE
         SBuffer             m_publicKeyOrTokenBLOB;
         PEKIND              m_kProcessorArchitecture;
         AssemblyContentType m_kContentType;
-        SBuffer             m_customBLOB;
         DWORD               m_dwIdentityFlags;
     };
 

src/coreclr/binder/inc/stringlexer.hpp

@@ -55,32 +55,28 @@ namespace BINDER_SPACE
         inline StringLexer();
         inline ~StringLexer();
 
-        inline void Init(SString &inputString, BOOL fSupportEscaping);
+        inline void Init(SString &inputString);
 
         static inline BOOL IsWhitespace(WCHAR wcChar);
         static inline BOOL IsEOS(WCHAR wcChar);
         static inline BOOL IsQuoteCharacter(WCHAR wcChar);
 
-        virtual BOOL IsSeparatorChar(WCHAR wcChar) = NULL;
-        virtual LEXEME_TYPE GetLexemeType(WCHAR wcChar) = NULL;
+        BOOL IsSeparatorChar(WCHAR wcChar);
+        LEXEME_TYPE GetLexemeType(WCHAR wcChar);
 
     protected:
         static const WCHAR INVALID_CHARACTER = -1;
 
-        LEXEME_TYPE GetNextLexeme(SString &currentString, BOOL fPermitUnescapedQuotes = FALSE);
+        LEXEME_TYPE GetNextLexeme(SString &currentString);
 
         inline WCHAR PopCharacter(BOOL *pfIsEscaped);
         inline void PushCharacter(WCHAR wcCurrentChar,
                                   BOOL fIsEscaped);
 
         inline WCHAR GetRawCharacter();
-        inline void PushRawCharacter();
-        inline WCHAR DecodeUTF16Character();
         inline WCHAR GetNextCharacter(BOOL *pfIsEscaped);
 
-        inline WCHAR ParseUnicode();
-        LEXEME_TYPE ParseString(SString &currentString,
-                                BOOL     fPermitUnescapeQuotes);
+        LEXEME_TYPE ParseString(SString &currentString);
 
         void TrimTrailingWhiteSpaces(SString &currentString);
 
@@ -89,8 +85,6 @@ namespace BINDER_SPACE
 
         WCHAR m_wcCurrentChar;
         BOOL m_fCurrentCharIsEscaped;
-        BOOL m_fSupportEscaping;
-        BOOL m_fReadRawCharacter;
     };
 
 #include "stringlexer.inl"

src/coreclr/binder/inc/stringlexer.inl

@@ -25,12 +25,10 @@ StringLexer::~StringLexer()
     // Nothing to do here
 }
 
-void StringLexer::Init(SString &inputString, BOOL fSupportEscaping)
+void StringLexer::Init(SString &inputString)
 {
     m_cursor = inputString.Begin();
     m_end = inputString.End();
-    m_fSupportEscaping = fSupportEscaping;
-    m_fReadRawCharacter = FALSE;
 }
 
 BOOL StringLexer::IsWhitespace(WCHAR wcChar)
@@ -55,6 +53,7 @@ WCHAR StringLexer::PopCharacter(BOOL *pfIsEscaped)
     {
         m_wcCurrentChar = INVALID_CHARACTER;
         *pfIsEscaped = m_fCurrentCharIsEscaped;
+        m_cursor++;
     }
     else
     {
@@ -71,172 +70,63 @@ void StringLexer::PushCharacter(WCHAR wcCurrentChar,
 
     m_wcCurrentChar = wcCurrentChar;
     m_fCurrentCharIsEscaped = fIsEscaped;
+    m_cursor--;
 }
 
 WCHAR StringLexer::GetRawCharacter()
 {
     WCHAR wcCurrentChar = 0;
 
-    if (m_cursor <= m_end)
+    if (m_cursor < m_end)
     {
         wcCurrentChar = m_cursor[0];
-        m_fReadRawCharacter = TRUE;
         m_cursor++;
-    }
-    else
-    {
-        m_fReadRawCharacter = FALSE;
-    }
-
-    return wcCurrentChar;
-}
-
-void StringLexer::PushRawCharacter()
-{
-    if (m_fReadRawCharacter)
-    {
-        m_cursor--;
-        m_fReadRawCharacter = FALSE;
-    }
-}
 
-WCHAR StringLexer::DecodeUTF16Character()
-{
-    // See http://www.ietf.org/rfc/rfc2781.txt for details on UTF-16 encoding.
-
-    WCHAR wcCurrentChar = 0;
-    SCOUNT_T nCharacters = m_end - m_cursor + 1;
-    WCHAR wcChar1 = GetRawCharacter();
-
-    if (wcChar1 < 0xd800)
-    {
-        wcCurrentChar = wcChar1;
+        // do not allow \0 anywhere in the string.
+        if (wcCurrentChar == 0)
+        {
+            wcCurrentChar = INVALID_CHARACTER;
+        }
     }
     else
     {
-        // StringLexer is not designed to handle UTF-16 characters beyond the Basic Multilingual Plane,
-        // since it stores all characters in 16-bit WCHARs.
-        // However, since the vast majority of the time, we (Microsoft) produce the manifests,
-        // this is likely a non-scenario, as the other Unicode planes would never be used in practice.
-
-        if (wcChar1 <= 0xdbff) // 0xd800 - 0xdbff indicates the first WCHAR of a surrogate pair
-        {
-            if (nCharacters >= 2)
-            {
-                GetRawCharacter(); // Skip the second WCHAR of the surrogate pair
-            }
-        }
-        // Otherwise, the character is either in the 0xdc00 - 0xdfff range, indicating the second WCHAR of a surrogate pair,
-        // or in the 0xE000 - 0xFFFF range, which has within it ranges of invalid characters, and which we conservatively treat
-        // as invalid.
-
-        wcCurrentChar = INVALID_CHARACTER;
+        // EOS
+        wcCurrentChar = 0;
     }
 
     return wcCurrentChar;
 }
 
-
 WCHAR StringLexer::GetNextCharacter(BOOL *pfIsEscaped)
 {
     *pfIsEscaped = FALSE;
 
-    WCHAR wcCurrentChar = GetRawCharacter(); // DecodeUTF16Character()
+    WCHAR wcCurrentChar = GetRawCharacter();
     if (wcCurrentChar == L'\\')
     {
-        WCHAR wcTempChar = GetRawCharacter(); // DecodeUTF16Character()
+        WCHAR wcTempChar = GetRawCharacter();
 
-        if (m_fSupportEscaping)
-        {
-            // Handle standard escapes
-            switch (wcTempChar)
-            {
-            case L'"':
-            case L'\'':
-            case L',':
-            case L'\\':
-            case L'/':
-            case L'=':
-                break;
-            case L't':
-                wcTempChar = 9;
-                break;
-            case L'n':
-                wcTempChar = 10;
-                break;
-            case L'r':
-                wcTempChar = 13;
-                break;
-            case L'u':
-                wcTempChar = ParseUnicode();
-                break;
-            default:
-                return INVALID_CHARACTER;
-            }
-
-            *pfIsEscaped = TRUE;
-            wcCurrentChar = wcTempChar;
-        }
-        else
-        {
-            // Do not handle escapes except for quotes
-            switch (wcTempChar)
-            {
-            case L'"':
-            case L'\'':
-                *pfIsEscaped = TRUE;
-                wcCurrentChar = wcTempChar;
-                break;
-            default:
-                PushRawCharacter();
-                break;
-            }
-        }
-    }
-
-    return wcCurrentChar;
-}
-
-WCHAR StringLexer::ParseUnicode()
-{
-    int nCharacters = 0;
-    WCHAR wcUnicodeChar = 0;
-
-    for(;;)
-    {
-        WCHAR wcCurrentChar = DecodeUTF16Character();
-        nCharacters++;
-
-        if (wcCurrentChar == L';')
+        // Handle standard escapes
+        switch (wcTempChar)
         {
+        case L'"':
+        case L'\'':
+        case L',':
+        case L'\\':
+        case L'=':
+        case L't':
+        case L'n':
+        case L'r':
             break;
-        }
-        else if ((wcCurrentChar == INVALID_CHARACTER) || (nCharacters >= 9))
-        {
+        default:
             return INVALID_CHARACTER;
         }
 
-        wcUnicodeChar <<= 4;
-
-        if ((wcCurrentChar >= L'0') && (wcCurrentChar <= L'9'))
-        {
-            wcUnicodeChar += (wcCurrentChar - L'0');
-        }
-        else if ((wcCurrentChar >= L'a') && (wcCurrentChar <= L'f'))
-        {
-            wcUnicodeChar += (wcCurrentChar - L'a') + 10;
-        }
-        else if ((wcCurrentChar >= L'A') && (wcCurrentChar <= L'F'))
-        {
-            wcUnicodeChar += (wcCurrentChar - L'A') + 10;
-        }
-        else
-        {
-            return INVALID_CHARACTER;
-        }
+        *pfIsEscaped = TRUE;
+        wcCurrentChar = wcTempChar;
     }
 
-    return wcUnicodeChar;
+    return wcCurrentChar;
 }
 
 #endif

src/coreclr/binder/inc/textualidentityparser.hpp

@@ -28,12 +28,9 @@ namespace BINDER_SPACE
         TextualIdentityParser(AssemblyIdentity *pAssemblyIdentity);
         ~TextualIdentityParser();
 
-        virtual BOOL IsSeparatorChar(WCHAR wcChar);
-        virtual StringLexer::LEXEME_TYPE GetLexemeType(WCHAR wcChar);
-
         static HRESULT Parse(/* in */  SString           &textualIdentity,
-                             /* out */ AssemblyIdentity *pAssemblyIdentity,
-                             /* in */  BOOL              fPermitUnescapedQuotes = FALSE);
+                             /* out */ AssemblyIdentity *pAssemblyIdentity);
+
         static HRESULT ToString(/* in */  AssemblyIdentity *pAssemblyIdentity,
                                 /* in */  DWORD             dwIdentityFlags,
                                 /* out */ SString          &textualIdentity);
@@ -45,15 +42,15 @@ namespace BINDER_SPACE
                               /* in */  BOOL     fValidateHex,
                               /* in */  BOOL     fIsToken,
                               /* out */ SBuffer &publicKeyOrTokenBLOB);
+
         static void BlobToHex(/* in */  SBuffer &publicKeyOrTokenBLOB,
                               /* out */ SString &publicKeyOrToken);
 
         BOOL ParseString(/* in */  SString &textualString,
                          /* out */ SString &contentString);
 
     protected:
-        BOOL Parse(/* in */  SString &textualIdentity,
-                   /* in */  BOOL     fPermitUnescapedQuotes = FALSE);
+        BOOL Parse(/* in */  SString &textualIdentity);
 
         BOOL PopulateAssemblyIdentity(/* in */ SString &attributeString,
                                       /* in */ SString &valueString);

src/coreclr/binder/stringlexer.cpp

@@ -19,7 +19,7 @@
 namespace BINDER_SPACE
 {
     StringLexer::LEXEME_TYPE
-    StringLexer::GetNextLexeme(SString &currentString, BOOL fPermitUnescapedQuotes)
+    StringLexer::GetNextLexeme(SString &currentString)
     {
         BOOL fIsEscaped = FALSE;
         WCHAR wcCurrentChar = INVALID_CHARACTER;
@@ -43,11 +43,11 @@ namespace BINDER_SPACE
 
         // First character of string lexeme; push it back
         PushCharacter(wcCurrentChar, fIsEscaped);
-        return ParseString(currentString, fPermitUnescapedQuotes);
+        return ParseString(currentString);
     }
 
     StringLexer::LEXEME_TYPE
-    StringLexer::ParseString(SString &currentString, BOOL fPermitUnescapedQuotes)
+    StringLexer::ParseString(SString &currentString)
     {
         BOOL fIsFirstCharacter = TRUE;
         WCHAR wcCurrentChar = INVALID_CHARACTER;
@@ -99,7 +99,7 @@ namespace BINDER_SPACE
                 break;
             }
 
-            if (!fPermitUnescapedQuotes && !fIsEscaped && IsQuoteCharacter(wcCurrentChar) && !IsQuoteCharacter(wcOpeningQuote))
+            if (!fIsEscaped && IsQuoteCharacter(wcCurrentChar) && !IsQuoteCharacter(wcOpeningQuote))
             {
                 // Unescaped quotes in the middle of the string are an error
                 return LEXEME_TYPE_INVALID;
@@ -147,4 +147,24 @@ namespace BINDER_SPACE
             currentString.Truncate(cursor + 1);
         }
     }
+
+    BOOL StringLexer::IsSeparatorChar(WCHAR wcChar)
+    {
+        return ((wcChar == W(',')) || (wcChar == W('=')));
+    }
+
+    StringLexer::LEXEME_TYPE StringLexer::GetLexemeType(WCHAR wcChar)
+    {
+        switch (wcChar)
+        {
+        case W('='):
+            return LEXEME_TYPE_EQUALS;
+        case W(','):
+            return LEXEME_TYPE_COMMA;
+        case 0:
+            return LEXEME_TYPE_END_OF_STREAM;
+        default:
+            return LEXEME_TYPE_STRING;
+        }
+    }
 };