blob: 4ba18d6a47457fc86eebaaf2a0dd3a14c02750e7 (
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
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
|
/* Compiler implementation of the D programming language
* Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
* written by Walter Bright
* http://www.digitalmars.com
* Distributed under the Boost Software License, Version 1.0.
* http://www.boost.org/LICENSE_1_0.txt
* https://github.com/dlang/dmd/blob/master/src/dmd/init.h
*/
#pragma once
#include "root/root.h"
#include "ast_node.h"
#include "globals.h"
#include "arraytypes.h"
#include "visitor.h"
class Identifier;
class Expression;
struct Scope;
class Type;
class AggregateDeclaration;
class Initializer;
class ErrorInitializer;
class VoidInitializer;
class StructInitializer;
class ArrayInitializer;
class ExpInitializer;
enum NeedInterpret { INITnointerpret, INITinterpret };
Initializer *initializerSemantic(Initializer *init, Scope *sc, Type *t, NeedInterpret needInterpret);
class Initializer : public ASTNode
{
public:
Loc loc;
Initializer(Loc loc);
virtual Initializer *syntaxCopy() = 0;
static Initializers *arraySyntaxCopy(Initializers *ai);
const char *toChars();
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; }
void accept(Visitor *v) { v->visit(this); }
};
class VoidInitializer : public Initializer
{
public:
Type *type; // type that this will initialize to
VoidInitializer(Loc loc);
Initializer *syntaxCopy();
virtual VoidInitializer *isVoidInitializer() { return this; }
void accept(Visitor *v) { v->visit(this); }
};
class ErrorInitializer : public Initializer
{
public:
ErrorInitializer();
Initializer *syntaxCopy();
virtual ErrorInitializer *isErrorInitializer() { return this; }
void accept(Visitor *v) { v->visit(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);
StructInitializer *isStructInitializer() { return this; }
void accept(Visitor *v) { v->visit(this); }
};
class ArrayInitializer : public Initializer
{
public:
Expressions index; // indices
Initializers value; // of Initializer *'s
unsigned dim; // length of array being initialized
Type *type; // type that array will be used to initialize
bool sem; // true if semantic() is run
ArrayInitializer(Loc loc);
Initializer *syntaxCopy();
void addInit(Expression *index, Initializer *value);
bool isAssociativeArray();
Expression *toAssocArrayLiteral();
ArrayInitializer *isArrayInitializer() { return this; }
void accept(Visitor *v) { v->visit(this); }
};
class ExpInitializer : public Initializer
{
public:
Expression *exp;
bool expandTuples;
ExpInitializer(Loc loc, Expression *exp);
Initializer *syntaxCopy();
ExpInitializer *isExpInitializer() { return this; }
void accept(Visitor *v) { v->visit(this); }
};
Expression *initializerToExpression(Initializer *init, Type *t = NULL);
|
