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
|
#pragma once
#include "Operator.h"
namespace storm {
namespace bs {
STORM_PKG(lang.bs);
/**
* Implementation of operators used in Basic Storm.
*/
/**
* Info for the assignment operator.
*/
class AssignOpInfo : public OpInfo {
STORM_CLASS;
public:
// Ctor.
STORM_CTOR AssignOpInfo(syntax::SStr *op, Int prio, Bool leftAssoc);
// Custom meaning.
virtual Expr *STORM_FN meaning(Block *block, Expr *lhs, Expr *rhs);
private:
// Try to find an applicable setter function.
Expr *findSetter(Block *block, Expr *lhs, Expr *rhs);
};
// Assignment operator. (right associative).
OpInfo *STORM_FN assignOperator(syntax::SStr *op, Int priority);
/**
* Info for the 'is' operator.
*/
class IsOperator : public OpInfo {
STORM_CLASS;
public:
// Create.
STORM_CTOR IsOperator(syntax::SStr *op, Int prio, Bool negate);
// Custom meaning.
virtual Expr *STORM_FN meaning(Block *block, Expr *lhs, Expr *rhs);
private:
// Negated.
Bool negate;
};
/**
* Combined operator, ie an operator that combines assignment with another operator. First
* looks for a specific overload of the operator, if it is not found, turns the expression
* into 'lhs = lhs + rhs'.
*/
class CombinedOperator : public OpInfo {
STORM_CLASS;
public:
// Ctor.
STORM_CTOR CombinedOperator(OpInfo *op, Int prio);
// Meaning.
virtual Expr *STORM_FN meaning(Block *block, Expr *lhs, Expr *rhs);
private:
// Wrapped operator.
OpInfo *op;
};
// Description of a fallback.
struct OpFallback;
/**
* Operator with a number of 'fallbacks'. Used to implement automatic generation of
* operators such as '<', '!=', '>', etc.
*/
class FallbackOperator : public OpInfo {
STORM_CLASS;
public:
// Ctor. 'fallback' needs to be statically allocated.
FallbackOperator(syntax::SStr *op, Int prio, Bool leftAssoc, const OpFallback *fallback);
// Meaning.
virtual Expr *STORM_FN meaning(Block *block, Expr *lhs, Expr *rhs);
private:
// Fallback description.
const OpFallback *fallback;
// Try the fallback at 'id'. May advance 'id' by one if required.
Expr *tryFallback(Nat &id, Block *block, Expr *lhs, Expr *rhs);
Expr *tryFallback(const OpFallback &f, Block *block, Expr *lhs, Expr *rhs);
};
// Create fallback operators for the comparison operators.
OpInfo *STORM_FN compareLt(syntax::SStr *op, Int priority);
OpInfo *STORM_FN compareLte(syntax::SStr *op, Int priority);
OpInfo *STORM_FN compareGt(syntax::SStr *op, Int priority);
OpInfo *STORM_FN compareGte(syntax::SStr *op, Int priority);
OpInfo *STORM_FN compareEq(syntax::SStr *op, Int priority);
OpInfo *STORM_FN compareNeq(syntax::SStr *op, Int priority);
}
}
|
