Convert XFA_ELEMENT to an enum class

xfa/fxfa/parser/xfa_basic_imp.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/parser/xfa_basic_imp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
@@ skipping 90 matching lines @@
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
   return nullptr;
 }
 const XFA_ATTRIBUTEINFO* XFA_GetAttributeByID(XFA_ATTRIBUTE eName) {
   return (eName < g_iXFAAttributeCount) ? (g_XFAAttributeData + eName) : NULL;
 }
 FX_BOOL XFA_GetAttributeDefaultValue(void*& pValue,
-                                     XFA_ELEMENT eElement,
+                                     XFA_Element eElement,
                                      XFA_ATTRIBUTE eAttribute,
                                      XFA_ATTRIBUTETYPE eType,
                                      uint32_t dwPacket) {
   const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
   if (pInfo == NULL) {
     return FALSE;
   }
   if (dwPacket && (dwPacket & pInfo->dwPackets) == 0) {
     return FALSE;
   }
   if (pInfo->eType == eType) {
     pValue = pInfo->pDefValue;
     return TRUE;
   } else if (pInfo->eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pAttr =
         XFA_GetNotsureAttribute(eElement, eAttribute, eType);
     if (pAttr) {
       pValue = pAttr->pValue;
       return TRUE;
     }
   }
   return FALSE;
 }
-XFA_ATTRIBUTEENUM XFA_GetAttributeDefaultValue_Enum(XFA_ELEMENT eElement,
+XFA_ATTRIBUTEENUM XFA_GetAttributeDefaultValue_Enum(XFA_Element eElement,
                                                     XFA_ATTRIBUTE eAttribute,
                                                     uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Enum, dwPacket)) {
     return (XFA_ATTRIBUTEENUM)(uintptr_t)pValue;
   }
   return XFA_ATTRIBUTEENUM_Unknown;
 }
-CFX_WideStringC XFA_GetAttributeDefaultValue_Cdata(XFA_ELEMENT eElement,
+CFX_WideStringC XFA_GetAttributeDefaultValue_Cdata(XFA_Element eElement,
                                                    XFA_ATTRIBUTE eAttribute,
                                                    uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Cdata, dwPacket)) {
     return (const FX_WCHAR*)pValue;
   }
   return NULL;
 }
-FX_BOOL XFA_GetAttributeDefaultValue_Boolean(XFA_ELEMENT eElement,
+FX_BOOL XFA_GetAttributeDefaultValue_Boolean(XFA_Element eElement,
                                              XFA_ATTRIBUTE eAttribute,
                                              uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Boolean, dwPacket)) {
     return (FX_BOOL)(uintptr_t)pValue;
   }
   return FALSE;
 }
 
-CXFA_Measurement XFA_GetAttributeDefaultValue_Measure(XFA_ELEMENT eElement,
+CXFA_Measurement XFA_GetAttributeDefaultValue_Measure(XFA_Element eElement,
                                                       XFA_ATTRIBUTE eAttribute,
                                                       uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Measure, dwPacket)) {
     return *(CXFA_Measurement*)pValue;
   }
   return CXFA_Measurement();
 }
 
 const XFA_ELEMENTINFO* XFA_GetElementByName(const CFX_WideStringC& wsName) {
   if (wsName.IsEmpty())
     return nullptr;
 
   uint32_t uHash = FX_HashCode_GetW(wsName, false);
   int32_t iStart = 0;
   int32_t iEnd = g_iXFAElementCount - 1;
   do {
     int32_t iMid = (iStart + iEnd) / 2;
     const XFA_ELEMENTINFO* pInfo = g_XFAElementData + iMid;
     if (uHash == pInfo->uHash) {
       return pInfo;
     } else if (uHash < pInfo->uHash) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
-  return NULL;
+  return nullptr;
 }
-const XFA_ELEMENTINFO* XFA_GetElementByID(XFA_ELEMENT eName) {
-  return (eName < g_iXFAElementCount) ? (g_XFAElementData + eName) : NULL;
+const XFA_ELEMENTINFO* XFA_GetElementByID(XFA_Element eName) {
+  return eName == XFA_Element::Unknown
+             ? nullptr
+             : g_XFAElementData + static_cast<int32_t>(eName);
 }
 
-const uint8_t* XFA_GetElementAttributes(XFA_ELEMENT eElement, int32_t& iCount) {
-  if (eElement >= g_iXFAElementCount) {
-    return NULL;
-  }
-  const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementAttributeIndex + eElement;
+const uint8_t* XFA_GetElementAttributes(XFA_Element eElement, int32_t& iCount) {
+  if (eElement == XFA_Element::Unknown)
+    return nullptr;
+
+  const XFA_ELEMENTHIERARCHY* pElement =
+      g_XFAElementAttributeIndex + static_cast<int32_t>(eElement);
   iCount = pElement->wCount;
   return g_XFAElementAttributeData + pElement->wStart;
 }
 
-const XFA_ATTRIBUTEINFO* XFA_GetAttributeOfElement(XFA_ELEMENT eElement,
+const XFA_ATTRIBUTEINFO* XFA_GetAttributeOfElement(XFA_Element eElement,
                                                    XFA_ATTRIBUTE eAttribute,
                                                    uint32_t dwPacket) {
   int32_t iCount = 0;
   const uint8_t* pAttr = XFA_GetElementAttributes(eElement, iCount);
   if (!pAttr || iCount < 1)
     return nullptr;
 
   if (!std::binary_search(pAttr, pAttr + iCount, eAttribute))
     return nullptr;
 
   const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
   ASSERT(pInfo);
   if (dwPacket == XFA_XDPPACKET_UNKNOWN)
     return pInfo;
   return (dwPacket & pInfo->dwPackets) ? pInfo : nullptr;
 }
 
-const XFA_PROPERTY* XFA_GetElementProperties(XFA_ELEMENT eElement,
+const XFA_PROPERTY* XFA_GetElementProperties(XFA_Element eElement,
                                              int32_t& iCount) {
-  if (eElement >= g_iXFAElementCount) {
+  if (eElement == XFA_Element::Unknown)
     return NULL;
-  }
-  const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementPropertyIndex + eElement;
+
+  const XFA_ELEMENTHIERARCHY* pElement =
+      g_XFAElementPropertyIndex + static_cast<int32_t>(eElement);
   iCount = pElement->wCount;
   return g_XFAElementPropertyData + pElement->wStart;
 }
-const XFA_PROPERTY* XFA_GetPropertyOfElement(XFA_ELEMENT eElement,
-                                             XFA_ELEMENT eProperty,
+const XFA_PROPERTY* XFA_GetPropertyOfElement(XFA_Element eElement,
+                                             XFA_Element eProperty,
                                              uint32_t dwPacket) {
   int32_t iCount = 0;
   const XFA_PROPERTY* pProperty = XFA_GetElementProperties(eElement, iCount);
   if (pProperty == NULL || iCount < 1) {
     return NULL;
   }
   int32_t iStart = 0, iEnd = iCount - 1, iMid;
   do {
     iMid = (iStart + iEnd) / 2;
-    XFA_ELEMENT eName = (XFA_ELEMENT)pProperty[iMid].eName;
+    XFA_Element eName = pProperty[iMid].eName;
     if (eProperty == eName) {
       break;
     } else if (eProperty < eName) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
   if (iStart > iEnd) {
     return NULL;
   }
   const XFA_ELEMENTINFO* pInfo = XFA_GetElementByID(eProperty);
   ASSERT(pInfo);
   if (dwPacket == XFA_XDPPACKET_UNKNOWN)
     return pProperty + iMid;
   return (dwPacket & pInfo->dwPackets) ? (pProperty + iMid) : NULL;
 }
-const XFA_NOTSUREATTRIBUTE* XFA_GetNotsureAttribute(XFA_ELEMENT eElement,
+const XFA_NOTSUREATTRIBUTE* XFA_GetNotsureAttribute(XFA_Element eElement,
                                                     XFA_ATTRIBUTE eAttribute,
                                                     XFA_ATTRIBUTETYPE eType) {
   int32_t iStart = 0, iEnd = g_iXFANotsureCount - 1;
   do {
     int32_t iMid = (iStart + iEnd) / 2;
     const XFA_NOTSUREATTRIBUTE* pAttr = g_XFANotsureAttributes + iMid;
     if (eElement == pAttr->eElement) {
       if (pAttr->eAttribute == eAttribute) {
         if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType) {
           return pAttr;
@@ skipping 38 matching lines @@
       }
     } else if (eElement < pAttr->eElement) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
   return NULL;
 }
 
-const XFA_METHODINFO* XFA_GetMethodByName(XFA_ELEMENT eElement,
+const XFA_METHODINFO* XFA_GetMethodByName(XFA_Element eElement,
                                           const CFX_WideStringC& wsMethodName) {
   if (wsMethodName.IsEmpty())
     return nullptr;
 
-  int32_t iElementIndex = eElement;
+  int32_t iElementIndex = static_cast<int32_t>(eElement);
   while (iElementIndex != -1) {
     const XFA_SCRIPTHIERARCHY* scriptIndex = g_XFAScriptIndex + iElementIndex;
     int32_t icount = scriptIndex->wMethodCount;
     if (icount == 0) {
       iElementIndex = scriptIndex->wParentIndex;
       continue;
     }
     uint32_t uHash = FX_HashCode_GetW(wsMethodName, false);
     int32_t iStart = scriptIndex->wMethodStart;
     int32_t iEnd = iStart + icount - 1;
     do {
       int32_t iMid = (iStart + iEnd) / 2;
       const XFA_METHODINFO* pInfo = g_SomMethodData + iMid;
       if (uHash == pInfo->uHash) {
         return pInfo;
       } else if (uHash < pInfo->uHash) {
         iEnd = iMid - 1;
       } else {
         iStart = iMid + 1;
       }
     } while (iStart <= iEnd);
     iElementIndex = scriptIndex->wParentIndex;
   }
   return NULL;
 }
 const XFA_SCRIPTATTRIBUTEINFO* XFA_GetScriptAttributeByName(
-    XFA_ELEMENT eElement,
+    XFA_Element eElement,
     const CFX_WideStringC& wsAttributeName) {
   if (wsAttributeName.IsEmpty())
     return nullptr;
 
-  int32_t iElementIndex = eElement;
+  int32_t iElementIndex = static_cast<int32_t>(eElement);
   while (iElementIndex != -1) {
     const XFA_SCRIPTHIERARCHY* scriptIndex = g_XFAScriptIndex + iElementIndex;
     int32_t icount = scriptIndex->wAttributeCount;
     if (icount == 0) {
       iElementIndex = scriptIndex->wParentIndex;
       continue;
     }
     uint32_t uHash = FX_HashCode_GetW(wsAttributeName, false);
     int32_t iStart = scriptIndex->wAttributeStart, iEnd = iStart + icount - 1;
     do {
@@ skipping 215 matching lines @@
   return NULL;
 }
 
 void CXFA_WideTextRead::Lock() {}
 
 void CXFA_WideTextRead::Unlock() {}
 
 CFX_WideString CXFA_WideTextRead::GetSrcText() const {
   return m_wsBuffer;
 }