3 * Copyright © 2010 Intel Corporation
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
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
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
25 #ifndef S_EXPRESSION_H
26 #define S_EXPRESSION_H
28 #include "util/strtod.h"
31 /* Type-safe downcasting macros (also safe to pass NULL) */
32 #define SX_AS_(t,x) ((x) && ((s_expression*) x)->is_##t()) ? ((s_##t*) (x)) \
34 #define SX_AS_LIST(x) SX_AS_(list, x)
35 #define SX_AS_SYMBOL(x) SX_AS_(symbol, x)
36 #define SX_AS_NUMBER(x) SX_AS_(number, x)
37 #define SX_AS_INT(x) SX_AS_(int, x)
39 /* Pattern matching macros */
40 #define MATCH(list, pat) s_match(list, ARRAY_SIZE(pat), pat, false)
41 #define PARTIAL_MATCH(list, pat) s_match(list, ARRAY_SIZE(pat), pat, true)
43 /* For our purposes, S-Expressions are:
47 * - (expr1 expr2 ... exprN) where exprN is an S-Expression
49 * Unlike LISP/Scheme, we do not support (foo . bar) pairs.
51 class s_expression
: public exec_node
55 * Read an S-Expression from the given string.
56 * Advances the supplied pointer to just after the expression read.
58 * Any allocation will be performed with 'ctx' as the ralloc owner.
60 static s_expression
*read_expression(void *ctx
, const char *&src
);
63 * Print out an S-Expression. Useful for debugging.
65 virtual void print() = 0;
67 virtual bool is_list() const { return false; }
68 virtual bool is_symbol() const { return false; }
69 virtual bool is_number() const { return false; }
70 virtual bool is_int() const { return false; }
78 class s_number
: public s_expression
81 bool is_number() const { return true; }
83 virtual float fvalue() = 0;
89 class s_int
: public s_number
92 s_int(int x
) : val(x
) { }
94 bool is_int() const { return true; }
96 float fvalue() { return float(this->val
); }
97 int value() { return this->val
; }
105 class s_float
: public s_number
108 s_float(float x
) : val(x
) { }
110 float fvalue() { return this->val
; }
118 class s_symbol
: public s_expression
121 s_symbol(const char *, size_t);
123 bool is_symbol() const { return true; }
125 const char *value() { return this->str
; }
133 /* Lists of expressions: (expr1 ... exprN) */
134 class s_list
: public s_expression
139 virtual bool is_list() const { return true; }
143 exec_list subexpressions
;
146 // ------------------------------------------------------------
149 * Part of a pattern to match - essentially a record holding a pointer to the
150 * storage for the component to match, along with the appropriate type.
154 s_pattern(s_expression
*&s
) : p_expr(&s
), type(EXPR
) { }
155 s_pattern(s_list
*&s
) : p_list(&s
), type(LIST
) { }
156 s_pattern(s_symbol
*&s
) : p_symbol(&s
), type(SYMBOL
) { }
157 s_pattern(s_number
*&s
) : p_number(&s
), type(NUMBER
) { }
158 s_pattern(s_int
*&s
) : p_int(&s
), type(INT
) { }
159 s_pattern(const char *str
) : literal(str
), type(STRING
) { }
161 bool match(s_expression
*expr
);
165 s_expression
**p_expr
;
172 enum { EXPR
, LIST
, SYMBOL
, NUMBER
, INT
, STRING
} type
;
176 s_match(s_expression
*top
, unsigned n
, s_pattern
*pattern
, bool partial
);
178 #endif /* S_EXPRESSION_H */