libX11 libXinerama mesa git update 1 Feb 2011

1 files changed, 180 insertions, 180 deletions

diff --git a/mesalib/src/glsl/s_expression.h b/mesalib/src/glsl/s_expression.h
index 1bb437736..c9dc676b3 100644
--- a/mesalib/src/glsl/s_expression.h
+++ b/mesalib/src/glsl/s_expression.h
@@ -1,180 +1,180 @@
-/* -*- 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 talloc 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:

-   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 */

+/* -*- 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:
+   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 */