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