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