29767047230

Committed 20 Jul 2026 06:16PM UTC coverage: 90.628% (+0.05%) from 90.582%

Build # 29767047230

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #48 from rieske/perf/parser/2-automaton

perf(parser): core-hash automaton and worklist closure

Coverage Stats

187 of 192 new or added lines in 7 files covered. (97.4%)

5212 of 5751 relevant lines covered (90.63%)

162489.24 hits per line

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

63.41

/src/driver/CompilerComponentsFactory.cpp

#include "CompilerComponentsFactory.h"

#include "ast/AbstractSyntaxTreeBuilder.h"
#include "ast/VerboseSyntaxTreeBuilder.h"
#include "parser/BNFFileReader.h"
#include "parser/FilePersistedParsingTable.h"
#include "parser/GeneratedParsingTable.h"
#include "parser/LR1Parser.h"
#include "parser/ParseTreeBuilder.h"
#include "scanner/LexFileScannerReader.h"
#include "util/Logger.h"
#include "util/LogManager.h"
#include "Configuration.h"

#include "codegen/AssemblyGenerator.h"
#include "codegen/IntelInstructionSet.h"

#include <chrono>

CompilerComponentsFactory::CompilerComponentsFactory(Configuration configuration) :
        configuration { configuration }
{
}

std::unique_ptr<scanner::Scanner> CompilerComponentsFactory::makeScannerForSourceFile(std::string sourceFileName) const {
    Logger logger { configuration.isScannerLoggingEnabled() ? &std::cout : &NullStream::getInstance() };
    LogManager::registerComponentLogger(Component::SCANNER, logger);

    scanner::LexFileScannerReader scannerReader;
    return std::make_unique<scanner::Scanner>(sourceFileName, scannerReader.fromConfiguration(configuration.getLexPath()));
}

parser::Grammar CompilerComponentsFactory::makeGrammar() const {
    parser::BNFFileReader reader;
    return reader.readGrammar(configuration.getGrammarPath());
}

std::unique_ptr<parser::Parser> CompilerComponentsFactory::makeParser(parser::Grammar* grammar) const {
    Logger logger { configuration.isParserLoggingEnabled() ? &std::cout : &NullStream::getInstance() };
    LogManager::registerComponentLogger(Component::PARSER, logger);

    parser::ParsingTable* parsingTable;
    if (configuration.usingCustomGrammar()) {
        parsingTable = generateParsingTable(grammar);
    } else {
        parsingTable = new parser::FilePersistedParsingTable(configuration.getParsingTablePath(), grammar);
    }

    return std::make_unique<parser::LR1Parser>(parsingTable);
}

parser::ParsingTable* CompilerComponentsFactory::generateParsingTable(const parser::Grammar* grammar) const {
    std::cout << "Generating parsing table" << std::endl;
    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();

    parser::GeneratedParsingTable* generatedTable = new parser::GeneratedParsingTable(grammar);

    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
    std::cout << "Parsing table generation took "
        << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count()
        << "[µs]" << std::endl;

    std::string parsingTableLocation {"logs/parsing_table"};
    generatedTable->persistToFile(parsingTableLocation);

    std::cout << "Parsing table saved to: " << parsingTableLocation << std::endl;

    return generatedTable;
}

std::unique_ptr<parser::SyntaxTreeBuilder> CompilerComponentsFactory::makeSyntaxTreeBuilder(
        std::string sourceFileName, const parser::Grammar* grammar) const
{
    if (configuration.usingCustomGrammar()) {
        return std::make_unique<parser::ParseTreeBuilder>(sourceFileName, grammar);
    }
    if (configuration.isSyntaxTreeLoggingEnabled()) {
        return std::make_unique<ast::VerboseSyntaxTreeBuilder>(sourceFileName, grammar);
    }
    return std::make_unique<ast::AbstractSyntaxTreeBuilder>(grammar);
}

std::unique_ptr<codegen::AssemblyGenerator> CompilerComponentsFactory::makeAssemblyGenerator(std::ostream* assemblyFile) const {
    return std::make_unique<codegen::AssemblyGenerator>(
            std::make_unique<codegen::StackMachine>(
                    assemblyFile,
                    std::make_unique<codegen::IntelInstructionSet>(),
                    std::make_unique<codegen::Amd64Registers>()));
}

1	#include "CompilerComponentsFactory.h"
2
3	#include "ast/AbstractSyntaxTreeBuilder.h"
4	#include "ast/VerboseSyntaxTreeBuilder.h"
5	#include "parser/BNFFileReader.h"
6	#include "parser/FilePersistedParsingTable.h"
7	#include "parser/GeneratedParsingTable.h"
8	#include "parser/LR1Parser.h"
9	#include "parser/ParseTreeBuilder.h"
10	#include "scanner/LexFileScannerReader.h"
11	#include "util/Logger.h"
12	#include "util/LogManager.h"
13	#include "Configuration.h"
14
15	#include "codegen/AssemblyGenerator.h"
16	#include "codegen/IntelInstructionSet.h"
17
18	#include <chrono>
19
20	CompilerComponentsFactory::CompilerComponentsFactory(Configuration configuration) :	386✔
21	configuration { configuration }	386✔
22	{
23	}	386✔
24
25	std::unique_ptr<scanner::Scanner> CompilerComponentsFactory::makeScannerForSourceFile(std::string sourceFileName) const {	386✔
26	Logger logger { configuration.isScannerLoggingEnabled() ? &std::cout : &NullStream::getInstance() };	386✔
27	LogManager::registerComponentLogger(Component::SCANNER, logger);	386✔
28
29	scanner::LexFileScannerReader scannerReader;
30	return std::make_unique<scanner::Scanner>(sourceFileName, scannerReader.fromConfiguration(configuration.getLexPath()));	772✔
31	}	386✔
32
33	parser::Grammar CompilerComponentsFactory::makeGrammar() const {	380✔
34	parser::BNFFileReader reader;
35	return reader.readGrammar(configuration.getGrammarPath());	380✔
36	}
37
38	std::unique_ptr<parser::Parser> CompilerComponentsFactory::makeParser(parser::Grammar* grammar) const {	380✔
39	Logger logger { configuration.isParserLoggingEnabled() ? &std::cout : &NullStream::getInstance() };	380✔
40	LogManager::registerComponentLogger(Component::PARSER, logger);	380✔
41
42	parser::ParsingTable* parsingTable;
43	if (configuration.usingCustomGrammar()) {	380✔
44	parsingTable = generateParsingTable(grammar);	×
45	} else {
46	parsingTable = new parser::FilePersistedParsingTable(configuration.getParsingTablePath(), grammar);	380✔
47	}
48
49	return std::make_unique<parser::LR1Parser>(parsingTable);	760✔
50	}	380✔
51
52	parser::ParsingTable* CompilerComponentsFactory::generateParsingTable(const parser::Grammar* grammar) const {	×
53	std::cout << "Generating parsing table" << std::endl;	×
54	std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();	×
55
NEW 56	parser::GeneratedParsingTable* generatedTable = new parser::GeneratedParsingTable(grammar);	×
57
58	std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();	×
59	std::cout << "Parsing table generation took "	×
60	<< std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count()	×
61	<< "[µs]" << std::endl;	×
62
63	std::string parsingTableLocation {"logs/parsing_table"};	×
64	generatedTable->persistToFile(parsingTableLocation);	×
65
66	std::cout << "Parsing table saved to: " << parsingTableLocation << std::endl;	×
67
68	return generatedTable;	×
69	}	×
70
71	std::unique_ptr<parser::SyntaxTreeBuilder> CompilerComponentsFactory::makeSyntaxTreeBuilder(	384✔
72	std::string sourceFileName, const parser::Grammar* grammar) const
73	{
74	if (configuration.usingCustomGrammar()) {	384✔
75	return std::make_unique<parser::ParseTreeBuilder>(sourceFileName, grammar);	6✔
76	}
77	if (configuration.isSyntaxTreeLoggingEnabled()) {	378✔
78	return std::make_unique<ast::VerboseSyntaxTreeBuilder>(sourceFileName, grammar);	378✔
79	}
80	return std::make_unique<ast::AbstractSyntaxTreeBuilder>(grammar);	×
81	}
82
83	std::unique_ptr<codegen::AssemblyGenerator> CompilerComponentsFactory::makeAssemblyGenerator(std::ostream* assemblyFile) const {	364✔
84	return std::make_unique<codegen::AssemblyGenerator>(
85	std::make_unique<codegen::StackMachine>(	728✔
86	assemblyFile,
87	std::make_unique<codegen::IntelInstructionSet>(),	728✔
88	std::make_unique<codegen::Amd64Registers>()));	1,092✔
89	}

rieske / trans / 29767047230

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