aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/Xft1/xftgram.y
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/Xft1/xftgram.y')
-rw-r--r--nx-X11/lib/Xft1/xftgram.y452
1 files changed, 452 insertions, 0 deletions
diff --git a/nx-X11/lib/Xft1/xftgram.y b/nx-X11/lib/Xft1/xftgram.y
new file mode 100644
index 000000000..04e231e7c
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftgram.y
@@ -0,0 +1,452 @@
+/*
+ * $XFree86: xc/lib/Xft/xftgram.y,v 1.5 2001/05/16 10:32:54 keithp Exp $
+ *
+ * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+%{
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "xftint.h"
+
+static XftMatrix matrix;
+
+%}
+
+%union {
+ int ival;
+ double dval;
+ char *sval;
+ XftExpr *eval;
+ XftPattern *pval;
+ XftValue vval;
+ XftEdit *Eval;
+ XftOp oval;
+ XftQual qval;
+ XftTest *tval;
+}
+
+%token <ival> INTEGER
+%token <dval> DOUBLE
+%token <sval> STRING NAME
+%token <ival> ANY ALL
+%token <ival> DIR CACHE INCLUDE INCLUDEIF MATCH EDIT
+%token <ival> TOK_TRUE TOK_FALSE TOK_NIL
+%token <ival> EQUAL SEMI OS CS
+
+%type <eval> expr
+%type <vval> value
+%type <sval> field
+%type <Eval> edit
+%type <Eval> edits
+%type <oval> eqop
+%type <qval> qual
+%type <oval> compare
+%type <tval> tests test
+%type <dval> number
+
+%right <ival> QUEST COLON
+%left <ival> OROR
+%left <ival> ANDAND
+%left <ival> EQEQ NOTEQ
+%left <ival> LESS LESSEQ MORE MOREEQ
+%left <ival> PLUS MINUS
+%left <ival> TIMES DIVIDE
+%right <ival> NOT
+
+%%
+configs : configs config
+ |
+ ;
+config : DIR STRING
+ { XftConfigAddDir ($2); }
+ | CACHE STRING
+ { XftConfigSetCache ($2); }
+ | INCLUDE STRING
+ { XftConfigPushInput ($2, True); }
+ | INCLUDEIF STRING
+ { XftConfigPushInput ($2, False); }
+ | MATCH tests EDIT edits
+ { XftConfigAddEdit ($2, $4); }
+ ;
+tests : test tests
+ { $1->next = $2; $$ = $1; }
+ |
+ { $$ = 0; }
+ ;
+test : qual field compare value
+ { $$ = XftTestCreate ($1, $2, $3, $4); }
+ ;
+qual : ANY
+ { $$ = XftQualAny; }
+ | ALL
+ { $$ = XftQualAll; }
+ |
+ { $$ = XftQualAny; }
+ ;
+field : NAME
+ {
+ $$ = XftConfigSaveField ($1);
+ }
+ ;
+compare : EQUAL
+ { $$ = XftOpEqual; }
+ | EQEQ
+ { $$ = XftOpEqual; }
+ | NOTEQ
+ { $$ = XftOpNotEqual; }
+ | LESS
+ { $$ = XftOpLess; }
+ | LESSEQ
+ { $$ = XftOpLessEqual; }
+ | MORE
+ { $$ = XftOpMore; }
+ | MOREEQ
+ { $$ = XftOpMoreEqual; }
+ ;
+value : INTEGER
+ {
+ $$.type = XftTypeInteger;
+ $$.u.i = $1;
+ }
+ | DOUBLE
+ {
+ $$.type = XftTypeDouble;
+ $$.u.d = $1;
+ }
+ | STRING
+ {
+ $$.type = XftTypeString;
+ $$.u.s = $1;
+ }
+ | TOK_TRUE
+ {
+ $$.type = XftTypeBool;
+ $$.u.b = True;
+ }
+ | TOK_FALSE
+ {
+ $$.type = XftTypeBool;
+ $$.u.b = False;
+ }
+ | TOK_NIL
+ {
+ $$.type = XftTypeVoid;
+ }
+ | matrix
+ {
+ $$.type = XftTypeMatrix;
+ $$.u.m = &matrix;
+ }
+ ;
+matrix : OS number number number number CS
+ {
+ matrix.xx = $2;
+ matrix.xy = $3;
+ matrix.yx = $4;
+ matrix.__REALLY_YY__ = $5;
+ }
+number : INTEGER
+ { $$ = (double) $1; }
+ | DOUBLE
+ ;
+edits : edit edits
+ { $1->next = $2; $$ = $1; }
+ |
+ { $$ = 0; }
+ ;
+edit : field eqop expr SEMI
+ { $$ = XftEditCreate ($1, $2, $3); }
+ ;
+eqop : EQUAL
+ { $$ = XftOpAssign; }
+ | PLUS EQUAL
+ { $$ = XftOpPrepend; }
+ | EQUAL PLUS
+ { $$ = XftOpAppend; }
+ ;
+expr : INTEGER
+ { $$ = XftExprCreateInteger ($1); }
+ | DOUBLE
+ { $$ = XftExprCreateDouble ($1); }
+ | STRING
+ { $$ = XftExprCreateString ($1); }
+ | TOK_TRUE
+ { $$ = XftExprCreateBool (True); }
+ | TOK_FALSE
+ { $$ = XftExprCreateBool (False); }
+ | TOK_NIL
+ { $$ = XftExprCreateNil (); }
+ | matrix
+ { $$ = XftExprCreateMatrix (&matrix); }
+ | NAME
+ { $$ = XftExprCreateField ($1); }
+ | expr OROR expr
+ { $$ = XftExprCreateOp ($1, XftOpOr, $3); }
+ | expr ANDAND expr
+ { $$ = XftExprCreateOp ($1, XftOpAnd, $3); }
+ | expr EQEQ expr
+ { $$ = XftExprCreateOp ($1, XftOpEqual, $3); }
+ | expr NOTEQ expr
+ { $$ = XftExprCreateOp ($1, XftOpNotEqual, $3); }
+ | expr LESS expr
+ { $$ = XftExprCreateOp ($1, XftOpLess, $3); }
+ | expr LESSEQ expr
+ { $$ = XftExprCreateOp ($1, XftOpLessEqual, $3); }
+ | expr MORE expr
+ { $$ = XftExprCreateOp ($1, XftOpMore, $3); }
+ | expr MOREEQ expr
+ { $$ = XftExprCreateOp ($1, XftOpMoreEqual, $3); }
+ | expr PLUS expr
+ { $$ = XftExprCreateOp ($1, XftOpPlus, $3); }
+ | expr MINUS expr
+ { $$ = XftExprCreateOp ($1, XftOpMinus, $3); }
+ | expr TIMES expr
+ { $$ = XftExprCreateOp ($1, XftOpTimes, $3); }
+ | expr DIVIDE expr
+ { $$ = XftExprCreateOp ($1, XftOpDivide, $3); }
+ | NOT expr
+ { $$ = XftExprCreateOp ($2, XftOpNot, (XftExpr *) 0); }
+ | expr QUEST expr COLON expr
+ { $$ = XftExprCreateOp ($1, XftOpQuest, XftExprCreateOp ($3, XftOpQuest, $5)); }
+ ;
+%%
+
+int
+XftConfigwrap (void)
+{
+ return 1;
+}
+
+void
+XftConfigerror (char *fmt, ...)
+{
+ va_list args;
+
+ fprintf (stderr, "\"%s\": line %d, ", XftConfigFile, XftConfigLineno);
+ va_start (args, fmt);
+ vfprintf (stderr, fmt, args);
+ va_end (args);
+ fprintf (stderr, "\n");
+}
+
+XftTest *
+XftTestCreate (XftQual qual, const char *field, XftOp compare, XftValue value)
+{
+ XftTest *test = (XftTest *) malloc (sizeof (XftTest));;
+
+ if (test)
+ {
+ test->next = 0;
+ test->qual = qual;
+ test->field = field; /* already saved in grammar */
+ test->op = compare;
+ if (value.type == XftTypeString)
+ value.u.s = _XftSaveString (value.u.s);
+ else if (value.type == XftTypeMatrix)
+ value.u.m = _XftSaveMatrix (value.u.m);
+ test->value = value;
+ }
+ return test;
+}
+
+XftExpr *
+XftExprCreateInteger (int i)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpInteger;
+ e->u.ival = i;
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateDouble (double d)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpDouble;
+ e->u.dval = d;
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateString (const char *s)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpString;
+ e->u.sval = _XftSaveString (s);
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateMatrix (const XftMatrix *m)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpMatrix;
+ e->u.mval = _XftSaveMatrix (m);
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateBool (Bool b)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpBool;
+ e->u.bval = b;
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateNil (void)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpNil;
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateField (const char *field)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpField;
+ e->u.field = _XftSaveString (field);
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateOp (XftExpr *left, XftOp op, XftExpr *right)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = op;
+ e->u.tree.left = left;
+ e->u.tree.right = right;
+ }
+ return e;
+}
+
+void
+XftExprDestroy (XftExpr *e)
+{
+ switch (e->op) {
+ case XftOpInteger:
+ break;
+ case XftOpDouble:
+ break;
+ case XftOpString:
+ free (e->u.sval);
+ break;
+ case XftOpMatrix:
+ free (e->u.mval);
+ break;
+ case XftOpBool:
+ break;
+ case XftOpField:
+ free (e->u.field);
+ break;
+ case XftOpAssign:
+ case XftOpPrepend:
+ case XftOpAppend:
+ break;
+ case XftOpOr:
+ case XftOpAnd:
+ case XftOpEqual:
+ case XftOpNotEqual:
+ case XftOpLess:
+ case XftOpLessEqual:
+ case XftOpMore:
+ case XftOpMoreEqual:
+ case XftOpPlus:
+ case XftOpMinus:
+ case XftOpTimes:
+ case XftOpDivide:
+ case XftOpQuest:
+ XftExprDestroy (e->u.tree.right);
+ /* fall through */
+ case XftOpNot:
+ XftExprDestroy (e->u.tree.left);
+ break;
+ case XftOpNil:
+ break;
+ }
+ free (e);
+}
+
+XftEdit *
+XftEditCreate (const char *field, XftOp op, XftExpr *expr)
+{
+ XftEdit *e = (XftEdit *) malloc (sizeof (XftEdit));
+
+ if (e)
+ {
+ e->next = 0;
+ e->field = field; /* already saved in grammar */
+ e->op = op;
+ e->expr = expr;
+ }
+ return e;
+}
+
+void
+XftEditDestroy (XftEdit *e)
+{
+ if (e->next)
+ XftEditDestroy (e->next);
+ free ((void *) e->field);
+ if (e->expr)
+ XftExprDestroy (e->expr);
+}
+
+char *
+XftConfigSaveField (const char *field)
+{
+ return _XftSaveString (field);
+}