LTP GCOV extension - code coverage report
Current view: directory - src/cpp/dev/idlc - const_exp.cpp
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 61
Code covered: 88.5 % Executed lines: 54

       1                 : //==============================================================================
       2                 : // File <$/src/cpp/dev/idlc/const_exp.cpp>
       3                 : // This file is part of YaOrb : Yet Another Object Request Broker,
       4                 : // Copyright (c) 2000-2003, Marc Alff.
       5                 : //
       6                 : // This program is free software; you can redistribute it and/or
       7                 : // modify it under the terms of the GNU General Public License
       8                 : // as published by the Free Software Foundation; either version 2
       9                 : // of the License, or (at your option) any later version.
      10                 : //
      11                 : // This program is distributed in the hope that it will be useful,
      12                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 : // GNU General Public License for more details.
      15                 : //
      16                 : // You should have received a copy of the GNU General Public License
      17                 : // along with this program; if not, write to the Free Software
      18                 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
      19                 : //
      20                 : //==============================================================================
      21                 : 
      22                 : #include <stdio.h>
      23                 : 
      24                 : #include "src/cpp/prod/tool/Assert.h"
      25                 : 
      26                 : #include "src/cpp/dev/idlc/const_exp.h"
      27                 : #include "src/cpp/dev/idlc/value.h"
      28                 : 
      29                 : // IDLConstExp
      30                 : 
      31            1205 : IDLConstExp::IDLConstExp()
      32                 : {}
      33                 : 
      34            1040 : IDLConstExp::~IDLConstExp()
      35               0 : {}
      36                 : 
      37                 : // IDLValueExp
      38                 : 
      39             950 : IDLValueExp::IDLValueExp(IDLValue *v)
      40             950 : : _value(v)
      41                 : {
      42                 :    ASSERT(v != NULL) ;
      43                 : }
      44                 : 
      45             785 : IDLValueExp::~IDLValueExp()
      46                 : {
      47             785 :    delete _value ;
      48               0 : }
      49                 : 
      50             949 : IDLValue *IDLValueExp::evaluate(IDLType *type)
      51                 : {
      52             949 :    IDLValue *result = _value->copy() ;
      53                 : 
      54                 :    ASSERT(result != NULL) ;
      55                 : 
      56             949 :    result->convert(type) ;
      57                 :    return result ;
      58                 : }
      59                 : 
      60                 : // IDLUnaryExp
      61                 : 
      62              75 : IDLUnaryExp::IDLUnaryExp(IDLUnaryOperator_e op, IDLConstExp *e)
      63              75 : : IDLConstExp(), _op(op), _operand(e)
      64                 : {
      65                 :    ASSERT (e != NULL) ;
      66                 : }
      67                 : 
      68              75 : IDLUnaryExp::~IDLUnaryExp()
      69                 : {
      70              75 :    delete _operand ;
      71               0 : }
      72                 : 
      73              75 : IDLValue *IDLUnaryExp::evaluate(IDLType *type)
      74                 : {
      75              75 :    IDLValue *v = _operand->evaluate(type) ;
      76                 :    IDLValue *result = NULL ;
      77                 : 
      78                 :    ASSERT (v != NULL) ;
      79                 : 
      80              75 :    if (v->IsError())
      81                 :    {
      82                 :       result = v ;
      83                 :    }
      84                 :    else
      85                 :    {
      86              74 :       switch(_op)
      87                 :       {
      88                 :          case idl_unary_minus:
      89                 :          {
      90              66 :             result = v->computeMinus() ;
      91              66 :             break ;
      92                 :          }
      93                 :          case idl_unary_neg:
      94                 :          {
      95               8 :             result = v->computeNeg() ;
      96                 :             break ;
      97                 :          }
      98                 :       }
      99               0 :       delete v ;
     100                 :    }
     101                 : 
     102                 :    ASSERT(result != NULL) ;
     103                 :    return result ;
     104                 : }
     105                 : 
     106                 : // IDLBinaryExp
     107                 : 
     108                 : IDLBinaryExp::IDLBinaryExp(
     109                 :    IDLConstExp *e1,
     110                 :    IDLBinaryOperator_e op,
     111             180 :    IDLConstExp *e2)
     112             180 : : IDLConstExp(), _op(op), _operand1(e1), _operand2(e2)
     113                 : {
     114                 :    ASSERT (e1 != NULL) ;
     115                 :    ASSERT (e2 != NULL) ;
     116                 : }
     117                 : 
     118             180 : IDLBinaryExp::~IDLBinaryExp()
     119                 : {
     120             180 :    delete _operand1 ;
     121             180 :    delete _operand2 ;
     122               0 : }
     123                 : 
     124             180 : IDLValue *IDLBinaryExp::evaluate(IDLType *type)
     125                 : {
     126             180 :    IDLValue *v1 = _operand1->evaluate(type) ;
     127             180 :    IDLValue *v2 = _operand2->evaluate(type) ;
     128                 :    IDLValue *result = NULL ;
     129                 : 
     130                 :    ASSERT (v1 != NULL) ;
     131                 :    ASSERT (v2 != NULL) ;
     132                 : 
     133             180 :    if (v1->IsError() || v2->IsError())
     134                 :    {
     135                 :       result = v1 ;
     136               1 :       delete v2 ;
     137               1 :       result->SetError() ;
     138                 :    }
     139                 :    else
     140                 :    {
     141             179 :       switch(_op)
     142                 :       {
     143                 :          case idl_add :
     144                 :          {
     145              29 :             result = v1->computeAdd(v2) ;
     146              29 :             break ; 
     147                 :          }
     148                 :          case idl_sub :
     149                 :          {
     150              29 :             result = v1->computeSub(v2) ;
     151              29 :             break ; 
     152                 :          }
     153                 :          case idl_mul :
     154                 :          {
     155              11 :             result = v1->computeMul(v2) ;
     156              11 :             break ; 
     157                 :          }
     158                 :          case idl_div :
     159                 :          {
     160              11 :             result = v1->computeDiv(v2) ;
     161              11 :             break ; 
     162                 :          }
     163                 :          case idl_shl :
     164                 :          {
     165              59 :             result = v1->computeShl(v2) ;
     166              59 :             break ; 
     167                 :          }
     168                 :          case idl_shr :
     169                 :          {
     170               8 :             result = v1->computeShr(v2) ;
     171               8 :             break ; 
     172                 :          }
     173                 :          case idl_mod :
     174                 :          {
     175               8 :             result = v1->computeMod(v2) ;
     176               8 :             break ; 
     177                 :          }
     178                 :          case idl_or :
     179                 :          {
     180               8 :             result = v1->computeOr(v2) ;
     181               8 :             break ; 
     182                 :          }
     183                 :          case idl_xor :
     184                 :          {
     185               8 :             result = v1->computeXor(v2) ;
     186               8 :             break ; 
     187                 :          }
     188                 :          case idl_and :
     189                 :          {
     190               8 :             result = v1->computeAnd(v2) ;
     191                 :             break ; 
     192                 :          }
     193                 :          // No default : switch on enum
     194                 :          // (gcc will warn if a case is missing)
     195                 :       }
     196                 : 
     197               0 :       delete v1 ;
     198             179 :       delete v2 ;
     199                 :    }
     200                 : 
     201                 :    ASSERT (result != NULL) ;
     202                 :    return result ;
     203              63 : }

Generated by: LTP GCOV extension version 1.4