-
Notifications
You must be signed in to change notification settings - Fork 3
/
init.h
147 lines (117 loc) · 4.2 KB
/
init.h
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
// Compiler implementation of the D programming language
// Copyright (c) 1999-2013 by Digital Mars
// All Rights Reserved
// written by Walter Bright
// http://www.digitalmars.com
// License for redistribution is by either the Artistic License
// in artistic.txt, or the GNU General Public License in gnu.txt.
// See the included readme.txt for details.
#ifndef INIT_H
#define INIT_H
#include "root.h"
#include "mars.h"
#include "arraytypes.h"
class Identifier;
class Expression;
struct Scope;
class Type;
struct dt_t;
class AggregateDeclaration;
class ErrorInitializer;
class VoidInitializer;
class StructInitializer;
class ArrayInitializer;
class ExpInitializer;
struct HdrGenState;
enum NeedInterpret { INITnointerpret, INITinterpret };
class Initializer : public RootObject
{
public:
Loc loc;
Initializer(Loc loc);
virtual Initializer *syntaxCopy();
// needInterpret is INITinterpret if must be a manifest constant, 0 if not.
virtual Initializer *semantic(Scope *sc, Type *t, NeedInterpret needInterpret);
virtual Type *inferType(Scope *sc);
virtual Expression *toExpression(Type *t = NULL) = 0;
virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs) = 0;
char *toChars();
static Initializers *arraySyntaxCopy(Initializers *ai);
virtual dt_t *toDt();
virtual ErrorInitializer *isErrorInitializer() { return NULL; }
virtual VoidInitializer *isVoidInitializer() { return NULL; }
virtual StructInitializer *isStructInitializer() { return NULL; }
virtual ArrayInitializer *isArrayInitializer() { return NULL; }
virtual ExpInitializer *isExpInitializer() { return NULL; }
};
class VoidInitializer : public Initializer
{
public:
Type *type; // type that this will initialize to
VoidInitializer(Loc loc);
Initializer *syntaxCopy();
Initializer *semantic(Scope *sc, Type *t, NeedInterpret needInterpret);
Expression *toExpression(Type *t = NULL);
void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
dt_t *toDt();
virtual VoidInitializer *isVoidInitializer() { return this; }
};
class ErrorInitializer : public Initializer
{
public:
ErrorInitializer();
Initializer *syntaxCopy();
Initializer *semantic(Scope *sc, Type *t, NeedInterpret needInterpret);
Expression *toExpression(Type *t = NULL);
void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
virtual ErrorInitializer *isErrorInitializer() { return this; }
};
class StructInitializer : public Initializer
{
public:
Identifiers field; // of Identifier *'s
Initializers value; // parallel array of Initializer *'s
StructInitializer(Loc loc);
Initializer *syntaxCopy();
void addInit(Identifier *field, Initializer *value);
Initializer *semantic(Scope *sc, Type *t, NeedInterpret needInterpret);
Expression *toExpression(Type *t = NULL);
void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
dt_t *toDt();
StructInitializer *isStructInitializer() { return this; }
};
class ArrayInitializer : public Initializer
{
public:
Expressions index; // indices
Initializers value; // of Initializer *'s
size_t dim; // length of array being initialized
Type *type; // type that array will be used to initialize
int sem; // !=0 if semantic() is run
ArrayInitializer(Loc loc);
Initializer *syntaxCopy();
void addInit(Expression *index, Initializer *value);
Initializer *semantic(Scope *sc, Type *t, NeedInterpret needInterpret);
int isAssociativeArray();
Type *inferType(Scope *sc);
Expression *toExpression(Type *t = NULL);
Expression *toAssocArrayLiteral(Type *t = NULL);
void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
dt_t *toDt();
ArrayInitializer *isArrayInitializer() { return this; }
};
class ExpInitializer : public Initializer
{
public:
Expression *exp;
int expandTuples;
ExpInitializer(Loc loc, Expression *exp);
Initializer *syntaxCopy();
Initializer *semantic(Scope *sc, Type *t, NeedInterpret needInterpret);
Type *inferType(Scope *sc);
Expression *toExpression(Type *t = NULL);
void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
dt_t *toDt();
virtual ExpInitializer *isExpInitializer() { return this; }
};
#endif