Delete trailing whitespace at end of lines.
[pspp-builds.git] / src / language / expressions / private.h
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or
5    modify it under the terms of the GNU General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    License, or (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful, but
10    WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program; if not, write to the Free Software
16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17    02110-1301, USA. */
18
19 #ifndef EXPRESSIONS_PRIVATE_H
20 #define EXPRESSIONS_PRIVATE_H
21
22 #include <assert.h>
23 #include <stddef.h>
24 #include <data/format.h>
25 #include <libpspp/str.h>
26
27 #include "public.h"
28 #include "operations.h"
29
30 enum operation_flags
31   {
32     /* Most operations produce a missing output value if any
33        input value is missing.  Setting this bit indicates that
34        this operation may produce a non-missing result given
35        missing input values (although it is not obliged to do
36        so).  Unless this bit is set, the operation's evaluation
37        function will never be passed a missing argument. */
38     OPF_ABSORB_MISS = 004,
39
40     /* If set, this operation's final operand is an array of one
41        or more elements. */
42     OPF_ARRAY_OPERAND = 001,
43
44     /* If set, the user can specify the minimum number of array
45        elements that must be non-missing for the function result
46        to be non-missing.  The operation must have an array
47        operand and the array must contain `double's.  Both
48        OPF_ABSORB_MISS and OPF_ARRAY_OPERAND must also be set. */
49     OPF_MIN_VALID = 002,
50
51     /* If set, operation is non-optimizable in general.  Unless
52        combined with OPF_ABSORB_MISS, missing input values are
53        still assumed to yield missing results. */
54     OPF_NONOPTIMIZABLE = 010,
55
56     /* If set, this operation is not implemented. */
57     OPF_UNIMPLEMENTED = 020,
58
59     /* If set, this operation is a PSPP extension. */
60     OPF_EXTENSION = 040,
61
62     /* If set, this operation may not occur after TEMPORARY.
63        (Currently this applies only to LAG.) */
64     OPF_PERM_ONLY = 0100,
65
66     /* If set, this operation's name may not be abbreviated. */
67     OPF_NO_ABBREV = 0200
68   };
69
70 #define EXPR_ARG_MAX 4
71 struct operation
72   {
73     const char *name;
74     const char *prototype;
75     enum operation_flags flags;
76     atom_type returns;
77     int arg_cnt;
78     atom_type args[EXPR_ARG_MAX];
79     int array_min_elems;
80     int array_granularity;
81   };
82
83 extern const struct operation operations[];
84
85 /* Tree structured expressions. */
86
87 /* Atoms. */
88 struct number_node
89   {
90     operation_type type;   /* OP_number. */
91     double n;
92   };
93
94 struct string_node
95   {
96     operation_type type;   /* OP_string. */
97     struct substring s;
98   };
99
100 struct variable_node
101   {
102     operation_type type;   /* OP_variable. */
103     const struct variable *v;
104   };
105
106 struct integer_node
107   {
108     operation_type type;   /* OP_integer. */
109     int i;
110   };
111
112 struct vector_node
113   {
114     operation_type type;   /* OP_vector. */
115     const struct vector *v;
116   };
117
118 struct format_node
119   {
120     operation_type type;   /* OP_format. */
121     struct fmt_spec f;
122   };
123
124 /* Any composite node. */
125 struct composite_node
126   {
127     operation_type type;   /* One of OP_*. */
128     size_t arg_cnt;             /* Number of arguments. */
129     union any_node **args;      /* Arguments. */
130     size_t min_valid;           /* Min valid array args to get valid result. */
131   };
132
133 /* Any node. */
134 union any_node
135   {
136     operation_type type;
137     struct number_node number;
138     struct string_node string;
139     struct variable_node variable;
140     struct integer_node integer;
141     struct vector_node vector;
142     struct format_node format;
143     struct composite_node composite;
144   };
145
146 union operation_data
147   {
148     operation_type operation;
149     double number;
150     struct substring string;
151     const struct variable *variable;
152     const struct vector *vector;
153     struct fmt_spec *format;
154     int integer;
155   };
156
157 /* An expression. */
158 struct expression
159   {
160     struct pool *expr_pool;     /* Pool for expression static data. */
161     struct dataset *ds ;        /* The dataset */
162     atom_type type;             /* Type of expression result. */
163
164     union operation_data *ops;  /* Expression data. */
165     operation_type *op_types;   /* ops[] element types (for debugging). */
166     size_t op_cnt, op_cap;      /* Number of ops, amount of allocated space. */
167
168     double *number_stack;       /* Evaluation stack: numerics, Booleans. */
169     struct substring *string_stack; /* Evaluation stack: strings. */
170     struct pool *eval_pool;     /* Pool for evaluation temporaries. */
171   };
172
173 struct expression *expr_parse_any (struct lexer *lexer, struct dataset *,  bool optimize);
174 void expr_debug_print_postfix (const struct expression *);
175
176 union any_node *expr_optimize (union any_node *, struct expression *);
177 void expr_flatten (union any_node *, struct expression *);
178
179 atom_type expr_node_returns (const union any_node *);
180
181 union any_node *expr_allocate_nullary (struct expression *e, operation_type);
182 union any_node *expr_allocate_unary (struct expression *e,
183                                      operation_type, union any_node *);
184 union any_node *expr_allocate_binary (struct expression *e, operation_type,
185                                  union any_node *, union any_node *);
186 union any_node *expr_allocate_composite (struct expression *e, operation_type,
187                                          union any_node **, size_t);
188 union any_node *expr_allocate_number (struct expression *e, double);
189 union any_node *expr_allocate_boolean (struct expression *e, double);
190 union any_node *expr_allocate_integer (struct expression *e, int);
191 union any_node *expr_allocate_pos_int (struct expression *e, int);
192 union any_node *expr_allocate_string_buffer (struct expression *e,
193                                              const char *string, size_t length);
194 union any_node *expr_allocate_string (struct expression *e,
195                                       struct substring);
196 union any_node *expr_allocate_variable (struct expression *e,
197                                         const struct variable *);
198 union any_node *expr_allocate_format (struct expression *e,
199                                  const struct fmt_spec *);
200 union any_node *expr_allocate_vector (struct expression *e,
201                                       const struct vector *);
202
203 #endif /* expressions/private.h */