/* -*- c++ -*- */
/*
* Copyright © 2010 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#pragma once
#ifndef S_EXPRESSION_H
#define S_EXPRESSION_H
#include "main/core.h" /* for Elements */
#include "strtod.h"
#include "list.h"
/* Type-safe downcasting macros (also safe to pass NULL) */
#define SX_AS_(t,x) ((x) && ((s_expression*) x)->is_##t()) ? ((s_##t*) (x)) \
: NULL
#define SX_AS_LIST(x) SX_AS_(list, x)
#define SX_AS_SYMBOL(x) SX_AS_(symbol, x)
#define SX_AS_NUMBER(x) SX_AS_(number, x)
#define SX_AS_INT(x) SX_AS_(int, x)
/* Pattern matching macros */
#define MATCH(list, pat) s_match(list, Elements(pat), pat, false)
#define PARTIAL_MATCH(list, pat) s_match(list, Elements(pat), pat, true)
/* For our purposes, S-Expressions are:
* - <int>
* - <float>
* - symbol
* - (expr1 expr2 ... exprN) where exprN is an S-Expression
*
* Unlike LISP/Scheme, we do not support (foo . bar) pairs.
*/
class s_expression : public exec_node
{
public:
/**
* Read an S-Expression from the given string.
* Advances the supplied pointer to just after the expression read.
*
* Any allocation will be performed with 'ctx' as the ralloc owner.
*/
static s_expression *read_expression(void *ctx, const char *&src);
/**
* Print out an S-Expression. Useful for debugging.
*/
virtual void print() = 0;
virtual bool is_list() const { return false; }
virtual bool is_symbol() const { return false; }
virtual bool is_number() const { return false; }
virtual bool is_int() const { return false; }
protected:
s_expression() { }
};
/* Atoms */
class s_number : public s_expression
{
public:
bool is_number() const { return true; }
virtual float fvalue() = 0;
protected:
s_number() { }
};
class s_int : public s_number
{
public:
s_int(int x) : val(x) { }
bool is_int() const { return true; }
float fvalue() { return float(this->val); }
int value() { return this->val; }
void print();
private:
int val;
};
class s_float : public s_number
{
public:
s_float(float x) : val(x) { }
float fvalue() { return this->val; }
void print();
private:
float val;
};
class s_symbol : public s_expression
{
public:
s_symbol(const char *, size_t);
bool is_symbol() const { return true; }
const char *value() { return this->str; }
void print();
private:
const char *str;
};
/* Lists of expressions: (expr1 ... exprN) */
class s_list : public s_expression
{
public:
s_list();
virtual bool is_list() const { return true; }
void print();
exec_list subexpressions;
};
// ------------------------------------------------------------
/**
* Part of a pattern to match - essentially a record holding a pointer to the
* storage for the component to match, along with the appropriate type.
*/
class s_pattern {
public:
s_pattern(s_expression *&s) : p_expr(&s), type(EXPR) { }
s_pattern(s_list *&s) : p_list(&s), type(LIST) { }
s_pattern(s_symbol *&s) : p_symbol(&s), type(SYMBOL) { }
s_pattern(s_number *&s) : p_number(&s), type(NUMBER) { }
s_pattern(s_int *&s) : p_int(&s), type(INT) { }
s_pattern(const char *str) : literal(str), type(STRING) { }
bool match(s_expression *expr);
private:
union {
s_expression **p_expr;
s_list **p_list;
s_symbol **p_symbol;
s_number **p_number;
s_int **p_int;
const char *literal;
};
enum { EXPR, LIST, SYMBOL, NUMBER, INT, STRING } type;
};
bool
s_match(s_expression *top, unsigned n, s_pattern *pattern, bool partial);
#endif /* S_EXPRESSION_H */