FX_BOOL considered harmful.

fpdfsdk/src/javascript/PublicMethods.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 "../../include/javascript/JavaScript.h"
 #include "../../include/javascript/IJavaScript.h"
 #include "../../include/javascript/JS_Define.h"
 #include "../../include/javascript/JS_Object.h"
@@ skipping 54 matching lines @@
 static const FX_WCHAR* months[] =
 {
         L"Jan", L"Feb", L"Mar", L"Apr", L"May", L"Jun", L"Jul", L"Aug", L"Sep", L"Oct", L"Nov", L"Dec"
 };
 
 static const FX_WCHAR* fullmonths[] =
 {
         L"January", L"February", L"March", L"April", L"May", L"June", L"July", L"August", L"September", L"October", L"November", L"December"
 };
 
-FX_BOOL CJS_PublicMethods::IsNumber(const FX_WCHAR* string)
+bool CJS_PublicMethods::IsNumber(const FX_WCHAR* string)
 {
         CFX_WideString sTrim = StrTrim(string);
         const FX_WCHAR* pTrim = sTrim.c_str();
         const FX_WCHAR* p = pTrim;
 
 
-        FX_BOOL bDot = FALSE;
-        FX_BOOL bKXJS = FALSE;
+        bool bDot = false;
+        bool bKXJS = false;
 
         wchar_t c;
         while ((c = *p))
         {
                 if (c == '.' || c == ',')
                 {
-                        if (bDot) return FALSE;
-                        bDot = TRUE;
+                        if (bDot) return false;
+                        bDot = true;
                 }
                 else if (c == '-' || c == '+')
                 {
                         if (p != pTrim)
-                                return FALSE;
+                                return false;
                 }
                 else if (c == 'e' || c == 'E')
                 {
-                        if (bKXJS) return FALSE;
+                        if (bKXJS) return false;
 
                         p++;
                         c = *p;
                         if (c == '+' || c == '-')
                         {
-                                bKXJS = TRUE;
+                                bKXJS = true;
                         }
                         else
                         {
-                                return FALSE;
+                                return false;
                         }
                 }
                 else if (!IsDigit(c))
                 {
-                        return FALSE;
+                        return false;
                 }
                 p++;
         }
 
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CJS_PublicMethods::IsDigit(wchar_t ch)
+bool CJS_PublicMethods::IsDigit(wchar_t ch)
 {
         return (ch >= L'0' && ch <= L'9');
 }
 
-FX_BOOL CJS_PublicMethods::IsDigit(char ch)
+bool CJS_PublicMethods::IsDigit(char ch)
 {
         return (ch >= '0' && ch <= '9');
 }
 
-FX_BOOL CJS_PublicMethods::IsAlphabetic(wchar_t ch)
+bool CJS_PublicMethods::IsAlphabetic(wchar_t ch)
 {
         return ((ch >= L'a' && ch <= L'z') || (ch >= L'A' && ch <= L'Z'));
 }
 
-FX_BOOL CJS_PublicMethods::IsAlphaNumeric(wchar_t ch)
+bool CJS_PublicMethods::IsAlphaNumeric(wchar_t ch)
 {
         return (IsDigit(ch) || IsAlphabetic(ch));
 }
 
-FX_BOOL CJS_PublicMethods::maskSatisfied(wchar_t c_Change,wchar_t c_Mask)
+bool CJS_PublicMethods::maskSatisfied(wchar_t c_Change,wchar_t c_Mask)
 {
         switch (c_Mask)
         {
         case L'9':
         return IsDigit(c_Change);
     case L'A':
         return IsAlphabetic(c_Change);
     case L'O':
         return IsAlphaNumeric(c_Change);
     case L'X':
-        return TRUE;
+        return true;
         default:
         return (c_Change == c_Mask);
         }
 }
 
-FX_BOOL CJS_PublicMethods::isReservedMaskChar(wchar_t ch)
+bool CJS_PublicMethods::isReservedMaskChar(wchar_t ch)
 {
         return ch == L'9' || ch == L'A' || ch == L'O' || ch == L'X';
 }
 
 double CJS_PublicMethods::AF_Simple(const FX_WCHAR* sFuction, double dValue1, double dValue2)
 {
         if (FXSYS_wcsicmp(sFuction,L"AVG") == 0 || FXSYS_wcsicmp(sFuction,L"SUM") == 0)
         {
                 return dValue1 + dValue2;
         }
@@ skipping 48 matching lines @@
         while (p > pStr && *(p - 1) == L' ') p--;
 
         return CFX_ByteString(pStr,p-pStr);
 }
 
 CFX_ByteString CJS_PublicMethods::StrTrim(const FX_CHAR* pStr)
 {
         return StrRTrim(StrLTrim(pStr));
 }
 
-double CJS_PublicMethods::ParseNumber(const FX_WCHAR* swSource, FX_BOOL& bAllDigits, FX_BOOL& bDot, FX_BOOL& bSign, FX_BOOL& bKXJS)
+double CJS_PublicMethods::ParseNumber(const FX_WCHAR* swSource, bool& bAllDigits, bool& bDot, bool& bSign, bool& bKXJS)
 {
-        bDot = FALSE;
-        bSign = FALSE;
-        bKXJS = FALSE;
+        bDot = false;
+        bSign = false;
+        bKXJS = false;
 
-        FX_BOOL bDigitExist = FALSE;
+        bool bDigitExist = false;
 
         const FX_WCHAR* p = swSource;
         wchar_t c;
 
         const FX_WCHAR* pStart = NULL;
         const FX_WCHAR* pEnd = NULL;
 
         while ((c = *p))
         {
                 if (!pStart && c != L' ')
                 {
                         pStart = p;
                 }
 
                 pEnd = p;
                 p++;
         }
 
         if (!pStart)
         {
-                bAllDigits = FALSE;
+                bAllDigits = false;
                 return 0;
         }
 
         while (pEnd != pStart)
         {
                 if (*pEnd == L' ')
                         pEnd --;
                 else
                         break;
         }
 
         double dRet = 0;
         p = pStart;
-        bAllDigits = TRUE;
+        bAllDigits = true;
         CFX_WideString swDigits;
 
         while (p <= pEnd)
         {
                 c = *p;
 
                 if (IsDigit(c))
                 {
                         swDigits += c;
-                        bDigitExist = TRUE;
+                        bDigitExist = true;
                 }
                 else
                 {
                         switch (c)
                         {
                         case L' ':
-                                bAllDigits = FALSE;
+                                bAllDigits = false;
                                 break;
                         case L'.':
                         case L',':
                                 if (!bDot)
                                 {
                                         if (bDigitExist)
                                         {
                                                 swDigits += L'.';
                                         }
                                         else
                                         {
                                                 swDigits += L'0';
                                                 swDigits += L'.';
-                                                bDigitExist = TRUE;
+                                                bDigitExist = true;
                                         }
 
-                                        bDot = TRUE;
+                                        bDot = true;
                                         break;
                                 }
                         case 'e':
                         case 'E':
                                 if (!bKXJS)
                                 {
                                         p++;
                                         c = *p;
                                         if (c == '+' || c == '-')
                                         {
-                                                bKXJS = TRUE;
+                                                bKXJS = true;
                                                 swDigits += 'e';
                                                 swDigits += c;
                                         }
                                         break;
                                 }
                         case L'-':
                                 if (!bDigitExist && !bSign)
                                 {
                                         swDigits += c;
-                                        bSign = TRUE;
+                                        bSign = true;
                                         break;
                                 }
                         default:
-                                bAllDigits = FALSE;
+                                bAllDigits = false;
 
                                 if (p != pStart && !bDot && bDigitExist)
                                 {
                                         swDigits += L'.';
-                                        bDot = TRUE;
+                                        bDot = true;
                                 }
                                 else
                                 {
-                                        bDot = FALSE;
-                                        bDigitExist = FALSE;
+                                        bDot = false;
+                                        bDigitExist = false;
                                         swDigits = L"";
                                 }
                                 break;
                         }
                 }
 
                 p++;
         }
 
         if (swDigits.GetLength() > 0 && swDigits.GetLength() < 17)
@@ skipping 17 matching lines @@
                         }
                 }
 
         }
 
         return dRet;
 }
 
 double CJS_PublicMethods::ParseStringToNumber(const FX_WCHAR* swSource)
 {
-        FX_BOOL bAllDigits = FALSE;
-        FX_BOOL bDot = FALSE;
-        FX_BOOL bSign = FALSE;
-        FX_BOOL bKXJS = FALSE;
+        bool bAllDigits = false;
+        bool bDot = false;
+        bool bSign = false;
+        bool bKXJS = false;
 
         return ParseNumber(swSource, bAllDigits, bDot, bSign, bKXJS);
 }
 
-FX_BOOL CJS_PublicMethods::ConvertStringToNumber(const FX_WCHAR* swSource, double & dRet, FX_BOOL & bDot)
+bool    CJS_PublicMethods::ConvertStringToNumber(const FX_WCHAR* swSource, double & dRet, bool & bDot)
 {
-        FX_BOOL bAllDigits = FALSE;
-        FX_BOOL bSign = FALSE;
-        FX_BOOL bKXJS = FALSE;
+        bool bAllDigits = false;
+        bool bSign = false;
+        bool bKXJS = false;
 
         dRet = ParseNumber(swSource, bAllDigits, bDot, bSign, bKXJS);
 
         return bAllDigits;
 }
 
 CJS_Array CJS_PublicMethods::AF_MakeArrayFromList(v8::Isolate* isolate, CJS_Value val)
 {
         CJS_Array StrArray(isolate);
         if(val.IsArrayObject())
@@ skipping 70 matching lines @@
                         swRet += c;
                         nSkip = i - nStart + 1;
                 }
                 else
                         break;
         }
 
         return swRet;
 }
 
-double CJS_PublicMethods::ParseNormalDate(const CFX_WideString & value, FX_BOOL& bWrongFormat)
+double CJS_PublicMethods::ParseNormalDate(const CFX_WideString & value, bool& bWrongFormat)
 {
         double dt = JS_GetDateTime();
 
         int nYear = JS_GetYearFromTime(dt);
         int nMonth = JS_GetMonthFromTime(dt) + 1;
         int nDay = JS_GetDayFromTime(dt);
         int nHour = JS_GetHourFromTime(dt);
         int nMin = JS_GetMinFromTime(dt);
         int nSec = JS_GetSecFromTime(dt);
 
@@ skipping 27 matching lines @@
                 {
                         nMonth = number[0];
                         nDay = number[1];
                 }
                 else if ((number[0] >= 1 && number[0] <= 31) && (number[1] >= 1 && number[1] <= 12))
                 {
                         nDay = number[0];
                         nMonth = number[1];
                 }
 
-                bWrongFormat = FALSE;
+                bWrongFormat = false;
         }
         else if (nIndex == 3)
         {
                 // case1: year/month/day
                 // case2: month/day/year
                 // case3: day/month/year
 
                 if (number[0] > 12 && (number[1] >= 1 && number[1] <= 12) && (number[2] >= 1 && number[2] <= 31))
                 {
                         nYear = number[0];
                         nMonth = number[1];
                         nDay = number[2];
                 }
                 else if ((number[0] >= 1 && number[0] <= 12) && (number[1] >= 1 && number[1] <= 31) && number[2] > 31)
                 {
                         nMonth = number[0];
                         nDay = number[1];
                         nYear = number[2];
                 }
                 else if ((number[0] >= 1 && number[0] <= 31) && (number[1] >= 1 && number[1] <= 12) && number[2] > 31)
                 {
                         nDay = number[0];
                         nMonth = number[1];
                         nYear = number[2];
                 }
 
-                bWrongFormat = FALSE;
+                bWrongFormat = false;
         }
         else
         {
-                bWrongFormat = TRUE;
+                bWrongFormat = true;
                 return dt;
         }
 
         CFX_WideString swTemp;
         swTemp.Format(L"%d/%d/%d %d:%d:%d",nMonth,nDay,nYear,nHour,nMin,nSec);
         return JS_DateParse(swTemp.c_str());
 }
 
-double CJS_PublicMethods::MakeRegularDate(const CFX_WideString & value, const CFX_WideString & format, FX_BOOL& bWrongFormat)
+double CJS_PublicMethods::MakeRegularDate(const CFX_WideString & value, const CFX_WideString & format, bool& bWrongFormat)
 {
         double dt = JS_GetDateTime();
 
         if (format.IsEmpty() || value.IsEmpty())
                 return dt;
 
         int nYear = JS_GetYearFromTime(dt);
         int nMonth = JS_GetMonthFromTime(dt) + 1;
         int nDay = JS_GetDayFromTime(dt);
         int nHour = JS_GetHourFromTime(dt);
         int nMin = JS_GetMinFromTime(dt);
         int nSec = JS_GetSecFromTime(dt);
 
         int nYearSub = 99; //nYear - 2000;
 
-        FX_BOOL bPm = FALSE;
-        FX_BOOL bExit = FALSE;
-        bWrongFormat = FALSE;
+        bool bPm = false;
+        bool bExit = false;
+        bWrongFormat = false;
 
         int i=0;
         int j=0;
 
         while (i < format.GetLength())
         {
                 if (bExit) break;
 
                 FX_WCHAR c = format.GetAt(i);
                 switch (c)
@@ skipping 111 matching lines @@
                                                                 break;
                                                 }
                                         }
                                         else if (remaining == 2 || format.GetAt(i+3) != c)
                                         {
                                                 switch (c)
                                                 {
                                                         case 'm':
                                                                 {
                                                                         CFX_WideString sMonth = ParseStringString(value, j, nSkip);
-                                                                        FX_BOOL bFind = FALSE;
+                                                                        bool bFind = false;
                                                                         for (int m = 0; m < 12; m++)
                                                                         {
                                                                                 if (sMonth.CompareNoCase(months[m]) == 0)
                                                                                 {
                                                                                         nMonth = m + 1;
                                                                                         i+=3;
                                                                                         j+=nSkip;
-                                                                                        bFind = TRUE;
+                                                                                        bFind = true;
                                                                                         break;
                                                                                 }
                                                                         }
 
                                                                         if (!bFind)
                                                                         {
                                                                                 nMonth = ParseStringInteger(value, j, nSkip, 3);
                                                                                 i+=3;
                                                                                 j += nSkip;
                                                                         }
@@ skipping 13 matching lines @@
                                                 {
 
 
                                                         case 'y':
                                                                 nYear = ParseStringInteger(value, j, nSkip, 4);
                                                                 j += nSkip;
                                                                 i += 4;
                                                                 break;
                                                         case 'm':
                                                                 {
-                                                                        FX_BOOL bFind = FALSE;
+                                                                        bool bFind = false;
 
                                                                         CFX_WideString sMonth = ParseStringString(value, j, nSkip);
                                                                         sMonth.MakeLower();
 
                                                                         for (int m = 0; m < 12; m++)
                                                                         {
                                                                                 CFX_WideString sFullMonths = fullmonths[m];
                                                                                 sFullMonths.MakeLower();
 
                                                                                 if (sFullMonths.Find(sMonth.c_str(), 0) != -1)
                                                                                 {
                                                                                         nMonth = m + 1;
                                                                                         i += 4;
                                                                                         j += nSkip;
-                                                                                        bFind = TRUE;
+                                                                                        bFind = true;
                                                                                         break;
                                                                                 }
                                                                         }
 
                                                                         if (!bFind)
                                                                         {
                                                                                 nMonth = ParseStringInteger(value, j, nSkip, 4);
                                                                                 i+=4;
                                                                                 j += nSkip;
                                                                         }
                                                                 }
                                                                 break;
                                                         default:
                                                                 i += 4;
                                                                 j += 4;
                                                                 break;
                                                 }
                                         }
                                         else
                                         {
                                                 if (j >= value.GetLength() || format.GetAt(i) != value.GetAt(j))
                                                 {
-                                                        bWrongFormat = TRUE;
-                                                        bExit = TRUE;
+                                                        bWrongFormat = true;
+                                                        bExit = true;
                                                 }
                                                 i++;
                                                 j++;
                                         }
 
                                         if (oldj == j)
                                         {
-                                                bWrongFormat = TRUE;
-                                                bExit = TRUE;
+                                                bWrongFormat = true;
+                                                bExit = true;
                                         }
                                 }
 
                                 break;
                         default:
                                 if (value.GetLength() <= j)
                                 {
-                                        bExit = TRUE;
+                                        bExit = true;
                                 }
                                 else if (format.GetAt(i) != value.GetAt(j))
                                 {
-                                        bWrongFormat = TRUE;
-                                        bExit = TRUE;
+                                        bWrongFormat = true;
+                                        bExit = true;
                                 }
 
                                 i++;
                                 j++;
                                 break;
                 }
         }
 
         if (bPm) nHour += 12;
 
         if (nYear >= 0 && nYear <= nYearSub)
                 nYear += 2000;
 
         if (nMonth < 1 || nMonth > 12)
-                bWrongFormat = TRUE;
+                bWrongFormat = true;
 
         if (nDay < 1 || nDay > 31)
-                bWrongFormat = TRUE;
+                bWrongFormat = true;
 
         if (nHour < 0 || nHour > 24)
-                bWrongFormat = TRUE;
+                bWrongFormat = true;
 
         if (nMin < 0 || nMin > 60)
-                bWrongFormat = TRUE;
+                bWrongFormat = true;
 
         if (nSec < 0 || nSec > 60)
-                bWrongFormat = TRUE;
+                bWrongFormat = true;
 
         double dRet = 0;
 
         if (bWrongFormat)
         {
                 dRet = ParseNormalDate(value, bWrongFormat);
         }
         else
         {
                 dRet = JS_MakeDate(JS_MakeDay(nYear,nMonth - 1,nDay),JS_MakeTime(nHour, nMin, nSec, 0));
@@ skipping 155 matching lines @@
 
                 sRet += sPart;
         }
 
         return sRet;
 }
 
 /* -------------------------------------------------------------------------- */
 
 //function AFNumber_Format(nDec, sepStyle, negStyle, currStyle, strCurrency, bCurrencyPrepend)
-FX_BOOL CJS_PublicMethods::AFNumber_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFNumber_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
 #if _FX_OS_ != _FX_ANDROID_
         v8::Isolate* isolate = ::GetIsolate(cc);
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
         CJS_EventHandler* pEvent = pContext->GetEventHandler();
         ASSERT(pEvent != NULL);
 
         if (params.size() != 6)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
         if(!pEvent->m_pValue)
-                return FALSE;
+                return false;
         CFX_WideString& Value = pEvent->Value();
         CFX_ByteString strValue = StrTrim(CFX_ByteString::FromUnicode(Value));
 
-        if (strValue.IsEmpty()) return TRUE;
+        if (strValue.IsEmpty()) return true;
 
         int iDec = params[0].ToInt();
         int iSepStyle = params[1].ToInt();
         int iNegStyle = params[2].ToInt();
         // params[3] is iCurrStyle, it's not used.
         std::wstring wstrCurrency(params[4].ToCFXWideString().c_str());
-        FX_BOOL bCurrencyPrepend = params[5].ToBool();
+        bool bCurrencyPrepend = params[5].ToBool();
 
         if (iDec < 0) iDec = -iDec;
 
         if (iSepStyle < 0 || iSepStyle > 3)
                 iSepStyle = 0;
 
         if (iNegStyle < 0 || iNegStyle > 3)
                 iNegStyle = 0;
 
 
         //////////////////////////////////////////////////////
         //for processing decimal places
         strValue.Replace(",", ".");
         double dValue = atof(strValue);
         if (iDec > 0)
                 dValue += DOUBLE_CORRECT;
 
         int iDec2;
-        FX_BOOL bNegative = FALSE;
+        int iNegative = 0;
 
-        strValue = fcvt(dValue,iDec,&iDec2,&bNegative);
+        strValue = fcvt(dValue, iDec, &iDec2, &iNegative);
         if (strValue.IsEmpty())
         {
                 dValue = 0;
-                strValue = fcvt(dValue,iDec,&iDec2,&bNegative);
+                strValue = fcvt(dValue, iDec, &iDec2, &iNegative);
                 if (strValue.IsEmpty())
                 {
                         strValue = "0";
                         iDec2 = 1;
                 }
 
         }
 
         if (iDec2 < 0)
         {
@@ skipping 57 matching lines @@
 
         if (bCurrencyPrepend)
                 strValue2 = wstrCurrency + strValue2;
         else
                 strValue2 = strValue2 + wstrCurrency;
 
 
 
         /////////////////////////////////////////////////////////////////////////
         //for processing negative style
-        if (bNegative)
+        if (iNegative)
         {
                 if (iNegStyle == 0)
                 {
                         strValue2.insert(0,L"-");
                 }
                 if (iNegStyle == 2 || iNegStyle == 3)
                 {
                         strValue2.insert(0,L"(");
                         strValue2.insert(strValue2.length(),L")");
                 }
@@ skipping 53 matching lines @@
                                         vProp2.StartGetting();
                                         vProp2<<arColor;
                                         vProp2.StartSetting();
                                 fTarget->textColor(cc,vProp2,sError);
                                 }
                         }
                 }
         }
         Value = strValue2.c_str();
 #endif
-        return TRUE;
+        return true;
 }
 
 //function AFNumber_Keystroke(nDec, sepStyle, negStyle, currStyle, strCurrency, bCurrencyPrepend)
-FX_BOOL CJS_PublicMethods::AFNumber_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFNumber_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
         CJS_EventHandler* pEvent = pContext->GetEventHandler();
         ASSERT(pEvent != NULL);
 
         if(params.size() < 2)
-                return FALSE;
+                return false;
         int iSepStyle = params[1].ToInt();
 
         if (iSepStyle < 0 || iSepStyle > 3)
                 iSepStyle = 0;
         if(!pEvent->m_pValue)
-                return FALSE;
+                return false;
         CFX_WideString & val = pEvent->Value();
         CFX_WideString & w_strChange = pEvent->Change();
     CFX_WideString w_strValue = val;
 
         if (pEvent->WillCommit())
         {
                 CFX_WideString wstrChange = w_strChange;
                 CFX_WideString wstrValue = StrLTrim(w_strValue.c_str());
                 if (wstrValue.IsEmpty())
-                        return TRUE;
+                        return true;
 
                 CFX_WideString swTemp = wstrValue;
                 swTemp.Replace(L",", L".");
                 if (!IsNumber(swTemp.c_str()))
                 {
-                        pEvent->Rc() = FALSE;
+                        pEvent->Rc() = false;
                         sError = JSGetStringFromID(pContext, IDS_STRING_JSAFNUMBER_KEYSTROKE);
                         Alert(pContext, sError.c_str());
-                        return TRUE;
+                        return true;
                 }
-                return TRUE; // it happens after the last keystroke and before validating,
+                return true; // it happens after the last keystroke and before validating,
         }
 
         std::wstring w_strValue2 = w_strValue.c_str();
         std::wstring w_strChange2 = w_strChange.c_str();
         std::wstring w_strSelected;
         if(-1 != pEvent->SelStart())
                 w_strSelected = w_strValue2.substr(pEvent->SelStart(),(pEvent->SelEnd() - pEvent->SelStart()));
-        FX_BOOL bHasSign = (w_strValue2.find('-') != -1) && (w_strSelected.find('-') == -1);
+        bool bHasSign = (w_strValue2.find('-') != -1) && (w_strSelected.find('-') == -1);
         if (bHasSign)
         {
                 //can't insert "change" in front to sign postion.
                 if (pEvent->SelStart() == 0)
                 {
-            FX_BOOL &bRc = pEvent->Rc();
-                        bRc = FALSE;
-                        return TRUE;
+            bool &bRc = pEvent->Rc();
+                        bRc = false;
+                        return true;
                 }
         }
 
         char cSep = L'.';
 
         switch (iSepStyle)
         {
         case 0:
         case 1:
                 cSep = L'.';
                 break;
         case 2:
         case 3:
                 cSep = L',';
                 break;
         }
 
-        FX_BOOL bHasSep = (w_strValue2.find(cSep) != -1);
+        bool bHasSep = (w_strValue2.find(cSep) != -1);
         for (std::wstring::iterator it = w_strChange2.begin(); it != w_strChange2.end(); it++)
         {
                 if (*it == cSep)
                 {
                         if (bHasSep)
                         {
-                                FX_BOOL &bRc = pEvent->Rc();
-                                bRc = FALSE;
-                                return TRUE;
+                                bool &bRc = pEvent->Rc();
+                                bRc = false;
+                                return true;
                         }
                         else
                         {
-                                bHasSep = TRUE;
+                                bHasSep = true;
                                 continue;
                         }
                 }
                 if (*it == L'-')
                 {
                         if (bHasSign)
                         {
-                                FX_BOOL &bRc = pEvent->Rc();
-                                bRc = FALSE;
-                                return TRUE;
+                                bool &bRc = pEvent->Rc();
+                                bRc = false;
+                                return true;
                         }
                         else if (it != w_strChange2.begin()) //sign's position is not correct
                         {
-                                FX_BOOL &bRc = pEvent->Rc();
-                                bRc = FALSE;
-                                return TRUE;
+                                bool &bRc = pEvent->Rc();
+                                bRc = false;
+                                return true;
                         }
                         else if (pEvent->SelStart() != 0)
                         {
-                                FX_BOOL &bRc = pEvent->Rc();
-                                bRc = FALSE;
-                                return TRUE;
+                                bool &bRc = pEvent->Rc();
+                                bRc = false;
+                                return true;
                         }
-                        bHasSign = TRUE;
+                        bHasSign = true;
                         continue;
                 }
 
                 if (!IsDigit(*it))
                 {
-                        FX_BOOL &bRc = pEvent->Rc();
-                        bRc = FALSE;
-                        return TRUE;
+                        bool &bRc = pEvent->Rc();
+                        bRc = false;
+                        return true;
                 }
         }
 
 
         std::wstring w_prefix = w_strValue2.substr(0,pEvent->SelStart());
         std::wstring w_postfix;
         if (pEvent->SelEnd()<(int)w_strValue2.length())
                 w_postfix  = w_strValue2.substr(pEvent->SelEnd());
         w_strValue2 = w_prefix + w_strChange2 + w_postfix;
         w_strValue = w_strValue2.c_str();
         val = w_strValue;
-        return TRUE;
+        return true;
 
 }
 
 //function AFPercent_Format(nDec, sepStyle)
-FX_BOOL CJS_PublicMethods::AFPercent_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFPercent_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
 #if _FX_OS_ != _FX_ANDROID_
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
         CJS_EventHandler* pEvent = pContext->GetEventHandler();
         ASSERT(pEvent != NULL);
 
     if (params.size() != 2)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
         if(!pEvent->m_pValue)
-                return FALSE;
+                return false;
 
         CFX_WideString& Value = pEvent->Value();
         CFX_ByteString strValue = StrTrim(CFX_ByteString::FromUnicode(Value));
         if (strValue.IsEmpty())
-                return TRUE;
+                return true;
 
         int iDec = params[0].ToInt();
         if (iDec < 0)
                 iDec = -iDec;
 
         int iSepStyle = params[1].ToInt();
         if (iSepStyle < 0 || iSepStyle > 3)
                 iSepStyle = 0;
 
         //////////////////////////////////////////////////////
         //for processing decimal places
         double dValue = atof(strValue);
         dValue *= 100;
         if (iDec > 0)
                 dValue += DOUBLE_CORRECT;//УÕý
 
         int iDec2;
-        FX_BOOL bNegative = FALSE;
-        strValue = fcvt(dValue,iDec,&iDec2,&bNegative);
+        int iNegative = 0;
+        strValue = fcvt(dValue, iDec, &iDec2, &iNegative);
     if (strValue.IsEmpty())
         {
                 dValue = 0;
-                strValue = fcvt(dValue,iDec,&iDec2,&bNegative);
+                strValue = fcvt(dValue, iDec, &iDec2, &iNegative);
         }
 
         if (iDec2 < 0)
         {
                 for (int iNum = 0; iNum < abs(iDec2); iNum++)
                 {
                         strValue = "0" + strValue;
                 }
                 iDec2 = 0;
 
@@ skipping 37 matching lines @@
                 iDecPositive = iDec2;
 
                 for (iDecPositive = iDec2 -3; iDecPositive > 0; iDecPositive -= 3)
                 {
                         strValue.Insert(iDecPositive,cSeperator);
                         iMax++;
                 }
         }
         ////////////////////////////////////////////////////////////////////
         //negative mark
-        if(bNegative)
+        if (iNegative)
                 strValue = "-" + strValue;
         strValue += "%";
         Value = CFX_WideString::FromLocal(strValue);
 #endif
-        return TRUE;
+        return true;
 }
 //AFPercent_Keystroke(nDec, sepStyle)
-FX_BOOL CJS_PublicMethods::AFPercent_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFPercent_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         return AFNumber_Keystroke(cc,params,vRet,sError);
 }
 
 //function AFDate_FormatEx(cFormat)
-FX_BOOL CJS_PublicMethods::AFDate_FormatEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFDate_FormatEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
         CJS_EventHandler* pEvent = pContext->GetEventHandler();
         ASSERT(pEvent != NULL);
 
         if (params.size() != 1)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
         if(!pEvent->m_pValue)
-                return FALSE;
+                return false;
 
         CFX_WideString& val = pEvent->Value();
         CFX_WideString strValue = val;
         if (strValue.IsEmpty())
-                return TRUE;
+                return true;
 
         CFX_WideString sFormat = params[0].ToCFXWideString();
-        FX_BOOL bWrongFormat = FALSE;
+        bool bWrongFormat = false;
         double dDate = 0.0f;
 
         if(strValue.Find(L"GMT") != -1)
         {
                 //for GMT format time
                 //such as "Tue Aug 11 14:24:16 GMT+08002009"
                 dDate = MakeInterDate(strValue);
         }
         else
         {
                 dDate = MakeRegularDate(strValue,sFormat,bWrongFormat);
         }
 
         if (JS_PortIsNan(dDate))
         {
                 CFX_WideString swMsg;
                 swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE).c_str(), sFormat.c_str());
                 Alert(pContext, swMsg.c_str());
-                return FALSE;
+                return false;
         }
 
         val =  MakeFormatDate(dDate,sFormat);
-        return TRUE;
+        return true;
 }
 
 double CJS_PublicMethods::MakeInterDate(CFX_WideString strValue)
 {
         int nHour;
         int nMin;
         int nSec;
         int nYear;
         int nMonth;
         int nDay;
@@ skipping 43 matching lines @@
 
         if (JS_PortIsNan(dRet))
         {
                 dRet = JS_DateParse(strValue.c_str());
         }
 
         return dRet;
 }
 
 //AFDate_KeystrokeEx(cFormat)
-FX_BOOL CJS_PublicMethods::AFDate_KeystrokeEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFDate_KeystrokeEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
         CJS_EventHandler* pEvent = pContext->GetEventHandler();
         ASSERT(pEvent != NULL);
 
         if (params.size() != 1)
         {
                 sError = L"AFDate_KeystrokeEx's parameters' size r not correct";
-                return FALSE;
+                return false;
         }
 
         if (pEvent->WillCommit())
         {
                 if(!pEvent->m_pValue)
-                        return FALSE;
+                        return false;
                 CFX_WideString strValue = pEvent->Value();
                 if (strValue.IsEmpty())
-                        return TRUE;
+                        return true;
 
                 CFX_WideString sFormat = params[0].ToCFXWideString();
-                FX_BOOL bWrongFormat = FALSE;
+                bool bWrongFormat = false;
                 double dRet = MakeRegularDate(strValue,sFormat,bWrongFormat);
                 if (bWrongFormat || JS_PortIsNan(dRet))
                 {
                         CFX_WideString swMsg;
                         swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE).c_str(), sFormat.c_str());
                         Alert(pContext, swMsg.c_str());
-                        pEvent->Rc() = FALSE;
-                        return TRUE;
+                        pEvent->Rc() = false;
+                        return true;
                 }
         }
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CJS_PublicMethods::AFDate_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFDate_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         v8::Isolate* isolate = ::GetIsolate(cc);
 
         if (params.size() != 1)
         {
                 CJS_Context* pContext = (CJS_Context*)cc;
                 ASSERT(pContext != NULL);
 
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         int iIndex = params[0].ToInt();
         const FX_WCHAR* cFormats[] =  {L"m/d", L"m/d/yy", L"mm/dd/yy", L"mm/yy", L"d-mmm", L"d-mmm-yy", L"dd-mmm-yy",
                 L"yy-mm-dd", L"mmm-yy", L"mmmm-yy", L"mmm d, yyyy", L"mmmm d, yyyy",
                 L"m/d/yy h:MM tt", L"m/d/yy HH:MM" };
 
         ASSERT(iIndex < FX_ArraySize(cFormats));
 
         if (iIndex < 0)
                 iIndex = 0;
         if (iIndex >= FX_ArraySize(cFormats))
                 iIndex = 0;
         CJS_Parameters newParams;
         CJS_Value val(isolate,cFormats[iIndex]);
         newParams.push_back(val);
         return AFDate_FormatEx(cc,newParams,vRet,sError);
 }
 
 //AFDate_KeystrokeEx(cFormat)
-FX_BOOL CJS_PublicMethods::AFDate_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFDate_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         v8::Isolate* isolate = ::GetIsolate(cc);
 
         if (params.size() != 1)
         {
                 CJS_Context* pContext = (CJS_Context*)cc;
                 ASSERT(pContext != NULL);
 
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         int iIndex = params[0].ToInt();
         const FX_WCHAR* cFormats[] =  {L"m/d", L"m/d/yy", L"mm/dd/yy", L"mm/yy", L"d-mmm", L"d-mmm-yy", L"dd-mmm-yy",
                 L"yy-mm-dd", L"mmm-yy", L"mmmm-yy", L"mmm d, yyyy", L"mmmm d, yyyy",
                 L"m/d/yy h:MM tt", L"m/d/yy HH:MM" };
 
         ASSERT(iIndex<FX_ArraySize(cFormats));
 
         if (iIndex < 0)
                 iIndex = 0;
         if (iIndex >= FX_ArraySize(cFormats))
                 iIndex = 0;
         CJS_Parameters newParams;
         CJS_Value val(isolate,cFormats[iIndex]);
         newParams.push_back(val);
         return AFDate_KeystrokeEx(cc,newParams,vRet,sError);
 }
 
 //function AFTime_Format(ptf)
-FX_BOOL CJS_PublicMethods::AFTime_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFTime_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         v8::Isolate* isolate = ::GetIsolate(cc);
 
         if (params.size() != 1)
         {
                 CJS_Context* pContext = (CJS_Context*)cc;
                 ASSERT(pContext != NULL);
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         int iIndex = params[0].ToInt();
         const FX_WCHAR* cFormats[] = {L"HH:MM", L"h:MM tt", L"HH:MM:ss", L"h:MM:ss tt"};
 
         ASSERT(iIndex<FX_ArraySize(cFormats));
 
         if (iIndex < 0)
                 iIndex = 0;
         if (iIndex >= FX_ArraySize(cFormats))
                 iIndex = 0;
         CJS_Parameters newParams;
         CJS_Value val(isolate,cFormats[iIndex]);
         newParams.push_back(val);
         return AFDate_FormatEx(cc,newParams,vRet,sError);
 }
 
-FX_BOOL CJS_PublicMethods::AFTime_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFTime_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         v8::Isolate* isolate = ::GetIsolate(cc);
         if (params.size() != 1)
         {
                 CJS_Context* pContext = (CJS_Context*)cc;
                 ASSERT(pContext != NULL);
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         int iIndex = params[0].ToInt();
         const FX_WCHAR* cFormats[] = {L"HH:MM", L"h:MM tt", L"HH:MM:ss", L"h:MM:ss tt"};
 
         ASSERT(iIndex<FX_ArraySize(cFormats));
 
         if (iIndex < 0)
                 iIndex = 0;
         if (iIndex >= FX_ArraySize(cFormats))
                 iIndex = 0;
         CJS_Parameters newParams;
         CJS_Value val(isolate,cFormats[iIndex]);
         newParams.push_back(val);
         return AFDate_KeystrokeEx(cc,newParams,vRet,sError);
 }
 
-FX_BOOL CJS_PublicMethods::AFTime_FormatEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFTime_FormatEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         return AFDate_FormatEx(cc,params,vRet,sError);
 }
 
-FX_BOOL CJS_PublicMethods::AFTime_KeystrokeEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFTime_KeystrokeEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         return AFDate_KeystrokeEx(cc,params,vRet,sError);
 }
 
 //function AFSpecial_Format(psf)
-FX_BOOL CJS_PublicMethods::AFSpecial_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFSpecial_Format(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
 
         if (params.size() != 1)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         std::string cFormat;
         int iIndex = params[0].ToInt();
 
         CJS_EventHandler* pEvent = pContext->GetEventHandler();
         ASSERT(pEvent != NULL);
 
         if(!pEvent->m_pValue)
-                return FALSE;
+                return false;
         CFX_WideString& Value = pEvent->Value();
         std::string strSrc = CFX_ByteString::FromUnicode(Value).c_str();
 
         switch (iIndex)
         {
         case 0:
                 cFormat = "99999";
                 break;
         case 1:
                 cFormat = "99999-9999";
                 break;
         case 2:
                 {
                         std::string NumberStr;
                         util::printx("9999999999", strSrc,NumberStr);
                         if (NumberStr.length() >= 10 )
                                 cFormat = "(999) 999-9999";
                         else
                                 cFormat = "999-9999";
                         break;
                 }
         case 3:
                 cFormat = "999-99-9999";
                 break;
         }
 
         std::string strDes;
         util::printx(cFormat,strSrc,strDes);
         Value = CFX_WideString::FromLocal(strDes.c_str());
-        return TRUE;
+        return true;
 }
 
 
 //function AFSpecial_KeystrokeEx(mask)
-FX_BOOL CJS_PublicMethods::AFSpecial_KeystrokeEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFSpecial_KeystrokeEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
         CJS_EventHandler* pEvent = pContext->GetEventHandler();
 
         ASSERT(pEvent != NULL);
 
         if (params.size() < 1)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         if(!pEvent->m_pValue)
-                return FALSE;
+                return false;
         CFX_WideString& valEvent = pEvent->Value();
 
         CFX_WideString wstrMask = params[0].ToCFXWideString();
         if (wstrMask.IsEmpty())
-                return TRUE;
+                return true;
 
         std::wstring wstrValue = valEvent.c_str();
 
         if (pEvent->WillCommit())
         {
                 if (wstrValue.empty())
-                        return TRUE;
+                        return true;
                 int iIndexMask = 0;
                 for (std::wstring::iterator it = wstrValue.begin(); it != wstrValue.end(); it++)
                 {
                         wchar_t w_Value = *it;
                         if (!maskSatisfied(w_Value,wstrMask[iIndexMask]))
                                 break;
                         iIndexMask++;
                 }
 
                 if (iIndexMask != wstrMask.GetLength() || (iIndexMask != wstrValue.size() && wstrMask.GetLength() != 0))
                 {
                         Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSAFNUMBER_KEYSTROKE).c_str());
-                        pEvent->Rc() = FALSE;
+                        pEvent->Rc() = false;
                 }
-                return TRUE;
+                return true;
         }
 
         CFX_WideString &wideChange = pEvent->Change();
         std::wstring wChange = wideChange.c_str();
         if (wChange.empty())
-                return TRUE;
+                return true;
 
         int iIndexMask = pEvent->SelStart();
 
         if (wstrValue.length() - (pEvent->SelEnd()-pEvent->SelStart()) + wChange.length() > (FX_DWORD)wstrMask.GetLength())
         {
                 Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_TOOLONG).c_str());
-                pEvent->Rc() = FALSE;
-                return TRUE;
+                pEvent->Rc() = false;
+                return true;
         }
 
         if (iIndexMask >= wstrMask.GetLength() && (!wChange.empty()))
         {
                 Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_TOOLONG).c_str());
-                pEvent->Rc() = FALSE;
-                return TRUE;
+                pEvent->Rc() = false;
+                return true;
         }
 
         for (std::wstring::iterator it = wChange.begin(); it != wChange.end(); it++)
         {
                 if (iIndexMask >= wstrMask.GetLength())
                 {
                         Alert(pContext, JSGetStringFromID(pContext, IDS_STRING_JSPARAM_TOOLONG).c_str());
-                        pEvent->Rc() = FALSE;
-                        return TRUE;
+                        pEvent->Rc() = false;
+                        return true;
                 }
                 wchar_t w_Mask = wstrMask[iIndexMask];
                 if (!isReservedMaskChar(w_Mask))
                 {
                         *it = w_Mask;
                 }
                 wchar_t w_Change = *it;
                 if (!maskSatisfied(w_Change,w_Mask))
                 {
-                        pEvent->Rc() = FALSE;
-                        return TRUE;
+                        pEvent->Rc() = false;
+                        return true;
                 }
                 iIndexMask++;
         }
 
         wideChange = wChange.c_str();
-        return TRUE;
+        return true;
 }
 
 
 //function AFSpecial_Keystroke(psf)
-FX_BOOL CJS_PublicMethods::AFSpecial_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFSpecial_Keystroke(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         v8::Isolate* isolate = ::GetIsolate(cc);
 
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
         CJS_EventHandler* pEvent = pContext->GetEventHandler();
         ASSERT(pEvent != NULL);
 
         if (params.size() != 1)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         std::string cFormat;
         int iIndex = params[0].ToInt();
 
         if(!pEvent->m_pValue)
-                return FALSE;
+                return false;
         //CJS_Value val = pEvent->Value();
         CFX_WideString& val = pEvent->Value();
         std::string strSrc = CFX_ByteString::FromUnicode(val).c_str();
         std::wstring wstrChange = pEvent->Change().c_str();
 
         switch (iIndex)
         {
         case 0:
                 cFormat = "99999";
                 break;
@@ skipping 19 matching lines @@
                 break;
         }
 
         CJS_Parameters params2;
         CJS_Value vMask(isolate, cFormat.c_str());
         params2.push_back(vMask);
 
     return AFSpecial_KeystrokeEx(cc,params2,vRet,sError);
 }
 
-FX_BOOL CJS_PublicMethods::AFMergeChange(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFMergeChange(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
         CJS_EventHandler* pEventHandler = pContext->GetEventHandler();
         ASSERT(pEventHandler != NULL);
 
         if (params.size() != 1)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         CFX_WideString swValue;
         if (pEventHandler->m_pValue != NULL)
                 swValue = pEventHandler->Value();
 
         if (pEventHandler->WillCommit())
         {
                 vRet = swValue.c_str();
-                return TRUE;
+                return true;
         }
 
         CFX_WideString prefix,postfix;
 
         if (pEventHandler->SelStart() >= 0)
                 prefix = swValue.Mid(0,pEventHandler->SelStart());
         else
                 prefix = L"";
 
 
         if (pEventHandler->SelEnd() >= 0 && pEventHandler->SelEnd() <= swValue.GetLength())
                 postfix = swValue.Mid(pEventHandler->SelEnd(), swValue.GetLength() - pEventHandler->SelEnd());
         else postfix = L"";
 
         vRet = (prefix + pEventHandler->Change() + postfix).c_str();
 
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CJS_PublicMethods::AFParseDateEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFParseDateEx(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
 
         if (params.size() != 2)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         CFX_WideString sValue = params[0].ToCFXWideString();
         CFX_WideString sFormat = params[1].ToCFXWideString();
 
-        FX_BOOL bWrongFormat = FALSE;
+        bool bWrongFormat = false;
         double dDate = MakeRegularDate(sValue,sFormat,bWrongFormat);
 
         if (JS_PortIsNan(dDate))
         {
                 CFX_WideString swMsg;
                 swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSPARSEDATE).c_str(), sFormat.c_str());
                 Alert((CJS_Context *)cc, swMsg.c_str());
-                return FALSE;
+                return false;
         }
 
         vRet = dDate;
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CJS_PublicMethods::AFSimple(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFSimple(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         if (params.size() != 3)
         {
                 CJS_Context* pContext = (CJS_Context *)cc;
                 ASSERT(pContext != NULL);
 
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         vRet = (double)AF_Simple(params[0].ToCFXWideString().c_str(), params[1].ToDouble(), params[2].ToDouble());
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CJS_PublicMethods::AFMakeNumber(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFMakeNumber(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         if (params.size() != 1)
         {
                 CJS_Context* pContext = (CJS_Context *)cc;
                 ASSERT(pContext != NULL);
 
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
         vRet = ParseStringToNumber(params[0].ToCFXWideString().c_str());
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CJS_PublicMethods::AFSimple_Calculate(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFSimple_Calculate(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         v8::Isolate* isolate = ::GetIsolate(cc);
 
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
 
         if (params.size() != 2)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         CJS_Value params1 = params[1];
 
         if (!params1.IsArrayObject() && params1.GetType() != VT_string)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         CPDFSDK_Document* pReaderDoc = pContext->GetReaderDocument();
     ASSERT(pReaderDoc != NULL);
 
         CPDFSDK_InterForm* pReaderInterForm = pReaderDoc->GetInterForm();
         ASSERT(pReaderInterForm != NULL);
 
         CPDF_InterForm* pInterForm = pReaderInterForm->GetInterForm();
         ASSERT(pInterForm != NULL);
@@ skipping 79 matching lines @@
         }
 
         if (wcscmp(sFunction.c_str(), L"AVG") == 0 && nFieldsCount > 0)
                 dValue /= nFieldsCount;
 
         dValue = (double)floor(dValue * FXSYS_pow((double)10,(double)6) + 0.49) / FXSYS_pow((double)10,(double)6);
         CJS_Value jsValue(isolate,dValue);
         if((CJS_EventHandler*)pContext->GetEventHandler()->m_pValue)
                 ((CJS_EventHandler*)pContext->GetEventHandler())->Value() = jsValue.ToCFXWideString();
 
-        return TRUE;
+        return true;
 }
 
 /* This function validates the current event to ensure that its value is
 ** within the specified range. */
 
-FX_BOOL CJS_PublicMethods::AFRange_Validate(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFRange_Validate(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         CJS_Context* pContext = (CJS_Context *)cc;
         ASSERT(pContext != NULL);
         CJS_EventHandler* pEvent = pContext->GetEventHandler();
         ASSERT(pEvent != NULL);
 
         if (params.size() != 4)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         if(!pEvent->m_pValue)
-                return FALSE;
+                return false;
         if (pEvent->Value().IsEmpty() )
-                return TRUE;
+                return true;
         double dEentValue = atof(CFX_ByteString::FromUnicode(pEvent->Value()));
-        FX_BOOL bGreaterThan = params[0].ToBool();
+        bool bGreaterThan = params[0].ToBool();
         double dGreaterThan = params[1].ToDouble();
-        FX_BOOL bLessThan = params[2].ToBool();
+        bool bLessThan = params[2].ToBool();
         double dLessThan = params[3].ToDouble();
         CFX_WideString swMsg;
 
         if (bGreaterThan && bLessThan)
         {
                 if (dEentValue < dGreaterThan || dEentValue > dLessThan)
                         swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRANGE1).c_str(),
                                                  params[1].ToCFXWideString().c_str(),
                                                  params[3].ToCFXWideString().c_str());
         }
         else if (bGreaterThan)
         {
                 if (dEentValue < dGreaterThan)
                         swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRANGE2).c_str(),
                                                  params[1].ToCFXWideString().c_str());
         }
         else if (bLessThan)
         {
                 if (dEentValue > dLessThan)
                         swMsg.Format(JSGetStringFromID(pContext, IDS_STRING_JSRANGE3).c_str(),
                                                  params[3].ToCFXWideString().c_str());
         }
 
         if (!swMsg.IsEmpty())
         {
                 Alert(pContext, swMsg.c_str());
-                pEvent->Rc() = FALSE;
+                pEvent->Rc() = false;
         }
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CJS_PublicMethods::AFExtractNums(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
+bool CJS_PublicMethods::AFExtractNums(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
 {
         v8::Isolate* isolate = ::GetIsolate(cc);
         CJS_Context* pContext = (CJS_Context*)cc;
         ASSERT(pContext != NULL);
 
         if (params.size() != 1)
         {
                 sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
-                return FALSE;
+                return false;
         }
 
         CJS_Array nums(isolate);
 
         CFX_WideString str = params[0].ToCFXWideString();
         CFX_WideString sPart;
 
         if (str.GetAt(0) == L'.' || str.GetAt(0) == L',')
                 str = L"0" + str;
 
@@ skipping 19 matching lines @@
         if (sPart.GetLength() > 0)
         {
                 nums.SetElement(nIndex,CJS_Value(isolate,sPart.c_str()));
         }
 
         if (nums.GetLength() > 0)
                 vRet = nums;
         else
                 vRet.SetNull();
 
-        return TRUE;
+        return true;
 }