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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
// Copyright (c) 1996 James Clark
// See the file copying.txt for copying permission.
#ifndef ProcessingMode_INCLUDED
#define ProcessingMode_INCLUDED 1
#include "Named.h"
#include "StringC.h"
#include "Location.h"
#include "Owner.h"
#include "Vector.h"
#include "NCVector.h"
#include "NamedTable.h"
#include "Expression.h"
#include "Insn.h"
#include "Boolean.h"
#include "Node.h"
#include "FOTBuilder.h"
#include "IList.h"
#include "Pattern.h"
#ifdef DSSSL_NAMESPACE
namespace DSSSL_NAMESPACE {
#endif
class Interpreter;
class SosofoObj;
class ProcessingMode : public Named {
public:
enum RuleType {
styleRule,
constructionRule
};
enum { nRuleType = 2 };
class Specificity {
public:
Specificity();
bool isStyle() const;
private:
bool toInitial_; // 1 if the match fell through from a named processing mode to
// the initial processing mode
RuleType ruleType_;
size_t nextRuleIndex_;
friend class ProcessingMode;
};
class Action : public Resource {
public:
Action(unsigned partIndex, Owner<Expression> &, const Location &);
void compile(Interpreter &, RuleType);
void get(InsnPtr &, SosofoObj *&) const;
const Location &location() const;
unsigned partIndex() const;
private:
Location defLoc_;
Owner<Expression> expr_;
// One of these will be non-null.
InsnPtr insn_;
// must be permanent
SosofoObj *sosofo_;
unsigned partIndex_;
};
class Rule {
public:
Rule();
Rule(const Ptr<Action> &);
const Action &action() const;
Action &action();
virtual int compareSpecificity(const Rule &) const;
const Location &location() const;
void swap(Rule &);
private:
Ptr<Action> action_;
};
class ElementRule : public Rule, public Pattern, public Link {
public:
ElementRule(const Ptr<Action> &, Pattern &);
int compareSpecificity(const Rule &) const;
};
ProcessingMode(const StringC &, const ProcessingMode *initial = 0);
void addRule(bool matchesRoot, NCVector<Pattern> &, Owner<Expression> &expr,
RuleType, const Location &, Interpreter &);
// Specificity gives specificity of last match; gets specificity of current match.
const Rule *findMatch(const NodePtr &, Pattern::MatchContext &, Messenger &,
Specificity &) const;
void compile(Interpreter &);
bool defined() const;
void setDefined();
struct ElementRules : public Named {
public:
ElementRules(const StringC &);
Vector<const ElementRule *> rules[nRuleType];
};
struct GroveRules {
GroveRules();
bool built;
NamedTable<ElementRules> elementTable;
Vector<const ElementRule *> otherRules[nRuleType];
void build(const IList<ElementRule> *, const NodePtr &, Messenger &);
static void sortRules(Vector<const ElementRule *> &v);
};
private:
const Rule *findElementMatch(const StringC &, const NodePtr &,
Pattern::MatchContext &, Messenger &,
Specificity &) const;
const Rule *findRootMatch(const NodePtr &, Pattern::MatchContext &, Messenger &,
Specificity &) const;
const GroveRules &groveRules(const NodePtr &, Messenger &) const;
static void elementRuleAdvance(const NodePtr &nd, Pattern::MatchContext &context,
Messenger &mgr, Specificity &specificity,
const Vector<const ElementRule *> &vec);
Vector<Rule> rootRules_[nRuleType];
IList<ElementRule> elementRules_[nRuleType];
NCVector<GroveRules> groveRules_;
const ProcessingMode *initial_; // 0 for initial mode
bool defined_;
};
inline
bool ProcessingMode::defined() const
{
return defined_;
}
inline
void ProcessingMode::setDefined()
{
defined_ = 1;
}
inline
ProcessingMode::Specificity::Specificity()
: toInitial_(0), nextRuleIndex_(0), ruleType_(styleRule)
{
}
inline
bool ProcessingMode::Specificity::isStyle() const
{
return ruleType_ == styleRule;
}
inline
void ProcessingMode::Action::get(InsnPtr &insn, SosofoObj *&sosofo) const
{
insn = insn_;
sosofo = sosofo_;
}
inline
const Location &ProcessingMode::Action::location() const
{
return defLoc_;
}
inline
ProcessingMode::Action &ProcessingMode::Rule::action()
{
return *action_;
}
inline
const ProcessingMode::Action &ProcessingMode::Rule::action() const
{
return *action_;
}
inline
unsigned ProcessingMode::Action::partIndex() const
{
return partIndex_;
}
inline
const Location &ProcessingMode::Rule::location() const
{
return action_->location();
}
inline
void ProcessingMode::Rule::swap(Rule &r)
{
action_.swap(r.action_);
}
#ifdef DSSSL_NAMESPACE
}
#endif
#endif /* not ProcessingMode_INCLUDED */
|
