/usr/include/JAGS/compiler/Compiler.h is in jags 3.4.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | #ifndef COMPILER_H_
#define COMPILER_H_
#include <compiler/LogicalFactory.h>
#include <compiler/ConstantFactory.h>
#include <compiler/MixtureFactory.h>
#include <compiler/CounterTab.h>
#include <compiler/ObsFuncTab.h>
#include <distribution/DistTab.h>
#include <function/FuncTab.h>
#include <model/BUGSModel.h>
#include <graph/Graph.h>
#include <map>
#include <string>
#include <utility>
#include <list>
class ParseTree;
class SymTab;
class FuncTab;
class DistTab;
class NodeAlias;
class Compiler;
typedef void (Compiler::*CompilerMemFn) (ParseTree const *);
/**
* @short Creates a BUGSModel from a ParseTree
*/
class Compiler {
BUGSModel &_model;
CounterTab _countertab;
std::map<std::string, SArray> const &_data_table;
std::map<std::string, std::vector<bool> > _constant_mask;
unsigned int _n_resolved, _n_relations;
bool *_is_resolved;
bool _strict_resolution;
int _index_expression;
std::vector<Node*> _index_nodes;
ConstantFactory _constantfactory;
LogicalFactory _logicalfactory;
MixtureFactory _mixfactory1;
MixtureFactory _mixfactory2;
std::map<std::string, std::vector<std::vector<int> > > _node_array_ranges;
Node *getArraySubset(ParseTree const *t);
Range VariableSubsetRange(ParseTree const *var);
Range CounterRange(ParseTree const *var);
Node* VarGetNode(ParseTree const *var);
Range getRange(ParseTree const *var, Range const &default_range);
void traverseTree(ParseTree const *relations, CompilerMemFn fun,
bool resetcounter=true);
void allocate(ParseTree const *rel);
Node * allocateStochastic(ParseTree const *stoch_rel);
Node * allocateLogical(ParseTree const *dtrm_rel);
void setConstantMask(ParseTree const *rel);
void writeConstantData(ParseTree const *rel);
Node *getLength(ParseTree const *p, SymTab const &symtab);
Node *getDim(ParseTree const *p, SymTab const &symtab);
void getArrayDim(ParseTree const *p);
bool getParameterVector(ParseTree const *t,
std::vector<Node const *> &parents);
Node * constFromTable(ParseTree const *p);
void addDevianceNode();
public:
bool indexExpression(ParseTree const *t, int &value);
BUGSModel &model() const;
Node * getParameter(ParseTree const *t);
/**
* @param model Model to be created by the compiler.
*
* @param datatab Data table, mapping a variable name onto a
* multi-dimensional array of values. This is required since some
* constant expressions in the BUGS language may depend on data
* values.
*/
Compiler(BUGSModel &model, std::map<std::string, SArray> const &data_table);
/**
* Adds variables to the symbol table.
*
* @param pvariables vector of ParseTree pointers, each one corresponding
* to a parsed variable declaration.
*/
void declareVariables(std::vector<ParseTree*> const &pvariables);
/**
* Adds variables without an explicit declaration to the symbol
* table. Variables supplied in the data table are added, then
* any variables that appear on the left hand side of a relation
*
* @param prelations ParseTree corresponding to a parsed model block
*/
void undeclaredVariables(ParseTree const *prelations);
/**
* Traverses the ParseTree creating nodes.
*
* @param prelations ParseTree corresponding to a parsed model block
*/
void writeRelations(ParseTree const *prelations);
/**
* The function table used by the compiler to look up functions by
* name. It is shared by all Compiler objects.
*
* @see Module
*/
static FuncTab &funcTab();
/**
* The distribution table used by the compiler to look up
* distributions by name. It is shared by all Compiler objects.
*
* @see Module
*/
static DistTab &distTab();
/**
* The table for observable functions used by the compiler to substitute
* a logical node for a stochastic node when required
*/
static ObsFuncTab &obsFuncTab();
MixtureFactory &mixtureFactory1();
MixtureFactory &mixtureFactory2();
};
#endif /* COMPILER_H_ */
|