Fix Wvarargs warning in XFA error code.

xfa/fxfa/fm2js/xfa_fmparse.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/fm2js/xfa_fmparse.h"
 
 #include <memory>
 
@@ skipping 12 matching lines @@
     if (m_lexer->HasError()) {
       break;
     }
     m_pToken = m_lexer->NextToken();
   }
 }
 
 void CXFA_FMParse::Check(XFA_FM_TOKEN op) {
   if (m_pToken->m_type != op) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
-    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
-          XFA_FM_KeywordToString(op), ws_TempString.c_str());
+    Error(m_pToken->m_uLinenum, kFMErrExpectedToken, XFA_FM_KeywordToString(op),
+          ws_TempString.c_str());
   }
   NextToken();
 }
 
-void CXFA_FMParse::Error(uint32_t lineNum, XFA_FM_ERRMSG msg, ...) {
+void CXFA_FMParse::Error(uint32_t lineNum, const FX_WCHAR* msg, ...) {
   m_pErrorInfo->linenum = lineNum;
-  const FX_WCHAR* lpMessageInfo = XFA_FM_ErrorMsg(msg);
   va_list ap;
   va_start(ap, msg);
-  m_pErrorInfo->message.FormatV(lpMessageInfo, ap);
+  m_pErrorInfo->message.FormatV(msg, ap);
   va_end(ap);
 }
 
 CFX_PtrArray* CXFA_FMParse::ParseTopExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
   CFX_PtrArray* expression = new CFX_PtrArray();
   while (1) {
     if (m_pToken->m_type == TOKeof || m_pToken->m_type == TOKendfunc ||
         m_pToken->m_type == TOKendif || m_pToken->m_type == TOKelseif ||
         m_pToken->m_type == TOKelse || m_pToken->m_type == TOKreserver) {
@@ skipping 21 matching lines @@
 
 CXFA_FMExpression* CXFA_FMParse::ParseFunction() {
   std::unique_ptr<CXFA_FMExpression> e;
   CFX_WideStringC ident;
   std::unique_ptr<CFX_WideStringCArray> pArguments;
   std::unique_ptr<CFX_PtrArray> pExpressions;
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
-    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+    Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
           ws_TempString.c_str());
   } else {
     ident = m_pToken->m_wstring;
     NextToken();
   }
   Check(TOKlparen);
   if (m_pToken->m_type == TOKrparen) {
     NextToken();
   } else {
     pArguments.reset(new CFX_WideStringCArray());
     CFX_WideStringC p;
     while (1) {
       if (m_pToken->m_type == TOKidentifier) {
         p = m_pToken->m_wstring;
         pArguments->Add(p);
         NextToken();
         if (m_pToken->m_type == TOKcomma) {
           NextToken();
           continue;
         } else if (m_pToken->m_type == TOKrparen) {
           NextToken();
           break;
         } else {
           Check(TOKrparen);
           break;
         }
       } else {
         CFX_WideString ws_TempString = m_pToken->m_wstring;
-        Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+        Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
               ws_TempString.c_str());
         NextToken();
         break;
       }
     }
   }
   Check(TOKdo);
   if (m_pToken->m_type == TOKendfunc) {
     NextToken();
   } else {
@@ skipping 49 matching lines @@
     case TOKbreak:
       e.reset(new CXFA_FMBreakExpression(line));
       NextToken();
       break;
     case TOKcontinue:
       e.reset(new CXFA_FMContinueExpression(line));
       NextToken();
       break;
     default:
       CFX_WideString ws_TempString = m_pToken->m_wstring;
-      Error(m_pToken->m_uLinenum, FMERR_UNEXPECTED_EXPRESSION,
+      Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression,
             ws_TempString.c_str());
       NextToken();
       break;
   }
   return e.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseVarExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
   CFX_WideStringC ident;
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
-    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+    Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
           ws_TempString.c_str());
   } else {
     ident = m_pToken->m_wstring;
     NextToken();
   }
   if (m_pToken->m_type == TOKassign) {
     NextToken();
     e.reset(ParseExpExpression());
   }
   if (m_pErrorInfo->message.IsEmpty()) {
@@ skipping 315 matching lines @@
       break;
     case TOKnull:
       e.reset(new CXFA_FMNullExpression(line));
       NextToken();
       break;
     case TOKlparen:
       e.reset(ParseParenExpression());
       break;
     default:
       CFX_WideString ws_TempString = m_pToken->m_wstring;
-      Error(m_pToken->m_uLinenum, FMERR_UNEXPECTED_EXPRESSION,
+      Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression,
             ws_TempString.c_str());
       NextToken();
       break;
   }
   e.reset(ParsePostExpression(e.release()));
   if (!(m_pErrorInfo->message.IsEmpty()))
     e.reset();
   return e.release();
 }
 
@@ skipping 14 matching lines @@
             }
             if (m_pToken->m_type == TOKcomma) {
               NextToken();
             } else if (m_pToken->m_type == TOKeof ||
                        m_pToken->m_type == TOKreserver) {
               break;
             }
           }
           if (m_pToken->m_type != TOKrparen) {
             CFX_WideString ws_TempString = m_pToken->m_wstring;
-            Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
+            Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
                   XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str());
           }
         }
         if (m_pErrorInfo->message.IsEmpty()) {
           e = new CXFA_FMCallExpression(line, e, pArray.release(), FALSE);
           NextToken();
           if (m_pToken->m_type != TOKlbracket) {
             continue;
           }
           CXFA_FMSimpleExpression* s = ParseIndexExpression();
@@ skipping 32 matching lines @@
                 pArray->Add(exp);
                 if (m_pToken->m_type == TOKcomma) {
                   NextToken();
                 } else if (m_pToken->m_type == TOKeof ||
                            m_pToken->m_type == TOKreserver) {
                   break;
                 }
               }
               if (m_pToken->m_type != TOKrparen) {
                 CFX_WideString ws_TempString = m_pToken->m_wstring;
-                Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
+                Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
                       XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str());
               }
             }
             if (m_pErrorInfo->message.IsEmpty()) {
               CXFA_FMSimpleExpression* pIdentifier =
                   new CXFA_FMIdentifierExpressionn(tempLine, tempStr);
               pExpCall = new CXFA_FMCallExpression(line, pIdentifier,
                                                    pArray.release(), TRUE);
               e = new CXFA_FMMethodCallExpression(line, pExpAccessor, pExpCall);
               NextToken();
@@ skipping 27 matching lines @@
             e = new CXFA_FMDotAccessorExpression(tempLine, e, TOKdot, tempStr,
                                                  s.release());
           } else {
             CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression(
                 tempLine, ACCESSOR_NO_INDEX, NULL, FALSE);
             e = new CXFA_FMDotAccessorExpression(line, e, TOKdot, tempStr, s);
             continue;
           }
         } else {
           CFX_WideString ws_TempString = m_pToken->m_wstring;
-          Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+          Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
                 ws_TempString.c_str());
           return e;
         }
         break;
       case TOKdotdot:
         NextToken();
         if (m_pToken->m_type == TOKidentifier) {
           CFX_WideStringC tempStr = m_pToken->m_wstring;
           uint32_t tempLine = m_pToken->m_uLinenum;
           NextToken();
           if (m_pToken->m_type == TOKlbracket) {
             std::unique_ptr<CXFA_FMSimpleExpression> s(ParseIndexExpression());
             if (!(m_pErrorInfo->message.IsEmpty())) {
               delete e;
               return nullptr;
             }
             e = new CXFA_FMDotDotAccessorExpression(tempLine, e, TOKdotdot,
                                                     tempStr, s.release());
           } else {
             CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression(
                 tempLine, ACCESSOR_NO_INDEX, NULL, FALSE);
             e = new CXFA_FMDotDotAccessorExpression(line, e, TOKdotdot, tempStr,
                                                     s);
             continue;
           }
         } else {
           CFX_WideString ws_TempString = m_pToken->m_wstring;
-          Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+          Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
                 ws_TempString.c_str());
           return e;
         }
         break;
       case TOKdotscream:
         NextToken();
         if (m_pToken->m_type == TOKidentifier) {
           CFX_WideStringC tempStr = m_pToken->m_wstring;
           uint32_t tempLine = m_pToken->m_uLinenum;
           NextToken();
           if (m_pToken->m_type == TOKlbracket) {
             std::unique_ptr<CXFA_FMSimpleExpression> s(ParseIndexExpression());
             if (!(m_pErrorInfo->message.IsEmpty())) {
               delete e;
               return nullptr;
             }
             e = new CXFA_FMDotAccessorExpression(tempLine, e, TOKdotscream,
                                                  tempStr, s.release());
           } else {
             CXFA_FMSimpleExpression* s = new CXFA_FMIndexExpression(
                 tempLine, ACCESSOR_NO_INDEX, NULL, FALSE);
             e = new CXFA_FMDotAccessorExpression(line, e, TOKdotscream, tempStr,
                                                  s);
             continue;
           }
         } else {
           CFX_WideString ws_TempString = m_pToken->m_wstring;
-          Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IDENTIFIER,
+          Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
                 ws_TempString.c_str());
           return e;
         }
         break;
       case TOKdotstar: {
         CXFA_FMSimpleExpression* s =
             new CXFA_FMIndexExpression(line, ACCESSOR_NO_INDEX, NULL, FALSE);
         e = new CXFA_FMDotAccessorExpression(line, e, TOKdotstar,
                                              FX_WSTRC(L"*"), s);
       } break;
@@ skipping 10 matching lines @@
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   std::unique_ptr<CXFA_FMSimpleExpression> s;
   XFA_FM_AccessorIndex accessorIndex = ACCESSOR_NO_RELATIVEINDEX;
   if (m_pToken->m_type == TOKmul) {
     pExp.reset(
         new CXFA_FMIndexExpression(line, accessorIndex, s.release(), TRUE));
     NextToken();
     if (m_pToken->m_type != TOKrbracket) {
       CFX_WideString ws_TempString = m_pToken->m_wstring;
-      Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
+      Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
             XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str());
       pExp.reset();
     }
     return pExp.release();
   }
   if (m_pToken->m_type == TOKplus) {
     accessorIndex = ACCESSOR_POSITIVE_INDEX;
     NextToken();
   } else if (m_pToken->m_type == TOKminus) {
     accessorIndex = ACCESSOR_NEGATIVE_INDEX;
     NextToken();
   }
   s.reset(ParseSimpleExpression());
   if (m_pToken->m_type != TOKrbracket) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
-    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
+    Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
           XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str());
   } else {
     pExp.reset(
         new CXFA_FMIndexExpression(line, accessorIndex, s.release(), FALSE));
   }
   return pExp.release();
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseParenExpression() {
   Check(TOKlparen);
 
   if (m_pToken->m_type == TOKrparen) {
-    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_NON_EMPTY_EXPRESSION);
+    Error(m_pToken->m_uLinenum, kFMErrExpectedNonEmptyExpression);
     NextToken();
     return nullptr;
   }
 
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> pExp1(ParseLogicalOrExpression());
 
   while (m_pToken->m_type == TOKassign) {
     NextToken();
     std::unique_ptr<CXFA_FMSimpleExpression> pExp2(ParseLogicalOrExpression());
@@ skipping 86 matching lines @@
     case TOKelseif:
       pElseExpression.reset(ParseIfExpression());
       break;
     case TOKelse:
       NextToken();
       pElseExpression.reset(ParseBlockExpression());
       Check(TOKendif);
       break;
     default:
       CFX_WideString ws_TempString = m_pToken->m_wstring;
-      Error(m_pToken->m_uLinenum, FMERR_EXPECTED_IFEND, ws_TempString.c_str());
+      Error(m_pToken->m_uLinenum, kFMErrExpectedEndIf, ws_TempString.c_str());
       NextToken();
       break;
   }
   std::unique_ptr<CXFA_FMIfExpression> pExp;
   if (m_pErrorInfo->message.IsEmpty()) {
     pExp.reset(new CXFA_FMIfExpression(line, pExpression.release(),
                                        pIfExpression.release(),
                                        pElseExpression.release()));
   }
   return pExp.release();
@@ skipping 15 matching lines @@
 }
 
 CXFA_FMSimpleExpression* CXFA_FMParse::ParseSubassignmentInForExpression() {
   std::unique_ptr<CXFA_FMSimpleExpression> e;
   switch (m_pToken->m_type) {
     case TOKidentifier:
       e.reset(ParseSimpleExpression());
       break;
     default:
       CFX_WideString ws_TempString = m_pToken->m_wstring;
-      Error(m_pToken->m_uLinenum, FMERR_UNEXPECTED_EXPRESSION,
+      Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression,
             ws_TempString.c_str());
       NextToken();
       break;
   }
   return e.release();
 }
 
 CXFA_FMExpression* CXFA_FMParse::ParseForExpression() {
   CFX_WideStringC wsVariant;
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
-    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
+    Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
           XFA_FM_KeywordToString(m_pToken->m_type), ws_TempString.c_str());
   }
   wsVariant = m_pToken->m_wstring;
   NextToken();
   std::unique_ptr<CXFA_FMSimpleExpression> pAssignment;
   if (m_pToken->m_type == TOKassign) {
     NextToken();
     pAssignment.reset(ParseSimpleExpression());
   } else {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
-    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
+    Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
           XFA_FM_KeywordToString(m_pToken->m_type), ws_TempString.c_str());
   }
   int32_t iDirection = 0;
   if (m_pToken->m_type == TOKupto) {
     iDirection = 1;
   } else if (m_pToken->m_type == TOKdownto) {
     iDirection = -1;
   } else {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
-    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN, L"upto or downto",
+    Error(m_pToken->m_uLinenum, kFMErrExpectedToken, L"upto or downto",
           ws_TempString.c_str());
   }
   NextToken();
   std::unique_ptr<CXFA_FMSimpleExpression> pAccessor(ParseSimpleExpression());
   std::unique_ptr<CXFA_FMSimpleExpression> pStep;
   if (m_pToken->m_type == TOKstep) {
     NextToken();
     pStep.reset(ParseSimpleExpression());
   }
   Check(TOKdo);
@@ skipping 10 matching lines @@
 
 CXFA_FMExpression* CXFA_FMParse::ParseForeachExpression() {
   std::unique_ptr<CXFA_FMExpression> e;
   CFX_WideStringC wsIdentifier;
   std::unique_ptr<CFX_PtrArray> pAccessors;
   std::unique_ptr<CXFA_FMExpression> pList;
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
-    Error(m_pToken->m_uLinenum, FMERR_EXPECTED_TOKEN,
+    Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
           XFA_FM_KeywordToString(m_pToken->m_type), ws_TempString.c_str());
   }
   wsIdentifier = m_pToken->m_wstring;
   NextToken();
   Check(TOKin);
   Check(TOKlparen);
   if (m_pToken->m_type == TOKrparen) {
     CFX_WideString ws_TempString = m_pToken->m_wstring;
-    Error(m_pToken->m_uLinenum, FMERR_UNEXPECTED_EXPRESSION,
+    Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression,
           ws_TempString.c_str());
     NextToken();
   } else {
     pAccessors.reset(new CFX_PtrArray());
     while (m_pToken->m_type != TOKrparen) {
       CXFA_FMSimpleExpression* s = ParseSimpleExpression();
       if (s) {
         pAccessors->Add(s);
       }
       if (m_pToken->m_type == TOKcomma) {
@@ skipping 25 matching lines @@
   NextToken();
   e.reset(ParseBlockExpression());
   Check(TOKend);
   if (m_pErrorInfo->message.IsEmpty()) {
     e.reset(new CXFA_FMDoExpression(line, e.release()));
   } else {
     e.reset();
   }
   return e.release();
 }