License Header change: Removed the LICENSE_END before beta
[scilab.git] / scilab / modules / ast / src / cpp / analysis / check_and.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2014-2015 - Scilab Enterprises - Calixte DENIZET
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15
16 // This file has been generated, so don't modify it by hand !!
17
18 #include "checkers/Checkers.hxx"
19
20 namespace analysis
21 {
22     TIType Checkers::check_and(GVN & gvn, const TIType & in0)
23     {
24         switch (in0.type)
25         {
26         case TIType::BOOLEAN :
27         {
28             return TIType(gvn, TIType::BOOLEAN, 1, 1);
29         }
30         case TIType::COMPLEX :
31         {
32             return TIType(gvn, TIType::BOOLEAN, 1, 1);
33         }
34         case TIType::DOUBLE :
35         {
36             return TIType(gvn, TIType::BOOLEAN, 1, 1);
37         }
38         case TIType::INT16 :
39         {
40             return TIType(gvn, TIType::BOOLEAN, 1, 1);
41         }
42         case TIType::INT32 :
43         {
44             return TIType(gvn, TIType::BOOLEAN, 1, 1);
45         }
46         case TIType::INT64 :
47         {
48             return TIType(gvn, TIType::BOOLEAN, 1, 1);
49         }
50         case TIType::INT8 :
51         {
52             return TIType(gvn, TIType::BOOLEAN, 1, 1);
53         }
54         case TIType::UINT16 :
55         {
56             return TIType(gvn, TIType::BOOLEAN, 1, 1);
57         }
58         case TIType::UINT32 :
59         {
60             return TIType(gvn, TIType::BOOLEAN, 1, 1);
61         }
62         case TIType::UINT64 :
63         {
64             return TIType(gvn, TIType::BOOLEAN, 1, 1);
65         }
66         case TIType::UINT8 :
67         {
68             return TIType(gvn, TIType::BOOLEAN, 1, 1);
69         }
70         default :
71             return TIType(gvn);
72         }
73     }
74
75     TIType Checkers::check_and(GVN & gvn, const TIType & in0, const TIType & in1)
76     {
77         switch (in0.type)
78         {
79         case TIType::BOOLEAN :
80         {
81             switch (in1.type)
82             {
83             case TIType::DOUBLE :
84             {
85                 if (in1.rows == 1 && in1.cols == 1)
86                 {
87                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
88                 }
89                 return TIType(gvn);
90             }
91             case TIType::STRING :
92             {
93                 if (in1.rows == 1 && in1.cols == 1)
94                 {
95                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
96                 }
97                 return TIType(gvn);
98             }
99             default :
100                 return TIType(gvn);
101             }
102             return TIType(gvn);
103         }
104         case TIType::COMPLEX :
105         {
106             switch (in1.type)
107             {
108             case TIType::DOUBLE :
109             {
110                 if (in1.rows == 1 && in1.cols == 1)
111                 {
112                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
113                 }
114                 return TIType(gvn);
115             }
116             case TIType::STRING :
117             {
118                 if (in1.rows == 1 && in1.cols == 1)
119                 {
120                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
121                 }
122                 return TIType(gvn);
123             }
124             default :
125                 return TIType(gvn);
126             }
127             return TIType(gvn);
128         }
129         case TIType::DOUBLE :
130         {
131             switch (in1.type)
132             {
133             case TIType::DOUBLE :
134             {
135                 if (in1.rows == 1 && in1.cols == 1)
136                 {
137                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
138                 }
139                 return TIType(gvn);
140             }
141             case TIType::STRING :
142             {
143                 if (in1.rows == 1 && in1.cols == 1)
144                 {
145                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
146                 }
147                 return TIType(gvn);
148             }
149             default :
150                 return TIType(gvn);
151             }
152             return TIType(gvn);
153         }
154         case TIType::INT16 :
155         {
156             switch (in1.type)
157             {
158             case TIType::DOUBLE :
159             {
160                 if (in1.rows == 1 && in1.cols == 1)
161                 {
162                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
163                 }
164                 return TIType(gvn);
165             }
166             case TIType::STRING :
167             {
168                 if (in1.rows == 1 && in1.cols == 1)
169                 {
170                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
171                 }
172                 return TIType(gvn);
173             }
174             default :
175                 return TIType(gvn);
176             }
177             return TIType(gvn);
178         }
179         case TIType::INT32 :
180         {
181             switch (in1.type)
182             {
183             case TIType::DOUBLE :
184             {
185                 if (in1.rows == 1 && in1.cols == 1)
186                 {
187                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
188                 }
189                 return TIType(gvn);
190             }
191             case TIType::STRING :
192             {
193                 if (in1.rows == 1 && in1.cols == 1)
194                 {
195                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
196                 }
197                 return TIType(gvn);
198             }
199             default :
200                 return TIType(gvn);
201             }
202             return TIType(gvn);
203         }
204         case TIType::INT64 :
205         {
206             switch (in1.type)
207             {
208             case TIType::DOUBLE :
209             {
210                 if (in1.rows == 1 && in1.cols == 1)
211                 {
212                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
213                 }
214                 return TIType(gvn);
215             }
216             case TIType::STRING :
217             {
218                 if (in1.rows == 1 && in1.cols == 1)
219                 {
220                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
221                 }
222                 return TIType(gvn);
223             }
224             default :
225                 return TIType(gvn);
226             }
227             return TIType(gvn);
228         }
229         case TIType::INT8 :
230         {
231             switch (in1.type)
232             {
233             case TIType::DOUBLE :
234             {
235                 if (in1.rows == 1 && in1.cols == 1)
236                 {
237                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
238                 }
239                 return TIType(gvn);
240             }
241             case TIType::STRING :
242             {
243                 if (in1.rows == 1 && in1.cols == 1)
244                 {
245                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
246                 }
247                 return TIType(gvn);
248             }
249             default :
250                 return TIType(gvn);
251             }
252             return TIType(gvn);
253         }
254         case TIType::UINT16 :
255         {
256             switch (in1.type)
257             {
258             case TIType::DOUBLE :
259             {
260                 if (in1.rows == 1 && in1.cols == 1)
261                 {
262                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
263                 }
264                 return TIType(gvn);
265             }
266             case TIType::STRING :
267             {
268                 if (in1.rows == 1 && in1.cols == 1)
269                 {
270                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
271                 }
272                 return TIType(gvn);
273             }
274             default :
275                 return TIType(gvn);
276             }
277             return TIType(gvn);
278         }
279         case TIType::UINT32 :
280         {
281             switch (in1.type)
282             {
283             case TIType::DOUBLE :
284             {
285                 if (in1.rows == 1 && in1.cols == 1)
286                 {
287                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
288                 }
289                 return TIType(gvn);
290             }
291             case TIType::STRING :
292             {
293                 if (in1.rows == 1 && in1.cols == 1)
294                 {
295                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
296                 }
297                 return TIType(gvn);
298             }
299             default :
300                 return TIType(gvn);
301             }
302             return TIType(gvn);
303         }
304         case TIType::UINT64 :
305         {
306             switch (in1.type)
307             {
308             case TIType::DOUBLE :
309             {
310                 if (in1.rows == 1 && in1.cols == 1)
311                 {
312                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
313                 }
314                 return TIType(gvn);
315             }
316             case TIType::STRING :
317             {
318                 if (in1.rows == 1 && in1.cols == 1)
319                 {
320                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
321                 }
322                 return TIType(gvn);
323             }
324             default :
325                 return TIType(gvn);
326             }
327             return TIType(gvn);
328         }
329         case TIType::UINT8 :
330         {
331             switch (in1.type)
332             {
333             case TIType::DOUBLE :
334             {
335                 if (in1.rows == 1 && in1.cols == 1)
336                 {
337                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
338                 }
339                 return TIType(gvn);
340             }
341             case TIType::STRING :
342             {
343                 if (in1.rows == 1 && in1.cols == 1)
344                 {
345                     return TIType(gvn, TIType::BOOLEAN, 1, 1);
346                 }
347                 return TIType(gvn);
348             }
349             default :
350                 return TIType(gvn);
351             }
352             return TIType(gvn);
353         }
354         default :
355             return TIType(gvn);
356         }
357     }
358
359 } // namespace analysis