]> git.cworth.org Git - apitrace/blob - common/trace_callset.cpp
qapitrace: Determine binary dir in run-time.
[apitrace] / common / trace_callset.cpp
1 /**************************************************************************
2  *
3  * Copyright 2012 VMware, Inc.
4  * All Rights Reserved.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  *
24  **************************************************************************/
25
26
27 #include <assert.h>
28 #include <stdlib.h>
29
30 #include <limits>
31 #include <fstream>
32 #include <iostream>
33 #include <string>
34
35 #include <trace_callset.hpp>
36
37
38 using namespace trace;
39
40
41 // Parser class for call sets
42 class CallSetParser
43 {
44     CallSet &set;
45
46 protected:
47     char lookahead;
48
49     CallSetParser(CallSet &_set) :
50         set(_set),
51         lookahead(0)
52     {}
53
54 public:
55     void parse() {
56         skipWhiteSpace();
57         while (lookahead) {
58             assert(!isSpace());
59             parseRange();
60             // skip any comma
61             isOperator(',');
62         }
63     }
64
65 private:
66     void parseRange() {
67         CallNo start = std::numeric_limits<CallNo>::min();
68         CallNo stop = std::numeric_limits<CallNo>::max();
69         CallNo step = 1;
70         CallFlags freq = FREQUENCY_ALL;
71         if (isAlpha()) {
72             freq = parseFrequency();
73         } else {
74             if (isOperator('*')) {
75                 // no-change
76             } else {
77                 start = parseCallNo();
78                 if (isOperator('-')) {
79                     if (isDigit()) {
80                         stop = parseCallNo();
81                     } else {
82                         // no-change
83                     }
84                 } else {
85                     stop = start;
86                 }
87             }
88             if (isOperator('/')) {
89                 if (isDigit()) {
90                     step = parseCallNo();
91                 } else {
92                     freq = parseFrequency();
93                 }
94             }
95         }
96         set.addRange(CallRange(start, stop, step, freq));
97     }
98
99     // match and consume an operator
100     bool isOperator(char c) {
101         if (lookahead == c) {
102             consume();
103             skipWhiteSpace();
104             return true;
105         } else {
106             return false;
107         }
108     }
109
110     CallNo parseCallNo() {
111         CallNo number = 0;
112         if (isDigit()) {
113             do {
114                 CallNo digit = consume() - '0';
115                 number = number * 10 + digit;
116             } while (isDigit());
117         } else {
118             std::cerr << "error: expected digit, found '" << lookahead << "'\n";
119             exit(0);
120         }
121         skipWhiteSpace();
122         return number;
123     }
124
125     CallFlags parseFrequency() {
126         std::string freq;
127         if (isAlpha()) {
128             do {
129                 freq.push_back(consume());
130             } while (isAlpha());
131         } else {
132             std::cerr << "error: expected frequency, found '" << lookahead << "'\n";
133             exit(0);
134         }
135         skipWhiteSpace();
136         if (freq == "frame") {
137             return FREQUENCY_FRAME;
138         } else if (freq == "rendertarget" || freq == "fbo") {
139             return FREQUENCY_RENDERTARGET;
140         } else if (freq == "render" || freq == "draw") {
141             return FREQUENCY_RENDER;
142         } else {
143             std::cerr << "error: expected frequency, found '" << freq << "'\n";
144             exit(0);
145             return FREQUENCY_NONE;
146         }
147     }
148
149     // match lookahead with a digit (does not consume)
150     bool isDigit() const {
151         return lookahead >= '0' && lookahead <= '9';
152     }
153
154     bool isAlpha() const {
155         return lookahead >= 'a' && lookahead <= 'z';
156     }
157
158     void skipWhiteSpace() {
159         while (isSpace()) {
160             consume();
161         }
162     }
163
164     bool isSpace() const {
165         return lookahead == ' ' ||
166                lookahead == '\t' ||
167                lookahead == '\r' ||
168                lookahead == '\n';
169     }
170
171     virtual char consume() = 0;
172 };
173
174
175 class StringCallSetParser : public CallSetParser
176 {
177     const char *buf;
178
179 public:
180     StringCallSetParser(CallSet &_set, const char *_buf) :
181         CallSetParser(_set),
182         buf(_buf)
183     {
184         lookahead = *buf;
185     }
186
187     char consume() {
188         char c = lookahead;
189         if (lookahead) {
190             ++buf;
191             lookahead = *buf;
192         }
193         return c;
194     }
195 };
196
197
198 class FileCallSetParser : public CallSetParser
199 {
200     std::ifstream stream;
201
202 public:
203     FileCallSetParser(CallSet &_set, const char *filename) :
204         CallSetParser(_set)
205     {
206         stream.open(filename);
207         if (!stream.is_open()) {
208             std::cerr << "error: failed to open \"" << filename << "\"\n";
209             exit(1);
210         }
211
212         stream.get(lookahead);
213     }
214
215     char consume() {
216         char c = lookahead;
217         if (stream.eof()) {
218             lookahead = 0;
219         } else {
220             stream.get(lookahead);
221         }
222         return c;
223     }
224 };
225
226
227 CallSet::CallSet(const char *string)
228 {
229     if (*string == '@') {
230         FileCallSetParser parser(*this, &string[1]);
231         parser.parse();
232     } else {
233         StringCallSetParser parser(*this, string);
234         parser.parse();
235     }
236 }
237
238
239 CallSet::CallSet(CallFlags freq) {
240     if (freq != FREQUENCY_NONE) {
241         CallNo start = std::numeric_limits<CallNo>::min();
242         CallNo stop = std::numeric_limits<CallNo>::max();
243         CallNo step = 1;
244         addRange(CallRange(start, stop, step, freq));
245         assert(!empty());
246     }
247 }