| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_basic.hxx" | |
| #include <math.h> | |
| #include <rtl/math.hxx> | |
| #include "sbcomp.hxx" | |
| #include "expr.hxx" | |
| ////////////////////////////////////////////////////////////////////////// | |
| SbiExprNode::SbiExprNode( void ) | |
| { | |
| pLeft = NULL; | |
| pRight = NULL; | |
| eNodeType = SbxDUMMY; | |
| } | |
| SbiExprNode::SbiExprNode( SbiParser* p, SbiExprNode* l, SbiToken t, SbiExprNode* r ) | |
| { | |
| BaseInit( p ); | |
| pLeft = l; | |
| pRight = r; | |
| eTok = t; | |
| nVal = 0; | |
| eType = SbxVARIANT; // Nodes sind immer Variant | |
| eNodeType = SbxNODE; | |
| bComposite= sal_True; | |
| } | |
| SbiExprNode::SbiExprNode( SbiParser* p, double n, SbxDataType t ) | |
| { | |
| BaseInit( p ); | |
| eType = t; | |
| eNodeType = SbxNUMVAL; | |
| nVal = n; | |
| } | |
| SbiExprNode::SbiExprNode( SbiParser* p, const String& rVal ) | |
| { | |
| BaseInit( p ); | |
| eType = SbxSTRING; | |
| eNodeType = SbxSTRVAL; | |
| aStrVal = rVal; | |
| } | |
| SbiExprNode::SbiExprNode( SbiParser* p, const SbiSymDef& r, SbxDataType t, SbiExprList* l ) | |
| { | |
| BaseInit( p ); | |
| eType = ( t == SbxVARIANT ) ? r.GetType() : t; | |
| eNodeType = SbxVARVAL; | |
| aVar.pDef = (SbiSymDef*) &r; | |
| aVar.pPar = l; | |
| aVar.pvMorePar = NULL; | |
| aVar.pNext= NULL; | |
| // Funktionsergebnisse sind nie starr | |
| bComposite= sal_Bool( aVar.pDef->GetProcDef() != NULL ); | |
| } | |
| // #120061 TypeOf | |
| SbiExprNode::SbiExprNode( SbiParser* p, SbiExprNode* l, sal_uInt16 nId ) | |
| { | |
| BaseInit( p ); | |
| pLeft = l; | |
| eType = SbxBOOL; | |
| eNodeType = SbxTYPEOF; | |
| nTypeStrId = nId; | |
| } | |
| // new <type> | |
| SbiExprNode::SbiExprNode( SbiParser* p, sal_uInt16 nId ) | |
| { | |
| BaseInit( p ); | |
| eType = SbxOBJECT; | |
| eNodeType = SbxNEW; | |
| nTypeStrId = nId; | |
| } | |
| // AB: 17.12.95, Hilfsfunktion fuer Ctor fuer einheitliche Initialisierung | |
| void SbiExprNode::BaseInit( SbiParser* p ) | |
| { | |
| pGen = &p->aGen; | |
| eTok = NIL; | |
| pLeft = NULL; | |
| pRight = NULL; | |
| pWithParent = NULL; | |
| bComposite = sal_False; | |
| bError = sal_False; | |
| } | |
| SbiExprNode::~SbiExprNode() | |
| { | |
| delete pLeft; | |
| delete pRight; | |
| if( IsVariable() ) | |
| { | |
| delete aVar.pPar; | |
| delete aVar.pNext; | |
| SbiExprListVector* pvMorePar = aVar.pvMorePar; | |
| if( pvMorePar ) | |
| { | |
| SbiExprListVector::iterator it; | |
| for( it = pvMorePar->begin() ; it != pvMorePar->end() ; ++it ) | |
| delete *it; | |
| delete pvMorePar; | |
| } | |
| } | |
| } | |
| SbiSymDef* SbiExprNode::GetVar() | |
| { | |
| if( eNodeType == SbxVARVAL ) | |
| return aVar.pDef; | |
| else | |
| return NULL; | |
| } | |
| SbiSymDef* SbiExprNode::GetRealVar() | |
| { | |
| SbiExprNode* p = GetRealNode(); | |
| if( p ) | |
| return p->GetVar(); | |
| else | |
| return NULL; | |
| } | |
| // AB: 18.12.95 | |
| SbiExprNode* SbiExprNode::GetRealNode() | |
| { | |
| if( eNodeType == SbxVARVAL ) | |
| { | |
| SbiExprNode* p = this; | |
| while( p->aVar.pNext ) | |
| p = p->aVar.pNext; | |
| return p; | |
| } | |
| else | |
| return NULL; | |
| } | |
| // Diese Methode setzt den Typ um, falls er in den Integer-Bereich hineinpasst | |
| sal_Bool SbiExprNode::IsIntConst() | |
| { | |
| if( eNodeType == SbxNUMVAL ) | |
| { | |
| if( eType >= SbxINTEGER && eType <= SbxDOUBLE ) | |
| { | |
| double n; | |
| if( nVal >= SbxMININT && nVal <= SbxMAXINT && modf( nVal, &n ) == 0 ) | |
| { | |
| nVal = (double) (short) nVal; | |
| eType = SbxINTEGER; | |
| return sal_True; | |
| } | |
| } | |
| } | |
| return sal_False; | |
| } | |
| sal_Bool SbiExprNode::IsNumber() | |
| { | |
| return sal_Bool( eNodeType == SbxNUMVAL ); | |
| } | |
| sal_Bool SbiExprNode::IsString() | |
| { | |
| return sal_Bool( eNodeType == SbxSTRVAL ); | |
| } | |
| sal_Bool SbiExprNode::IsVariable() | |
| { | |
| return sal_Bool( eNodeType == SbxVARVAL ); | |
| } | |
| sal_Bool SbiExprNode::IsLvalue() | |
| { | |
| return IsVariable(); | |
| } | |
| // Ermitteln der Tiefe eines Baumes | |
| short SbiExprNode::GetDepth() | |
| { | |
| if( IsOperand() ) return 0; | |
| else | |
| { | |
| short d1 = pLeft->GetDepth(); | |
| short d2 = pRight->GetDepth(); | |
| return( (d1 < d2 ) ? d2 : d1 ) + 1; | |
| } | |
| } | |
| // Abgleich eines Baumes: | |
| // 1. Constant Folding | |
| // 2. Typabgleich | |
| // 3. Umwandlung der Operanden in Strings | |
| // 4. Hochziehen der Composite- und Error-Bits | |
| void SbiExprNode::Optimize() | |
| { | |
| FoldConstants(); | |
| CollectBits(); | |
| } | |
| // Hochziehen der Composite- und Fehlerbits | |
| void SbiExprNode::CollectBits() | |
| { | |
| if( pLeft ) | |
| { | |
| pLeft->CollectBits(); | |
| bError |= pLeft->bError; | |
| bComposite |= pLeft->bComposite; | |
| } | |
| if( pRight ) | |
| { | |
| pRight->CollectBits(); | |
| bError |= pRight->bError; | |
| bComposite |= pRight->bComposite; | |
| } | |
| } | |
| // Kann ein Zweig umgeformt werden, wird sal_True zurueckgeliefert. In diesem | |
| // Fall ist das Ergebnis im linken Zweig. | |
| void SbiExprNode::FoldConstants() | |
| { | |
| if( IsOperand() || eTok == LIKE ) return; | |
| if( pLeft ) | |
| pLeft->FoldConstants(); | |
| if( pRight ) | |
| { | |
| pRight->FoldConstants(); | |
| if( pLeft->IsConstant() && pRight->IsConstant() | |
| && pLeft->eNodeType == pRight->eNodeType ) | |
| { | |
| CollectBits(); | |
| if( eTok == CAT ) | |
| // CAT verbindet auch zwei Zahlen miteinander! | |
| eType = SbxSTRING; | |
| if( pLeft->eType == SbxSTRING ) | |
| // Kein Type Mismatch! | |
| eType = SbxSTRING; | |
| if( eType == SbxSTRING ) | |
| { | |
| String rl( pLeft->GetString() ); | |
| String rr( pRight->GetString() ); | |
| delete pLeft; pLeft = NULL; | |
| delete pRight; pRight = NULL; | |
| bComposite = sal_False; | |
| if( eTok == PLUS || eTok == CAT ) | |
| { | |
| eTok = CAT; | |
| // Verkettung: | |
| aStrVal = rl; | |
| aStrVal += rr; | |
| eType = SbxSTRING; | |
| eNodeType = SbxSTRVAL; | |
| } | |
| else | |
| { | |
| eType = SbxDOUBLE; | |
| eNodeType = SbxNUMVAL; | |
| StringCompare eRes = rr.CompareTo( rl ); | |
| switch( eTok ) | |
| { | |
| case EQ: | |
| nVal = ( eRes == COMPARE_EQUAL ) ? SbxTRUE : SbxFALSE; | |
| break; | |
| case NE: | |
| nVal = ( eRes != COMPARE_EQUAL ) ? SbxTRUE : SbxFALSE; | |
| break; | |
| case LT: | |
| nVal = ( eRes == COMPARE_LESS ) ? SbxTRUE : SbxFALSE; | |
| break; | |
| case GT: | |
| nVal = ( eRes == COMPARE_GREATER ) ? SbxTRUE : SbxFALSE; | |
| break; | |
| case LE: | |
| nVal = ( eRes != COMPARE_GREATER ) ? SbxTRUE : SbxFALSE; | |
| break; | |
| case GE: | |
| nVal = ( eRes != COMPARE_LESS ) ? SbxTRUE : SbxFALSE; | |
| break; | |
| default: | |
| pGen->GetParser()->Error( SbERR_CONVERSION ); | |
| bError = sal_True; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| double nl = pLeft->nVal; | |
| double nr = pRight->nVal; | |
| long ll = 0, lr = 0; | |
| long llMod = 0, lrMod = 0; | |
| if( ( eTok >= AND && eTok <= IMP ) | |
| || eTok == IDIV || eTok == MOD ) | |
| { | |
| // Integer-Operationen | |
| sal_Bool err = sal_False; | |
| if( nl > SbxMAXLNG ) err = sal_True, nl = SbxMAXLNG; | |
| else | |
| if( nl < SbxMINLNG ) err = sal_True, nl = SbxMINLNG; | |
| if( nr > SbxMAXLNG ) err = sal_True, nr = SbxMAXLNG; | |
| else | |
| if( nr < SbxMINLNG ) err = sal_True, nr = SbxMINLNG; | |
| ll = (long) nl; lr = (long) nr; | |
| llMod = (long) (nl < 0 ? nl - 0.5 : nl + 0.5); | |
| lrMod = (long) (nr < 0 ? nr - 0.5 : nr + 0.5); | |
| if( err ) | |
| { | |
| pGen->GetParser()->Error( SbERR_MATH_OVERFLOW ); | |
| bError = sal_True; | |
| } | |
| } | |
| sal_Bool bBothInt = sal_Bool( pLeft->eType < SbxSINGLE | |
| && pRight->eType < SbxSINGLE ); | |
| delete pLeft; pLeft = NULL; | |
| delete pRight; pRight = NULL; | |
| nVal = 0; | |
| eType = SbxDOUBLE; | |
| eNodeType = SbxNUMVAL; | |
| bComposite = sal_False; | |
| sal_Bool bCheckType = sal_False; | |
| switch( eTok ) | |
| { | |
| case EXPON: | |
| nVal = pow( nl, nr ); break; | |
| case MUL: | |
| bCheckType = sal_True; | |
| nVal = nl * nr; break; | |
| case DIV: | |
| if( !nr ) | |
| { | |
| pGen->GetParser()->Error( SbERR_ZERODIV ); nVal = HUGE_VAL; | |
| bError = sal_True; | |
| } else nVal = nl / nr; | |
| break; | |
| case PLUS: | |
| bCheckType = sal_True; | |
| nVal = nl + nr; break; | |
| case MINUS: | |
| bCheckType = sal_True; | |
| nVal = nl - nr; break; | |
| case EQ: | |
| nVal = ( nl == nr ) ? SbxTRUE : SbxFALSE; | |
| eType = SbxINTEGER; break; | |
| case NE: | |
| nVal = ( nl != nr ) ? SbxTRUE : SbxFALSE; | |
| eType = SbxINTEGER; break; | |
| case LT: | |
| nVal = ( nl < nr ) ? SbxTRUE : SbxFALSE; | |
| eType = SbxINTEGER; break; | |
| case GT: | |
| nVal = ( nl > nr ) ? SbxTRUE : SbxFALSE; | |
| eType = SbxINTEGER; break; | |
| case LE: | |
| nVal = ( nl <= nr ) ? SbxTRUE : SbxFALSE; | |
| eType = SbxINTEGER; break; | |
| case GE: | |
| nVal = ( nl >= nr ) ? SbxTRUE : SbxFALSE; | |
| eType = SbxINTEGER; break; | |
| case IDIV: | |
| if( !lr ) | |
| { | |
| pGen->GetParser()->Error( SbERR_ZERODIV ); nVal = HUGE_VAL; | |
| bError = sal_True; | |
| } else nVal = ll / lr; | |
| eType = SbxLONG; break; | |
| case MOD: | |
| if( !lr ) | |
| { | |
| pGen->GetParser()->Error( SbERR_ZERODIV ); nVal = HUGE_VAL; | |
| bError = sal_True; | |
| } else nVal = llMod % lrMod; | |
| eType = SbxLONG; break; | |
| case AND: | |
| nVal = (double) ( ll & lr ); eType = SbxLONG; break; | |
| case OR: | |
| nVal = (double) ( ll | lr ); eType = SbxLONG; break; | |
| case XOR: | |
| nVal = (double) ( ll ^ lr ); eType = SbxLONG; break; | |
| case EQV: | |
| nVal = (double) ( ~ll ^ lr ); eType = SbxLONG; break; | |
| case IMP: | |
| nVal = (double) ( ~ll | lr ); eType = SbxLONG; break; | |
| default: break; | |
| } | |
| if( !::rtl::math::isFinite( nVal ) ) | |
| pGen->GetParser()->Error( SbERR_MATH_OVERFLOW ); | |
| // Den Datentyp wiederherstellen, um Rundungsfehler | |
| // zu killen | |
| if( bCheckType && bBothInt | |
| && nVal >= SbxMINLNG && nVal <= SbxMAXLNG ) | |
| { | |
| // NK-Stellen weg | |
| long n = (long) nVal; | |
| nVal = n; | |
| eType = ( n >= SbxMININT && n <= SbxMAXINT ) | |
| ? SbxINTEGER : SbxLONG; | |
| } | |
| } | |
| } | |
| } | |
| else if( pLeft && pLeft->IsNumber() ) | |
| { | |
| nVal = pLeft->nVal; | |
| delete pLeft; | |
| pLeft = NULL; | |
| eType = SbxDOUBLE; | |
| eNodeType = SbxNUMVAL; | |
| bComposite = sal_False; | |
| switch( eTok ) | |
| { | |
| case NEG: | |
| nVal = -nVal; break; | |
| case NOT: { | |
| // Integer-Operation! | |
| sal_Bool err = sal_False; | |
| if( nVal > SbxMAXLNG ) err = sal_True, nVal = SbxMAXLNG; | |
| else | |
| if( nVal < SbxMINLNG ) err = sal_True, nVal = SbxMINLNG; | |
| if( err ) | |
| { | |
| pGen->GetParser()->Error( SbERR_MATH_OVERFLOW ); | |
| bError = sal_True; | |
| } | |
| nVal = (double) ~((long) nVal); | |
| eType = SbxLONG; | |
| } break; | |
| default: break; | |
| } | |
| } | |
| if( eNodeType == SbxNUMVAL ) | |
| { | |
| // Evtl auf INTEGER falten (wg. besserem Opcode)? | |
| if( eType == SbxSINGLE || eType == SbxDOUBLE ) | |
| { | |
| double x; | |
| if( nVal >= SbxMINLNG && nVal <= SbxMAXLNG | |
| && !modf( nVal, &x ) ) | |
| eType = SbxLONG; | |
| } | |
| if( eType == SbxLONG && nVal >= SbxMININT && nVal <= SbxMAXINT ) | |
| eType = SbxINTEGER; | |
| } | |
| } |