idlc/source/astexpression.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <astexpression.hxx>
  21 #include <astconstant.hxx>
  22 #include <astscope.hxx>
  23 #include <errorhandler.hxx>
  24
  25 #include <o3tl/float_int_conversion.hxx>
  26 #include <osl/diagnose.h>
  27
  28 #include <limits.h>
  29 #include <float.h>
  30 #include <memory>
  31
  32 AstExpression::AstExpression(ExprComb c, AstExpression* pExpr1, AstExpression* pExpr2)
  33     : m_combOperator(c)
  34     , m_subExpr1(pExpr1)
  35     , m_subExpr2(pExpr2)
  36 {
  37 }
  38
  39 AstExpression::AstExpression(sal_Int32 l)
  40     : m_combOperator(ExprComb::NONE)
  41 {
  42     m_exprValue.reset(new AstExprValue);
  43     m_exprValue->et = ET_long;
  44     m_exprValue->u.lval = l;
  45 }
  46
  47 AstExpression::AstExpression(sal_Int32 l, ExprType et)
  48     : m_combOperator(ExprComb::NONE)
  49 {
  50     m_exprValue.reset(new AstExprValue);
  51     m_exprValue->et = et;
  52     m_exprValue->u.lval = l;
  53 }
  54
  55 AstExpression::AstExpression(sal_Int64 h)
  56     : m_combOperator(ExprComb::NONE)
  57 {
  58     m_exprValue.reset(new AstExprValue);
  59     m_exprValue->et = ET_hyper;
  60     m_exprValue->u.hval = h;
  61 }
  62
  63 AstExpression::AstExpression(sal_uInt64 uh)
  64     : m_combOperator(ExprComb::NONE)
  65 {
  66     m_exprValue.reset(new AstExprValue);
  67     m_exprValue->et = ET_uhyper;
  68     m_exprValue->u.uhval = uh;
  69 }
  70
  71 AstExpression::AstExpression(double d)
  72     : m_combOperator(ExprComb::NONE)
  73 {
  74     m_exprValue.reset(new AstExprValue);
  75     m_exprValue->et = ET_double;
  76     m_exprValue->u.dval = d;
  77 }
  78
  79 AstExpression::AstExpression(OString* scopedName)
  80     : m_combOperator(ExprComb::Symbol)
  81 {
  82     if (scopedName)
  83         m_xSymbolicName = *scopedName;
  84 }
  85
  86 AstExpression::~AstExpression() {}
  87
  88 /*
  89  * Perform the coercion from the given AstExprValue to the requested
  90  * ExprType. Return an AstExprValue if successful, NULL if failed.
  91  * must be done for hyper, uhyper
  92  */
  93 static bool coerce_value(AstExprValue* ev, ExprType t)
  94 {
  95     if (ev == nullptr)
  96         return false;
  97
  98     switch (t)
  99     {
 100         case ET_short:
 101             switch (ev->et)
 102             {
 103                 case ET_short:
 104                     return true;
 105                 case ET_ushort:
 106                 {
 107                     if (ev->u.usval > SAL_MAX_INT16)
 108                         return false;
 109                     auto tmp = static_cast<sal_Int16>(ev->u.usval);
 110                     ev->u.sval = tmp;
 111                     ev->et = ET_short;
 112                     return true;
 113                 }
 114                 case ET_long:
 115                 {
 116                     if (ev->u.lval < SAL_MIN_INT16 || ev->u.lval > SAL_MAX_INT16)
 117                         return false;
 118                     auto tmp = static_cast<sal_Int16>(ev->u.lval);
 119                     ev->u.sval = tmp;
 120                     ev->et = ET_short;
 121                     return true;
 122                 }
 123                 case ET_ulong:
 124                 {
 125                     if (ev->u.ulval > SAL_MAX_INT16)
 126                         return false;
 127                     auto tmp = static_cast<sal_Int16>(ev->u.ulval);
 128                     ev->u.sval = tmp;
 129                     ev->et = ET_short;
 130                     return true;
 131                 }
 132                 case ET_hyper:
 133                 {
 134                     if (ev->u.hval < SAL_MIN_INT16 || ev->u.hval > SAL_MAX_INT16)
 135                         return false;
 136                     auto tmp = static_cast<sal_Int16>(ev->u.hval);
 137                     ev->u.sval = tmp;
 138                     ev->et = ET_short;
 139                     return true;
 140                 }
 141                 case ET_uhyper:
 142                 {
 143                     if (ev->u.uhval > SAL_MAX_INT16)
 144                         return false;
 145                     auto tmp = static_cast<sal_Int16>(ev->u.uhval);
 146                     ev->u.sval = tmp;
 147                     ev->et = ET_short;
 148                     return true;
 149                 }
 150                 case ET_boolean:
 151                 {
 152                     auto tmp = static_cast<sal_Int16>(ev->u.bval);
 153                     ev->u.sval = tmp;
 154                     ev->et = ET_short;
 155                     return true;
 156                 }
 157                 case ET_float:
 158                 {
 159                     if (!(o3tl::convertsToAtLeast(o3tl::roundAway(ev->u.fval), SAL_MIN_INT16)
 160                           && o3tl::convertsToAtMost(o3tl::roundAway(ev->u.fval), SAL_MAX_INT16)))
 161                     {
 162                         return false;
 163                     }
 164                     auto tmp = static_cast<sal_Int16>(ev->u.fval);
 165                     ev->u.sval = tmp;
 166                     ev->et = ET_short;
 167                     return true;
 168                 }
 169                 case ET_double:
 170                 {
 171                     if (!(o3tl::convertsToAtLeast(o3tl::roundAway(ev->u.dval), SAL_MIN_INT16)
 172                           && o3tl::convertsToAtMost(o3tl::roundAway(ev->u.dval), SAL_MAX_INT16)))
 173                     {
 174                         return false;
 175                     }
 176                     auto tmp = static_cast<sal_Int16>(ev->u.dval);
 177                     ev->u.sval = tmp;
 178                     ev->et = ET_short;
 179                     return true;
 180                 }
 181                 case ET_byte:
 182                 {
 183                     auto tmp = static_cast<sal_Int16>(ev->u.byval);
 184                     ev->u.sval = tmp;
 185                     ev->et = ET_short;
 186                     return true;
 187                 }
 188                 default:
 189                     OSL_ASSERT(false);
 190                     return false;
 191             }
 192         case ET_ushort:
 193             switch (ev->et)
 194             {
 195                 case ET_short:
 196                 {
 197                     if (ev->u.sval < 0)
 198                         return false;
 199                     auto tmp = static_cast<sal_uInt16>(ev->u.sval);
 200                     ev->u.usval = tmp;
 201                     ev->et = ET_ushort;
 202                     return true;
 203                 }
 204                 case ET_ushort:
 205                     return true;
 206                 case ET_long:
 207                 {
 208                     if (ev->u.lval < 0 || ev->u.lval > SAL_MAX_UINT16)
 209                         return false;
 210                     auto tmp = static_cast<sal_uInt16>(ev->u.lval);
 211                     ev->u.usval = tmp;
 212                     ev->et = ET_ushort;
 213                     return true;
 214                 }
 215                 case ET_ulong:
 216                 {
 217                     if (ev->u.ulval > SAL_MAX_UINT16)
 218                         return false;
 219                     auto tmp = static_cast<sal_uInt16>(ev->u.ulval);
 220                     ev->u.usval = tmp;
 221                     ev->et = ET_ushort;
 222                     return true;
 223                 }
 224                 case ET_hyper:
 225                 {
 226                     if (ev->u.hval < 0 || ev->u.hval > SAL_MAX_UINT16)
 227                         return false;
 228                     auto tmp = static_cast<sal_uInt16>(ev->u.hval);
 229                     ev->u.usval = tmp;
 230                     ev->et = ET_ushort;
 231                     return true;
 232                 }
 233                 case ET_uhyper:
 234                 {
 235                     if (ev->u.uhval > SAL_MAX_UINT16)
 236                         return false;
 237                     auto tmp = static_cast<sal_uInt16>(ev->u.uhval);
 238                     ev->u.usval = tmp;
 239                     ev->et = ET_ushort;
 240                     return true;
 241                 }
 242                 case ET_boolean:
 243                 {
 244                     auto tmp = static_cast<sal_uInt16>(ev->u.bval);
 245                     ev->u.usval = tmp;
 246                     ev->et = ET_short;
 247                     return true;
 248                 }
 249                 case ET_float:
 250                 {
 251                     if (ev->u.fval < 0.0
 252                         || !o3tl::convertsToAtMost(o3tl::roundAway(ev->u.fval), SAL_MAX_UINT16))
 253                     {
 254                         return false;
 255                     }
 256                     auto tmp = static_cast<sal_uInt16>(ev->u.fval);
 257                     ev->u.usval = tmp;
 258                     ev->et = ET_short;
 259                     return true;
 260                 }
 261                 case ET_double:
 262                 {
 263                     if (ev->u.dval < 0.0
 264                         || !o3tl::convertsToAtMost(o3tl::roundAway(ev->u.dval), SAL_MAX_UINT16))
 265                     {
 266                         return false;
 267                     }
 268                     auto tmp = static_cast<sal_uInt16>(ev->u.dval);
 269                     ev->u.usval = tmp;
 270                     ev->et = ET_short;
 271                     return true;
 272                 }
 273                 case ET_byte:
 274                 {
 275                     auto tmp = static_cast<sal_uInt16>(ev->u.byval);
 276                     ev->u.usval = tmp;
 277                     ev->et = ET_ushort;
 278                     return true;
 279                 }
 280                 default:
 281                     OSL_ASSERT(false);
 282                     return false;
 283             }
 284         case ET_long:
 285             switch (ev->et)
 286             {
 287                 case ET_short:
 288                 {
 289                     auto tmp = static_cast<sal_Int32>(ev->u.sval);
 290                     ev->u.lval = tmp;
 291                     ev->et = ET_long;
 292                     return true;
 293                 }
 294                 case ET_ushort:
 295                 {
 296                     auto tmp = static_cast<sal_Int32>(ev->u.usval);
 297                     ev->u.lval = tmp;
 298                     ev->et = ET_long;
 299                     return true;
 300                 }
 301                 case ET_long:
 302                     return true;
 303                 case ET_ulong:
 304                 {
 305                     if (ev->u.ulval > SAL_MAX_INT32)
 306                         return false;
 307                     auto tmp = static_cast<sal_Int32>(ev->u.ulval);
 308                     ev->u.lval = tmp;
 309                     ev->et = ET_long;
 310                     return true;
 311                 }
 312                 case ET_hyper:
 313                 {
 314                     if (ev->u.hval < SAL_MIN_INT32 || ev->u.hval > SAL_MAX_INT32)
 315                         return false;
 316                     auto tmp = static_cast<sal_Int32>(ev->u.hval);
 317                     ev->u.lval = tmp;
 318                     ev->et = ET_long;
 319                     return true;
 320                 }
 321                 case ET_uhyper:
 322                 {
 323                     if (ev->u.uhval > SAL_MAX_INT32)
 324                         return false;
 325                     auto tmp = static_cast<sal_Int32>(ev->u.uhval);
 326                     ev->u.lval = tmp;
 327                     ev->et = ET_long;
 328                     return true;
 329                 }
 330                 case ET_boolean:
 331                 {
 332                     auto tmp = static_cast<sal_Int32>(ev->u.bval);
 333                     ev->u.lval = tmp;
 334                     ev->et = ET_long;
 335                     return true;
 336                 }
 337                 case ET_float:
 338                 {
 339                     if (!(o3tl::convertsToAtLeast(o3tl::roundAway(ev->u.fval), SAL_MIN_INT32)
 340                           && o3tl::convertsToAtMost(o3tl::roundAway(ev->u.fval), SAL_MAX_INT32)))
 341                     {
 342                         return false;
 343                     }
 344                     auto tmp = static_cast<sal_Int32>(ev->u.fval);
 345                     ev->u.lval = tmp;
 346                     ev->et = ET_long;
 347                     return true;
 348                 }
 349                 case ET_double:
 350                 {
 351                     if (!(o3tl::convertsToAtLeast(o3tl::roundAway(ev->u.dval), SAL_MIN_INT32)
 352                           && o3tl::convertsToAtMost(o3tl::roundAway(ev->u.dval), SAL_MAX_INT32)))
 353                     {
 354                         return false;
 355                     }
 356                     auto tmp = static_cast<sal_Int32>(ev->u.dval);
 357                     ev->u.lval = tmp;
 358                     ev->et = ET_long;
 359                     return true;
 360                 }
 361                 case ET_byte:
 362                 {
 363                     auto tmp = static_cast<sal_Int32>(ev->u.byval);
 364                     ev->u.lval = tmp;
 365                     ev->et = ET_long;
 366                     return true;
 367                 }
 368                 default:
 369                     OSL_ASSERT(false);
 370                     return false;
 371             }
 372         case ET_ulong:
 373             switch (ev->et)
 374             {
 375                 case ET_short:
 376                 {
 377                     if (ev->u.sval < 0)
 378                         return false;
 379                     auto tmp = static_cast<sal_uInt32>(ev->u.sval);
 380                     ev->u.ulval = tmp;
 381                     ev->et = ET_ulong;
 382                     return true;
 383                 }
 384                 case ET_ushort:
 385                 {
 386                     auto tmp = static_cast<sal_uInt32>(ev->u.usval);
 387                     ev->u.ulval = tmp;
 388                     ev->et = ET_ulong;
 389                     return true;
 390                 }
 391                 case ET_long:
 392                 {
 393                     if (ev->u.lval < 0)
 394                         return false;
 395                     auto tmp = static_cast<sal_uInt32>(ev->u.lval);
 396                     ev->u.ulval = tmp;
 397                     ev->et = ET_ulong;
 398                     return true;
 399                 }
 400                 case ET_ulong:
 401                     return true;
 402                 case ET_hyper:
 403                 {
 404                     if (ev->u.hval < 0 || ev->u.hval > SAL_MAX_UINT32)
 405                         return false;
 406                     auto tmp = static_cast<sal_uInt32>(ev->u.hval);
 407                     ev->u.lval = tmp;
 408                     ev->et = ET_ulong;
 409                     return true;
 410                 }
 411                 case ET_uhyper:
 412                 {
 413                     if (ev->u.uhval > SAL_MAX_UINT32)
 414                         return false;
 415                     auto tmp = static_cast<sal_uInt32>(ev->u.uhval);
 416                     ev->u.ulval = tmp;
 417                     ev->et = ET_ulong;
 418                     return true;
 419                 }
 420                 case ET_boolean:
 421                 {
 422                     auto tmp = static_cast<sal_uInt32>(ev->u.bval);
 423                     ev->u.ulval = tmp;
 424                     ev->et = ET_ulong;
 425                     return true;
 426                 }
 427                 case ET_float:
 428                 {
 429                     if (ev->u.fval < 0.0
 430                         || !o3tl::convertsToAtMost(o3tl::roundAway(ev->u.fval), SAL_MAX_UINT32))
 431                     {
 432                         return false;
 433                     }
 434                     auto tmp = static_cast<sal_uInt32>(ev->u.fval);
 435                     ev->u.ulval = tmp;
 436                     ev->et = ET_ulong;
 437                     return true;
 438                 }
 439                 case ET_double:
 440                 {
 441                     if (ev->u.dval < 0.0
 442                         || !o3tl::convertsToAtMost(o3tl::roundAway(ev->u.dval), SAL_MAX_UINT32))
 443                     {
 444                         return false;
 445                     }
 446                     auto tmp = static_cast<sal_uInt32>(ev->u.dval);
 447                     ev->u.ulval = tmp;
 448                     ev->et = ET_ulong;
 449                     return true;
 450                 }
 451                 case ET_byte:
 452                 {
 453                     auto tmp = static_cast<sal_uInt32>(ev->u.byval);
 454                     ev->u.ulval = tmp;
 455                     ev->et = ET_ulong;
 456                     return true;
 457                 }
 458                 default:
 459                     OSL_ASSERT(false);
 460                     return false;
 461             }
 462         case ET_hyper:
 463             switch (ev->et)
 464             {
 465                 case ET_short:
 466                 {
 467                     auto tmp = static_cast<sal_Int64>(ev->u.sval);
 468                     ev->u.hval = tmp;
 469                     ev->et = ET_hyper;
 470                     return true;
 471                 }
 472                 case ET_ushort:
 473                 {
 474                     auto tmp = static_cast<sal_Int64>(ev->u.usval);
 475                     ev->u.hval = tmp;
 476                     ev->et = ET_hyper;
 477                     return true;
 478                 }
 479                 case ET_long:
 480                 {
 481                     auto tmp = static_cast<sal_Int64>(ev->u.lval);
 482                     ev->u.hval = tmp;
 483                     ev->et = ET_hyper;
 484                     return true;
 485                 }
 486                 case ET_ulong:
 487                 {
 488                     auto tmp = static_cast<sal_Int64>(ev->u.ulval);
 489                     ev->u.hval = tmp;
 490                     ev->et = ET_hyper;
 491                     return true;
 492                 }
 493                 case ET_hyper:
 494                     return true;
 495                 case ET_uhyper:
 496                 {
 497                     if (ev->u.uhval > SAL_MAX_INT64)
 498                         return false;
 499                     auto tmp = static_cast<sal_Int64>(ev->u.uhval);
 500                     ev->u.hval = tmp;
 501                     ev->et = ET_long;
 502                     return true;
 503                 }
 504                 case ET_boolean:
 505                 {
 506                     auto tmp = static_cast<sal_Int64>(ev->u.bval);
 507                     ev->u.hval = tmp;
 508                     ev->et = ET_hyper;
 509                     return true;
 510                 }
 511                 case ET_float:
 512                 {
 513                     if (!(o3tl::convertsToAtLeast(o3tl::roundAway(ev->u.fval), SAL_MIN_INT64)
 514                           && o3tl::convertsToAtMost(o3tl::roundAway(ev->u.fval), SAL_MAX_INT64)))
 515                     {
 516                         return false;
 517                     }
 518                     auto tmp = static_cast<sal_Int64>(ev->u.fval);
 519                     ev->u.hval = tmp;
 520                     ev->et = ET_hyper;
 521                     return true;
 522                 }
 523                 case ET_double:
 524                 {
 525                     if (!(o3tl::convertsToAtLeast(o3tl::roundAway(ev->u.dval), SAL_MIN_INT64)
 526                           && o3tl::convertsToAtMost(o3tl::roundAway(ev->u.dval), SAL_MAX_INT64)))
 527                     {
 528                         return false;
 529                     }
 530                     auto tmp = static_cast<sal_Int64>(ev->u.dval);
 531                     ev->u.hval = tmp;
 532                     ev->et = ET_hyper;
 533                     return true;
 534                 }
 535                 case ET_byte:
 536                 {
 537                     auto tmp = static_cast<sal_Int64>(ev->u.byval);
 538                     ev->u.hval = tmp;
 539                     ev->et = ET_hyper;
 540                     return true;
 541                 }
 542                 default:
 543                     OSL_ASSERT(false);
 544                     return false;
 545             }
 546         case ET_uhyper:
 547             switch (ev->et)
 548             {
 549                 case ET_short:
 550                 {
 551                     if (ev->u.sval < 0)
 552                         return false;
 553                     auto tmp = static_cast<sal_uInt64>(ev->u.sval);
 554                     ev->u.uhval = tmp;
 555                     ev->et = ET_uhyper;
 556                     return true;
 557                 }
 558                 case ET_ushort:
 559                 {
 560                     auto tmp = static_cast<sal_uInt64>(ev->u.usval);
 561                     ev->u.uhval = tmp;
 562                     ev->et = ET_uhyper;
 563                     return true;
 564                 }
 565                 case ET_long:
 566                 {
 567                     if (ev->u.lval < 0)
 568                         return false;
 569                     auto tmp = static_cast<sal_uInt64>(ev->u.lval);
 570                     ev->u.uhval = tmp;
 571                     ev->et = ET_uhyper;
 572                     return true;
 573                 }
 574                 case ET_ulong:
 575                 {
 576                     auto tmp = static_cast<sal_uInt64>(ev->u.ulval);
 577                     ev->u.uhval = tmp;
 578                     ev->et = ET_uhyper;
 579                     return true;
 580                 }
 581                 case ET_hyper:
 582                 {
 583                     if (ev->u.hval < 0)
 584                         return false;
 585                     auto tmp = static_cast<sal_uInt64>(ev->u.hval);
 586                     ev->u.uhval = tmp;
 587                     ev->et = ET_uhyper;
 588                     return true;
 589                 }
 590                 case ET_uhyper:
 591                     return true;
 592                 case ET_boolean:
 593                 {
 594                     auto tmp = static_cast<sal_uInt64>(ev->u.bval);
 595                     ev->u.uhval = tmp;
 596                     ev->et = ET_uhyper;
 597                     return true;
 598                 }
 599                 case ET_float:
 600                 {
 601                     if (ev->u.fval < 0.0
 602                         || !o3tl::convertsToAtMost(o3tl::roundAway(ev->u.fval), SAL_MAX_UINT64))
 603                     {
 604                         return false;
 605                     }
 606                     auto tmp = static_cast<sal_uInt64>(ev->u.fval);
 607                     ev->u.uhval = tmp;
 608                     ev->et = ET_uhyper;
 609                     return true;
 610                 }
 611                 case ET_double:
 612                 {
 613                     if (ev->u.dval < 0.0
 614                         || !o3tl::convertsToAtMost(o3tl::roundAway(ev->u.dval), SAL_MAX_UINT64))
 615                     {
 616                         return false;
 617                     }
 618                     auto tmp = static_cast<sal_uInt64>(ev->u.dval);
 619                     ev->u.uhval = tmp;
 620                     ev->et = ET_uhyper;
 621                     return true;
 622                 }
 623                 case ET_byte:
 624                 {
 625                     auto tmp = static_cast<sal_uInt64>(ev->u.byval);
 626                     ev->u.uhval = tmp;
 627                     ev->et = ET_uhyper;
 628                     return true;
 629                 }
 630                 default:
 631                     OSL_ASSERT(false);
 632                     return false;
 633             }
 634         case ET_boolean:
 635             switch (ev->et)
 636             {
 637                 case ET_short:
 638                     ev->u.bval = ev->u.sval != 0;
 639                     ev->et = ET_boolean;
 640                     return true;
 641                 case ET_ushort:
 642                     ev->u.bval = ev->u.usval != 0;
 643                     ev->et = ET_boolean;
 644                     return true;
 645                 case ET_long:
 646                     ev->u.bval = ev->u.lval != 0;
 647                     ev->et = ET_boolean;
 648                     return true;
 649                 case ET_ulong:
 650                     ev->u.bval = ev->u.ulval != 0;
 651                     ev->et = ET_boolean;
 652                     return true;
 653                 case ET_hyper:
 654                     ev->u.bval = ev->u.hval != 0;
 655                     ev->et = ET_boolean;
 656                     return true;
 657                 case ET_uhyper:
 658                     ev->u.bval = ev->u.uhval != 0;
 659                     ev->et = ET_boolean;
 660                     return true;
 661                 case ET_boolean:
 662                     return true;
 663                 case ET_float:
 664                     ev->u.bval = ev->u.fval != 0.0;
 665                     ev->et = ET_boolean;
 666                     return true;
 667                 case ET_double:
 668                     ev->u.bval = ev->u.dval != 0.0;
 669                     ev->et = ET_boolean;
 670                     return true;
 671                 case ET_byte:
 672                     ev->u.bval = ev->u.byval != 0;
 673                     ev->et = ET_boolean;
 674                     return true;
 675                 default:
 676                     OSL_ASSERT(false);
 677                     return false;
 678             }
 679         case ET_float:
 680             switch (ev->et)
 681             {
 682                 case ET_short:
 683                 {
 684                     auto tmp = static_cast<float>(ev->u.sval);
 685                     ev->u.fval = tmp;
 686                     ev->et = ET_float;
 687                     return true;
 688                 }
 689                 case ET_ushort:
 690                 {
 691                     auto tmp = static_cast<float>(ev->u.usval);
 692                     ev->u.fval = tmp;
 693                     ev->et = ET_float;
 694                     return true;
 695                 }
 696                 case ET_long:
 697                 {
 698                     auto tmp = static_cast<float>(ev->u.lval);
 699                     ev->u.fval = tmp;
 700                     ev->et = ET_float;
 701                     return true;
 702                 }
 703                 case ET_ulong:
 704                 {
 705                     auto tmp = static_cast<float>(ev->u.ulval);
 706                     ev->u.fval = tmp;
 707                     ev->et = ET_float;
 708                     return true;
 709                 }
 710                 case ET_hyper:
 711                 {
 712                     auto tmp = static_cast<float>(ev->u.hval);
 713                     ev->u.fval = tmp;
 714                     ev->et = ET_float;
 715                     return true;
 716                 }
 717                 case ET_uhyper:
 718                 {
 719                     if (static_cast<float>(ev->u.ulval) > FLT_MAX)
 720                         return false;
 721                     auto tmp = static_cast<float>(ev->u.ulval);
 722                     ev->u.fval = tmp;
 723                     ev->et = ET_float;
 724                     return true;
 725                 }
 726                 case ET_boolean:
 727                     ev->u.fval = ev->u.bval ? 1.0f : 0.0f;
 728                     ev->et = ET_float;
 729                     return true;
 730                 case ET_float:
 731                     return true;
 732                 case ET_double:
 733                 {
 734                     if (static_cast<float>(ev->u.dval) > FLT_MAX
 735                         || static_cast<float>(ev->u.dval) < -FLT_MAX)
 736                         return false;
 737                     auto tmp = static_cast<float>(ev->u.dval);
 738                     ev->u.fval = tmp;
 739                     ev->et = ET_float;
 740                     return true;
 741                 }
 742                 case ET_byte:
 743                 {
 744                     auto tmp = static_cast<float>(ev->u.byval);
 745                     ev->u.fval = tmp;
 746                     ev->et = ET_float;
 747                     return true;
 748                 }
 749                 default:
 750                     OSL_ASSERT(false);
 751                     return false;
 752             }
 753         case ET_double:
 754             switch (ev->et)
 755             {
 756                 case ET_short:
 757                 {
 758                     auto tmp = static_cast<double>(ev->u.sval);
 759                     ev->u.dval = tmp;
 760                     ev->et = ET_double;
 761                     return true;
 762                 }
 763                 case ET_ushort:
 764                 {
 765                     auto tmp = static_cast<double>(ev->u.usval);
 766                     ev->u.dval = tmp;
 767                     ev->et = ET_double;
 768                     return true;
 769                 }
 770                 case ET_long:
 771                 {
 772                     auto tmp = static_cast<double>(ev->u.lval);
 773                     ev->u.dval = tmp;
 774                     ev->et = ET_double;
 775                     return true;
 776                 }
 777                 case ET_ulong:
 778                 {
 779                     auto tmp = static_cast<double>(ev->u.ulval);
 780                     ev->u.dval = tmp;
 781                     ev->et = ET_double;
 782                     return true;
 783                 }
 784                 case ET_hyper:
 785                 {
 786                     auto tmp = static_cast<double>(ev->u.hval);
 787                     ev->u.dval = tmp;
 788                     ev->et = ET_double;
 789                     return true;
 790                 }
 791                 case ET_uhyper:
 792                 {
 793                     if (ev->u.dval > FLT_MAX || ev->u.dval < -FLT_MAX)
 794                         return false;
 795                     auto tmp = static_cast<double>(ev->u.ulval);
 796                     ev->u.dval = tmp;
 797                     ev->et = ET_double;
 798                     return true;
 799                 }
 800                 case ET_boolean:
 801                     ev->u.dval = ev->u.bval ? 1.0 : 0.0;
 802                     ev->et = ET_double;
 803                     return true;
 804                 case ET_float:
 805                 {
 806                     auto tmp = static_cast<double>(ev->u.fval);
 807                     ev->u.dval = tmp;
 808                     ev->et = ET_double;
 809                     return true;
 810                 }
 811                 case ET_double:
 812                     return true;
 813                 case ET_byte:
 814                 {
 815                     auto tmp = static_cast<double>(ev->u.byval);
 816                     ev->u.dval = tmp;
 817                     ev->et = ET_double;
 818                     return true;
 819                 }
 820                 default:
 821                     OSL_ASSERT(false);
 822                     return false;
 823             }
 824         case ET_byte:
 825             switch (ev->et)
 826             {
 827                 case ET_short:
 828                 {
 829                     if (ev->u.sval < SAL_MIN_INT8 || ev->u.sval > SAL_MAX_UINT8)
 830                         return false;
 831                     auto tmp = static_cast<unsigned char>(ev->u.sval);
 832                     ev->u.byval = tmp;
 833                     ev->et = ET_byte;
 834                     return true;
 835                 }
 836                 case ET_ushort:
 837                 {
 838                     if (ev->u.usval > SAL_MAX_UINT8)
 839                         return false;
 840                     auto tmp = static_cast<unsigned char>(ev->u.usval);
 841                     ev->u.byval = tmp;
 842                     ev->et = ET_byte;
 843                     return true;
 844                 }
 845                 case ET_long:
 846                 {
 847                     if (ev->u.lval < SAL_MIN_INT8 || ev->u.lval > SAL_MAX_UINT8)
 848                         return false;
 849                     auto tmp = static_cast<unsigned char>(ev->u.lval);
 850                     ev->u.byval = tmp;
 851                     ev->et = ET_byte;
 852                     return true;
 853                 }
 854                 case ET_ulong:
 855                 {
 856                     if (ev->u.ulval > SAL_MAX_UINT8)
 857                         return false;
 858                     auto tmp = static_cast<unsigned char>(ev->u.ulval);
 859                     ev->u.byval = tmp;
 860                     ev->et = ET_byte;
 861                     return true;
 862                 }
 863                 case ET_hyper:
 864                 {
 865                     if (ev->u.hval < SAL_MIN_INT8 || ev->u.hval > SAL_MAX_UINT8)
 866                         return false;
 867                     auto tmp = static_cast<unsigned char>(ev->u.hval);
 868                     ev->u.byval = tmp;
 869                     ev->et = ET_byte;
 870                     return true;
 871                 }
 872                 case ET_uhyper:
 873                 {
 874                     if (ev->u.uhval > SAL_MAX_UINT8)
 875                         return false;
 876                     auto tmp = static_cast<unsigned char>(ev->u.uhval);
 877                     ev->u.byval = tmp;
 878                     ev->et = ET_byte;
 879                     return true;
 880                 }
 881                 case ET_boolean:
 882                     ev->u.byval = ev->u.bval ? 1 : 0;
 883                     ev->et = ET_byte;
 884                     return true;
 885                 case ET_float:
 886                 {
 887                     if (!(o3tl::convertsToAtLeast(o3tl::roundAway(ev->u.fval), SAL_MIN_INT8)
 888                           && o3tl::convertsToAtMost(o3tl::roundAway(ev->u.fval), SAL_MAX_UINT8)))
 889                     {
 890                         return false;
 891                     }
 892                     auto tmp = static_cast<unsigned char>(static_cast<sal_Int32>(ev->u.fval));
 893                     ev->u.byval = tmp;
 894                     ev->et = ET_byte;
 895                     return true;
 896                 }
 897                 case ET_double:
 898                 {
 899                     if (!(o3tl::convertsToAtLeast(o3tl::roundAway(ev->u.dval), SAL_MIN_INT8)
 900                           && o3tl::convertsToAtMost(o3tl::roundAway(ev->u.dval), SAL_MAX_UINT8)))
 901                     {
 902                         return false;
 903                     }
 904                     auto tmp = static_cast<unsigned char>(static_cast<sal_Int32>(ev->u.dval));
 905                     ev->u.byval = tmp;
 906                     ev->et = ET_byte;
 907                     return true;
 908                 }
 909                 case ET_byte:
 910                     return true;
 911                 default:
 912                     OSL_ASSERT(false);
 913                     return false;
 914             }
 915         default:
 916             OSL_ASSERT(false);
 917             return false;
 918     }
 919 }
 920
 921 bool AstExpression::coerce(ExprType t)
 922 {
 923     /*
 924      * Is it already of the right type?
 925      */
 926     if (m_exprValue != nullptr && m_exprValue->et == t)
 927         return true;
 928     /*
 929      * OK, must coerce
 930      *
 931      * First, evaluate it, then try to coerce result type
 932      * If already evaluated, return the result
 933      */
 934     evaluate();
 935     if (m_exprValue == nullptr)
 936         return false;
 937
 938     if (!coerce_value(m_exprValue.get(), t))
 939         m_exprValue.reset();
 940
 941     return m_exprValue != nullptr;
 942 }
 943
 944 bool AstExpression::compareLong(AstExpression* pExpr)
 945 {
 946     bool bRet = false;
 947     if (m_combOperator != pExpr->m_combOperator)
 948         return bRet;
 949     evaluate();
 950     pExpr->evaluate();
 951     if (m_exprValue == nullptr || pExpr->getExprValue() == nullptr)
 952         return bRet;
 953     if (m_exprValue->et != pExpr->getExprValue()->et)
 954         return bRet;
 955     switch (m_exprValue->et)
 956     {
 957         case ET_long:
 958             bRet = m_exprValue->u.lval == pExpr->getExprValue()->u.lval;
 959             break;
 960         default:
 961             OSL_ASSERT(false);
 962             bRet = false;
 963             break;
 964     }
 965     return bRet;
 966 }
 967
 968 void AstExpression::evaluate()
 969 {
 970     /*
 971      * Already evaluated?
 972      */
 973     if (m_exprValue != nullptr)
 974         return;
 975     /*
 976      * OK, must evaluate operator
 977      */
 978     switch (m_combOperator)
 979     {
 980         case ExprComb::Add:
 981         case ExprComb::Minus:
 982         case ExprComb::Mul:
 983         case ExprComb::Div:
 984         case ExprComb::Mod:
 985             m_exprValue = eval_bin_op();
 986             break;
 987         case ExprComb::Or:
 988         case ExprComb::Xor:
 989         case ExprComb::And:
 990         case ExprComb::Left:
 991         case ExprComb::Right:
 992             m_exprValue = eval_bit_op();
 993             break;
 994         case ExprComb::UPlus:
 995         case ExprComb::UMinus:
 996             m_exprValue = eval_un_op();
 997             break;
 998         case ExprComb::Symbol:
 999             m_exprValue = eval_symbol();
1000             break;
1001         case ExprComb::NONE:
1002             break;
1003     }
1004 }
1005
1006 std::unique_ptr<AstExprValue> AstExpression::eval_bin_op()
1007 {
1008     ExprType eType = ET_double;
1009
1010     if (m_combOperator == ExprComb::Mod)
1011         eType = ET_hyper;
1012
1013     if (m_subExpr1 == nullptr || m_subExpr2 == nullptr)
1014         return nullptr;
1015     m_subExpr1->evaluate();
1016     if (m_subExpr1->getExprValue() == nullptr)
1017         return nullptr;
1018     if (!m_subExpr1->coerce(eType))
1019         return nullptr;
1020     m_subExpr2->evaluate();
1021     if (m_subExpr2->getExprValue() == nullptr)
1022         return nullptr;
1023     if (!m_subExpr2->coerce(eType))
1024         return nullptr;
1025
1026     std::unique_ptr<AstExprValue> retval(new AstExprValue);
1027     retval->et = eType;
1028
1029     switch (m_combOperator)
1030     {
1031         case ExprComb::Mod:
1032             if (m_subExpr2->getExprValue()->u.hval == 0)
1033                 return nullptr;
1034             retval->u.hval
1035                 = m_subExpr1->getExprValue()->u.hval % m_subExpr2->getExprValue()->u.hval;
1036             break;
1037         case ExprComb::Add:
1038             retval->u.dval
1039                 = m_subExpr1->getExprValue()->u.dval + m_subExpr2->getExprValue()->u.dval;
1040             break;
1041         case ExprComb::Minus:
1042             retval->u.dval
1043                 = m_subExpr1->getExprValue()->u.dval - m_subExpr2->getExprValue()->u.dval;
1044             break;
1045         case ExprComb::Mul:
1046             retval->u.dval
1047                 = m_subExpr1->getExprValue()->u.dval * m_subExpr2->getExprValue()->u.dval;
1048             break;
1049         case ExprComb::Div:
1050             if (m_subExpr2->getExprValue()->u.dval == 0.0)
1051                 return nullptr;
1052             retval->u.dval
1053                 = m_subExpr1->getExprValue()->u.dval / m_subExpr2->getExprValue()->u.dval;
1054             break;
1055         default:
1056             return nullptr;
1057     }
1058
1059     return retval;
1060 }
1061
1062 std::unique_ptr<AstExprValue> AstExpression::eval_bit_op()
1063 {
1064     if (m_subExpr1 == nullptr || m_subExpr2 == nullptr)
1065         return nullptr;
1066     m_subExpr1->evaluate();
1067     if (m_subExpr1->getExprValue() == nullptr)
1068         return nullptr;
1069     if (!m_subExpr1->coerce(ET_long))
1070         return nullptr;
1071     m_subExpr2->evaluate();
1072     if (m_subExpr2->getExprValue() == nullptr)
1073         return nullptr;
1074     if (!m_subExpr2->coerce(ET_long))
1075         return nullptr;
1076
1077     std::unique_ptr<AstExprValue> retval(new AstExprValue);
1078     retval->et = ET_long;
1079
1080     switch (m_combOperator)
1081     {
1082         case ExprComb::Or:
1083             retval->u.lval
1084                 = m_subExpr1->getExprValue()->u.lval | m_subExpr2->getExprValue()->u.lval;
1085             break;
1086         case ExprComb::Xor:
1087             retval->u.lval
1088                 = m_subExpr1->getExprValue()->u.lval ^ m_subExpr2->getExprValue()->u.lval;
1089             break;
1090         case ExprComb::And:
1091             retval->u.lval
1092                 = m_subExpr1->getExprValue()->u.lval & m_subExpr2->getExprValue()->u.lval;
1093             break;
1094         case ExprComb::Left:
1095             retval->u.lval = m_subExpr1->getExprValue()->u.lval
1096                              << m_subExpr2->getExprValue()->u.lval;
1097             break;
1098         case ExprComb::Right:
1099             retval->u.lval
1100                 = m_subExpr1->getExprValue()->u.lval >> m_subExpr2->getExprValue()->u.lval;
1101             break;
1102         default:
1103             return nullptr;
1104     }
1105
1106     return retval;
1107 }
1108
1109 std::unique_ptr<AstExprValue> AstExpression::eval_un_op()
1110 {
1111     if (m_subExpr1 == nullptr)
1112         return nullptr;
1113     m_subExpr1->evaluate();
1114     if (m_subExpr1->getExprValue() == nullptr)
1115         return nullptr;
1116     if (!m_subExpr1->coerce(ET_double))
1117         return nullptr;
1118
1119     std::unique_ptr<AstExprValue> retval(new AstExprValue);
1120     retval->et = ET_double;
1121
1122     switch (m_combOperator)
1123     {
1124         case ExprComb::UPlus:
1125             retval->u.lval = m_subExpr1->getExprValue()->u.lval;
1126             break;
1127         case ExprComb::UMinus:
1128             retval->u.lval = -(m_subExpr1->getExprValue()->u.lval);
1129             break;
1130         default:
1131             return nullptr;
1132     }
1133
1134     return retval;
1135 }
1136
1137 std::unique_ptr<AstExprValue> AstExpression::eval_symbol()
1138 {
1139     AstScope* pScope = nullptr;
1140     AstDeclaration* pDecl;
1141     AstConstant* pConst;
1142
1143     /*
1144      * Is there a symbol stored?
1145      */
1146     if (!m_xSymbolicName)
1147     {
1148         ErrorHandler::evalError(this);
1149         return nullptr;
1150     }
1151     /*
1152      * Get current scope for lookup
1153      */
1154     if (idlc()->scopes()->depth() > 0)
1155         pScope = idlc()->scopes()->topNonNull();
1156     if (!pScope)
1157     {
1158         ErrorHandler::lookupError(*m_xSymbolicName);
1159         return nullptr;
1160     }
1161     /*
1162      * Do lookup
1163      */
1164     pDecl = pScope->lookupByName(*m_xSymbolicName);
1165     if (pDecl == nullptr)
1166     {
1167         ErrorHandler::lookupError(*m_xSymbolicName);
1168         return nullptr;
1169     }
1170     /*
1171      * Is it a constant?
1172      */
1173     if (pDecl->getNodeType() != NT_const && pDecl->getNodeType() != NT_enum_val)
1174     {
1175         ErrorHandler::constantExpected(pDecl, *m_xSymbolicName);
1176         return nullptr;
1177     }
1178     if (!ErrorHandler::checkPublished(pDecl))
1179     {
1180         return nullptr;
1181     }
1182     /*
1183      * OK, now evaluate the constant we just got, to produce its value
1184      */
1185     pConst = static_cast<AstConstant*>(pDecl);
1186     pConst->getConstValue()->evaluate();
1187     auto const val = pConst->getConstValue()->getExprValue();
1188     return val == nullptr ? nullptr : std::make_unique<AstExprValue>(*val);
1189 }
1190
1191 OString AstExpression::toString()
1192 {
1193     OString exprStr;
1194     if (m_combOperator == ExprComb::Symbol)
1195         return m_xSymbolicName ? *m_xSymbolicName : OString("<Undefined Name>");
1196
1197     if (m_exprValue)
1198     {
1199         switch (m_exprValue->et)
1200         {
1201             case ET_short:
1202                 return OString::number(m_exprValue->u.sval);
1203             case ET_ushort:
1204                 return OString::number(m_exprValue->u.usval);
1205             case ET_long:
1206                 return OString::number(m_exprValue->u.lval);
1207             case ET_ulong:
1208                 return OString::number(m_exprValue->u.ulval);
1209             case ET_hyper:
1210                 return OString::number(m_exprValue->u.hval);
1211             case ET_uhyper:
1212                 return OString::number(m_exprValue->u.uhval);
1213             case ET_float:
1214                 return OString::number(m_exprValue->u.fval);
1215             case ET_double:
1216                 return OString::number(m_exprValue->u.dval);
1217             case ET_byte:
1218                 return OString::number(m_exprValue->u.byval);
1219             case ET_boolean:
1220                 if (m_exprValue->u.lval == 0)
1221                     return "FALSE";
1222                 else
1223                     return "TRUE";
1224             default:
1225                 OSL_ASSERT(false);
1226                 return OString();
1227         }
1228     }
1229
1230     switch (m_combOperator)
1231     {
1232         case ExprComb::UPlus:
1233             exprStr += "+";
1234             break;
1235         case ExprComb::UMinus:
1236             exprStr += "-";
1237             break;
1238         default:
1239             break;
1240     }
1241     if (m_subExpr1)
1242         exprStr += m_subExpr1->toString();
1243     switch (m_combOperator)
1244     {
1245         case ExprComb::Add:
1246             exprStr += " + ";
1247             break;
1248         case ExprComb::Minus:
1249             exprStr += " - ";
1250             break;
1251         case ExprComb::Mul:
1252             exprStr += " * ";
1253             break;
1254         case ExprComb::Div:
1255             exprStr += " / ";
1256             break;
1257         case ExprComb::Mod:
1258             exprStr += " % ";
1259             break;
1260         case ExprComb::Or:
1261             exprStr += " | ";
1262             break;
1263         case ExprComb::Xor:
1264             exprStr += " ^ ";
1265             break;
1266         case ExprComb::And:
1267             exprStr += " & ";
1268             break;
1269         case ExprComb::Left:
1270             exprStr += " << ";
1271             break;
1272         case ExprComb::Right:
1273             exprStr += " >> ";
1274             break;
1275         default:
1276             break;
1277     }
1278
1279     if (m_subExpr2)
1280         exprStr += m_subExpr2->toString();
1281
1282     return exprStr;
1283 }
1284
1285 // Convert the type of an AST_Expression to a char *
1286 const char* exprTypeToString(ExprType t)
1287 {
1288     switch (t)
1289     {
1290         case ET_short:
1291             return "short";
1292         case ET_ushort:
1293             return "unsigned short";
1294         case ET_long:
1295             return "long";
1296         case ET_ulong:
1297             return "unsigned long";
1298         case ET_hyper:
1299             return "hyper";
1300         case ET_uhyper:
1301             return "unsigned hyper";
1302         case ET_float:
1303             return "float";
1304         case ET_double:
1305             return "double";
1306         case ET_char:
1307             return "char";
1308         case ET_byte:
1309             return "byte";
1310         case ET_boolean:
1311             return "boolean";
1312         case ET_string:
1313             return "string";
1314         case ET_any:
1315             return "any";
1316         case ET_type:
1317             return "type";
1318         case ET_void:
1319             return "void";
1320         case ET_none:
1321             return "none";
1322     }
1323
1324     return "unknown";
1325 }
1326
1327 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */