 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
88.0% |
44 / 50 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
100.0% |
50 / 50 |
| |
|
Line Coverage: |
98.5% |
67 / 68 |
| |
 |
|
 |
1 : //===--- Types.cpp - Driver input & temporary type information ----------*-===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 :
10 : #include "clang/Driver/Types.h"
11 :
12 : #include "llvm/ADT/StringSwitch.h"
13 : #include <string.h>
14 : #include <cassert>
15 :
16 : using namespace clang::driver;
17 : using namespace clang::driver::types;
18 :
19 : struct TypeInfo {
20 : const char *Name;
21 : const char *Flags;
22 : const char *TempSuffix;
23 : ID PreprocessedType;
24 : };
25 :
26 : static const TypeInfo TypeInfos[] = {
27 : #define TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, FLAGS) \
28 : { NAME, FLAGS, TEMP_SUFFIX, TY_##PP_TYPE, },
29 : #include "clang/Driver/Types.def"
30 : #undef TYPE
31 : };
32 : static const unsigned numTypes = sizeof(TypeInfos) / sizeof(TypeInfos[0]);
33 :
34 6056: static const TypeInfo &getInfo(unsigned id) {
6056: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
6056: branch 3 taken
35 6056: assert(id > 0 && id - 1 < numTypes && "Invalid Type ID.");
36 6056: return TypeInfos[id - 1];
37 : }
38 :
39 275: const char *types::getTypeName(ID Id) {
40 275: return getInfo(Id).Name;
41 : }
42 :
43 2212: types::ID types::getPreprocessedType(ID Id) {
44 2212: return getInfo(Id).PreprocessedType;
45 : }
46 :
47 69: const char *types::getTypeTempSuffix(ID Id) {
48 69: return getInfo(Id).TempSuffix;
49 : }
50 :
51 1384: bool types::onlyAssembleType(ID Id) {
52 1384: return strchr(getInfo(Id).Flags, 'a');
53 : }
54 :
55 1286: bool types::onlyPrecompileType(ID Id) {
56 1286: return strchr(getInfo(Id).Flags, 'p');
57 : }
58 :
59 441: bool types::canTypeBeUserSpecified(ID Id) {
60 441: return strchr(getInfo(Id).Flags, 'u');
61 : }
62 :
63 31: bool types::appendSuffixForType(ID Id) {
64 31: return strchr(getInfo(Id).Flags, 'A');
65 : }
66 :
67 4: bool types::canLipoType(ID Id) {
68 : return (Id == TY_Nothing ||
69 : Id == TY_Image ||
4: branch 0 taken
0: branch 1 not taken
1: branch 2 taken
3: branch 3 taken
1: branch 4 taken
0: branch 5 not taken
70 4: Id == TY_Object);
71 : }
72 :
73 247: bool types::isAcceptedByClang(ID Id) {
45: branch 0 taken
202: branch 1 taken
74 247: switch (Id) {
75 : default:
76 45: return false;
77 :
78 : case TY_Asm:
79 : case TY_C: case TY_PP_C:
80 : case TY_CL:
81 : case TY_ObjC: case TY_PP_ObjC:
82 : case TY_CXX: case TY_PP_CXX:
83 : case TY_ObjCXX: case TY_PP_ObjCXX:
84 : case TY_CHeader: case TY_PP_CHeader:
85 : case TY_ObjCHeader: case TY_PP_ObjCHeader:
86 : case TY_CXXHeader: case TY_PP_CXXHeader:
87 : case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
88 : case TY_AST:
89 202: return true;
90 : }
91 : }
92 :
93 188: bool types::isObjC(ID Id) {
136: branch 0 taken
52: branch 1 taken
94 188: switch (Id) {
95 : default:
96 136: return false;
97 :
98 : case TY_ObjC: case TY_PP_ObjC:
99 : case TY_ObjCXX: case TY_PP_ObjCXX:
100 : case TY_ObjCHeader: case TY_PP_ObjCHeader:
101 : case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
102 52: return true;
103 : }
104 : }
105 :
106 195: bool types::isCXX(ID Id) {
176: branch 0 taken
19: branch 1 taken
107 195: switch (Id) {
108 : default:
109 176: return false;
110 :
111 : case TY_CXX: case TY_PP_CXX:
112 : case TY_ObjCXX: case TY_PP_ObjCXX:
113 : case TY_CXXHeader: case TY_PP_CXXHeader:
114 : case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
115 19: return true;
116 : }
117 : }
118 :
119 199: types::ID types::lookupTypeForExtension(const char *Ext) {
120 : return llvm::StringSwitch<types::ID>(Ext)
121 : .Case("c", TY_C)
122 : .Case("i", TY_PP_C)
123 : .Case("m", TY_ObjC)
124 : .Case("M", TY_ObjCXX)
125 : .Case("h", TY_CHeader)
126 : .Case("C", TY_CXX)
127 : .Case("H", TY_CXXHeader)
128 : .Case("f", TY_PP_Fortran)
129 : .Case("F", TY_Fortran)
130 : .Case("s", TY_PP_Asm)
131 : .Case("S", TY_Asm)
132 : .Case("ii", TY_PP_CXX)
133 : .Case("mi", TY_PP_ObjC)
134 : .Case("mm", TY_ObjCXX)
135 : .Case("cc", TY_CXX)
136 : .Case("CC", TY_CXX)
137 : .Case("cl", TY_CL)
138 : .Case("cp", TY_CXX)
139 : .Case("hh", TY_CXXHeader)
140 : .Case("hpp", TY_CXXHeader)
141 : .Case("ads", TY_Ada)
142 : .Case("adb", TY_Ada)
143 : .Case("ast", TY_AST)
144 : .Case("cxx", TY_CXX)
145 : .Case("cpp", TY_CXX)
146 : .Case("CPP", TY_CXX)
147 : .Case("CXX", TY_CXX)
148 : .Case("for", TY_PP_Fortran)
149 : .Case("FOR", TY_PP_Fortran)
150 : .Case("fpp", TY_Fortran)
151 : .Case("FPP", TY_Fortran)
152 : .Case("f90", TY_PP_Fortran)
153 : .Case("f95", TY_PP_Fortran)
154 : .Case("F90", TY_Fortran)
155 : .Case("F95", TY_Fortran)
156 : .Case("mii", TY_PP_ObjCXX)
157 199: .Default(TY_INVALID);
158 : }
159 :
160 37: types::ID types::lookupTypeForTypeSpecifier(const char *Name) {
161 37: unsigned N = strlen(Name);
162 :
431: branch 0 taken
0: branch 1 not taken
163 431: for (unsigned i=0; i<numTypes; ++i) {
164 431: types::ID Id = (types::ID) (i + 1);
358: branch 1 taken
73: branch 2 taken
37: branch 5 taken
321: branch 6 taken
37: branch 7 taken
394: branch 8 taken
165 431: if (canTypeBeUserSpecified(Id) &&
166 : memcmp(Name, getInfo(Id).Name, N + 1) == 0)
167 37: return Id;
168 : }
169 :
170 0: return TY_INVALID;
171 : }
172 :
173 : // FIXME: Why don't we just put this list in the defs file, eh.
174 :
175 1058: unsigned types::getNumCompilationPhases(ID Id) {
39: branch 0 taken
1019: branch 1 taken
176 1058: if (Id == TY_Object)
177 39: return 1;
178 :
179 1019: unsigned N = 0;
958: branch 1 taken
61: branch 2 taken
180 1019: if (getPreprocessedType(Id) != TY_INVALID)
181 958: N += 1;
182 :
58: branch 1 taken
961: branch 2 taken
183 1019: if (onlyAssembleType(Id))
184 58: return N + 2; // assemble, link
28: branch 1 taken
933: branch 2 taken
185 961: if (onlyPrecompileType(Id))
186 28: return N + 1; // precompile
187 :
188 933: return N + 3; // compile, assemble, link
189 : }
190 :
191 817: phases::ID types::getCompilationPhase(ID Id, unsigned N) {
817: branch 1 taken
0: branch 2 not taken
192 817: assert(N < getNumCompilationPhases(Id) && "Invalid index.");
193 :
26: branch 0 taken
791: branch 1 taken
194 817: if (Id == TY_Object)
195 26: return phases::Link;
196 :
745: branch 1 taken
46: branch 2 taken
197 791: if (getPreprocessedType(Id) != TY_INVALID) {
426: branch 0 taken
319: branch 1 taken
198 745: if (N == 0)
199 426: return phases::Preprocess;
200 319: --N;
201 : }
202 :
40: branch 1 taken
325: branch 2 taken
203 365: if (onlyAssembleType(Id))
26: branch 0 taken
14: branch 1 taken
204 40: return N == 0 ? phases::Assemble : phases::Link;
205 :
7: branch 1 taken
318: branch 2 taken
206 325: if (onlyPrecompileType(Id))
207 7: return phases::Precompile;
208 :
210: branch 0 taken
108: branch 1 taken
209 318: if (N == 0)
210 210: return phases::Compile;
81: branch 0 taken
27: branch 1 taken
211 108: if (N == 1)
212 81: return phases::Assemble;
213 :
214 27: return phases::Link;
215 : }
Generated: 2010-02-10 01:31 by zcov