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 :
|
