StatParser.h

Go to the documentation of this file.

#ifndef STAT_PARSER_H
#define STAT_PARSER_H

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <vector>

/* constants */

#ifndef TRUE
#define TRUE  1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#ifndef RETURN_OK
#define RETURN_OK 0
#endif
#ifndef RETURN_ERROR
#define RETURN_ERROR -1
#endif

/* predefined variable names */

#define STAT_COORD_A "a"
#define STAT_COORD_B "b"
#define STAT_COORD_X "x"
#define STAT_COORD_Y "y"
#define STAT_COORD_Z "z"
#define STAT_XMIN    "xmin"
#define STAT_XMAX    "xmax"
#define STAT_YMIN    "ymin"
#define STAT_YMAX    "ymax"
#define STAT_ZMIN    "zmin"
#define STAT_ZMAX    "zmax"
#define STAT_NX      "nx"
#define STAT_NY      "ny"
#define STAT_NZ      "nz"
#define STAT_NXF     "nxfine"
#define STAT_NYF     "nyfine"
#define STAT_NZF     "nzfine"

/* predefined average operations */
#define STAT_RAW      0
#define STAT_AVERAGED 1

#define STAT_PRIMITIVE 0
#define STAT_DERIVED   1

/* function prototypes */
void staterror (char const *msg);
void staterror (char const * msg, int l, int c);

void stat_parser_set_debug(void);
void stat_scanner_set_debug(void);

typedef double (*func_t1) (double);
typedef double (*func_t2) (double, double);

typedef struct {
    int na; /* number of point over which dimensiona are discretized */
    int ave;  /* do we average after sampling */
  } stat_thread;

typedef struct {
    int na, nb; 
    int avea, aveb;
  } stat_surface;

typedef struct {
    int dir, na, nb;
    double amin, amax, bmin, bmax, value;
  } stat_plane;

typedef union {
  stat_thread thread;
  stat_surface surface;
  stat_plane plane;
  double bndry[6];
} stat_uop;

template<class data_type>
class _symrec {
 public:
  int type;            /* type of symbol */
  int src;             /* source of information */
  char * name;         /* name of symbol */
  union {
    int    iptr;       /* integer variable index */
    int    ivalue;     /* integer value */
    double dvalue;     /* real values */
    void*  ptr;        /* pointer to function */
  } vdata;
  int npoints;         /* number of points to evaluate */
  data_type* pdata;    /* array of points to evaluate */
  class _symrec<data_type> * prev, * next, *ref;  /* linked list and pointer to original symbol */
};

#define YYPARSE_TEMPLATE_DEF template<class point_type, class data_type, int dim>
#define YYPARSE_PARAM_TYPE StatParser<point_type,data_type,dim>

YYPARSE_TEMPLATE_DEF
class StatParser {

 private:
    int _exec;
  
 public:
  typedef _symrec<data_type> symrec;
  typedef std::vector<symrec*> symvec;
  
 protected:

  /* all information regarding the probes is contained here */
  typedef struct {
    int type;
    stat_uop options;
    point_type * coords; /* coordinate of sample points */
    symvec sym_coords;  /* list of expressions to evaluate coordinates */
  } probe;

  typedef std::vector<probe*> provec;

  /* all groups with their list of variables and probes */
  typedef struct {
    int step;
    symvec  sym_table;
    provec  probe_table;
  } group;
  
  typedef std::vector<group*> grpvec;

  /* master symbol table */
  symvec sym_table;
  /* group table */
  grpvec group_table;
  /* temporary storage lists */
  symvec sym_stack;

  void dump_token(symrec* ptr, symrec* ptr_org);
  void dump_sym(symvec &list);
  void dump_probe(provec &list);
  char*  token(int tok);

  int delprobe(probe* ptr);
  int delgroup(group* ptr);

  int clearsym(symvec &table);  
  int cleargroup(grpvec &table);
  int clearprobe(provec &list);

  int evalstack(symvec& stack, point_type& xc);
  symrec* clonestack(symvec& stack);
  void unlinksym(symrec* ptr);
  int buildcoords(probe * ptr);
  int clearcoords(probe * ptr);

  symrec* allocsym(char const * sym_name);
  int freesym(symrec* ptr);

  int vectorize(symrec* ptr, int Npoints);
  int unvectorize(symrec* ptr);

 public:
  
  StatParser () ;
  ~StatParser ();

  /* helper functions */
  void   dump_all();

  /* master table functions */
  symrec * putsym(int sym_type, char const * sym_name);
  
  int parse(char const * fname);

  int parser_exec() { return _exec; };
  void parser_activate_exec() { _exec = 1; };
  void parser_deactivate_exec() { _exec = 0; };

  symrec * getsym(char const * sym_name);
  int addgroup(void);
  int group_step(int);
  int group_add_probe(int probe_type, stat_uop & options);
  int group_add_keys(void);
  int searchtoken(int tok);
  int searchtoken(char const * psz);
  int counttoken(int tok);

  /* work table functions */
  symrec * addsym(int sym_type, char const * sym_name = NULL);
};

/* pass argument from calling subroutine */
#define YYPARSE_PARAM parg

/* pass argument to lexer */
#define YYLEX_PARAM   parg

#include "StatParser_parser.c"
#include "StatParser_scanner.c"
#include "StatParser.ipp"

#endif