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