28460339749

Committed 30 Jun 2026 04:35PM UTC coverage: 90.401% (-0.1%) from 90.53%

Build # 28460339749

Build Type

Pull #44

github

Committed by

rieske

Commit Message

Simplify struct field codegen to FieldAddress only

Drop FieldLoad/FieldStore; materialize the field address then reuse
Dereference for reads and LvalueAssign for writes. Keep a single
baseIsPointer flag on FieldAddress for dot vs arrow.

Pull Request Pull Request #44: Implement C structs with member access

Coverage Stats

236 of 282 new or added lines in 12 files covered. (83.69%)

7 existing lines in 2 files now uncovered.

5349 of 5917 relevant lines covered (90.4%)

235740.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.11

/src/ast/AbstractSyntaxTreeBuilderContext.cpp

#include "AbstractSyntaxTreeBuilderContext.h"

namespace ast {

AbstractSyntaxTreeBuilderContext::AbstractSyntaxTreeBuilderContext() {
}

void AbstractSyntaxTreeBuilderContext::pushTerminal(TerminalSymbol terminal) {
    terminalSymbols.push(terminal);
}

TerminalSymbol AbstractSyntaxTreeBuilderContext::popTerminal() {
    auto terminal = terminalSymbols.top();
    terminalSymbols.pop();
    return terminal;
}

void AbstractSyntaxTreeBuilderContext::pushTypeSpecifier(TypeSpecifier typeSpecifier) {
    typeSpecifiers.push(typeSpecifier);
}

TypeSpecifier AbstractSyntaxTreeBuilderContext::popTypeSpecifier() {
    auto typeSpecifier = typeSpecifiers.top();
    typeSpecifiers.pop();
    return typeSpecifier;
}

void AbstractSyntaxTreeBuilderContext::pushStorageSpecifier(StorageSpecifier storageSpecifier) {
    storageSpecifiers.push(storageSpecifier);
}

StorageSpecifier AbstractSyntaxTreeBuilderContext::popStorageSpecifier() {
    auto storageSpecifier = storageSpecifiers.top();
    storageSpecifiers.pop();
    return storageSpecifier;
}

void AbstractSyntaxTreeBuilderContext::pushTypeQualifier(type::Qualifier typeQualifier) {
    typeQualifiers.push(typeQualifier);
}

type::Qualifier AbstractSyntaxTreeBuilderContext::popTypeQualifier() {
    auto typeQualifier = typeQualifiers.top();
    typeQualifiers.pop();
    return typeQualifier;
}

void AbstractSyntaxTreeBuilderContext::pushConstant(Constant constant) {
    constants.push(constant);
}

Constant AbstractSyntaxTreeBuilderContext::popConstant() {
    auto constant = constants.top();
    constants.pop();
    return constant;
}

void AbstractSyntaxTreeBuilderContext::pushExpression(std::unique_ptr<Expression> expression) {
    expressionStack.push(std::move(expression));
}

std::unique_ptr<Expression> AbstractSyntaxTreeBuilderContext::popExpression() {
    auto expression = std::move(expressionStack.top());
    expressionStack.pop();
    return expression;
}

void AbstractSyntaxTreeBuilderContext::newActualArgumentsList(std::unique_ptr<Expression> argument) {
    std::vector<std::unique_ptr<Expression>> arguments;
    arguments.push_back(std::move(argument));
    actualArgumentLists.push(std::move(arguments));
}

void AbstractSyntaxTreeBuilderContext::addToActualArgumentsList(std::unique_ptr<Expression> argument) {
    actualArgumentLists.top().push_back(std::move(argument));
}

std::vector<std::unique_ptr<Expression>> AbstractSyntaxTreeBuilderContext::popActualArgumentsList() {
    auto arguments = std::move(actualArgumentLists.top());
    actualArgumentLists.pop();
    return arguments;
}

void AbstractSyntaxTreeBuilderContext::newPointer(Pointer pointer) {
    pointerStack.push(std::vector<Pointer> { pointer });
}

void AbstractSyntaxTreeBuilderContext::pointerToPointer(Pointer pointer) {
    pointerStack.top().push_back(pointer);
}

std::vector<Pointer> AbstractSyntaxTreeBuilderContext::popPointers() {
    auto pointers = pointerStack.top();
    pointerStack.pop();
    return pointers;
}

void AbstractSyntaxTreeBuilderContext::pushStatement(std::unique_ptr<AbstractSyntaxTreeNode> statement) {
    statementStack.push(std::move(statement));
}

std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popStatement() {
    auto statement = std::move(statementStack.top());
    statementStack.pop();
    return statement;
}

void AbstractSyntaxTreeBuilderContext::pushDirectDeclarator(std::unique_ptr<DirectDeclarator> declarator) {
    directDeclarators.push(std::move(declarator));
}

std::unique_ptr<DirectDeclarator> AbstractSyntaxTreeBuilderContext::popDirectDeclarator() {
    auto declarator = std::move(directDeclarators.top());
    directDeclarators.pop();
    return declarator;
}

void AbstractSyntaxTreeBuilderContext::pushDeclarator(std::unique_ptr<Declarator> declarator) {
    declarators.push(std::move(declarator));
}

std::unique_ptr<Declarator> AbstractSyntaxTreeBuilderContext::popDeclarator() {
    auto declarator = std::move(declarators.top());
    declarators.pop();
    return declarator;
}

void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarator(std::unique_ptr<InitializedDeclarator> initializedDeclarator) {
    initializedDeclarators.push(std::move(initializedDeclarator));
}

std::unique_ptr<InitializedDeclarator> AbstractSyntaxTreeBuilderContext::popInitializedDeclarator() {
    auto initializedDeclarator = std::move(initializedDeclarators.top());
    initializedDeclarators.pop();
    return initializedDeclarator;
}

void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarators(std::vector<std::unique_ptr<InitializedDeclarator> > declarators) {
    initializedDeclaratorLists.push(std::move(declarators));
}

std::vector<std::unique_ptr<InitializedDeclarator> > AbstractSyntaxTreeBuilderContext::popInitializedDeclarators() {
    auto declarators = std::move(initializedDeclaratorLists.top());
    initializedDeclaratorLists.pop();
    return declarators;
}

void AbstractSyntaxTreeBuilderContext::pushDeclarationList(std::vector<std::unique_ptr<Declaration>> declarationList) {
    declarationLists.push(std::move(declarationList));
}

std::vector<std::unique_ptr<Declaration>> AbstractSyntaxTreeBuilderContext::popDeclarationList() {
    auto declarationList = std::move(declarationLists.top());
    declarationLists.pop();
    return declarationList;
}

void AbstractSyntaxTreeBuilderContext::pushFormalArgument(FormalArgument formalArgument) {
    formalArguments.push(std::move(formalArgument));
}

FormalArgument AbstractSyntaxTreeBuilderContext::popFormalArgument() {
    auto parameter = std::move(formalArguments.top());
    formalArguments.pop();
    return parameter;
}

void AbstractSyntaxTreeBuilderContext::pushFormalArguments(FormalArguments formalArguments) {
    formalArgumentLists.push(std::move(formalArguments));
}

FormalArguments AbstractSyntaxTreeBuilderContext::popFormalArguments() {
    auto formalArguments = std::move(formalArgumentLists.top());
    formalArgumentLists.pop();
    return formalArguments;
}

void AbstractSyntaxTreeBuilderContext::pushArgumentsDeclaration(std::pair<FormalArguments, bool> argumentsDeclaration) {
    argumentsDeclarations.push(std::move(argumentsDeclaration));
}

std::pair<FormalArguments, bool> AbstractSyntaxTreeBuilderContext::popArgumentsDeclaration() {
    auto argumentsDeclaration = std::move(argumentsDeclarations.top());
    argumentsDeclarations.pop();
    return argumentsDeclaration;
}

void AbstractSyntaxTreeBuilderContext::pushDeclarationSpecifiers(DeclarationSpecifiers declarationSpecifiers) {
    declarationSpecifiersStack.push(std::move(declarationSpecifiers));
}

DeclarationSpecifiers AbstractSyntaxTreeBuilderContext::popDeclarationSpecifiers() {
    auto declarationSpecifiers = std::move(declarationSpecifiersStack.top());
    declarationSpecifiersStack.pop();
    return declarationSpecifiers;
}

void AbstractSyntaxTreeBuilderContext::pushDeclaration(std::unique_ptr<Declaration> declaration) {
    declarations.push(std::move(declaration));
}

void AbstractSyntaxTreeBuilderContext::newTypeQualifierList(type::Qualifier qualifier) {
    typeQualifierLists.push( { qualifier });
}

void AbstractSyntaxTreeBuilderContext::addToTypeQualifierList(type::Qualifier qualifier) {
    typeQualifierLists.top().push_back(qualifier);
}

std::vector<type::Qualifier> AbstractSyntaxTreeBuilderContext::popTypeQualifierList() {
    auto qualifiers = typeQualifierLists.top();
    typeQualifierLists.pop();
    return qualifiers;
}

std::unique_ptr<Declaration> AbstractSyntaxTreeBuilderContext::popDeclaration() {
    auto declaration = std::move(declarations.top());
    declarations.pop();
    return declaration;
}

void AbstractSyntaxTreeBuilderContext::newStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {
    std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> statements;
    statements.push_back(std::move(statement));
    statementLists.push(std::move(statements));
}

void AbstractSyntaxTreeBuilderContext::addToStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {
    statementLists.top().push_back(std::move(statement));
}

std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> AbstractSyntaxTreeBuilderContext::popStatementList() {
    auto statements = std::move(statementLists.top());
    statementLists.pop();
    return statements;
}

void AbstractSyntaxTreeBuilderContext::pushExternalDeclaration(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {
    externalDeclarations.push(std::move(externalDeclaration));
}

std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popExternalDeclaration() {
    auto externalDeclaration = std::move(externalDeclarations.top());
    externalDeclarations.pop();
    return externalDeclaration;
}

void AbstractSyntaxTreeBuilderContext::addToTranslationUnit(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {
    translationUnit.push_back(std::move(externalDeclaration));
}

std::vector<std::unique_ptr<AbstractSyntaxTreeNode> > AbstractSyntaxTreeBuilderContext::popTranslationUnit() {
    return std::move(translationUnit);
}

void AbstractSyntaxTreeBuilderContext::newStructMemberList() {
    structMemberLists.push({});
}

void AbstractSyntaxTreeBuilderContext::addStructMember(std::string name, type::Type type) {
    if (structMemberLists.empty()) {
        structMemberLists.push({});
    }
    structMemberLists.top().emplace_back(std::move(name), std::move(type));
}

void AbstractSyntaxTreeBuilderContext::addStructMembersFromList(std::vector<std::pair<std::string, type::Type>> members) {
    for (auto& m : members) {
        structMemberLists.top().push_back(std::move(m));
    }
}

std::vector<std::pair<std::string, type::Type>> AbstractSyntaxTreeBuilderContext::popStructMemberList() {
    auto list = std::move(structMemberLists.top());
    structMemberLists.pop();
    return list;
}

void AbstractSyntaxTreeBuilderContext::pushStructMemberList(std::vector<std::pair<std::string, type::Type>> members) {
    structMemberLists.push(std::move(members));
}


void AbstractSyntaxTreeBuilderContext::newStructDeclaratorNameList() {
    structDeclaratorNameLists.push({});
}

void AbstractSyntaxTreeBuilderContext::addStructDeclaratorName(std::string name) {
    if (structDeclaratorNameLists.empty()) {
        structDeclaratorNameLists.push({});
    }
    structDeclaratorNameLists.top().push_back(std::move(name));
}

std::vector<std::string> AbstractSyntaxTreeBuilderContext::popStructDeclaratorNameList() {
    auto list = std::move(structDeclaratorNameLists.top());
    structDeclaratorNameLists.pop();
    return list;
}


void AbstractSyntaxTreeBuilderContext::defineStructTag(const std::string& tag, type::Type type) {
    if (!tag.empty()) {
        structTags.insert_or_assign(tag, std::move(type));
    }
}

std::optional<type::Type> AbstractSyntaxTreeBuilderContext::lookupStructTag(const std::string& tag) const {
    auto it = structTags.find(tag);
    if (it == structTags.end()) {
        return std::nullopt;
    }
    return it->second;
}

} // namespace ast

1	#include "AbstractSyntaxTreeBuilderContext.h"
2
3	namespace ast {
4
5	AbstractSyntaxTreeBuilderContext::AbstractSyntaxTreeBuilderContext() {	384✔
6	}	384✔
7
8	void AbstractSyntaxTreeBuilderContext::pushTerminal(TerminalSymbol terminal) {	17,324✔
9	terminalSymbols.push(terminal);	17,324✔
10	}	17,324✔
11
12	TerminalSymbol AbstractSyntaxTreeBuilderContext::popTerminal() {	17,254✔
13	auto terminal = terminalSymbols.top();	17,254✔
14	terminalSymbols.pop();	17,254✔
15	return terminal;	17,254✔
16	}
17
18	void AbstractSyntaxTreeBuilderContext::pushTypeSpecifier(TypeSpecifier typeSpecifier) {	1,162✔
19	typeSpecifiers.push(typeSpecifier);	1,162✔
20	}	1,162✔
21
22	TypeSpecifier AbstractSyntaxTreeBuilderContext::popTypeSpecifier() {	1,162✔
23	auto typeSpecifier = typeSpecifiers.top();	1,162✔
24	typeSpecifiers.pop();	1,162✔
25	return typeSpecifier;	1,162✔
26	}
27
28	void AbstractSyntaxTreeBuilderContext::pushStorageSpecifier(StorageSpecifier storageSpecifier) {	×
29	storageSpecifiers.push(storageSpecifier);	×
30	}	×
31
32	StorageSpecifier AbstractSyntaxTreeBuilderContext::popStorageSpecifier() {	×
33	auto storageSpecifier = storageSpecifiers.top();	×
34	storageSpecifiers.pop();	×
35	return storageSpecifier;	×
36	}
37
38	void AbstractSyntaxTreeBuilderContext::pushTypeQualifier(type::Qualifier typeQualifier) {	×
39	typeQualifiers.push(typeQualifier);	×
40	}	×
41
42	type::Qualifier AbstractSyntaxTreeBuilderContext::popTypeQualifier() {	×
43	auto typeQualifier = typeQualifiers.top();	×
44	typeQualifiers.pop();	×
45	return typeQualifier;	×
46	}
47
48	void AbstractSyntaxTreeBuilderContext::pushConstant(Constant constant) {	1,260✔
49	constants.push(constant);	1,260✔
50	}	1,260✔
51
52	Constant AbstractSyntaxTreeBuilderContext::popConstant() {	1,260✔
53	auto constant = constants.top();	1,260✔
54	constants.pop();	1,260✔
55	return constant;	1,260✔
56	}
57
58	void AbstractSyntaxTreeBuilderContext::pushExpression(std::unique_ptr<Expression> expression) {	7,122✔
59	expressionStack.push(std::move(expression));	7,122✔
60	}	7,122✔
61
62	std::unique_ptr<Expression> AbstractSyntaxTreeBuilderContext::popExpression() {	7,120✔
63	auto expression = std::move(expressionStack.top());	7,120✔
64	expressionStack.pop();	7,120✔
65	return expression;	7,120✔
66	}
67
68	void AbstractSyntaxTreeBuilderContext::newActualArgumentsList(std::unique_ptr<Expression> argument) {	888✔
69	std::vector<std::unique_ptr<Expression>> arguments;	888✔
70	arguments.push_back(std::move(argument));	888✔
71	actualArgumentLists.push(std::move(arguments));	888✔
72	}	888✔
73
74	void AbstractSyntaxTreeBuilderContext::addToActualArgumentsList(std::unique_ptr<Expression> argument) {	1,094✔
75	actualArgumentLists.top().push_back(std::move(argument));	1,094✔
76	}	1,094✔
77
78	std::vector<std::unique_ptr<Expression>> AbstractSyntaxTreeBuilderContext::popActualArgumentsList() {	888✔
79	auto arguments = std::move(actualArgumentLists.top());	888✔
80	actualArgumentLists.pop();	888✔
81	return arguments;	888✔
82	}
83
84	void AbstractSyntaxTreeBuilderContext::newPointer(Pointer pointer) {	68✔
85	pointerStack.push(std::vector<Pointer> { pointer });	204✔
86	}	136✔
87
88	void AbstractSyntaxTreeBuilderContext::pointerToPointer(Pointer pointer) {	×
89	pointerStack.top().push_back(pointer);	×
90	}	×
91
92	std::vector<Pointer> AbstractSyntaxTreeBuilderContext::popPointers() {	68✔
93	auto pointers = pointerStack.top();	68✔
94	pointerStack.pop();	68✔
95	return pointers;	68✔
96	}
97
98	void AbstractSyntaxTreeBuilderContext::pushStatement(std::unique_ptr<AbstractSyntaxTreeNode> statement) {	2,938✔
99	statementStack.push(std::move(statement));	2,938✔
100	}	2,938✔
101
102	std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popStatement() {	2,938✔
103	auto statement = std::move(statementStack.top());	2,938✔
104	statementStack.pop();	2,938✔
105	return statement;	2,938✔
106	}
107
108	void AbstractSyntaxTreeBuilderContext::pushDirectDeclarator(std::unique_ptr<DirectDeclarator> declarator) {	1,752✔
109	directDeclarators.push(std::move(declarator));	1,752✔
110	}	1,752✔
111
112	std::unique_ptr<DirectDeclarator> AbstractSyntaxTreeBuilderContext::popDirectDeclarator() {	1,752✔
113	auto declarator = std::move(directDeclarators.top());	1,752✔
114	directDeclarators.pop();	1,752✔
115	return declarator;	1,752✔
116	}
117
118	void AbstractSyntaxTreeBuilderContext::pushDeclarator(std::unique_ptr<Declarator> declarator) {	1,276✔
119	declarators.push(std::move(declarator));	1,276✔
120	}	1,276✔
121
122	std::unique_ptr<Declarator> AbstractSyntaxTreeBuilderContext::popDeclarator() {	1,274✔
123	auto declarator = std::move(declarators.top());	1,274✔
124	declarators.pop();	1,274✔
125	return declarator;	1,274✔
126	}
127
128	void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarator(std::unique_ptr<InitializedDeclarator> initializedDeclarator) {	620✔
129	initializedDeclarators.push(std::move(initializedDeclarator));	620✔
130	}	620✔
131
132	std::unique_ptr<InitializedDeclarator> AbstractSyntaxTreeBuilderContext::popInitializedDeclarator() {	620✔
133	auto initializedDeclarator = std::move(initializedDeclarators.top());	620✔
134	initializedDeclarators.pop();	620✔
135	return initializedDeclarator;	620✔
136	}
137
138	void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarators(std::vector<std::unique_ptr<InitializedDeclarator> > declarators) {	620✔
139	initializedDeclaratorLists.push(std::move(declarators));	620✔
140	}	620✔
141
142	std::vector<std::unique_ptr<InitializedDeclarator> > AbstractSyntaxTreeBuilderContext::popInitializedDeclarators() {	620✔
143	auto declarators = std::move(initializedDeclaratorLists.top());	620✔
144	initializedDeclaratorLists.pop();	620✔
145	return declarators;	620✔
146	}
147
148	void AbstractSyntaxTreeBuilderContext::pushDeclarationList(std::vector<std::unique_ptr<Declaration>> declarationList) {	382✔
149	declarationLists.push(std::move(declarationList));	382✔
150	}	382✔
151
152	std::vector<std::unique_ptr<Declaration>> AbstractSyntaxTreeBuilderContext::popDeclarationList() {	382✔
153	auto declarationList = std::move(declarationLists.top());	382✔
154	declarationLists.pop();	382✔
155	return declarationList;	382✔
156	}
157
158	void AbstractSyntaxTreeBuilderContext::pushFormalArgument(FormalArgument formalArgument) {	170✔
159	formalArguments.push(std::move(formalArgument));	170✔
160	}	170✔
161
162	FormalArgument AbstractSyntaxTreeBuilderContext::popFormalArgument() {	170✔
163	auto parameter = std::move(formalArguments.top());	170✔
164	formalArguments.pop();	170✔
165	return parameter;	170✔
166	}
167
168	void AbstractSyntaxTreeBuilderContext::pushFormalArguments(FormalArguments formalArguments) {	170✔
169	formalArgumentLists.push(std::move(formalArguments));	170✔
170	}	170✔
171
172	FormalArguments AbstractSyntaxTreeBuilderContext::popFormalArguments() {	170✔
173	auto formalArguments = std::move(formalArgumentLists.top());	170✔
174	formalArgumentLists.pop();	170✔
175	return formalArguments;	170✔
176	}
177
178	void AbstractSyntaxTreeBuilderContext::pushArgumentsDeclaration(std::pair<FormalArguments, bool> argumentsDeclaration) {	70✔
179	argumentsDeclarations.push(std::move(argumentsDeclaration));	70✔
180	}	70✔
181
182	std::pair<FormalArguments, bool> AbstractSyntaxTreeBuilderContext::popArgumentsDeclaration() {	70✔
183	auto argumentsDeclaration = std::move(argumentsDeclarations.top());	70✔
184	argumentsDeclarations.pop();	70✔
185	return argumentsDeclaration;	70✔
186	}
187
188	void AbstractSyntaxTreeBuilderContext::pushDeclarationSpecifiers(DeclarationSpecifiers declarationSpecifiers) {	1,150✔
189	declarationSpecifiersStack.push(std::move(declarationSpecifiers));	1,150✔
190	}	1,150✔
191
192	DeclarationSpecifiers AbstractSyntaxTreeBuilderContext::popDeclarationSpecifiers() {	1,148✔
193	auto declarationSpecifiers = std::move(declarationSpecifiersStack.top());	1,148✔
194	declarationSpecifiersStack.pop();	1,148✔
195	return declarationSpecifiers;	1,148✔
196	}
197
198	void AbstractSyntaxTreeBuilderContext::pushDeclaration(std::unique_ptr<Declaration> declaration) {	504✔
199	declarations.push(std::move(declaration));	504✔
200	}	504✔
201
202	void AbstractSyntaxTreeBuilderContext::newTypeQualifierList(type::Qualifier qualifier) {	×
203	typeQualifierLists.push( { qualifier });	×
204	}	×
205
206	void AbstractSyntaxTreeBuilderContext::addToTypeQualifierList(type::Qualifier qualifier) {	×
207	typeQualifierLists.top().push_back(qualifier);	×
208	}	×
209
210	std::vector<type::Qualifier> AbstractSyntaxTreeBuilderContext::popTypeQualifierList() {	×
211	auto qualifiers = typeQualifierLists.top();	×
212	typeQualifierLists.pop();	×
213	return qualifiers;	×
214	}
215
216	std::unique_ptr<Declaration> AbstractSyntaxTreeBuilderContext::popDeclaration() {	504✔
217	auto declaration = std::move(declarations.top());	504✔
218	declarations.pop();	504✔
219	return declaration;	504✔
220	}
221
222	void AbstractSyntaxTreeBuilderContext::newStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {	574✔
223	std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> statements;	574✔
224	statements.push_back(std::move(statement));	574✔
225	statementLists.push(std::move(statements));	574✔
226	}	574✔
227
228	void AbstractSyntaxTreeBuilderContext::addToStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {	1,314✔
229	statementLists.top().push_back(std::move(statement));	1,314✔
230	}	1,314✔
231
232	std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> AbstractSyntaxTreeBuilderContext::popStatementList() {	574✔
233	auto statements = std::move(statementLists.top());	574✔
234	statementLists.pop();	574✔
235	return statements;	574✔
236	}
237
238	void AbstractSyntaxTreeBuilderContext::pushExternalDeclaration(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {	596✔
239	externalDeclarations.push(std::move(externalDeclaration));	596✔
240	}	596✔
241
242	std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popExternalDeclaration() {	596✔
243	auto externalDeclaration = std::move(externalDeclarations.top());	596✔
244	externalDeclarations.pop();	596✔
245	return externalDeclaration;	596✔
246	}
247
248	void AbstractSyntaxTreeBuilderContext::addToTranslationUnit(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {	596✔
249	translationUnit.push_back(std::move(externalDeclaration));	596✔
250	}	596✔
251
252	std::vector<std::unique_ptr<AbstractSyntaxTreeNode> > AbstractSyntaxTreeBuilderContext::popTranslationUnit() {	382✔
253	return std::move(translationUnit);	382✔
254	}
255
NEW 256	void AbstractSyntaxTreeBuilderContext::newStructMemberList() {	×
NEW 257	structMemberLists.push({});	×
NEW 258	}	×
259
260	void AbstractSyntaxTreeBuilderContext::addStructMember(std::string name, type::Type type) {	12✔
261	if (structMemberLists.empty()) {	12✔
262	structMemberLists.push({});	6✔
263	}
264	structMemberLists.top().emplace_back(std::move(name), std::move(type));	12✔
265	}	12✔
266
NEW 267	void AbstractSyntaxTreeBuilderContext::addStructMembersFromList(std::vector<std::pair<std::string, type::Type>> members) {	×
NEW 268	for (auto& m : members) {	×
NEW 269	structMemberLists.top().push_back(std::move(m));	×
270	}
NEW 271	}	×
272
273	std::vector<std::pair<std::string, type::Type>> AbstractSyntaxTreeBuilderContext::popStructMemberList() {	6✔
274	auto list = std::move(structMemberLists.top());	6✔
275	structMemberLists.pop();	6✔
276	return list;	6✔
277	}
278
NEW 279	void AbstractSyntaxTreeBuilderContext::pushStructMemberList(std::vector<std::pair<std::string, type::Type>> members) {	×
NEW 280	structMemberLists.push(std::move(members));	×
NEW 281	}	×
282
283
NEW 284	void AbstractSyntaxTreeBuilderContext::newStructDeclaratorNameList() {	×
NEW 285	structDeclaratorNameLists.push({});	×
NEW 286	}	×
287
288	void AbstractSyntaxTreeBuilderContext::addStructDeclaratorName(std::string name) {	12✔
289	if (structDeclaratorNameLists.empty()) {	12✔
290	structDeclaratorNameLists.push({});	12✔
291	}
292	structDeclaratorNameLists.top().push_back(std::move(name));	12✔
293	}	12✔
294
295	std::vector<std::string> AbstractSyntaxTreeBuilderContext::popStructDeclaratorNameList() {	12✔
296	auto list = std::move(structDeclaratorNameLists.top());	12✔
297	structDeclaratorNameLists.pop();	12✔
298	return list;	12✔
299	}
300
301
302	void AbstractSyntaxTreeBuilderContext::defineStructTag(const std::string& tag, type::Type type) {	6✔
303	if (!tag.empty()) {	6✔
304	structTags.insert_or_assign(tag, std::move(type));	6✔
305	}
306	}	6✔
307
308	std::optional<type::Type> AbstractSyntaxTreeBuilderContext::lookupStructTag(const std::string& tag) const {	8✔
309	auto it = structTags.find(tag);	8✔
310	if (it == structTags.end()) {	8✔
NEW 311	return std::nullopt;	×
312	}
313	return it->second;	8✔
314	}
315
316	} // namespace ast

rieske / trans / 28460339749

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous