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