Get rest of Lib/Parser building

Compile the following files:
    - CharClassifier.cpp
    - CharSet.cpp
    - Parse.cpp
    - RegexParser.cpp
    - RegexPattern.cpp
    - RegexRuntime.cpp
    - Scan.cpp
    - StandardChars.cpp
    - TextbookBoyerMoore.cpp

Get scan.cpp compiling

Couple noteworthy items:
    - added _ltow_s/_ltow to the PAL
    - Exposed ULongMult from the PAL
    - Switched a __try/__finally in Scan.cpp to TryFinally

Author: digitalinfinity

lib/Common/CommonPal.h

@@ -391,3 +391,7 @@ void TryFinally(const TryFunc& tryFunc, const FinallyFunc& finallyFunc)
 
     finallyFunc(hasException);
 }
+
+__inline
+HRESULT ULongMult(ULONG ulMultiplicand, ULONG ulMultiplier, ULONG* pulResult);
+    

lib/Common/DataStructures/ContinuousPageStack.h

@@ -320,8 +320,8 @@ template<class T, const size_t InitialPageCount>
 __inline T &ContinuousPageStackOfFixedElements<T, InitialPageCount>::Iterator::operator *() const
 {
     Assert(*this);
-    Assert(nextTop <= stack.nextTop);
-    return *reinterpret_cast<T *>(&stack.Buffer()[nextTop - sizeof(T)]);
+    Assert(this->nextTop <= stack.nextTop);
+    return *reinterpret_cast<T *>(&stack.Buffer()[this->nextTop - sizeof(T)]);
 }
 
 template<class T, const size_t InitialPageCount>
@@ -334,7 +334,7 @@ template<class T, const size_t InitialPageCount>
 __inline typename ContinuousPageStackOfFixedElements<T, InitialPageCount>::Iterator &ContinuousPageStackOfFixedElements<T, InitialPageCount>::Iterator::operator ++() // pre-increment
 {
     Assert(*this);
-    nextTop -= sizeof(T);
+    this->nextTop -= sizeof(T);
     return *this;
 }
 
@@ -361,31 +361,31 @@ __inline ContinuousPageStackOfFixedElements<T, InitialPageCount>::ContinuousPage
 template<class T, const size_t InitialPageCount>
 __inline char* ContinuousPageStackOfFixedElements<T, InitialPageCount>::Push()
 {
-    return ContinuousPageStack::Push(sizeof(T));
+    return ContinuousPageStack<InitialPageCount>::Push(sizeof(T));
 }
 
 template<class T, const size_t InitialPageCount>
 __inline T* ContinuousPageStackOfFixedElements<T, InitialPageCount>::Top() const
 {
-    return reinterpret_cast<T*>(ContinuousPageStack::Top(sizeof(T)));
+    return reinterpret_cast<T*>(ContinuousPageStack<InitialPageCount>::Top(sizeof(T)));
 }
 
 template<class T, const size_t InitialPageCount>
 __inline T* ContinuousPageStackOfFixedElements<T, InitialPageCount>::Pop()
 {
-    return reinterpret_cast<T*>(ContinuousPageStack::Pop(sizeof(T)));
+    return reinterpret_cast<T*>(ContinuousPageStack<InitialPageCount>::Pop(sizeof(T)));
 }
 
 template<class T, const size_t InitialPageCount>
 __inline void ContinuousPageStackOfFixedElements<T, InitialPageCount>::UnPop()
 {
-    return ContinuousPageStack::UnPop(sizeof(T));
+    return ContinuousPageStack<InitialPageCount>::UnPop(sizeof(T));
 }
 
 template<class T, const size_t InitialPageCount>
 __inline void ContinuousPageStackOfFixedElements<T, InitialPageCount>::PopTo(const size_t position)
 {
-    ContinuousPageStack::PopTo(position);
+    ContinuousPageStack<InitialPageCount>::PopTo(position);
 }
 
 // -----------------------------------------------------------------------------------------------------------------------------
@@ -407,8 +407,8 @@ template<class T, const size_t InitialPageCount>
 __inline T &ContinuousPageStackOfVariableElements<T, InitialPageCount>::Iterator::operator *() const
 {
     Assert(*this);
-    Assert(nextTop <= stack.nextTop);
-    return *reinterpret_cast<T*>(reinterpret_cast<VariableElement *>(&stack.Buffer()[nextTop - topElementSize])->Data());
+    Assert(this->nextTop <= stack.nextTop);
+    return *reinterpret_cast<T*>(reinterpret_cast<VariableElement *>(&stack.Buffer()[this->nextTop - this->topElementSize])->Data());
 }
 
 template<class T, const size_t InitialPageCount>
@@ -421,8 +421,8 @@ template<class T, const size_t InitialPageCount>
 __inline typename ContinuousPageStackOfVariableElements<T, InitialPageCount>::Iterator &ContinuousPageStackOfVariableElements<T, InitialPageCount>::Iterator::operator ++() // pre-increment
 {
     Assert(*this);
-    Assert(nextTop <= stack.nextTop);
-    topElementSize = reinterpret_cast<VariableElement *>(&stack.Buffer()[nextTop -= topElementSize])->PreviousElementSize();
+    Assert(this->nextTop <= stack.nextTop);
+    topElementSize = reinterpret_cast<VariableElement *>(&stack.Buffer()[this->nextTop -= this->topElementSize])->PreviousElementSize();
     return *this;
 }
 
@@ -482,22 +482,23 @@ __inline char* ContinuousPageStackOfVariableElements<T, InitialPageCount>::Push(
 {
     TemplateParameter::SameOrDerivedFrom<ActualT, T>(); // ActualT must be the same type as, or a type derived from, T
     VariableElement *const element =
-        new(ContinuousPageStack::Push(VariableElement::Size<ActualT>())) VariableElement(topElementSize);
-    topElementSize = VariableElement::Size<ActualT>();
+        new(ContinuousPageStack<InitialPageCount>::Push(VariableElement::template
+        Size<ActualT>())) VariableElement(topElementSize);
+    topElementSize = VariableElement::template Size<ActualT>();
     return element->Data();
 }
 
 template<class T, const size_t InitialPageCount>
 __inline T* ContinuousPageStackOfVariableElements<T, InitialPageCount>::Top() const
 {
-    VariableElement* const element = reinterpret_cast<VariableElement*>(ContinuousPageStack::Top(topElementSize));
+    VariableElement* const element = reinterpret_cast<VariableElement*>(ContinuousPageStack<InitialPageCount>::Top(topElementSize));
     return element == 0 ? 0 : reinterpret_cast<T*>(element->Data());
 }
 
 template<class T, const size_t InitialPageCount>
 __inline T* ContinuousPageStackOfVariableElements<T, InitialPageCount>::Pop()
 {
-    VariableElement *const element = reinterpret_cast<VariableElement*>(ContinuousPageStack::Pop(topElementSize));
+    VariableElement *const element = reinterpret_cast<VariableElement*>(ContinuousPageStack<InitialPageCount>::Pop(topElementSize));
     if (element == 0)
         return 0;
     else
@@ -512,19 +513,21 @@ template<class ActualT>
 __inline void ContinuousPageStackOfVariableElements<T, InitialPageCount>::UnPop()
 {
     TemplateParameter::SameOrDerivedFrom<ActualT, T>(); // ActualT must be the same type as, or a type derived from, T
-    ContinuousPageStack::UnPop(VariableElement::Size<ActualT>());
-    Assert(reinterpret_cast<VariableElement*>(ContinuousPageStack::Top(VariableElement::Size<ActualT>()))->PreviousElementSize() == topElementSize);
-    topElementSize = VariableElement::Size<ActualT>();
+    ContinuousPageStack<InitialPageCount>::UnPop(VariableElement::template
+    Size<ActualT>());
+    Assert(reinterpret_cast<VariableElement*>(ContinuousPageStack<InitialPageCount>::Top(VariableElement::template
+    Size<ActualT>()))->PreviousElementSize() == topElementSize);
+    topElementSize = VariableElement::template Size<ActualT>();
 }
 
 template<class T, const size_t InitialPageCount>
 __inline void ContinuousPageStackOfVariableElements<T, InitialPageCount>::PopTo(const size_t position)
 {
-    Assert(position <= nextTop);
-    if(position != nextTop)
+    Assert(position <= this->nextTop);
+    if(position != this->nextTop)
     {
-        Assert(position + sizeof(VariableElement) <= nextTop);
-        topElementSize = reinterpret_cast<VariableElement *>(&Buffer()[position])->PreviousElementSize();
+        Assert(position + sizeof(VariableElement) <= this->nextTop);
+        topElementSize = reinterpret_cast<VariableElement *>(&this->Buffer()[position])->PreviousElementSize();
     }
-    ContinuousPageStack::PopTo(position);
+    ContinuousPageStack<InitialPageCount>::PopTo(position);
 }

lib/Parser/CMakeLists.txt

@@ -2,22 +2,22 @@ add_library (Chakra.Parser
     Alloc.cpp
     BackgroundParser.cpp
     CaseInsensitive.cpp
-    # CharClassifier.cpp
-    # CharSet.cpp
+    CharClassifier.cpp
+    CharSet.cpp
     CharTrie.cpp
     DebugWriter.cpp
     Hash.cpp
     OctoquadIdentifier.cpp
-    # Parse.cpp
+    Parse.cpp
     ParserPch.cpp
     RegexCompileTime.cpp
-    # RegexParser.cpp
-    # RegexPattern.cpp
-    # RegexRuntime.cpp
+    RegexParser.cpp
+    RegexPattern.cpp
+    RegexRuntime.cpp
     RegexStats.cpp
-    # Scan.cpp
-    # StandardChars.cpp
-    # TextbookBoyerMoore.cpp
+    Scan.cpp
+    StandardChars.cpp
+    TextbookBoyerMoore.cpp
     cmperr.cpp
     errstr.cpp
     globals.cpp

lib/Parser/CharMap.h

@@ -177,7 +177,7 @@ namespace UnifiedRegex
                 {
                     if (v == defv)
                         return;
-                    children[i] = For(allocator, level, defv);
+                    children[i] = Node::For(allocator, level, defv);
                 }
                 children[i]->Set(allocator, defv, level, k, v);
             }

lib/Parser/Parse.cpp

@@ -7254,7 +7254,7 @@ ParseNodePtr Parser::ParseStringTemplateDecl(ParseNodePtr pnodeTagFnc)
 
         // We are not able to pass more than a ushort worth of arguments to the tag
         // so use that as a logical limit on the number of string constant pieces.
-        if (stringConstantCount >= USHORT_MAX)
+        if (stringConstantCount >= USHRT_MAX)
         {
             Error(ERRnoMemory);
         }
@@ -7802,7 +7802,7 @@ LPCOLESTR Parser::AppendNameHints(LPCOLESTR left, IdentPtr right, ulong *pNameLe
 
     Assert(leftLen <= ULONG_MAX); // name hints should not exceed ULONG_MAX characters
 
-    if (left == nullptr || leftLen == 0 && !wrapInBrackets)
+    if (left == nullptr || (leftLen == 0 && !wrapInBrackets))
     {
         if (right != nullptr)
         {
@@ -8498,11 +8498,11 @@ PidRefStack* Parser::PushPidRef(IdentPtr pid)
     Assert(GetCurrentBlock() != nullptr);
     AssertMsg(pid != nullptr, "PID should be created");
     PidRefStack *ref = pid->GetTopRef();
-    if (!ref || (ref->GetScopeId() < GetCurrentBlock()->sxBlock.blockId)
+    if (!ref || ((ref->GetScopeId() < GetCurrentBlock()->sxBlock.blockId)
                 // We could have the ref from the parameter scope if it is merged with body scope. In that case we can skip creating a new one.
                 && !(m_currentBlockInfo->pBlockInfoOuter->pnodeBlock->sxBlock.blockId == ref->GetScopeId()
                     && m_currentBlockInfo->pBlockInfoOuter->pnodeBlock->sxBlock.blockType == PnodeBlockType::Parameter
-                    && m_currentBlockInfo->pBlockInfoOuter->pnodeBlock->sxBlock.scope->GetCanMergeWithBodyScope()))
+                    && m_currentBlockInfo->pBlockInfoOuter->pnodeBlock->sxBlock.scope->GetCanMergeWithBodyScope())))
     {
         ref = Anew(&m_nodeAllocator, PidRefStack);
         if (ref == nullptr)
@@ -10137,7 +10137,7 @@ ParseNodePtr Parser::ParseStatement()
             pCatch->sxCatch.pnodeNext = nullptr;
 
             // create a fake name for the catch var.
-            WCHAR *uniqueNameStr = _u("__ehobj");
+            const WCHAR *uniqueNameStr = _u("__ehobj");
             IdentPtr uniqueName = m_phtbl->PidHashNameLen(uniqueNameStr, static_cast<long>(wcslen(uniqueNameStr)));
 
             pCatch->sxCatch.pnodeParam = CreateNameNode(uniqueName);
@@ -10868,7 +10868,7 @@ ParseNodePtr Parser::Parse(LPCUTF8 pszSrc, size_t offset, size_t length, charcou
 
     m_scriptContext->AddSourceSize(m_length);
 
-    if(!m_parseType != ParseType_Deferred)
+    if (m_parseType != ParseType_Deferred)
     {
         JS_ETW(EventWriteJSCRIPT_PARSE_METHOD_STOP(m_sourceContextInfo->dwHostSourceContext, GetScriptContext(), pnodeProg->sxFnc.functionId, *m_pCurrentAstSize, false, Js::Constants::GlobalFunction));
     }
@@ -11656,7 +11656,7 @@ inline bool Parser::IsNaNOrInfinityLiteral(LPCOLESTR str)
     return str &&
            (wcscmp(_u("NaN"), str) == 0 ||
            wcscmp(_u("Infinity"), str) == 0 ||
-           CheckForNegativeInfinity && wcscmp(_u("-Infinity"), str) == 0);
+               (CheckForNegativeInfinity && wcscmp(_u("-Infinity"), str) == 0));
 }
 
 template <bool buildAST>

lib/Parser/RegexParser.cpp

@@ -149,7 +149,7 @@ namespace UnifiedRegex
         , deferredIfUnicodeError(nullptr)
     {
         if (isFromExternalSource)
-            FromExternalSource();
+            this->FromExternalSource();
     }
 
     //
@@ -163,15 +163,15 @@ namespace UnifiedRegex
         this->inputLim = inputLim;
         next = input;
         this->inBody = inBody;
-        RestoreMultiUnits(0);
+        this->RestoreMultiUnits(0);
     }
 
     template <typename P, const bool IsLiteral>
     inline CharCount Parser<P, IsLiteral>::Pos()
     {
         CharCount nextOffset = Chars<EncodedChar>::OSB(next, input);
-        Assert(nextOffset >= m_cMultiUnits);
-        return nextOffset - (CharCount)m_cMultiUnits;
+        Assert(nextOffset >= this->m_cMultiUnits);
+        return nextOffset - (CharCount) this->m_cMultiUnits;
     }
 
     template <typename P, const bool IsLiteral>
@@ -208,7 +208,7 @@ namespace UnifiedRegex
         Assert(next + n <= inputLim);
 #if DBG
         for (CharCount i = 0; i < n; i++)
-            Assert(!IsMultiUnitChar(next[i]));
+            Assert(!this->IsMultiUnitChar(next[i]));
 #endif
         next += n;
     }
@@ -342,7 +342,7 @@ namespace UnifiedRegex
             // while the bottom is used during Pass 1 (which isn't done when ParseNoAST)
             if(this->ctAllocator != nullptr)
             {
-                SurrogatePairTracker* node = Anew(this->ctAllocator, SurrogatePairTracker, location, this->tempLocationOfRange, codePoint, consumptionLength, m_cMultiUnits);
+                SurrogatePairTracker* node = Anew(this->ctAllocator, SurrogatePairTracker, location, this->tempLocationOfRange, codePoint, consumptionLength, this->m_cMultiUnits);
                 if (surrogatePairList == nullptr)
                 {
                     Assert(currentSurrogatePairNode == nullptr);
@@ -600,7 +600,7 @@ namespace UnifiedRegex
     {
         Assert(!IsEOF());
         // Could be an embedded 0
-        Char c = ReadFull<true>(next, inputLim);
+        Char c = this->template ReadFull<true>(next, inputLim);
         // No embedded newlines in literals
         if (IsLiteral && standardChars->IsNewline(c))
             Fail(ERRnoSlash);
@@ -1577,7 +1577,8 @@ namespace UnifiedRegex
                     digits++;
                 }
                 while (digits < 5 && ECCanConsume(digits + 1) && standardEncodedChars->IsDigit(ECLookahead(digits)));
-                if (n >= numGroups || ECCanConsume(digits + 1) && standardEncodedChars->IsDigit(ECLookahead(digits)))
+                if (n >= numGroups ||
+                    (ECCanConsume(digits + 1) && standardEncodedChars->IsDigit(ECLookahead(digits))))
                 {
                     if (standardEncodedChars->IsOctal(ECLookahead()))
                     {
@@ -1816,7 +1817,7 @@ namespace UnifiedRegex
 
             Assert(ECCanConsume(this->currentSurrogatePairNode->length));
             ECConsumeMultiUnit(this->currentSurrogatePairNode->length);
-            RestoreMultiUnits(this->currentSurrogatePairNode->multiUnits);
+            this->RestoreMultiUnits(this->currentSurrogatePairNode->multiUnits);
             this->currentSurrogatePairNode = this->currentSurrogatePairNode->next;
 
             return true;
@@ -2076,7 +2077,7 @@ namespace UnifiedRegex
                 pendingCodePoint = this->currentSurrogatePairNode->value;
                 Assert(ECCanConsume(this->currentSurrogatePairNode->length));
                 ECConsumeMultiUnit(this->currentSurrogatePairNode->length);
-                RestoreMultiUnits(this->currentSurrogatePairNode->multiUnits);
+                this->RestoreMultiUnits(this->currentSurrogatePairNode->multiUnits);
                 this->currentSurrogatePairNode = this->currentSurrogatePairNode->next;
             }
             else if (nextChar == '\\')
@@ -2948,7 +2949,7 @@ namespace UnifiedRegex
     {
         Assert(program->source == 0);
 
-        program->source = _u("");
+        program->source = const_cast<Char*>(_u(""));
         program->sourceLen = 0;
 
         program->numGroups = 1;
@@ -2965,7 +2966,7 @@ namespace UnifiedRegex
         // Program will own source string
         program->source = RecyclerNewArrayLeaf(recycler, Char, bodyChars + 1);
         // Don't need to zero out since we're writing to the buffer right here
-        ConvertToUnicode(program->source, bodyChars, body);
+        this->ConvertToUnicode(program->source, bodyChars, body);
         program->source[bodyChars] = 0;
         program->sourceLen = bodyChars;
 
@@ -3079,8 +3080,8 @@ namespace UnifiedRegex
         p.ParseDynamic(0, 0, 0, 0, f);
         p.ParseLiteral(0, 0, a, b, c, d, f);
         p.ParseLiteralNoAST(0, 0, a, b, c, d);
-        p.CompileProgram<true>(0, cp, a, b, c, f);
-        p.CompileProgram<false>(0, cp, a, b, c, f);
+        p.template CompileProgram<true>(0, cp, a, b, c, f);
+        p.template CompileProgram<false>(0, cp, a, b, c, f);
         p.CaptureEmptySourceAndNoGroups(0);
         p.CaptureSourceAndGroups(0, 0, 0, 0);
         p.FreeBody();