Simplify coerce_value signature

Change-Id: I0791600a5cc8600ea80233afba07724dd7f565e1

1 files changed, 163 insertions, 161 deletions

diff --git a/idlc/source/astexpression.cxx b/idlc/source/astexpression.cxx
index 3bde39121599..785e2284ad5c 100644
--- a/idlc/source/astexpression.cxx
+++ b/idlc/source/astexpression.cxx
@@ -133,11 +133,11 @@ AstExpression::~AstExpression()
  * ExprType. Return an AstExprValue if successful, NULL if failed.
  * must be done for hyper, uhyper
  */
-static AstExprValue *
+static bool
 coerce_value(AstExprValue *ev, ExprType t)
 {
     if (ev == NULL)
-        return NULL;
+        return false;
 
     switch (t)
     {
@@ -145,119 +145,119 @@ coerce_value(AstExprValue *ev, ExprType t)
             switch (ev->et)
             {
                 case ET_short:
-                    return ev;
+                    return true;
                 case ET_ushort:
                     if (ev->u.usval > SAL_MAX_INT16)
-                        return NULL;
+                        return false;
                     ev->u.sval = (sal_Int16)ev->u.usval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_long:
                     if (ev->u.lval < SAL_MIN_INT16 || ev->u.lval > SAL_MAX_INT16)
-                        return NULL;
+                        return false;
                     ev->u.sval = (sal_Int16)ev->u.lval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_ulong:
                     if (ev->u.ulval > SAL_MAX_INT16)
-                        return NULL;
+                        return false;
                     ev->u.sval = (sal_Int16)ev->u.ulval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_hyper:
                     if (ev->u.hval < SAL_MIN_INT16 || ev->u.hval > SAL_MAX_INT16)
-                        return NULL;
+                        return false;
                     ev->u.sval = (sal_Int16)ev->u.hval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_uhyper:
                     if (ev->u.uhval > SAL_MAX_INT16)
-                        return NULL;
+                        return false;
                     ev->u.sval = (sal_Int16)ev->u.uhval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_boolean:
                     ev->u.sval = (sal_Int16)ev->u.bval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_float:
                     if (ev->u.fval < SAL_MIN_INT16 || ev->u.fval > SAL_MAX_INT16)
-                        return NULL;
+                        return false;
                     ev->u.sval = (sal_Int16)ev->u.fval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_double:
                     if (ev->u.dval < SAL_MIN_INT16 || ev->u.dval > SAL_MAX_INT16)
-                        return NULL;
+                        return false;
                     ev->u.sval = (sal_Int16)ev->u.dval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_byte:
                     ev->u.sval = (sal_Int16)ev->u.byval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         case ET_ushort:
             switch (ev->et)
             {
                 case ET_short:
                     if (ev->u.sval < 0)
-                        return NULL;
+                        return false;
                     ev->u.usval = (sal_uInt16)ev->u.sval;
                     ev->et = ET_ushort;
-                    return ev;
+                    return true;
                 case ET_ushort:
-                    return ev;
+                    return true;
                 case ET_long:
                     if (ev->u.lval < 0 || ev->u.lval > SAL_MAX_UINT16)
-                        return NULL;
+                        return false;
                     ev->u.usval = (sal_uInt16)ev->u.lval;
                     ev->et = ET_ushort;
-                    return ev;
+                    return true;
                 case ET_ulong:
                     if (ev->u.ulval > SAL_MAX_UINT16)
-                        return NULL;
+                        return false;
                     ev->u.usval = (sal_uInt16)ev->u.ulval;
                     ev->et = ET_ushort;
-                    return ev;
+                    return true;
                 case ET_hyper:
                     if (ev->u.hval < 0 || ev->u.hval > SAL_MAX_UINT16)
-                        return NULL;
+                        return false;
                     ev->u.usval = (sal_uInt16)ev->u.hval;
                     ev->et = ET_ushort;
-                    return ev;
+                    return true;
                 case ET_uhyper:
                     if (ev->u.uhval > SAL_MAX_UINT16)
-                        return NULL;
+                        return false;
                     ev->u.usval = (sal_uInt16)ev->u.uhval;
                     ev->et = ET_ushort;
-                    return ev;
+                    return true;
                 case ET_boolean:
                     ev->u.usval = (sal_uInt16)ev->u.bval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_float:
                     if (ev->u.fval < 0.0 || ev->u.fval > SAL_MAX_UINT16)
-                        return NULL;
+                        return false;
                     ev->u.usval = (sal_uInt16)ev->u.fval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_double:
                     if (ev->u.dval < 0.0 || ev->u.dval > SAL_MAX_UINT16)
-                        return NULL;
+                        return false;
                     ev->u.usval = (sal_uInt16)ev->u.dval;
                     ev->et = ET_short;
-                    return ev;
+                    return true;
                 case ET_byte:
                     ev->u.usval = (sal_uInt16)ev->u.byval;
                     ev->et = ET_ushort;
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         case ET_long:
             switch (ev->et)
@@ -265,111 +265,111 @@ coerce_value(AstExprValue *ev, ExprType t)
                 case ET_short:
                     ev->u.lval = (sal_Int32)ev->u.sval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 case ET_ushort:
                     ev->u.lval = (sal_Int32)ev->u.usval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 case ET_long:
-                    return ev;
+                    return true;
                 case ET_ulong:
                     if (ev->u.ulval > SAL_MAX_INT32)
-                        return NULL;
+                        return false;
                     ev->u.lval = (sal_Int32)ev->u.ulval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 case ET_hyper:
                     if (ev->u.hval < SAL_MIN_INT32 || ev->u.hval > SAL_MAX_INT32)
-                        return NULL;
+                        return false;
                     ev->u.lval = (sal_Int32)ev->u.hval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 case ET_uhyper:
                     if (ev->u.uhval > SAL_MAX_INT32)
-                        return NULL;
+                        return false;
                     ev->u.lval = (sal_Int32)ev->u.uhval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 case ET_boolean:
                     ev->u.lval = (sal_Int32)ev->u.bval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 case ET_float:
                     if (ev->u.fval < SAL_MIN_INT32 || ev->u.fval > SAL_MAX_INT32)
-                        return NULL;
+                        return false;
                     ev->u.lval = (sal_Int32)ev->u.fval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 case ET_double:
                     if (ev->u.dval < SAL_MIN_INT32 || ev->u.dval > SAL_MAX_INT32)
-                        return NULL;
+                        return false;
                     ev->u.lval = (sal_Int32)ev->u.dval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 case ET_byte:
                     ev->u.lval = (sal_Int32) ev->u.byval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         case ET_ulong:
             switch (ev->et)
             {
                 case ET_short:
                     if (ev->u.sval < 0)
-                        return NULL;
+                        return false;
                     ev->u.ulval = (sal_uInt32)ev->u.sval;
                     ev->et = ET_ulong;
-                    return ev;
+                    return true;
                 case ET_ushort:
                     ev->u.ulval = (sal_uInt32)ev->u.usval;
                     ev->et = ET_ulong;
-                    return ev;
+                    return true;
                 case ET_long:
                     if (ev->u.lval < 0)
-                        return NULL;
+                        return false;
                     ev->u.ulval = (sal_uInt32)ev->u.lval;
                     ev->et = ET_ulong;
-                    return ev;
+                    return true;
                 case ET_ulong:
-                    return ev;
+                    return true;
                 case ET_hyper:
                     if (ev->u.hval < 0 || ev->u.hval > SAL_MAX_UINT32)
-                        return NULL;
+                        return false;
                     ev->u.lval = (sal_uInt32)ev->u.hval;
                     ev->et = ET_ulong;
-                    return ev;
+                    return true;
                 case ET_uhyper:
                     if (ev->u.uhval > SAL_MAX_UINT32)
-                        return NULL;
+                        return false;
                     ev->u.ulval = (sal_uInt32)ev->u.uhval;
                     ev->et = ET_ulong;
-                    return ev;
+                    return true;
                 case ET_boolean:
                     ev->u.ulval = (sal_uInt32)ev->u.bval;
                     ev->et = ET_ulong;
-                    return ev;
+                    return true;
                 case ET_float:
                     if (ev->u.fval < 0.0 || ev->u.fval > SAL_MAX_UINT32)
-                        return NULL;
+                        return false;
                     ev->u.ulval = (sal_uInt32)ev->u.fval;
                     ev->et = ET_ulong;
-                    return ev;
+                    return true;
                 case ET_double:
                     if (ev->u.dval < 0.0 || ev->u.dval > SAL_MAX_UINT32)
-                        return NULL;
+                        return false;
                     ev->u.ulval = (sal_uInt32)ev->u.dval;
                     ev->et = ET_ulong;
-                    return ev;
+                    return true;
                 case ET_byte:
                     ev->u.ulval = (sal_uInt32)ev->u.byval;
                     ev->et = ET_ulong;
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         case ET_hyper:
             switch (ev->et)
@@ -377,105 +377,105 @@ coerce_value(AstExprValue *ev, ExprType t)
                 case ET_short:
                     ev->u.hval = (sal_Int64)ev->u.sval;
                     ev->et = ET_hyper;
-                    return ev;
+                    return true;
                 case ET_ushort:
                     ev->u.hval = (sal_Int64)ev->u.usval;
                     ev->et = ET_hyper;
-                    return ev;
+                    return true;
                 case ET_long:
                     ev->u.hval = (sal_Int64)ev->u.lval;
                     ev->et = ET_hyper;
-                    return ev;
+                    return true;
                 case ET_ulong:
                     ev->u.hval = (sal_Int64)ev->u.ulval;
                     ev->et = ET_hyper;
-                    return ev;
+                    return true;
                 case ET_hyper:
-                    return ev;
+                    return true;
                 case ET_uhyper:
                     if (ev->u.uhval > SAL_MAX_INT64)
-                        return NULL;
+                        return false;
                     ev->u.hval = (sal_Int64)ev->u.uhval;
                     ev->et = ET_long;
-                    return ev;
+                    return true;
                 case ET_boolean:
                     ev->u.hval = (sal_Int64)ev->u.bval;
                     ev->et = ET_hyper;
-                    return ev;
+                    return true;
                 case ET_float:
                     if (ev->u.fval < SAL_MIN_INT64 || ev->u.fval > SAL_MAX_INT64)
-                        return NULL;
+                        return false;
                     ev->u.hval = (sal_Int64)ev->u.fval;
                     ev->et = ET_hyper;
-                    return ev;
+                    return true;
                 case ET_double:
                     if (ev->u.dval < SAL_MIN_INT64 || ev->u.dval > SAL_MAX_INT64)
-                        return NULL;
+                        return false;
                     ev->u.hval = (sal_Int64)ev->u.dval;
                     ev->et = ET_hyper;
-                    return ev;
+                    return true;
                 case ET_byte:
                     ev->u.hval = (sal_Int64)ev->u.byval;
                     ev->et = ET_hyper;
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         case ET_uhyper:
             switch (ev->et)
             {
                 case ET_short:
                     if (ev->u.sval < 0)
-                        return NULL;
+                        return false;
                     ev->u.uhval = (sal_uInt64)ev->u.sval;
                     ev->et = ET_uhyper;
-                    return ev;
+                    return true;
                 case ET_ushort:
                     ev->u.uhval = (sal_uInt64)ev->u.usval;
                     ev->et = ET_uhyper;
-                    return ev;
+                    return true;
                 case ET_long:
                     if (ev->u.lval < 0)
-                        return NULL;
+                        return false;
                     ev->u.uhval = (sal_uInt64)ev->u.lval;
                     ev->et = ET_uhyper;
-                    return ev;
+                    return true;
                 case ET_ulong:
                     ev->u.uhval = (sal_uInt64)ev->u.ulval;
                     ev->et = ET_uhyper;
-                    return ev;
+                    return true;
                 case ET_hyper:
                     if (ev->u.hval < 0)
-                        return NULL;
+                        return false;
                     ev->u.uhval = (sal_uInt64)ev->u.hval;
                     ev->et = ET_uhyper;
-                    return ev;
+                    return true;
                 case ET_uhyper:
-                    return ev;
+                    return true;
                 case ET_boolean:
                     ev->u.uhval = (sal_uInt64)ev->u.bval;
                     ev->et = ET_uhyper;
-                    return ev;
+                    return true;
                 case ET_float:
                     if (ev->u.fval < 0.0 || ev->u.fval > SAL_MAX_UINT64)
-                        return NULL;
+                        return false;
                     ev->u.uhval = (sal_uInt64)ev->u.fval;
                     ev->et = ET_uhyper;
-                    return ev;
+                    return true;
                 case ET_double:
                     if (ev->u.dval < 0.0 || ev->u.dval > SAL_MAX_UINT64)
-                        return NULL;
+                        return false;
                     ev->u.uhval = (sal_uInt64)ev->u.dval;
                     ev->et = ET_uhyper;
-                    return ev;
+                    return true;
                 case ET_byte:
                     ev->u.uhval = (sal_uInt64)ev->u.byval;
                     ev->et = ET_uhyper;
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         case ET_boolean:
             switch (ev->et)
@@ -483,44 +483,44 @@ coerce_value(AstExprValue *ev, ExprType t)
                 case ET_short:
                     ev->u.bval = ev->u.sval != 0;
                     ev->et = ET_boolean;
-                    return ev;
+                    return true;
                 case ET_ushort:
                     ev->u.bval = ev->u.usval != 0;
                     ev->et = ET_boolean;
-                    return ev;
+                    return true;
                 case ET_long:
                     ev->u.bval = ev->u.lval != 0;
                     ev->et = ET_boolean;
-                    return ev;
+                    return true;
                 case ET_ulong:
                     ev->u.bval = ev->u.ulval != 0;
                     ev->et = ET_boolean;
-                    return ev;
+                    return true;
                 case ET_hyper:
                     ev->u.bval = ev->u.hval != 0;
                     ev->et = ET_boolean;
-                    return ev;
+                    return true;
                 case ET_uhyper:
                     ev->u.bval = ev->u.uhval != 0;
                     ev->et = ET_boolean;
-                    return ev;
+                    return true;
                 case ET_boolean:
-                    return ev;
+                    return true;
                 case ET_float:
                     ev->u.bval = ev->u.fval != 0.0;
                     ev->et = ET_boolean;
-                    return ev;
+                    return true;
                 case ET_double:
                     ev->u.bval = ev->u.dval != 0.0;
                     ev->et = ET_boolean;
-                    return ev;
+                    return true;
                 case ET_byte:
                     ev->u.bval = ev->u.byval != 0;
                     ev->et = ET_boolean;
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         case ET_float:
             switch (ev->et)
@@ -528,48 +528,48 @@ coerce_value(AstExprValue *ev, ExprType t)
                 case ET_short:
                     ev->u.fval = (float)ev->u.sval;
                     ev->et = ET_float;
-                    return ev;
+                    return true;
                 case ET_ushort:
                     ev->u.fval = (float)ev->u.usval;
                     ev->et = ET_float;
-                    return ev;
+                    return true;
                 case ET_long:
                     ev->u.fval = (float)ev->u.lval;
                     ev->et = ET_float;
-                    return ev;
+                    return true;
                 case ET_ulong:
                     ev->u.fval = (float)ev->u.ulval;
                     ev->et = ET_float;
-                    return ev;
+                    return true;
                 case ET_hyper:
                     ev->u.fval = (float)ev->u.hval;
                     ev->et = ET_float;
-                    return ev;
+                    return true;
                 case ET_uhyper:
                     if ((float)ev->u.ulval > FLT_MAX)
-                        return NULL;
+                        return false;
                     ev->u.fval = (float)ev->u.ulval;
                     ev->et = ET_float;
-                    return ev;
+                    return true;
                 case ET_boolean:
                     ev->u.fval = ev->u.bval ? 1.0f : 0.0f;
                     ev->et = ET_float;
-                    return ev;
+                    return true;
                 case ET_float:
-                    return ev;
+                    return true;
                 case ET_double:
                     if ((float)ev->u.dval > FLT_MAX || (float)ev->u.dval < -FLT_MAX)
-                        return NULL;
+                        return false;
                     ev->u.fval = (float)ev->u.dval;
                     ev->et = ET_float;
-                    return ev;
+                    return true;
                 case ET_byte:
                     ev->u.fval = (float)ev->u.byval;
                     ev->et = ET_float;
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         case ET_double:
             switch (ev->et)
@@ -577,111 +577,111 @@ coerce_value(AstExprValue *ev, ExprType t)
                 case ET_short:
                     ev->u.dval = (double)ev->u.sval;
                     ev->et = ET_double;
-                    return ev;
+                    return true;
                 case ET_ushort:
                     ev->u.dval = (double)ev->u.usval;
                     ev->et = ET_double;
-                    return ev;
+                    return true;
                 case ET_long:
                     ev->u.dval = (double)ev->u.lval;
                     ev->et = ET_double;
-                    return ev;
+                    return true;
                 case ET_ulong:
                     ev->u.dval = (double)ev->u.ulval;
                     ev->et = ET_double;
-                    return ev;
+                    return true;
                 case ET_hyper:
                     ev->u.dval = (double)ev->u.hval;
                     ev->et = ET_double;
-                    return ev;
+                    return true;
                 case ET_uhyper:
                     if ((double)ev->u.dval > FLT_MAX || (double)ev->u.dval < -FLT_MAX)
-                        return NULL;
+                        return false;
                     ev->u.dval = (double)ev->u.ulval;
                     ev->et = ET_double;
-                    return ev;
+                    return true;
                 case ET_boolean:
                     ev->u.dval = ev->u.bval ? 1.0 : 0.0;
                     ev->et = ET_double;
-                    return ev;
+                    return true;
                 case ET_float:
                     ev->u.dval = (double)ev->u.fval;
                     ev->et = ET_double;
-                    return ev;
+                    return true;
                 case ET_double:
-                    return ev;
+                    return true;
                 case ET_byte:
                     ev->u.dval = (double)ev->u.byval;
                     ev->et = ET_double;
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         case ET_byte:
             switch (ev->et)
             {
                 case ET_short:
                     if (ev->u.sval < SAL_MIN_INT8 || ev->u.sval > SAL_MAX_UINT8)
-                        return NULL;
+                        return false;
                     ev->u.byval = (unsigned char)ev->u.sval;
                     ev->et = ET_byte;
-                    return ev;
+                    return true;
                 case ET_ushort:
                     if (ev->u.usval > SAL_MAX_UINT8)
-                        return NULL;
+                        return false;
                     ev->u.byval = (unsigned char)ev->u.usval;
                     ev->et = ET_byte;
-                    return ev;
+                    return true;
                 case ET_long:
                     if (ev->u.lval < SAL_MIN_INT8 || ev->u.lval > SAL_MAX_UINT8)
-                        return NULL;
+                        return false;
                     ev->u.byval = (unsigned char) ev->u.lval;
                     ev->et = ET_byte;
-                    return ev;
+                    return true;
                 case ET_ulong:
                     if (ev->u.ulval > SAL_MAX_UINT8)
-                        return NULL;
+                        return false;
                     ev->u.byval = (unsigned char) ev->u.ulval;
                     ev->et = ET_byte;
-                    return ev;
+                    return true;
                 case ET_hyper:
                     if (ev->u.hval < SAL_MIN_INT8 || ev->u.hval > SAL_MAX_UINT8)
-                        return NULL;
+                        return false;
                     ev->u.byval = (unsigned char) ev->u.hval;
                     ev->et = ET_byte;
-                    return ev;
+                    return true;
                 case ET_uhyper:
                     if (ev->u.uhval > SAL_MAX_UINT8)
-                        return NULL;
+                        return false;
                     ev->u.byval = (unsigned char) ev->u.uhval;
                     ev->et = ET_byte;
-                    return ev;
+                    return true;
                 case ET_boolean:
                     ev->u.byval = ev->u.bval ? 1 : 0;
                     ev->et = ET_byte;
-                    return ev;
+                    return true;
                 case ET_float:
                     if (ev->u.fval < SAL_MIN_INT8 || ev->u.fval > SAL_MAX_UINT8)
-                        return NULL;
+                        return false;
                     ev->u.byval = (unsigned char) ev->u.fval;
                     ev->et = ET_byte;
-                    return ev;
+                    return true;
                 case ET_double:
                     if (ev->u.dval < SAL_MIN_INT8 || ev->u.dval > SAL_MAX_UINT8)
-                        return NULL;
+                        return false;
                     ev->u.byval = (unsigned char) ev->u.dval;
                     ev->et = ET_byte;
-                    return ev;
+                    return true;
                 case ET_byte:
-                    return ev;
+                    return true;
                 default:
                     OSL_ASSERT(false);
-                    return NULL;
+                    return false;
             }
         default:
             OSL_ASSERT(false);
-            return NULL;
+            return false;
     }
 }
 
@@ -747,14 +747,16 @@ AstExprValue* AstExpression::coerce(ExprType t, bool bAssign)
             break;
     }
 
-    AstExprValue* const coerced(coerce_value(copy, t));
-    if (!coerced)
+    if (!coerce_value(copy, t))
+    {
         delete copy;
+        copy = nullptr;
+    }
 
     if (bAssign)
-        m_exprValue = coerced;
+        m_exprValue = copy;
 
-    return coerced;
+    return copy;
 }
 
 void AstExpression::evaluate()