1 /**************************************************************************
3 * Copyright 2010 VMware, Inc.
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
24 **************************************************************************/
26 #ifndef _TRACE_PARSER_HPP_
27 #define _TRACE_PARSER_HPP_
36 #include "trace_format.hpp"
37 #include "trace_model.hpp"
52 bool parse(const char *filename) {
53 unsigned long long version;
55 file = gzopen(filename, "rb");
60 version = read_uint();
61 if (version != TRACE_VERSION) {
62 std::cerr << "error: unsupported format version" << version << "\n";
66 while (!gzeof(file)) {
73 void parse_call(void) {
75 call.name = read_string();
79 if (c == Trace::CALL_END || c == -1) {
86 call.args.push_back(parse_arg());
89 call.ret = parse_value();
92 std::cerr << "error: unknown call detail " << c << "\n";
100 virtual void handle_call(Call &call) {
104 Arg parse_arg(void) {
105 std::string name = read_string();
106 Value *value = parse_value();
107 return Arg(name, value);
110 Value *parse_value(void) {
114 case Trace::TYPE_NULL:
116 case Trace::TYPE_FALSE:
117 return new Bool(false);
118 case Trace::TYPE_TRUE:
119 return new Bool(true);
120 case Trace::TYPE_SINT:
122 case Trace::TYPE_UINT:
124 case Trace::TYPE_FLOAT:
125 return parse_float();
126 case Trace::TYPE_DOUBLE:
127 return parse_double();
128 case Trace::TYPE_STRING:
129 return parse_string();
130 case Trace::TYPE_CONST:
131 return parse_const();
132 case Trace::TYPE_BITMASK:
133 return parse_bitmask();
134 case Trace::TYPE_ARRAY:
135 return parse_array();
136 case Trace::TYPE_STRUCT:
137 return parse_struct();
138 case Trace::TYPE_BLOB:
140 case Trace::TYPE_POINTER:
141 return parse_pointer();
142 case Trace::TYPE_OPAQUE:
143 return parse_opaque();
145 std::cerr << "error: unknown type " << c << "\n";
151 Value *parse_sint() {
152 return new SInt(-read_uint());
155 Value *parse_uint() {
156 return new UInt(read_uint());
159 Value *parse_float() {
161 gzread(file, &value, sizeof value);
162 return new Float(value);
165 Value *parse_double() {
167 gzread(file, &value, sizeof value);
168 return new Float(value);
171 Value *parse_string() {
172 return new String(read_string());
175 Value *parse_const() {
176 std::string name = read_string();
177 Value *value = parse_value();
178 return new Const(name, value);
181 Value *parse_bitmask() {
182 unsigned long long value = 0;
187 case Trace::TYPE_SINT:
188 value |= -read_uint();
190 case Trace::TYPE_UINT:
191 value |= read_uint();
193 case Trace::TYPE_CONST:
196 case Trace::TYPE_NULL:
199 std::cerr << "error: uexpected type " << c << "\n";
205 return new UInt(value);
208 Value *parse_array(void) {
209 size_t len = read_uint();
210 Array *array = new Array(len);
211 for (size_t i = 0; i < len; ++i) {
212 array->values[i] = parse_value();
217 Value *parse_blob(void) {
218 size_t size = read_uint();
219 Blob *blob = new Blob(size);
221 gzread(file, blob->buf, size);
226 Value *parse_pointer() {
227 unsigned long long addr;
230 value = parse_value();
232 value = new UInt(addr);
236 Value *parse_struct() {
239 name = read_string();
240 while(name.length()) {
241 Value *value = parse_value();
242 std::cout << " " << name << " = " << value << "\n";
243 name = read_string();
248 Value *parse_opaque() {
249 unsigned long long addr;
252 return new UInt(addr);
255 std::string read_string(void) {
256 size_t len = read_uint();
258 return std::string();
260 char * buf = new char[len];
261 gzread(file, buf, len);
262 std::string value(buf, len);
265 std::cerr << '"' << value << '"' << "\n";
270 unsigned long long read_uint(void) {
271 unsigned long long value = 0;
279 value |= (unsigned long long)(c & 0x7f) << shift;
283 std::cerr << value << "\n";
288 int read_byte(void) {
289 int c = gzgetc(file);
292 std::cerr << "EOF" << "\n";
294 std::cerr << "0x" << std::hex << c << "\n";
301 } /* namespace Trace */
303 #endif /* _TRACE_PARSER_HPP_ */