Fix some warnings
[scilab.git] / scilab / modules / ast / includes / analysis / TIType.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2014 - Scilab Enterprises - Calixte DENIZET
4  *
5  *  This file must be used under the terms of the CeCILL.
6  *  This source file is licensed as described in the file COPYING, which
7  *  you should have received as part of this distribution.  The terms
8  *  are also available at
9  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 // This file has been generated, so don't modify it by hand !!
14
15 #ifndef __TITYPE_HXX__
16 #define __TITYPE_HXX__
17
18 #include <iostream>
19
20 namespace analysis
21 {
22 struct TIType
23 {
24     enum Type { EMPTY, BOOLEAN, COMPLEX, DOUBLE, INT16, INT32, INT64, INT8, POLYNOMIAL, STRING, SPARSE, UINT16, UINT32, UINT64, UINT8, UNKNOWN, COUNT = 16 };
25     Type type;
26     int rows;
27     int cols;
28
29     TIType() : type(Type::UNKNOWN),  rows(1), cols(1) { }
30     TIType(Type _type) : type(_type), rows(1), cols(1) { }
31     TIType(Type _type, int _rows, int _cols) : type(_type), rows(_rows), cols(_cols) { }
32
33     inline bool isscalar() const
34     {
35         return rows == 1 && cols == 1;
36     }
37
38     inline bool isknown() const
39     {
40         return type != UNKNOWN;
41     }
42
43     inline bool operator==(const TIType & r) const
44     {
45         return type == r.type && rows == r.rows && cols == r.cols;
46     }
47
48     inline std::string get_mangling() const
49     {
50         const bool sc = rows == 1 && cols == 1;
51         switch (type)
52         {
53             case EMPTY :
54                 return "E";
55             case BOOLEAN :
56                 return sc ? "S_b" : "M_b";
57             case COMPLEX :
58                 return sc ? "S_c" : "M_c";
59             case DOUBLE :
60                 return sc ? "S_d" : "M_d";
61             case INT16 :
62                 return sc ? "S_i16" : "M_i16";
63             case INT32 :
64                 return sc ? "S_i32" : "M_i32";
65             case INT64 :
66                 return sc ? "S_i64" : "M_i64";
67             case INT8 :
68                 return sc ? "S_i8" : "M_i8";
69             case POLYNOMIAL :
70                 return sc ? "S_p" : "M_p";
71             case STRING :
72                 return sc ? "S_s" : "M_s";
73             case SPARSE :
74                 return sc ? "S_sp" : "M_sp";
75             case UINT16 :
76                 return sc ? "S_ui16" : "M_ui16";
77             case UINT32 :
78                 return sc ? "S_ui32" : "M_ui32";
79             case UINT64 :
80                 return sc ? "S_ui64" : "M_ui64";
81             case UINT8 :
82                 return sc ? "S_ui8" : "M_ui8";
83             default :
84                 return "??";
85         }
86     }
87
88     inline static std::string get_unary_mangling(const std::string & pre, const TIType & l)
89     {
90         return pre + "_" + l.get_mangling();
91     }
92
93     inline static std::string get_binary_mangling(const std::string & pre, const TIType & l, const TIType & r)
94     {
95         return pre + "_" + l.get_mangling() + "_" + r.get_mangling();
96     }
97
98     friend std::wostream & operator<<(std::wostream & out, const TIType & type)
99     {
100         switch (type.type)
101         {
102             case EMPTY :
103                 out << L"[]";
104                 break;
105             case BOOLEAN :
106                 out << L"boolean";
107                 break;
108             case COMPLEX :
109                 out << L"complex";
110                 break;
111             case DOUBLE :
112                 out << L"double";
113                 break;
114             case INT16 :
115                 out << L"int16";
116                 break;
117             case INT32 :
118                 out << L"int32";
119                 break;
120             case INT64 :
121                 out << L"int64";
122                 break;
123             case INT8 :
124                 out << L"int8";
125                 break;
126             case POLYNOMIAL :
127                 out << L"polynomial";
128                 break;
129             case STRING :
130                 out << L"string";
131                 break;
132             case SPARSE :
133                 out << L"sparse";
134                 break;
135             case UINT16 :
136                 out << L"uint16";
137                 break;
138             case UINT32 :
139                 out << L"uint32";
140                 break;
141             case UINT64 :
142                 out << L"uint64";
143                 break;
144             case UINT8 :
145                 out << L"uint8";
146                 break;
147             default :
148                 out << L"unknown";
149         }
150
151         if (type.type != EMPTY && type.type != UNKNOWN)
152         {
153             out << L"[" << type.rows << L", " << type.cols << L"]";
154         }
155
156         return out;
157     }
158 };
159
160 } // namespace analysis
161
162 namespace std
163 {
164 // useful to be able to put TIType in unorderd_set for example.
165 template<>
166 struct hash<analysis::TIType>
167 {
168     inline size_t operator()(const analysis::TIType & t) const
169     {
170         return t.type + (analysis::TIType::COUNT + 1) * (t.rows + 7057 * t.cols);
171     }
172 };
173 } // namespace std
174
175 #endif // __TITYPE_HXX__