basic/source/comp/exprgen.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 <basic/sberrors.hxx>
  21
  22 #include <codegen.hxx>
  23 #include <expr.hxx>
  24 #include <parser.hxx>
  25
  26 // Transform table for token operators and opcodes
  27
  28 struct OpTable {
  29         SbiToken  eTok;                 // Token
  30         SbiOpcode eOp;                  // Opcode
  31 };
  32
  33 static const OpTable aOpTable [] = {
  34     { EXPON,SbiOpcode::EXP_ },
  35     { MUL,  SbiOpcode::MUL_ },
  36     { DIV,  SbiOpcode::DIV_ },
  37     { IDIV, SbiOpcode::IDIV_ },
  38     { MOD,  SbiOpcode::MOD_ },
  39     { PLUS, SbiOpcode::PLUS_ },
  40     { MINUS,SbiOpcode::MINUS_ },
  41     { EQ,   SbiOpcode::EQ_ },
  42     { NE,   SbiOpcode::NE_ },
  43     { LE,   SbiOpcode::LE_ },
  44     { GE,   SbiOpcode::GE_ },
  45     { LT,   SbiOpcode::LT_ },
  46     { GT,   SbiOpcode::GT_ },
  47     { AND,  SbiOpcode::AND_ },
  48     { OR,   SbiOpcode::OR_ },
  49     { XOR,  SbiOpcode::XOR_ },
  50     { EQV,  SbiOpcode::EQV_ },
  51     { IMP,  SbiOpcode::IMP_ },
  52     { NOT,  SbiOpcode::NOT_ },
  53     { NEG,  SbiOpcode::NEG_ },
  54     { CAT,  SbiOpcode::CAT_ },
  55     { LIKE, SbiOpcode::LIKE_ },
  56     { IS,   SbiOpcode::IS_ },
  57     { NIL,  SbiOpcode::NOP_ }};
  58
  59 // Output of an element
  60 void SbiExprNode::Gen( SbiCodeGen& rGen, RecursiveMode eRecMode )
  61 {
  62     sal_uInt16 nStringId;
  63
  64     if( IsConstant() )
  65     {
  66         switch( GetType() )
  67         {
  68         case SbxEMPTY:
  69             rGen.Gen( SbiOpcode::EMPTY_ );
  70             break;
  71         case SbxINTEGER:
  72             rGen.Gen( SbiOpcode::CONST_,  static_cast<short>(nVal) );
  73             break;
  74         case SbxSTRING:
  75             nStringId = rGen.GetParser()->aGblStrings.Add( aStrVal );
  76             rGen.Gen( SbiOpcode::SCONST_, nStringId );
  77             break;
  78         default:
  79             nStringId = rGen.GetParser()->aGblStrings.Add( nVal, eType );
  80             rGen.Gen( SbiOpcode::NUMBER_, nStringId );
  81             break;
  82         }
  83     }
  84     else if( IsOperand() )
  85     {
  86         SbiExprNode* pWithParent_ = nullptr;
  87         SbiOpcode eOp;
  88         if( aVar.pDef->GetScope() == SbPARAM )
  89         {
  90             eOp = SbiOpcode::PARAM_;
  91             if( aVar.pDef->GetPos() == 0 )
  92             {
  93                 bool bTreatFunctionAsParam = true;
  94                 if( eRecMode == FORCE_CALL )
  95                 {
  96                     bTreatFunctionAsParam = false;
  97                 }
  98                 else if( eRecMode == UNDEFINED )
  99                 {
 100                     if( aVar.pPar && aVar.pPar->IsBracket() )
 101                     {
 102                          bTreatFunctionAsParam = false;
 103                     }
 104                 }
 105                 if( !bTreatFunctionAsParam )
 106                 {
 107                     eOp = aVar.pDef->IsGlobal() ? SbiOpcode::FIND_G_ : SbiOpcode::FIND_;
 108                 }
 109             }
 110         }
 111         // special treatment for WITH
 112         else if( (pWithParent_ = pWithParent) != nullptr )
 113         {
 114             eOp = SbiOpcode::ELEM_;            // .-Term in WITH
 115         }
 116         else
 117         {
 118             eOp = ( aVar.pDef->GetScope() == SbRTL ) ? SbiOpcode::RTL_ :
 119                 (aVar.pDef->IsGlobal() ? SbiOpcode::FIND_G_ : SbiOpcode::FIND_);
 120         }
 121
 122         if( eOp == SbiOpcode::FIND_ )
 123         {
 124
 125             SbiProcDef* pProc = aVar.pDef->GetProcDef();
 126             if ( rGen.GetParser()->bClassModule )
 127             {
 128                 eOp = SbiOpcode::FIND_CM_;
 129             }
 130             else if ( aVar.pDef->IsStatic() || (pProc && pProc->IsStatic()) )
 131             {
 132                 eOp = SbiOpcode::FIND_STATIC_;
 133             }
 134         }
 135         for( SbiExprNode* p = this; p; p = p->aVar.pNext )
 136         {
 137             if( p == this && pWithParent_ != nullptr )
 138             {
 139                 pWithParent_->Gen(rGen);
 140             }
 141             p->GenElement( rGen, eOp );
 142             eOp = SbiOpcode::ELEM_;
 143         }
 144     }
 145     else if( eNodeType == SbxTYPEOF )
 146     {
 147         pLeft->Gen(rGen);
 148         rGen.Gen( SbiOpcode::TESTCLASS_, nTypeStrId );
 149     }
 150     else if( eNodeType == SbxNEW )
 151     {
 152         rGen.Gen( SbiOpcode::CREATE_, 0, nTypeStrId );
 153     }
 154     else
 155     {
 156         pLeft->Gen(rGen);
 157         if( pRight )
 158         {
 159             pRight->Gen(rGen);
 160         }
 161         for( const OpTable* p = aOpTable; p->eTok != NIL; p++ )
 162         {
 163             if( p->eTok == eTok )
 164             {
 165                 rGen.Gen( p->eOp ); break;
 166             }
 167         }
 168     }
 169 }
 170
 171 // Output of an operand element
 172
 173 void SbiExprNode::GenElement( SbiCodeGen& rGen, SbiOpcode eOp )
 174 {
 175 #ifdef DBG_UTIL
 176     if ((eOp < SbiOpcode::RTL_ || eOp > SbiOpcode::CALLC_) && eOp != SbiOpcode::FIND_G_ && eOp != SbiOpcode::FIND_CM_ && eOp != SbiOpcode::FIND_STATIC_)
 177         rGen.GetParser()->Error( ERRCODE_BASIC_INTERNAL_ERROR, "Opcode" );
 178 #endif
 179     SbiSymDef* pDef = aVar.pDef;
 180     // The ID is either the position or the String-ID
 181     // If the bit Bit 0x8000 is set, the variable have
 182     // a parameter list.
 183     sal_uInt16 nId = ( eOp == SbiOpcode::PARAM_ ) ? pDef->GetPos() : pDef->GetId();
 184     // Build a parameter list
 185     if( aVar.pPar && aVar.pPar->GetSize() )
 186     {
 187         nId |= 0x8000;
 188         aVar.pPar->Gen(rGen);
 189     }
 190
 191     rGen.Gen( eOp, nId, sal::static_int_cast< sal_uInt16 >( GetType() ) );
 192
 193     if( aVar.pvMorePar )
 194     {
 195         for( auto& pExprList: *aVar.pvMorePar )
 196         {
 197             pExprList->Gen(rGen);
 198             rGen.Gen( SbiOpcode::ARRAYACCESS_ );
 199         }
 200     }
 201 }
 202
 203 // Create an Argv-Table
 204 // The first element remain available for return value etc.
 205 // See as well SbiProcDef::SbiProcDef() in symtbl.cxx
 206
 207 void SbiExprList::Gen(SbiCodeGen& rGen)
 208 {
 209     if( !aData.empty() )
 210     {
 211         rGen.Gen( SbiOpcode::ARGC_ );
 212         // Type adjustment at DECLARE
 213
 214         for( auto& pExpr: aData )
 215         {
 216             pExpr->Gen();
 217             if( !pExpr->GetName().isEmpty() )
 218             {
 219                 // named arg
 220                 sal_uInt16 nSid = rGen.GetParser()->aGblStrings.Add( pExpr->GetName() );
 221                 rGen.Gen( SbiOpcode::ARGN_, nSid );
 222
 223                 /* TODO: Check after Declare concept change
 224                 // From 1996-01-10: Type adjustment at named -> search suitable parameter
 225                 if( pProc )
 226                 {
 227                     // For the present: trigger an error
 228                     pParser->Error( ERRCODE_BASIC_NO_NAMED_ARGS );
 229
 230                     // Later, if Named Args at DECLARE is possible
 231                     //for( sal_uInt16 i = 1 ; i < nParAnz ; i++ )
 232                     //{
 233                     //  SbiSymDef* pDef = pPool->Get( i );
 234                     //  const String& rName = pDef->GetName();
 235                     //  if( rName.Len() )
 236                     //  {
 237                     //      if( pExpr->GetName().ICompare( rName )
 238                     //          == COMPARE_EQUAL )
 239                     //      {
 240                     //          pParser->aGen.Gen( ARGTYP_, pDef->GetType() );
 241                     //          break;
 242                     //      }
 243                     //  }
 244                     //}
 245                 }
 246                 */
 247             }
 248             else
 249             {
 250                 rGen.Gen( SbiOpcode::ARGV_ );
 251             }
 252         }
 253     }
 254 }
 255
 256 void SbiExpression::Gen( RecursiveMode eRecMode )
 257 {
 258     // special treatment for WITH
 259     // If pExpr == .-term in With, approximately Gen for Basis-Object
 260     pExpr->Gen( pParser->aGen, eRecMode );
 261     if( bByVal )
 262     {
 263         pParser->aGen.Gen( SbiOpcode::BYVAL_ );
 264     }
 265     if( bBased )
 266     {
 267         sal_uInt16 uBase = pParser->nBase;
 268         if( pParser->IsCompatible() )
 269         {
 270             uBase |= 0x8000;        // #109275 Flag compatibility
 271         }
 272         pParser->aGen.Gen( SbiOpcode::BASED_, uBase );
 273         pParser->aGen.Gen( SbiOpcode::ARGV_ );
 274     }
 275 }
 276
 277 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */