Win32 Path API wrappers and minimal coreclr refactor

Author: ramarag

src/ilasm/grammar_after.cpp

@@ -858,23 +858,18 @@ int yylex()
                                 if((parser->wzIncludePath != NULL)
                                  &&(wcschr(wzFile,'\\')==NULL)&&(wcschr(wzFile,':')==NULL))
                                 {
-                                    WCHAR* wzFullName =  new WCHAR[MAX_FILENAME_LENGTH+1];
-                                    if(wzFullName != NULL)
+                                    PathWCharString wzFullName;
+
+                                    WCHAR* pwz;
+                                    DWORD dw = WszSearchPath(parser->wzIncludePath,wzFile,NULL,
+                                                TRUE, wzFullName,&pwz);
+                                    if(dw != 0)
                                     {
-                                        WCHAR* pwz;
-                                        DWORD dw = WszSearchPath(parser->wzIncludePath,wzFile,NULL,
-                                                   MAX_FILENAME_LENGTH+1,wzFullName,&pwz);
-                                        if(dw != 0)
-                                        {
-                                            wzFullName[dw] = 0;
-                                            delete [] wzFile;
-                                            wzFile = wzFullName;
-                                        }
-                                        else
-                                        {
-                                            delete [] wzFullName;
-                                        }
+                                        wzFullName.CloseBuffer(pwz - wzFullName.GetString());
+                                        delete [] wzFile;
+                                        wzFile = wzFullName.ExtractString();
                                     }
+                                    
                                 }
                                 if(PASM->m_fReportProgress)
                                     parser->msg("\nIncluding '%S'\n",wzFile);

src/inc/stackstring.h

@@ -0,0 +1,196 @@
+// Licensed to the .NET Foundation under one or more agreements. 
+// The .NET Foundation licenses this file to you under the MIT license. 
+// See the LICENSE file in the project root for more information. 
+
+
+#ifndef __STACKSTRING_H_
+#define __STACKSTRING_H_
+
+#include "malloc.h"
+
+template <SIZE_T STACKCOUNT, class T>
+class StackString
+{
+private:
+    T m_innerBuffer[STACKCOUNT + 1];
+    T * m_buffer;
+    SIZE_T m_size; // actual allocated size
+    SIZE_T m_count; // actual length of string
+
+    void NullTerminate()
+    {
+        m_buffer[m_count] = 0;
+    }
+
+    void DeleteBuffer()
+    {
+        if (m_innerBuffer != m_buffer)
+            free(m_buffer);
+
+        m_buffer = NULL;
+        return;
+    }
+
+    void ReallocateBuffer(SIZE_T count)
+    {
+        // count is always > STACKCOUNT here.
+        T * newBuffer = (T *)malloc((count + 1) * sizeof(T));
+        if (NULL == newBuffer)
+        {
+            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+
+            DeleteBuffer();
+            m_count = 0;
+
+            return;
+        }
+
+        DeleteBuffer();
+        m_buffer = newBuffer;
+        m_count = count;
+        m_size = count+1;
+
+        return;
+    }
+
+    void Resize(SIZE_T count)
+    {
+        if (NULL == m_buffer)
+        {
+            if (count > STACKCOUNT)
+            {
+                ReallocateBuffer(count);
+            }
+            else
+            {
+                m_size = STACKCOUNT+1;
+                m_buffer = m_innerBuffer;
+                m_count = count;
+            }
+        }
+        else if (m_innerBuffer == m_buffer)
+        {
+            if (count > STACKCOUNT)
+            {
+                ReallocateBuffer(count);
+            }
+            else
+            {
+                m_count = count;
+                m_size = STACKCOUNT+1;
+            }
+        }
+        else
+        {
+            ReallocateBuffer(count);
+        }
+
+        return;
+    }
+
+    StackString(const StackString &s)
+    {
+        Set(s);
+    }
+
+public:
+    StackString()
+        : m_buffer(m_innerBuffer), m_count(0)
+    {
+    }
+
+    BOOL Set(const T * buffer, SIZE_T count)
+    {
+        Resize(count);
+        if (NULL == m_buffer)
+            return FALSE;
+
+        CopyMemory(m_buffer, buffer, (count + 1) * sizeof(T));
+        NullTerminate();
+        return TRUE;
+    }
+
+    BOOL Set(const StackString &s)
+    {
+        return Set(s.m_buffer, s.m_count);
+    }
+
+    SIZE_T GetCount() const
+    {
+        return m_count;
+    }
+
+    SIZE_T GetAllocationCount() const
+    {
+        return m_size;
+    }
+    
+    SIZE_T GetSizeOf() const
+    {
+        return m_size * sizeof(T);
+    }
+
+    CONST T * GetString() const
+    {
+        return (const T *)m_buffer;
+    }
+
+    T * ExtractString() 
+    {
+        T * ret_buffer;
+
+        if (m_innerBuffer != m_buffer)
+        {
+            //it is heap allocated just return the memory
+            ret_buffer = m_buffer;
+            m_buffer = NULL;
+        }
+        else
+        {
+            ret_buffer = (T *)malloc((m_count + 1) * sizeof(T));
+            if (NULL == ret_buffer)
+            {
+                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+                return NULL;
+            }
+            CopyMemory(ret_buffer, m_buffer, (m_count + 1) * sizeof(T));
+            ret_buffer[m_count] = 0;
+        }
+        return ret_buffer;
+    }
+
+    T * OpenStringBuffer(SIZE_T count)
+    {
+        Resize(count);
+        return (T *)m_buffer;
+    }
+
+    void Clear()
+    {
+        m_count = 1;
+        NullTerminate();
+        return;
+    }
+    void CloseBuffer(SIZE_T count)
+    {
+        if (m_count > count)
+            m_count = count;
+
+        NullTerminate();
+        return;
+    }
+    
+    ~StackString()
+    {
+        DeleteBuffer();
+    }
+};
+
+#if _DEBUG
+typedef StackString<32, CHAR> PathCharString;
+typedef StackString<32, WCHAR> PathWCharString; 
+#else
+typedef StackString<260, CHAR> PathCharString;
+typedef StackString<260, WCHAR> PathWCharString; 
+#endif
+#endif