Fix Wvarargs warning in XFA error code.

xfa/fxfa/fm2js/xfa_lexer.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_lexer.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 
@@ skipping 159 matching lines @@
 CXFA_FMToken* CXFA_FMLexer::NextToken() {
   m_pToken.reset(Scan());
   return m_pToken.get();
 }
 
 CXFA_FMToken* CXFA_FMLexer::Scan() {
   uint16_t ch = 0;
   CXFA_FMToken* p = new CXFA_FMToken(m_uCurrentLine);
   if (!XFA_FMDChar::isAvalid(m_ptr)) {
     ch = XFA_FMDChar::get(m_ptr);
-    Error(FMERR_UNSUPPORTED_CHAR, ch);
+    Error(kFMErrUnsupportedChar, ch);
     return p;
   }
   int iRet = 0;
   while (1) {
     if (!XFA_FMDChar::isAvalid(m_ptr)) {
       ch = XFA_FMDChar::get(m_ptr);
-      Error(FMERR_UNSUPPORTED_CHAR, ch);
+      Error(kFMErrUnsupportedChar, ch);
       return p;
     }
     ch = XFA_FMDChar::get(m_ptr);
     switch (ch) {
       case 0:
         p->m_type = TOKeof;
         return p;
       case 0x0A:
         ++m_uCurrentLine;
         p->m_uLinenum = m_uCurrentLine;
@@ skipping 22 matching lines @@
       case '5':
       case '6':
       case '7':
       case '8':
       case '9': {
         p->m_type = TOKnumber;
         const FX_WCHAR* pTemp = 0;
         iRet = Number(p, m_ptr, pTemp);
         m_ptr = pTemp;
         if (iRet) {
-          Error(FMERR_BAD_SUFFIX_NUMBER);
+          Error(kFMErrBadSuffixNumber);
           return p;
         }
       }
         return p;
       case '=':
         XFA_FMDChar::inc(m_ptr);
         if (XFA_FMDChar::isAvalid(m_ptr)) {
           ch = XFA_FMDChar::get(m_ptr);
           if (ch == '=') {
             p->m_type = TOKeq;
             XFA_FMDChar::inc(m_ptr);
             return p;
           } else {
             p->m_type = TOKassign;
             return p;
           }
         } else {
           ch = XFA_FMDChar::get(m_ptr);
-          Error(FMERR_UNSUPPORTED_CHAR, ch);
+          Error(kFMErrUnsupportedChar, ch);
           return p;
         }
         break;
       case '<':
         XFA_FMDChar::inc(m_ptr);
         if (XFA_FMDChar::isAvalid(m_ptr)) {
           ch = XFA_FMDChar::get(m_ptr);
           if (ch == '=') {
             p->m_type = TOKle;
             XFA_FMDChar::inc(m_ptr);
             return p;
           } else if (ch == '>') {
             p->m_type = TOKne;
             XFA_FMDChar::inc(m_ptr);
             return p;
           } else {
             p->m_type = TOKlt;
             return p;
           }
         } else {
           ch = XFA_FMDChar::get(m_ptr);
-          Error(FMERR_UNSUPPORTED_CHAR, ch);
+          Error(kFMErrUnsupportedChar, ch);
           return p;
         }
         break;
       case '>':
         XFA_FMDChar::inc(m_ptr);
         if (XFA_FMDChar::isAvalid(m_ptr)) {
           ch = XFA_FMDChar::get(m_ptr);
           if (ch == '=') {
             p->m_type = TOKge;
             XFA_FMDChar::inc(m_ptr);
             return p;
           } else {
             p->m_type = TOKgt;
             return p;
           }
         } else {
           ch = XFA_FMDChar::get(m_ptr);
-          Error(FMERR_UNSUPPORTED_CHAR, ch);
+          Error(kFMErrUnsupportedChar, ch);
           return p;
         }
         break;
       case ',':
         p->m_type = TOKcomma;
         XFA_FMDChar::inc(m_ptr);
         return p;
       case '(':
         p->m_type = TOKlparen;
         XFA_FMDChar::inc(m_ptr);
@@ skipping 38 matching lines @@
             const FX_WCHAR* pTemp = 0;
             Comment(m_ptr, pTemp);
             m_ptr = pTemp;
             break;
           } else {
             p->m_type = TOKdiv;
             return p;
           }
         } else {
           ch = XFA_FMDChar::get(m_ptr);
-          Error(FMERR_UNSUPPORTED_CHAR, ch);
+          Error(kFMErrUnsupportedChar, ch);
           return p;
         }
         break;
       case '.':
         XFA_FMDChar::inc(m_ptr);
         if (XFA_FMDChar::isAvalid(m_ptr)) {
           ch = XFA_FMDChar::get(m_ptr);
           if (ch == '.') {
             p->m_type = TOKdotdot;
             XFA_FMDChar::inc(m_ptr);
             return p;
           } else if (ch == '*') {
             p->m_type = TOKdotstar;
             XFA_FMDChar::inc(m_ptr);
             return p;
           } else if (ch == '#') {
             p->m_type = TOKdotscream;
             XFA_FMDChar::inc(m_ptr);
             return p;
           } else if (ch <= '9' && ch >= '0') {
             p->m_type = TOKnumber;
             const FX_WCHAR* pTemp = 0;
             XFA_FMDChar::dec(m_ptr);
             iRet = Number(p, m_ptr, pTemp);
             m_ptr = pTemp;
             if (iRet) {
-              Error(FMERR_BAD_SUFFIX_NUMBER);
+              Error(kFMErrBadSuffixNumber);
             }
             return p;
           } else {
             p->m_type = TOKdot;
             return p;
           }
         } else {
           ch = XFA_FMDChar::get(m_ptr);
-          Error(FMERR_UNSUPPORTED_CHAR, ch);
+          Error(kFMErrUnsupportedChar, ch);
           return p;
         }
       case 0x09:
       case 0x0B:
       case 0x0C:
       case 0x20:
         XFA_FMDChar::inc(m_ptr);
         break;
       default: {
         const FX_WCHAR* pTemp = 0;
@@ skipping 28 matching lines @@
                               const FX_WCHAR*& pEnd) {
   const FX_WCHAR* pStart = p;
   uint16_t ch = 0;
   XFA_FMDChar::inc(p);
   ch = XFA_FMDChar::get(p);
   while (ch) {
     if (!XFA_FMDChar::isAvalid(p)) {
       ch = XFA_FMDChar::get(p);
       pEnd = p;
       t->m_wstring = CFX_WideStringC(pStart, (pEnd - pStart));
-      Error(FMERR_UNSUPPORTED_CHAR, ch);
+      Error(kFMErrUnsupportedChar, ch);
       return 1;
     }
     if (ch == '"') {
       XFA_FMDChar::inc(p);
       if (!XFA_FMDChar::isAvalid(p)) {
         ch = XFA_FMDChar::get(p);
         pEnd = p;
         t->m_wstring = CFX_WideStringC(pStart, (pEnd - pStart));
-        Error(FMERR_UNSUPPORTED_CHAR, ch);
+        Error(kFMErrUnsupportedChar, ch);
         return 1;
       }
       ch = XFA_FMDChar::get(p);
       if (ch == '"') {
         goto NEXT;
       } else {
         break;
       }
     }
   NEXT:
     XFA_FMDChar::inc(p);
     ch = XFA_FMDChar::get(p);
   }
   pEnd = p;
   t->m_wstring = CFX_WideStringC(pStart, (pEnd - pStart));
   return 0;
 }
 
 uint32_t CXFA_FMLexer::Identifiers(CXFA_FMToken* t,
                                    const FX_WCHAR* p,
                                    const FX_WCHAR*& pEnd) {
   const FX_WCHAR* pStart = p;
   uint16_t ch = 0;
   ch = XFA_FMDChar::get(p);
   XFA_FMDChar::inc(p);
   if (!XFA_FMDChar::isAvalid(p)) {
     pEnd = p;
     t->m_wstring = CFX_WideStringC(pStart, (pEnd - pStart));
-    Error(FMERR_UNSUPPORTED_CHAR, ch);
+    Error(kFMErrUnsupportedChar, ch);
     return 1;
   }
   ch = XFA_FMDChar::get(p);
   while (ch) {
     if (!XFA_FMDChar::isAvalid(p)) {
       pEnd = p;
       t->m_wstring = CFX_WideStringC(pStart, (pEnd - pStart));
-      Error(FMERR_UNSUPPORTED_CHAR, ch);
+      Error(kFMErrUnsupportedChar, ch);
       return 1;
     }
     ch = XFA_FMDChar::get(p);
     if (XFA_FMDChar::isUnicodeAlpha(ch)) {
       XFA_FMDChar::inc(p);
     } else {
       pEnd = p;
       t->m_wstring = CFX_WideStringC(pStart, (pEnd - pStart));
       return 0;
     }
@@ skipping 35 matching lines @@
     if (uHash == keyword.m_uHash)
       return keyword.m_type;
     if (uHash < keyword.m_uHash)
       iEnd = iMid - 1;
     else
       iStart = iMid + 1;
   } while (iStart <= iEnd);
   return TOKidentifier;
 }
 
-void CXFA_FMLexer::Error(XFA_FM_ERRMSG msg, ...) {
+void CXFA_FMLexer::Error(const FX_WCHAR* msg, ...) {
   m_pErrorInfo->linenum = m_uCurrentLine;
-  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);
 }
 
 FX_BOOL CXFA_FMLexer::HasError() const {
   if (m_pErrorInfo->message.IsEmpty()) {
     return FALSE;
   }
   return TRUE;
 }