LTP GCOV extension - code coverage report
Current view: directory - src/cpp/dev/idlc - value.cpp
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 68
Code covered: 97.1 % Executed lines: 66

       1                 : //==============================================================================
       2                 : // File <$/src/cpp/dev/idlc/value.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/value.h"
      27                 : #include "src/cpp/dev/idlc/yyutils.h"
      28                 : 
      29                 : // IDLValue
      30                 : 
      31             924 : IDLValue::IDLValue(IDLType_e type)
      32             924 : : _type(type), _error(false)
      33                 : {}
      34                 : 
      35            1248 : IDLValue::IDLValue(const IDLValue& v)
      36            1248 : : _type(v._type), _error(v._error)
      37                 : {}
      38                 : 
      39            1823 : IDLValue::~IDLValue()
      40               0 : {}
      41                 : 
      42              24 : IDLType_e IDLValue::isA() const
      43                 : {
      44                 :    return _type ;
      45                 : }
      46                 : 
      47             143 : void IDLValue::SetError(void)
      48                 : {
      49             143 :    _error = true ;
      50                 : }
      51                 : 
      52            1127 : bool IDLValue::IsError(void) const
      53                 : {
      54                 :    return _error ;
      55                 : }
      56                 : 
      57               4 : IDLValue* IDLValue::computeError(const char* operation)
      58                 : {
      59               4 :    IDLCompileError("Unknown operation semantic") ;
      60               4 :    errLog << "Unary operation \"" << operation << "\" has no semantic for " ;
      61               4 :    print(errLog) ;
      62                 :    errLog << std::endl ;
      63                 : 
      64               4 :    IDLValue *result = copy() ;
      65               4 :    result->SetError() ;
      66                 :    return result ;
      67                 : }
      68                 : 
      69              20 : IDLValue* IDLValue::computeError(const char* operation, const IDLValue *v)
      70                 : {
      71              20 :    IDLCompileError("Unknown operation semantic") ;
      72              20 :    errLog << "Binary operation \"" << operation << "\" has no semantic for " ;
      73              20 :    print(errLog) ;
      74              20 :    errLog << ", " ;
      75              20 :    v->print(errLog) ;
      76                 :    errLog << std::endl ;
      77                 : 
      78              20 :    IDLValue *result = copy() ;
      79              20 :    result->SetError() ;
      80                 :    return result ;
      81                 : }
      82                 : 
      83              15 : void IDLValue::typeConvertionError(IDLType *type)
      84                 : {
      85              15 :    IDLCompileError("Type convertion error") ;
      86              15 :    errLog << "Can not convert " ;
      87              15 :    print(errLog) ;
      88              15 :    errLog << " to " ;
      89              15 :    type->print(errLog) ;
      90                 :    errLog << std::endl ;
      91                 : 
      92              15 :    SetError() ;
      93                 :    return ;
      94                 : }
      95                 : 
      96               6 : void IDLValue::overflowError(const char* operation)
      97                 : {
      98               6 :    IDLCompileError("Overflow") ;
      99                 :    errLog << "Unary operation \"" << operation
     100               6 :       << "\" causes an overflow for " ;
     101               6 :    print(errLog) ;
     102                 :    errLog << std::endl ;
     103                 : }
     104                 : 
     105              45 : void IDLValue::overflowError(const char* operation, const IDLValue *v)
     106                 : {
     107              45 :    IDLCompileError("Overflow") ;
     108                 :    errLog << "Binary operation \"" << operation
     109              45 :       << "\" causes an overflow for " ;
     110              45 :    print(errLog) ;
     111              45 :    errLog << ", " ;
     112              45 :    v->print(errLog) ;
     113                 :    errLog << std::endl ;
     114                 : 
     115                 : }
     116                 : 
     117               2 : IDLValue* IDLValue::computeAdd(const IDLValue *v)
     118                 : {
     119               2 :    return computeError("+", v) ;
     120                 : }
     121                 : 
     122               2 : IDLValue* IDLValue::computeSub(const IDLValue *v)
     123                 : {
     124               2 :    return computeError("-", v) ;
     125                 : }
     126                 : 
     127               2 : IDLValue* IDLValue::computeMul(const IDLValue *v)
     128                 : {
     129               2 :    return computeError("*", v) ;
     130                 : }
     131                 : 
     132               2 : IDLValue* IDLValue::computeDiv(const IDLValue *v)
     133                 : {
     134               2 :    return computeError("/", v) ;
     135                 : }
     136                 : 
     137               2 : IDLValue* IDLValue::computeShl(const IDLValue *v)
     138                 : {
     139               2 :    return computeError("<<", v) ;
     140                 : }
     141                 : 
     142               2 : IDLValue* IDLValue::computeShr(const IDLValue *v)
     143                 : {
     144               2 :    return computeError(">>", v) ;
     145                 : }
     146                 : 
     147               2 : IDLValue* IDLValue::computeMod(const IDLValue *v)
     148                 : {
     149               2 :    return computeError("%", v) ;
     150                 : }
     151                 : 
     152               2 : IDLValue* IDLValue::computeOr(const IDLValue *v)
     153                 : {
     154               2 :    return computeError("|", v) ;
     155                 : }
     156                 : 
     157               2 : IDLValue* IDLValue::computeXor(const IDLValue *v)
     158                 : {
     159               2 :    return computeError("^", v) ;
     160                 : }
     161                 : 
     162               2 : IDLValue* IDLValue::computeAnd(const IDLValue *v)
     163                 : {
     164               2 :    return computeError("&", v) ;
     165                 : }
     166                 : 
     167               2 : IDLValue* IDLValue::computeMinus(void)
     168                 : {
     169               2 :    return computeError("-") ;
     170                 : }
     171                 : 
     172               2 : IDLValue* IDLValue::computeNeg(void)
     173                 : {
     174               2 :    return computeError("~") ;
     175              63 : }
     176              63 : 

Generated by: LTP GCOV extension version 1.4