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.
30 #include "s_expression.h"
32 s_symbol::s_symbol(const char *str
, size_t n
)
34 /* Assume the given string is already nul-terminated and in memory that
35 * will live as long as this node.
37 assert(str
[n
] == '\0');
46 skip_whitespace(const char *&src
, char *&symbol_buffer
)
48 size_t n
= strspn(src
, " \v\t\r\n");
51 /* Also skip Scheme-style comments: semi-colon 'til end of line */
53 n
= strcspn(src
, "\n");
56 skip_whitespace(src
, symbol_buffer
);
61 read_atom(void *ctx
, const char *&src
, char *&symbol_buffer
)
63 s_expression
*expr
= NULL
;
65 skip_whitespace(src
, symbol_buffer
);
67 size_t n
= strcspn(src
, "( \v\t\r\n);");
69 return NULL
; // no atom
71 // Check for the special symbol '+INF', which means +Infinity. Note: C99
72 // requires strtof to parse '+INF' as +Infinity, but we still support some
73 // non-C99-compliant compilers (e.g. MSVC).
74 if (n
== 4 && strncmp(src
, "+INF", 4) == 0) {
75 expr
= new(ctx
) s_float(INFINITY
);
77 // Check if the atom is a number.
78 char *float_end
= NULL
;
79 float f
= _mesa_strtof(src
, &float_end
);
80 if (float_end
!= src
) {
82 int i
= strtol(src
, &int_end
, 10);
83 // If strtof matched more characters, it must have a decimal part
84 if (float_end
> int_end
)
85 expr
= new(ctx
) s_float(f
);
87 expr
= new(ctx
) s_int(i
);
89 // Not a number; return a symbol.
90 symbol_buffer
[n
] = '\0';
91 expr
= new(ctx
) s_symbol(symbol_buffer
, n
);
101 static s_expression
*
102 __read_expression(void *ctx
, const char *&src
, char *&symbol_buffer
)
104 s_expression
*atom
= read_atom(ctx
, src
, symbol_buffer
);
108 skip_whitespace(src
, symbol_buffer
);
113 s_list
*list
= new(ctx
) s_list
;
116 while ((expr
= __read_expression(ctx
, src
, symbol_buffer
)) != NULL
) {
117 list
->subexpressions
.push_tail(expr
);
119 skip_whitespace(src
, symbol_buffer
);
121 printf("Unclosed expression (check your parenthesis).\n");
132 s_expression::read_expression(void *ctx
, const char *&src
)
136 /* When we encounter a Symbol, we need to save a nul-terminated copy of
137 * the string. However, ralloc_strndup'ing every individual Symbol is
138 * extremely expensive. We could avoid this by simply overwriting the
139 * next character (guaranteed to be whitespace, parens, or semicolon) with
140 * a nul-byte. But overwriting non-whitespace would mess up parsing.
142 * So, just copy the whole buffer ahead of time. Walk both, leaving the
143 * original source string unmodified, and altering the copy to contain the
144 * necessary nul-bytes whenever we encounter a symbol.
146 char *symbol_buffer
= ralloc_strdup(ctx
, src
);
147 return __read_expression(ctx
, src
, symbol_buffer
);
152 printf("%d", this->val
);
155 void s_float::print()
157 printf("%f", this->val
);
160 void s_symbol::print()
162 printf("%s", this->str
);
168 foreach_in_list(s_expression
, expr
, &this->subexpressions
) {
170 if (!expr
->next
->is_tail_sentinel())
176 // --------------------------------------------------
179 s_pattern::match(s_expression
*expr
)
183 case EXPR
: *p_expr
= expr
; break;
184 case LIST
: if (expr
->is_list()) *p_list
= (s_list
*) expr
; break;
185 case SYMBOL
: if (expr
->is_symbol()) *p_symbol
= (s_symbol
*) expr
; break;
186 case NUMBER
: if (expr
->is_number()) *p_number
= (s_number
*) expr
; break;
187 case INT
: if (expr
->is_int()) *p_int
= (s_int
*) expr
; break;
189 s_symbol
*sym
= SX_AS_SYMBOL(expr
);
190 if (sym
!= NULL
&& strcmp(sym
->value(), literal
) == 0)
195 return *p_expr
== expr
;
199 s_match(s_expression
*top
, unsigned n
, s_pattern
*pattern
, bool partial
)
201 s_list
*list
= SX_AS_LIST(top
);
206 foreach_in_list(s_expression
, expr
, &list
->subexpressions
) {
208 return partial
; /* More actual items than the pattern expected */
210 if (expr
== NULL
|| !pattern
[i
].match(expr
))
217 return false; /* Less actual items than the pattern expected */