28461496314

Committed 30 Jun 2026 04:55PM UTC coverage: 90.13% (-0.4%) from 90.53%

Build # 28461496314

Build Type

Pull #44

github

Committed by

rieske

Commit Message

Support multi-word struct pass/return and expand struct tests

Pass multi-word structs on the stack with correct SP adjustments when
pushing words; copy aggregates word-wise on assign. Return up to two
words in RAX/RDX and restore them on retrieve. Use the real function
return type from declaration specs (fixes void calls and struct
returns). Expand StructsTest for by-value/by-address args in different
positions, mutation, return by value/pointer, assign, and chains.

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

Coverage Stats

329 of 404 new or added lines in 13 files covered. (81.44%)

5415 of 6008 relevant lines covered (90.13%)

240586.41 hits per line

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

80.54

/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));
}



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;
}


void AbstractSyntaxTreeBuilderContext::addStructDeclarator(std::unique_ptr<Declarator> declarator) {
    if (structDeclaratorLists.empty()) {
        structDeclaratorLists.push({});
    }
    structDeclaratorLists.top().push_back(std::move(declarator));
}

std::vector<std::unique_ptr<Declarator>> AbstractSyntaxTreeBuilderContext::popStructDeclarators() {
    if (structDeclaratorLists.empty()) {
        return {};
    }
    auto list = std::move(structDeclaratorLists.top());
    structDeclaratorLists.pop();
    return list;
}

type::Type AbstractSyntaxTreeBuilderContext::ensureStructTag(const std::string& tag) {
    auto it = structTags.find(tag);
    if (it != structTags.end()) {
        return it->second;
    }
    type::Type incomplete = type::incompleteStructure();
    structTags.insert_or_assign(tag, incomplete);
    return incomplete;
}

} // namespace ast

1	#include "AbstractSyntaxTreeBuilderContext.h"
2
3	namespace ast {
4
5	AbstractSyntaxTreeBuilderContext::AbstractSyntaxTreeBuilderContext() {	412✔
6	}	412✔
7
8	void AbstractSyntaxTreeBuilderContext::pushTerminal(TerminalSymbol terminal) {	19,380✔
9	terminalSymbols.push(terminal);	19,380✔
10	}	19,380✔
11
12	TerminalSymbol AbstractSyntaxTreeBuilderContext::popTerminal() {	19,310✔
13	auto terminal = terminalSymbols.top();	19,310✔
14	terminalSymbols.pop();	19,310✔
15	return terminal;	19,310✔
16	}
17
18	void AbstractSyntaxTreeBuilderContext::pushTypeSpecifier(TypeSpecifier typeSpecifier) {	1,370✔
19	typeSpecifiers.push(typeSpecifier);	1,370✔
20	}	1,370✔
21
22	TypeSpecifier AbstractSyntaxTreeBuilderContext::popTypeSpecifier() {	1,370✔
23	auto typeSpecifier = typeSpecifiers.top();	1,370✔
24	typeSpecifiers.pop();	1,370✔
25	return typeSpecifier;	1,370✔
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,374✔
49	constants.push(constant);	1,374✔
50	}	1,374✔
51
52	Constant AbstractSyntaxTreeBuilderContext::popConstant() {	1,374✔
53	auto constant = constants.top();	1,374✔
54	constants.pop();	1,374✔
55	return constant;	1,374✔
56	}
57
58	void AbstractSyntaxTreeBuilderContext::pushExpression(std::unique_ptr<Expression> expression) {	7,832✔
59	expressionStack.push(std::move(expression));	7,832✔
60	}	7,832✔
61
62	std::unique_ptr<Expression> AbstractSyntaxTreeBuilderContext::popExpression() {	7,830✔
63	auto expression = std::move(expressionStack.top());	7,830✔
64	expressionStack.pop();	7,830✔
65	return expression;	7,830✔
66	}
67
68	void AbstractSyntaxTreeBuilderContext::newActualArgumentsList(std::unique_ptr<Expression> argument) {	932✔
69	std::vector<std::unique_ptr<Expression>> arguments;	932✔
70	arguments.push_back(std::move(argument));	932✔
71	actualArgumentLists.push(std::move(arguments));	932✔
72	}	932✔
73
74	void AbstractSyntaxTreeBuilderContext::addToActualArgumentsList(std::unique_ptr<Expression> argument) {	1,148✔
75	actualArgumentLists.top().push_back(std::move(argument));	1,148✔
76	}	1,148✔
77
78	std::vector<std::unique_ptr<Expression>> AbstractSyntaxTreeBuilderContext::popActualArgumentsList() {	932✔
79	auto arguments = std::move(actualArgumentLists.top());	932✔
80	actualArgumentLists.pop();	932✔
81	return arguments;	932✔
82	}
83
84	void AbstractSyntaxTreeBuilderContext::newPointer(Pointer pointer) {	84✔
85	pointerStack.push(std::vector<Pointer> { pointer });	252✔
86	}	168✔
87
88	void AbstractSyntaxTreeBuilderContext::pointerToPointer(Pointer pointer) {	×
89	pointerStack.top().push_back(pointer);	×
90	}	×
91
92	std::vector<Pointer> AbstractSyntaxTreeBuilderContext::popPointers() {	84✔
93	auto pointers = pointerStack.top();	84✔
94	pointerStack.pop();	84✔
95	return pointers;	84✔
96	}
97
98	void AbstractSyntaxTreeBuilderContext::pushStatement(std::unique_ptr<AbstractSyntaxTreeNode> statement) {	3,204✔
99	statementStack.push(std::move(statement));	3,204✔
100	}	3,204✔
101
102	std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popStatement() {	3,204✔
103	auto statement = std::move(statementStack.top());	3,204✔
104	statementStack.pop();	3,204✔
105	return statement;	3,204✔
106	}
107
108	void AbstractSyntaxTreeBuilderContext::pushDirectDeclarator(std::unique_ptr<DirectDeclarator> declarator) {	1,976✔
109	directDeclarators.push(std::move(declarator));	1,976✔
110	}	1,976✔
111
112	std::unique_ptr<DirectDeclarator> AbstractSyntaxTreeBuilderContext::popDirectDeclarator() {	1,976✔
113	auto declarator = std::move(directDeclarators.top());	1,976✔
114	directDeclarators.pop();	1,976✔
115	return declarator;	1,976✔
116	}
117
118	void AbstractSyntaxTreeBuilderContext::pushDeclarator(std::unique_ptr<Declarator> declarator) {	1,452✔
119	declarators.push(std::move(declarator));	1,452✔
120	}	1,452✔
121
122	std::unique_ptr<Declarator> AbstractSyntaxTreeBuilderContext::popDeclarator() {	1,450✔
123	auto declarator = std::move(declarators.top());	1,450✔
124	declarators.pop();	1,450✔
125	return declarator;	1,450✔
126	}
127
128	void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarator(std::unique_ptr<InitializedDeclarator> initializedDeclarator) {	662✔
129	initializedDeclarators.push(std::move(initializedDeclarator));	662✔
130	}	662✔
131
132	std::unique_ptr<InitializedDeclarator> AbstractSyntaxTreeBuilderContext::popInitializedDeclarator() {	662✔
133	auto initializedDeclarator = std::move(initializedDeclarators.top());	662✔
134	initializedDeclarators.pop();	662✔
135	return initializedDeclarator;	662✔
136	}
137
138	void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarators(std::vector<std::unique_ptr<InitializedDeclarator> > declarators) {	662✔
139	initializedDeclaratorLists.push(std::move(declarators));	662✔
140	}	662✔
141
142	std::vector<std::unique_ptr<InitializedDeclarator> > AbstractSyntaxTreeBuilderContext::popInitializedDeclarators() {	662✔
143	auto declarators = std::move(initializedDeclaratorLists.top());	662✔
144	initializedDeclaratorLists.pop();	662✔
145	return declarators;	662✔
146	}
147
148	void AbstractSyntaxTreeBuilderContext::pushDeclarationList(std::vector<std::unique_ptr<Declaration>> declarationList) {	422✔
149	declarationLists.push(std::move(declarationList));	422✔
150	}	422✔
151
152	std::vector<std::unique_ptr<Declaration>> AbstractSyntaxTreeBuilderContext::popDeclarationList() {	422✔
153	auto declarationList = std::move(declarationLists.top());	422✔
154	declarationLists.pop();	422✔
155	return declarationList;	422✔
156	}
157
158	void AbstractSyntaxTreeBuilderContext::pushFormalArgument(FormalArgument formalArgument) {	202✔
159	formalArguments.push(std::move(formalArgument));	202✔
160	}	202✔
161
162	FormalArgument AbstractSyntaxTreeBuilderContext::popFormalArgument() {	202✔
163	auto parameter = std::move(formalArguments.top());	202✔
164	formalArguments.pop();	202✔
165	return parameter;	202✔
166	}
167
168	void AbstractSyntaxTreeBuilderContext::pushFormalArguments(FormalArguments formalArguments) {	202✔
169	formalArgumentLists.push(std::move(formalArguments));	202✔
170	}	202✔
171
172	FormalArguments AbstractSyntaxTreeBuilderContext::popFormalArguments() {	202✔
173	auto formalArguments = std::move(formalArgumentLists.top());	202✔
174	formalArgumentLists.pop();	202✔
175	return formalArguments;	202✔
176	}
177
178	void AbstractSyntaxTreeBuilderContext::pushArgumentsDeclaration(std::pair<FormalArguments, bool> argumentsDeclaration) {	90✔
179	argumentsDeclarations.push(std::move(argumentsDeclaration));	90✔
180	}	90✔
181
182	std::pair<FormalArguments, bool> AbstractSyntaxTreeBuilderContext::popArgumentsDeclaration() {	90✔
183	auto argumentsDeclaration = std::move(argumentsDeclarations.top());	90✔
184	argumentsDeclarations.pop();	90✔
185	return argumentsDeclaration;	90✔
186	}
187
188	void AbstractSyntaxTreeBuilderContext::pushDeclarationSpecifiers(DeclarationSpecifiers declarationSpecifiers) {	1,300✔
189	declarationSpecifiersStack.push(std::move(declarationSpecifiers));	1,300✔
190	}	1,300✔
191
192	DeclarationSpecifiers AbstractSyntaxTreeBuilderContext::popDeclarationSpecifiers() {	1,298✔
193	auto declarationSpecifiers = std::move(declarationSpecifiersStack.top());	1,298✔
194	declarationSpecifiersStack.pop();	1,298✔
195	return declarationSpecifiers;	1,298✔
196	}
197
198	void AbstractSyntaxTreeBuilderContext::pushDeclaration(std::unique_ptr<Declaration> declaration) {	574✔
199	declarations.push(std::move(declaration));	574✔
200	}	574✔
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() {	574✔
217	auto declaration = std::move(declarations.top());	574✔
218	declarations.pop();	574✔
219	return declaration;	574✔
220	}
221
222	void AbstractSyntaxTreeBuilderContext::newStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {	622✔
223	std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> statements;	622✔
224	statements.push_back(std::move(statement));	622✔
225	statementLists.push(std::move(statements));	622✔
226	}	622✔
227
228	void AbstractSyntaxTreeBuilderContext::addToStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {	1,436✔
229	statementLists.top().push_back(std::move(statement));	1,436✔
230	}	1,436✔
231
232	std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> AbstractSyntaxTreeBuilderContext::popStatementList() {	622✔
233	auto statements = std::move(statementLists.top());	622✔
234	statementLists.pop();	622✔
235	return statements;	622✔
236	}
237
238	void AbstractSyntaxTreeBuilderContext::pushExternalDeclaration(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {	674✔
239	externalDeclarations.push(std::move(externalDeclaration));	674✔
240	}	674✔
241
242	std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popExternalDeclaration() {	674✔
243	auto externalDeclaration = std::move(externalDeclarations.top());	674✔
244	externalDeclarations.pop();	674✔
245	return externalDeclaration;	674✔
246	}
247
248	void AbstractSyntaxTreeBuilderContext::addToTranslationUnit(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {	674✔
249	translationUnit.push_back(std::move(externalDeclaration));	674✔
250	}	674✔
251
252	std::vector<std::unique_ptr<AbstractSyntaxTreeNode> > AbstractSyntaxTreeBuilderContext::popTranslationUnit() {	410✔
253	return std::move(translationUnit);	410✔
254	}
255
NEW 256	void AbstractSyntaxTreeBuilderContext::newStructMemberList() {	×
NEW 257	structMemberLists.push({});	×
NEW 258	}	×
259
260	void AbstractSyntaxTreeBuilderContext::addStructMember(std::string name, type::Type type) {	70✔
261	if (structMemberLists.empty()) {	70✔
262	structMemberLists.push({});	34✔
263	}
264	structMemberLists.top().emplace_back(std::move(name), std::move(type));	70✔
265	}	70✔
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() {	34✔
274	auto list = std::move(structMemberLists.top());	34✔
275	structMemberLists.pop();	34✔
276	return list;	34✔
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
284
NEW 285	std::optional<type::Type> AbstractSyntaxTreeBuilderContext::lookupStructTag(const std::string& tag) const {	×
NEW 286	auto it = structTags.find(tag);	×
NEW 287	if (it == structTags.end()) {	×
NEW 288	return std::nullopt;	×
289	}
NEW 290	return it->second;	×
291	}
292
293
294	void AbstractSyntaxTreeBuilderContext::addStructDeclarator(std::unique_ptr<Declarator> declarator) {	70✔
295	if (structDeclaratorLists.empty()) {	70✔
296	structDeclaratorLists.push({});	70✔
297	}
298	structDeclaratorLists.top().push_back(std::move(declarator));	70✔
299	}	70✔
300
301	std::vector<std::unique_ptr<Declarator>> AbstractSyntaxTreeBuilderContext::popStructDeclarators() {	70✔
302	if (structDeclaratorLists.empty()) {	70✔
NEW 303	return {};	×
304	}
305	auto list = std::move(structDeclaratorLists.top());	70✔
306	structDeclaratorLists.pop();	70✔
307	return list;	70✔
308	}	70✔
309
310	type::Type AbstractSyntaxTreeBuilderContext::ensureStructTag(const std::string& tag) {	106✔
311	auto it = structTags.find(tag);	106✔
312	if (it != structTags.end()) {	106✔
313	return it->second;	72✔
314	}
315	type::Type incomplete = type::incompleteStructure();	34✔
316	structTags.insert_or_assign(tag, incomplete);	34✔
317	return incomplete;	34✔
318	}	34✔
319
320	} // namespace ast

rieske / trans / 28461496314

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