blob: 6bfda56e8c6c577600853d861334a1aac6051940 (
plain)
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
|
// { dg-do run }
#include <stdlib.h>
#include <string>
class Literal;
class CallRuntime;
class AstNode {
public:
enum Type {
kLiteral, kCallRuntime,
kInvalid = -1
};
AstNode() { }
virtual ~AstNode() { }
virtual Type node_type() const = 0;
bool
IsLiteral() { return node_type() == AstNode::kLiteral; }
Literal *
AsLiteral() { return IsLiteral() ? reinterpret_cast<Literal*>(this)
: NULL; }
bool
IsCallRuntime() { return node_type() == AstNode::kCallRuntime; }
CallRuntime *
AsCallRuntime() { return IsCallRuntime() ? reinterpret_cast<CallRuntime*>(this)
: NULL; }
};
class Expression: public AstNode {
public:
private:
int id_;
};
class Literal: public Expression {
public:
virtual AstNode::Type node_type() const { return AstNode::kLiteral; }
private:
std::string ToString();
};
class CallRuntime: public Expression {
public:
virtual AstNode::Type node_type() const { return AstNode::kCallRuntime; }
private:
std::string name_;
};
Expression *
ExpressionCheck (bool *ok)
{
if (*ok == true)
return new CallRuntime();
else
return new Literal ();
return NULL;
}
Expression *
GetExpression (bool *ok)
{
Expression *expression = ExpressionCheck (ok);
Expression *return_expr = NULL;
if (expression != NULL && expression->AsLiteral() != NULL)
return_expr = new Literal();
else if (expression != NULL && expression->AsCallRuntime() != NULL)
return_expr = expression;
return return_expr;
}
int
main (int argc, char **argv)
{
bool a_bool = true;
AstNode *node = GetExpression (&a_bool);
return 0;
}
|
