├── .clang-format
├── .gitattributes
├── .gitignore
├── .travis.yml
├── CMakeLists.txt
├── CMakeSettings.json
├── Chapter01
    ├── CMakeLists.txt
    ├── Exercises.h
    ├── Exercises.inl
    ├── Program.cpp
    ├── Program.h
    └── Test.cpp
├── Chapter02
    ├── CMakeLists.txt
    ├── Program.cpp
    ├── Program.h
    └── Test.cpp
├── Chapter03
    ├── CMakeLists.txt
    ├── DeclerationParser.h
    ├── ErrorHandler.h
    ├── ExpressionParser.h
    ├── IdentifierParser.h
    ├── Program.cpp
    ├── Program.h
    ├── Skipper.h
    └── Test.cpp
├── Chapter04
    ├── AbstractSyntaxTree.h
    ├── Annotation.h
    ├── CMakeLists.txt
    ├── DeclerationParser.h
    ├── ErrorHandler.h
    ├── ExpressionParser.h
    ├── IdentifierParser.h
    ├── Program.cpp
    ├── Program.h
    ├── Skipper.h
    ├── StringParser.h
    └── Test.cpp
├── Chapter05
    ├── AbstractSyntaxTree.h
    ├── Annotation.h
    ├── CMakeLists.txt
    ├── Compiler.cpp
    ├── Compiler.h
    ├── DeclerationParser.h
    ├── ErrorHandler.h
    ├── ExpressionParser.h
    ├── IdentifierParser.h
    ├── Program.cpp
    ├── Program.h
    ├── Skipper.h
    ├── StringParser.h
    ├── Test.cpp
    └── Types.h
├── Chapter06
    ├── AbstractSyntaxTree.h
    ├── Annotation.h
    ├── CMakeLists.txt
    ├── CallingConvention.h
    ├── Compiler.cpp
    ├── Compiler.h
    ├── DeclerationParser.h
    ├── ErrorHandler.h
    ├── EscapeAnalyser.cpp
    ├── EscapeAnalyser.h
    ├── ExpressionParser.h
    ├── Frame.h
    ├── IdentifierParser.h
    ├── Program.cpp
    ├── Program.h
    ├── Skipper.h
    ├── StringParser.h
    ├── TempMap.cpp
    ├── TempMap.h
    ├── Test.cpp
    ├── Translator.cpp
    ├── Translator.h
    ├── Types.h
    └── x64FastCall
    │   ├── CallingConvention.cpp
    │   ├── CallingConvention.h
    │   ├── Frame.cpp
    │   └── Frame.h
├── Chapter07
    ├── AbstractSyntaxTree.h
    ├── Annotation.h
    ├── CMakeLists.txt
    ├── CallingConvention.h
    ├── DeclerationParser.h
    ├── ErrorHandler.h
    ├── EscapeAnalyser.cpp
    ├── EscapeAnalyser.h
    ├── ExpressionParser.h
    ├── Fragment.h
    ├── Frame.h
    ├── IdentifierParser.h
    ├── Program.cpp
    ├── Program.h
    ├── SemanticAnalyzer.cpp
    ├── SemanticAnalyzer.h
    ├── Skipper.h
    ├── StringParser.h
    ├── TempMap.cpp
    ├── TempMap.h
    ├── Test.cpp
    ├── Translator.cpp
    ├── Translator.h
    ├── Tree.cpp
    ├── Tree.h
    ├── Types.h
    └── x64FastCall
    │   ├── CallingConvention.cpp
    │   ├── CallingConvention.h
    │   ├── Frame.cpp
    │   ├── Frame.h
    │   └── Registers.h
├── Chapter08
    ├── AbstractSyntaxTree.h
    ├── Annotation.h
    ├── CMakeLists.txt
    ├── CallingConvention.h
    ├── Canonicalizer.cpp
    ├── Canonicalizer.h
    ├── DeclerationParser.h
    ├── ErrorHandler.h
    ├── EscapeAnalyser.cpp
    ├── EscapeAnalyser.h
    ├── ExpressionParser.h
    ├── Fragment.h
    ├── Frame.h
    ├── IdentifierParser.h
    ├── Program.cpp
    ├── Program.h
    ├── SemanticAnalyzer.cpp
    ├── SemanticAnalyzer.h
    ├── Skipper.h
    ├── StringParser.h
    ├── TempMap.cpp
    ├── TempMap.h
    ├── Test.cpp
    ├── Translator.cpp
    ├── Translator.h
    ├── Tree.cpp
    ├── Tree.h
    ├── Types.h
    └── x64FastCall
    │   ├── CallingConvention.cpp
    │   ├── CallingConvention.h
    │   ├── Frame.cpp
    │   ├── Frame.h
    │   └── Registers.h
├── Chapter09
    ├── AbstractSyntaxTree.h
    ├── Annotation.h
    ├── Assembly.cpp
    ├── Assembly.h
    ├── CMakeLists.txt
    ├── CallingConvention.cpp
    ├── CallingConvention.h
    ├── Canonicalizer.cpp
    ├── Canonicalizer.h
    ├── CodeGenerator.cpp
    ├── CodeGenerator.h
    ├── DeclerationParser.h
    ├── ErrorHandler.h
    ├── EscapeAnalyser.cpp
    ├── EscapeAnalyser.h
    ├── ExpressionParser.h
    ├── Fragment.h
    ├── Frame.h
    ├── IdentifierParser.h
    ├── Machine.h
    ├── MachineRegistrar.h
    ├── MachineRegistration.h.in
    ├── Program.cpp
    ├── Program.h
    ├── SemanticAnalyzer.cpp
    ├── SemanticAnalyzer.h
    ├── Skipper.h
    ├── StringParser.h
    ├── TempMap.cpp
    ├── TempMap.h
    ├── Translator.cpp
    ├── Translator.h
    ├── Tree.cpp
    ├── Tree.h
    ├── TreeAdapted.h
    ├── Types.h
    ├── m68k
    │   ├── CMakeLists.txt
    │   ├── m68kCallingConvention.cpp
    │   ├── m68kCallingConvention.h
    │   ├── m68kCodeGenerator.cpp
    │   ├── m68kCodeGenerator.h
    │   ├── m68kFrame.cpp
    │   ├── m68kFrame.h
    │   ├── m68kMachine.cpp
    │   ├── m68kMachine.h
    │   └── m68kRegisters.h
    ├── test
    │   ├── CMakeLists.txt
    │   ├── Test.h
    │   ├── TestMain.cpp
    │   ├── arithmetic.cpp
    │   ├── array.cpp
    │   ├── assignment.cpp
    │   ├── boolean.cpp
    │   ├── break.cpp
    │   ├── checkedCompile.cpp
    │   ├── comparison.cpp
    │   ├── compileFiles.cpp
    │   ├── for.cpp
    │   ├── functionCall.cpp
    │   ├── functionDeclarations.cpp
    │   ├── ifThen.cpp
    │   ├── integer.cpp
    │   ├── library.cpp
    │   ├── lvalue.cpp
    │   ├── nil.cpp
    │   ├── record.cpp
    │   ├── sequence.cpp
    │   ├── string.cpp
    │   ├── typeDeclarations.cpp
    │   └── while.cpp
    └── x64
    │   ├── CMakeLists.txt
    │   ├── x64CallingConvention.cpp
    │   ├── x64CallingConvention.h
    │   ├── x64CodeGenerator.cpp
    │   ├── x64CodeGenerator.h
    │   ├── x64Frame.cpp
    │   ├── x64Frame.h
    │   ├── x64Machine.cpp
    │   ├── x64Machine.h
    │   └── x64Registers.h
├── Chapter10
    ├── AbstractSyntaxTree.h
    ├── Annotation.h
    ├── Assembly.cpp
    ├── Assembly.h
    ├── CMakeLists.txt
    ├── CallingConvention.cpp
    ├── CallingConvention.h
    ├── Canonicalizer.cpp
    ├── Canonicalizer.h
    ├── CodeGenerator.cpp
    ├── CodeGenerator.h
    ├── DeclerationParser.h
    ├── ErrorHandler.h
    ├── EscapeAnalyser.cpp
    ├── EscapeAnalyser.h
    ├── ExpressionParser.h
    ├── FlowGraph.cpp
    ├── FlowGraph.h
    ├── Fragment.h
    ├── Frame.cpp
    ├── Frame.h
    ├── IdentifierParser.h
    ├── LivenessAnalyser.cpp
    ├── LivenessAnalyser.h
    ├── Machine.h
    ├── MachineRegistrar.h
    ├── MachineRegistration.h.in
    ├── Program.cpp
    ├── Program.h
    ├── SemanticAnalyzer.cpp
    ├── SemanticAnalyzer.h
    ├── Skipper.h
    ├── StringParser.h
    ├── TempLabel.h
    ├── TempMap.cpp
    ├── TempMap.h
    ├── TempRegister.h
    ├── Translator.cpp
    ├── Translator.h
    ├── Tree.cpp
    ├── Tree.h
    ├── TreeAdapted.h
    ├── Types.h
    ├── m68k
    │   ├── CMakeLists.txt
    │   ├── m68kCallingConvention.cpp
    │   ├── m68kCallingConvention.h
    │   ├── m68kCodeGenerator.cpp
    │   ├── m68kCodeGenerator.h
    │   ├── m68kFrame.cpp
    │   ├── m68kFrame.h
    │   ├── m68kMachine.cpp
    │   ├── m68kMachine.h
    │   └── m68kRegisters.h
    ├── test
    │   ├── CMakeLists.txt
    │   ├── Test.cpp
    │   ├── Test.h
    │   ├── TestMain.cpp
    │   ├── arithmetic.cpp
    │   ├── array.cpp
    │   ├── assignment.cpp
    │   ├── boolean.cpp
    │   ├── break.cpp
    │   ├── comparison.cpp
    │   ├── compileFiles.cpp
    │   ├── for.cpp
    │   ├── functionCall.cpp
    │   ├── functionDeclarations.cpp
    │   ├── ifThen.cpp
    │   ├── integer.cpp
    │   ├── library.cpp
    │   ├── lvalue.cpp
    │   ├── nil.cpp
    │   ├── record.cpp
    │   ├── sequence.cpp
    │   ├── string.cpp
    │   ├── typeDeclarations.cpp
    │   └── while.cpp
    └── x64
    │   ├── CMakeLists.txt
    │   ├── x64CallingConvention.cpp
    │   ├── x64CallingConvention.h
    │   ├── x64CodeGenerator.cpp
    │   ├── x64CodeGenerator.h
    │   ├── x64Frame.cpp
    │   ├── x64Frame.h
    │   ├── x64Machine.cpp
    │   ├── x64Machine.h
    │   └── x64Registers.h
├── README.md
├── appveyor.yml
├── book
    └── Modern Compiler Implementation in C.pdf
├── cmake
    ├── CatchAddTests.cmake
    ├── CatchDiscoverTests.cmake
    ├── CompilerWarnings.cmake
    └── HunterGate.cmake
├── include
    ├── CMakeLists.txt
    ├── fusionAccumulate.h
    ├── irange.h
    ├── overload_set.h
    ├── printRange.h
    ├── satisfy_boost_range_backport.hpp
    ├── strong_typedef.h
    ├── testsHelper.h.in
    ├── type_traits.h
    ├── variantMatch.h
    ├── vectorApply.h
    └── warning_suppress.h
└── module_bundle
    ├── chap1
        ├── main.c
        ├── makefile
        ├── prog1.c
        ├── prog1.h
        ├── slp.c
        ├── slp.h
        ├── util.c
        └── util.h
    ├── chap10
        ├── flowgraph.h
        ├── graph.c
        └── graph.h
    ├── chap11
        ├── color.h
        └── regalloc.h
    ├── chap12
        └── runtime.c
    ├── chap2
        ├── driver.c
        ├── errormsg.c
        ├── errormsg.h
        ├── makefile
        ├── tiger.lex
        ├── tokens.h
        ├── util.c
        └── util.h
    ├── chap3
        ├── errormsg.c
        ├── errormsg.h
        ├── lex.yy.c
        ├── makefile
        ├── parsetest.c
        ├── tiger.grm
        ├── util.c
        ├── util.h
        └── y.output
    ├── chap4
        ├── absyn.c
        ├── absyn.h
        ├── lex.yy.c
        ├── makefile
        ├── parse.c
        ├── parse.h
        ├── prabsyn.c
        ├── prabsyn.h
        ├── symbol.c
        ├── symbol.h
        ├── table.c
        ├── table.h
        └── tiger.grm
    ├── chap5
        ├── types.c
        └── types.h
    ├── chap6
        ├── temp.c
        └── temp.h
    ├── chap7
        ├── printtree.c
        ├── printtree.h
        ├── tree.c
        └── tree.h
    ├── chap8
        ├── canon.c
        └── canon.h
    ├── chap9
        ├── assem.c
        ├── assem.h
        ├── canon.c
        ├── canon.h
        └── main.c
    └── testcases
        ├── compilation_error
            ├── test10.tig
            ├── test11.tig
            ├── test13.tig
            ├── test14.tig
            ├── test15.tig
            ├── test16.tig
            ├── test17.tig
            ├── test18.tig
            ├── test19.tig
            ├── test20.tig
            ├── test21.tig
            ├── test22.tig
            ├── test23.tig
            ├── test24.tig
            ├── test25.tig
            ├── test26.tig
            ├── test28.tig
            ├── test29.tig
            ├── test31.tig
            ├── test32.tig
            ├── test33.tig
            ├── test34.tig
            ├── test35.tig
            ├── test36.tig
            ├── test40.tig
            ├── test43.tig
            ├── test45.tig
            └── test9.tig
        ├── merge.tig
        ├── parse_error
            └── test49.tig
        ├── queens.tig
        ├── test1.tig
        ├── test12.tig
        ├── test2.tig
        ├── test27.tig
        ├── test3.tig
        ├── test30.tig
        ├── test37.tig
        ├── test38.tig
        ├── test39.tig
        ├── test4.tig
        ├── test41.tig
        ├── test42.tig
        ├── test44.tig
        ├── test46.tig
        ├── test47.tig
        ├── test48.tig
        ├── test5.tig
        ├── test6.tig
        ├── test7.tig
        └── test8.tig


/.clang-format:
--------------------------------------------------------------------------------
 1 | Language:        Cpp
 2 | BasedOnStyle:  LLVM
 3 | AlignConsecutiveAssignments: true
 4 | AllowAllParametersOfDeclarationOnNextLine: false
 5 | AllowShortBlocksOnASingleLine: true
 6 | AlwaysBreakTemplateDeclarations: false
 7 | BraceWrapping:   
 8 |   IndentBraces:    false
 9 |   SplitEmptyFunction: false
10 |   SplitEmptyRecord: false
11 |   SplitEmptyNamespace: false
12 | BreakBeforeBinaryOperators: NonAssignment
13 | BreakBeforeBraces: Custom
14 | BreakConstructorInitializers: AfterColon
15 | BreakStringLiterals: false
16 | ColumnLimit:     80
17 | ContinuationIndentWidth: 2
18 | IncludeBlocks:   Merge
19 | IndentCaseLabels: true
20 | IndentWrappedFunctionNames: true
21 | KeepEmptyLinesAtTheStartOfBlocks: false
22 | MaxEmptyLinesToKeep: 1
23 | Standard:        Cpp11
24 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Visual Studio 2015 cache/options directory
 2 | .vs/
 3 | 
 4 | # VS Code
 5 | .vscode/
 6 | 
 7 | # build folders
 8 | _*/
 9 | build
10 | 


--------------------------------------------------------------------------------
/Chapter01/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES Program.cpp Exercises.inl Test.cpp)
 2 | set(HEADERS Program.h Exercises.h)
 3 | 
 4 | add_executable(Chapter01 ${HEADERS} ${SOURCES})
 5 | 
 6 | target_compile_definitions(Chapter01 PRIVATE CATCH_CPP14_OR_GREATER)
 7 | 
 8 | target_link_libraries(Chapter01 PRIVATE Boost::boost Catch2::Catch includeHeaders)
 9 | 
10 | parse_unit_tests(Chapter01)


--------------------------------------------------------------------------------
/Chapter02/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES Program.cpp Test.cpp)
 2 | set(HEADERS Program.h)
 3 | 
 4 | add_executable(Chapter02 ${HEADERS} ${SOURCES})
 5 | 
 6 | target_compile_definitions(Chapter02 PRIVATE CATCH_CPP14_OR_GREATER)
 7 | 
 8 | target_link_libraries(Chapter02 
 9 |     PRIVATE 
10 |         Boost::boost
11 |         Boost::filesystem
12 |         Boost::system
13 |         Catch2::Catch 
14 |         includeHeaders)
15 | 
16 | parse_unit_tests(Chapter02)


--------------------------------------------------------------------------------
/Chapter02/Program.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include <string>
3 | 
4 | bool lexFile(const std::string &filename);


--------------------------------------------------------------------------------
/Chapter02/Test.cpp:
--------------------------------------------------------------------------------
 1 | #include "Program.h"
 2 | #include "testsHelper.h"
 3 | #define CATCH_CONFIG_MAIN
 4 | #include <catch.hpp>
 5 | 
 6 | TEST_CASE("lex test files") {
 7 |   namespace fs = boost::filesystem;
 8 |   tiger::forEachTigerTest([](const fs::path &filepath, bool /*parseError*/,
 9 |                              bool /*compilationError*/) {
10 |     auto filename = filepath.filename();
11 |     CAPTURE(filename);
12 |     REQUIRE(lexFile(filepath.string()));
13 |   });
14 | }


--------------------------------------------------------------------------------
/Chapter03/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES Program.cpp Test.cpp)
 2 | set(HEADERS Program.h ErrorHandler.h ExpressionParser.h Skipper.h IdentifierParser.h DeclerationParser.h)
 3 | 
 4 | add_executable(Chapter03 ${HEADERS} ${SOURCES})
 5 | 
 6 | target_compile_definitions(Chapter03 PRIVATE CATCH_CPP14_OR_GREATER $<$<CONFIG:Debug>:BOOST_SPIRIT_DEBUG>)
 7 | 
 8 | target_link_libraries(Chapter03 
 9 |     PRIVATE 
10 |         Boost::boost 
11 |         Boost::filesystem 
12 |         Boost::system
13 |         Catch2::Catch 
14 |         includeHeaders)
15 | 
16 | parse_unit_tests(Chapter03)


--------------------------------------------------------------------------------
/Chapter03/ErrorHandler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/spirit/include/classic_position_iterator.hpp>
 3 | #include <iomanip>
 4 | #include <iostream>
 5 | 
 6 | namespace tiger {
 7 | template <typename Iterator> class ErrorHandler {
 8 | public:
 9 |   template <typename, typename, typename> struct result { typedef void type; };
10 | 
11 |   template <typename Message, typename What>
12 |   void operator()(Message const &message, What const &what,
13 |                   Iterator err_pos) const {
14 |     const auto &pos = err_pos.get_position();
15 |     std::cerr << message << what << " at file " << pos.file << " line "
16 |               << pos.line << " column " << pos.column << '\n';
17 |     std::cerr << "'";
18 |     std::copy(err_pos.get_currentline_begin(), err_pos.get_currentline_end(),
19 |               std::ostream_iterator<char>(std::cerr));
20 |     std::cerr << "'\n";
21 |     std::cerr << std::setw(pos.column) << " "
22 |               << "^- here\n";
23 |   }
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter03/IdentifierParser.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "ErrorHandler.h"
 3 | #include "Skipper.h"
 4 | #include "warning_suppress.h"
 5 | MSC_DIAG_OFF(4996 4459)
 6 | #include <boost/spirit/include/qi.hpp>
 7 | MSC_DIAG_ON()
 8 | 
 9 | namespace tiger {
10 | template <typename Iterator>
11 | class IdentifierParser
12 |     : public boost::spirit::qi::grammar<Iterator, Skipper<Iterator>> {
13 | public:
14 |   IdentifierParser(ErrorHandler<Iterator> & /* errorHandler */) :
15 |       IdentifierParser::base_type(identifier) {
16 |     namespace spirit = boost::spirit;
17 |     namespace qi     = spirit::qi;
18 |     namespace ascii  = spirit::ascii;
19 | 
20 |     using ascii::alnum;
21 |     using ascii::alpha;
22 | 
23 |     using qi::lexeme;
24 |     using qi::raw;
25 | 
26 |     keywords.add("array")("if")("then")("else")("while")("for")("to")("do")(
27 |       "let")("in")("end")("of")("break")("nil")("function")("var")("type");
28 | 
29 |     identifier =
30 |       !lexeme[keywords >> !(alnum | '_')] >> lexeme[alpha >> *(alnum | '_')];
31 | 
32 |     BOOST_SPIRIT_DEBUG_NODES((identifier))
33 |   }
34 | 
35 | private:
36 |   template <typename Signature = boost::spirit::qi::unused_type>
37 |   using rule = boost::spirit::qi::rule<Iterator, Skipper<Iterator>, Signature>;
38 |   template <typename... Types>
39 |   using symbols = boost::spirit::qi::symbols<Types...>;
40 | 
41 |   rule<> identifier;
42 | 
43 |   symbols<char> keywords;
44 | };
45 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter03/Program.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | 
 4 | namespace tiger {
 5 | 
 6 | bool parseFile(const std::string &filename);
 7 | 
 8 | bool parse(const std::string &string);
 9 | 
10 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter03/Skipper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "warning_suppress.h"
 3 | MSC_DIAG_OFF(4996 4459)
 4 | #include <boost/spirit/include/qi.hpp>
 5 | MSC_DIAG_ON()
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator>
 9 | class Skipper : public boost::spirit::qi::grammar<Iterator> {
10 | public:
11 |   Skipper() : Skipper::base_type(start) {
12 |     namespace ascii = boost::spirit::ascii;
13 | 
14 |     using ascii::char_;
15 |     ascii::space_type space;
16 | 
17 |     start = space                             // tab/space/cr/lf
18 |             | "/*" >> *(char_ - "*/") >> "*/" // comments
19 |       ;
20 | 
21 |     BOOST_SPIRIT_DEBUG_NODES((start))
22 |   }
23 | 
24 | private:
25 |   boost::spirit::qi::rule<Iterator> start;
26 | };
27 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter04/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES Program.cpp Test.cpp)
 2 | set(HEADERS Program.h ErrorHandler.h ExpressionParser.h Skipper.h IdentifierParser.h DeclerationParser.h AbstractSyntaxTree.h Annotation.h
 3 |     StringParser.h)
 4 | 
 5 | add_executable(Chapter04 ${HEADERS} ${SOURCES})
 6 | 
 7 | target_compile_definitions(Chapter04 PRIVATE CATCH_CPP14_OR_GREATER $<$<CONFIG:Debug>:BOOST_SPIRIT_DEBUG>)
 8 | 
 9 | if(MSVC)
10 | 	set_source_files_properties(Program.cpp PROPERTIES COMPILE_FLAGS /bigobj)
11 | endif()
12 | 
13 | target_link_libraries(Chapter04 
14 |     PRIVATE 
15 |         Boost::boost 
16 |         Boost::filesystem 
17 |         Boost::system
18 |         Catch2::Catch 
19 |         includeHeaders)
20 | 
21 | parse_unit_tests(Chapter04)


--------------------------------------------------------------------------------
/Chapter04/ErrorHandler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/spirit/include/classic_position_iterator.hpp>
 3 | #include <iomanip>
 4 | #include <iostream>
 5 | 
 6 | namespace tiger {
 7 | template <typename Iterator> class ErrorHandler {
 8 | public:
 9 |   template <typename, typename, typename> struct result { typedef void type; };
10 | 
11 |   template <typename Message, typename What>
12 |   void operator()(Message const &message, What const &what,
13 |                   Iterator err_pos) const {
14 |     const auto &pos = err_pos.get_position();
15 |     std::cerr << message << what << " at file " << pos.file << " line "
16 |               << pos.line << " column " << pos.column << '\n';
17 |     std::cerr << "'";
18 |     std::copy(err_pos.get_currentline_begin(), err_pos.get_currentline_end(),
19 |               std::ostream_iterator<char>(std::cerr));
20 |     std::cerr << "'\n";
21 |     std::cerr << std::setw(pos.column) << " "
22 |               << "^- here\n";
23 |   }
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter04/Program.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "AbstractSyntaxTree.h"
 3 | #include <string>
 4 | 
 5 | namespace tiger {
 6 | 
 7 | bool parseFile(const std::string &filename, ast::Expression &ast);
 8 | 
 9 | bool parse(const std::string &string, ast::Expression &ast);
10 | 
11 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter04/Skipper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "warning_suppress.h"
 3 | MSC_DIAG_OFF(4996 4459)
 4 | #include <boost/spirit/include/qi.hpp>
 5 | MSC_DIAG_ON()
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator>
 9 | class Skipper : public boost::spirit::qi::grammar<Iterator> {
10 | public:
11 |   Skipper() : Skipper::base_type(skip) {
12 |     namespace ascii = boost::spirit::ascii;
13 | 
14 |     using ascii::char_;
15 |     ascii::space_type space;
16 | 
17 |     skip = space                             // tab/space/cr/lf
18 |            | "/*" >> *(char_ - "*/") >> "*/" // comments
19 |       ;
20 |   }
21 | 
22 | private:
23 |   boost::spirit::qi::rule<Iterator> skip;
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter05/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES Program.cpp Test.cpp Compiler.cpp)
 2 | set(HEADERS Program.h ErrorHandler.h ExpressionParser.h Skipper.h IdentifierParser.h DeclerationParser.h AbstractSyntaxTree.h Annotation.h
 3 |     StringParser.h Compiler.h Types.h)
 4 | 
 5 | add_executable(Chapter05 ${HEADERS} ${SOURCES})
 6 | 
 7 | target_compile_definitions(Chapter05 PRIVATE CATCH_CPP14_OR_GREATER)
 8 | 
 9 | if(MSVC)
10 | 	set_source_files_properties(Program.cpp PROPERTIES COMPILE_FLAGS /bigobj)
11 | endif()
12 | 
13 | target_link_libraries(Chapter05 
14 |     PRIVATE 
15 |         Boost::boost 
16 |         Boost::filesystem 
17 |         Boost::system
18 |         Catch2::Catch 
19 |         includeHeaders)
20 | 
21 | parse_unit_tests(Chapter05)


--------------------------------------------------------------------------------
/Chapter05/ErrorHandler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/spirit/include/classic_position_iterator.hpp>
 3 | #include <iomanip>
 4 | #include <iostream>
 5 | 
 6 | namespace tiger {
 7 | template <typename Iterator> class ErrorHandler {
 8 | public:
 9 |   template <typename, typename, typename> struct result { typedef void type; };
10 | 
11 |   template <typename Message, typename What>
12 |   void operator()(Message const &message, What const &what,
13 |                   Iterator err_pos) const {
14 |     const auto &pos = err_pos.get_position();
15 |     std::cerr << message << ": " << what << " at file " << pos.file << " line "
16 |               << pos.line << " column " << pos.column << '\n';
17 |     std::cerr << "'";
18 |     std::copy(err_pos.get_currentline_begin(), err_pos.get_currentline_end(),
19 |               std::ostream_iterator<char>(std::cerr));
20 |     std::cerr << "'\n";
21 |     std::cerr << std::setw(pos.column) << " "
22 |               << "^- here\n";
23 |   }
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter05/Program.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | 
 4 | namespace tiger {
 5 | 
 6 | bool compileFile(const std::string &filename);
 7 | 
 8 | bool compile(const std::string &string);
 9 | 
10 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter05/Skipper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "warning_suppress.h"
 3 | MSC_DIAG_OFF(4996 4459)
 4 | #include <boost/spirit/include/qi.hpp>
 5 | MSC_DIAG_ON()
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator>
 9 | class Skipper : public boost::spirit::qi::grammar<Iterator> {
10 | public:
11 |   Skipper() : Skipper::base_type(skip) {
12 |     namespace ascii = boost::spirit::ascii;
13 | 
14 |     using ascii::char_;
15 |     ascii::space_type space;
16 | 
17 |     skip = space                             // tab/space/cr/lf
18 |            | "/*" >> *(char_ - "*/") >> "*/" // comments
19 |       ;
20 |   }
21 | 
22 | private:
23 |   boost::spirit::qi::rule<Iterator> skip;
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter05/Types.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <boost/variant.hpp>
 4 | #include <string>
 5 | #include <unordered_map>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | struct NilType {};
11 | 
12 | struct IntType {};
13 | 
14 | struct StringType {};
15 | 
16 | struct ArrayType;
17 | 
18 | struct RecordType;
19 | 
20 | struct NameType {
21 |   std::string m_name;
22 | };
23 | 
24 | struct VoidType {};
25 | 
26 | using Type =
27 |   boost::variant<NilType, IntType, StringType,
28 |                  boost::recursive_wrapper<ArrayType>,
29 |                  boost::recursive_wrapper<RecordType>, NameType, VoidType>;
30 | 
31 | struct NamedType {
32 |   std::string m_name;
33 |   Type m_type;
34 | };
35 | 
36 | struct ArrayType {
37 |   NamedType m_elementType;
38 | };
39 | 
40 | struct RecordType {
41 |   struct RecordField {
42 |     std::string m_name;
43 |     NamedType m_type;
44 |   };
45 |   std::vector<RecordField> m_fields;
46 | };
47 | 
48 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter06/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES Program.cpp Test.cpp Compiler.cpp TempMap.cpp EscapeAnalyser.cpp Translator.cpp)
 2 | set(HEADERS Program.h ErrorHandler.h ExpressionParser.h Skipper.h IdentifierParser.h DeclerationParser.h AbstractSyntaxTree.h Annotation.h
 3 |     StringParser.h Compiler.h Types.h TempMap.h Frame.h CallingConvention.h EscapeAnalyser.h Translator.h)
 4 | list(APPEND SOURCES x64FastCall/Frame.cpp x64FastCall/CallingConvention.cpp)
 5 | list(APPEND HEADERS x64FastCall/Frame.h x64FastCall/Frame.cpp)
 6 | 
 7 | add_executable(Chapter06 ${HEADERS} ${SOURCES})
 8 | 
 9 | target_compile_definitions(Chapter06 PRIVATE CATCH_CPP14_OR_GREATER)
10 | 
11 | if(MSVC)
12 | 	set_source_files_properties(Program.cpp PROPERTIES COMPILE_FLAGS /bigobj)
13 | endif()
14 | 
15 | target_link_libraries(Chapter06 
16 |     PRIVATE 
17 |         Boost::boost 
18 |         Boost::filesystem 
19 |         Boost::system
20 |         Catch2::Catch 
21 |         includeHeaders)
22 | 
23 | parse_unit_tests(Chapter06)


--------------------------------------------------------------------------------
/Chapter06/CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #include "Frame.h"
 2 | 
 3 | namespace tiger {
 4 | class CallingConvention {
 5 | public:
 6 |   virtual std::unique_ptr<Frame> createFrame(TempMap &tempMap,
 7 |                                              const Label &name,
 8 |                                              const BoolList &formals) = 0;
 9 | };
10 | } // namespace tiger
11 | 


--------------------------------------------------------------------------------
/Chapter06/ErrorHandler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/spirit/include/classic_position_iterator.hpp>
 3 | #include <iomanip>
 4 | #include <iostream>
 5 | 
 6 | namespace tiger {
 7 | template <typename Iterator> class ErrorHandler {
 8 | public:
 9 |   template <typename, typename, typename> struct result { typedef void type; };
10 | 
11 |   template <typename Message, typename What>
12 |   void operator()(Message const &message, What const &what,
13 |                   Iterator err_pos) const {
14 |     const auto &pos = err_pos.get_position();
15 |     std::cerr << message << ": " << what << " at file " << pos.file << " line "
16 |               << pos.line << " column " << pos.column << '\n';
17 |     std::cerr << "'";
18 |     std::copy(err_pos.get_currentline_begin(), err_pos.get_currentline_end(),
19 |               std::ostream_iterator<char>(std::cerr));
20 |     std::cerr << "'\n";
21 |     std::cerr << std::setw(pos.column) << " "
22 |               << "^- here\n";
23 |   }
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter06/EscapeAnalyser.h:
--------------------------------------------------------------------------------
 1 | #include "AbstractSyntaxTree.h"
 2 | #include <unordered_map>
 3 | #include <utility>
 4 | 
 5 | namespace tiger {
 6 | class EscapeAnalyser {
 7 | public:
 8 |   using result_type = bool;
 9 | 
10 |   result_type analyse(ast::Expression &exp);
11 | 
12 | private:
13 |   result_type analyseVar(ast::VarExpression &exp);
14 |   result_type analyseLet(ast::LetExpression &exp);
15 |   result_type analyseFuncDec(ast::FunctionDeclarations &decs);
16 |   result_type analyseVarDec(ast::VarDeclaration &dec);
17 | 
18 |   using Environment =
19 |     std::unordered_map<std::string, std::reference_wrapper<bool>>;
20 | 
21 |   std::vector<Environment> m_environments;
22 | };
23 | } // namespace tiger
24 | 


--------------------------------------------------------------------------------
/Chapter06/Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | #include <boost/dynamic_bitset_fwd.hpp>
 4 | #include <boost/variant.hpp>
 5 | #include <vector>
 6 | 
 7 | namespace tiger {
 8 | 
 9 | using BoolList = boost::dynamic_bitset<>;
10 | 
11 | struct InFrame {
12 |   int m_offset;
13 | };
14 | 
15 | struct InReg {
16 |   Temporary m_reg;
17 | };
18 | 
19 | using VariableAccess = boost::variant<InFrame, InReg>;
20 | using AccessList     = std::vector<VariableAccess>;
21 | 
22 | class Frame {
23 | public:
24 |   virtual ~Frame() noexcept                          = default;
25 |   virtual Label name() const                         = 0;
26 |   virtual AccessList formals() const                 = 0;
27 |   virtual VariableAccess allocateLocal(bool escapes) = 0;
28 | };
29 | 
30 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter06/Program.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | 
 4 | namespace tiger {
 5 | 
 6 | bool compileFile(const std::string &filename);
 7 | 
 8 | bool compile(const std::string &string);
 9 | 
10 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter06/Skipper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "warning_suppress.h"
 3 | MSC_DIAG_OFF(4996 4459)
 4 | #include <boost/spirit/include/qi.hpp>
 5 | MSC_DIAG_ON()
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator>
 9 | class Skipper : public boost::spirit::qi::grammar<Iterator> {
10 | public:
11 |   Skipper() : Skipper::base_type(skip) {
12 |     namespace ascii = boost::spirit::ascii;
13 | 
14 |     using ascii::char_;
15 |     ascii::space_type space;
16 | 
17 |     skip = space                             // tab/space/cr/lf
18 |            | "/*" >> *(char_ - "*/") >> "*/" // comments
19 |       ;
20 |   }
21 | 
22 | private:
23 |   boost::spirit::qi::rule<Iterator> skip;
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter06/TempMap.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * temp.cpp - functions to create and manipulate temporary variables which are
 3 |  *          used in the IR tree representation before it has been determined
 4 |  *          which variables are to go into registers.
 5 |  *
 6 |  */
 7 | 
 8 | #include "TempMap.h"
 9 | #include <boost/optional.hpp>
10 | #include <ostream>
11 | 
12 | namespace tiger {
13 | 
14 | std::ostream &operator<<(std::ostream &ost, const TempMap &map) {
15 |   for (const auto &it : map.m_map) {
16 |     ost << "t" << it.first << " -> " << it.second << '\n';
17 |   }
18 |   if (map.m_under) {
19 |     ost << "---------\n";
20 |     ost << *map.m_under;
21 |   }
22 | 
23 |   return ost;
24 | }
25 | 
26 | void TempMap::layerOver(TempMap &&under) {
27 |   if (m_under) {
28 |     m_under->layerOver(std::move(under));
29 |   } else {
30 |     m_under.reset(&under);
31 |   }
32 | }
33 | 
34 | Temporary TempMap::newTemp() {
35 |   static const auto MIN_TEMP = 100;
36 |   static auto temps          = MIN_TEMP;
37 |   auto res                   = temps++;
38 |   m_map[res]                 = std::to_string(res);
39 |   return res;
40 | }
41 | 
42 | boost::optional<std::string> TempMap::lookup(const Temporary &t) {
43 |   auto it = m_map.find(t);
44 |   if (it != m_map.end())
45 |     return it->second;
46 |   if (m_under)
47 |     return m_under->lookup(t);
48 |   return {};
49 | }
50 | 
51 | Label TempMap::newLabel() {
52 |   static const auto MIN_LABEL = 0;
53 |   static auto labels          = MIN_LABEL;
54 |   return "L" + std::to_string(labels++);
55 | }
56 | 
57 | } // namespace tiger
58 | 


--------------------------------------------------------------------------------
/Chapter06/TempMap.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/optional/optional_fwd.hpp>
 3 | #include <memory>
 4 | #include <string>
 5 | #include <unordered_map>
 6 | 
 7 | namespace tiger {
 8 | 
 9 | // a temporary is just a number
10 | using Temporary = int;
11 | 
12 | // a label is just a string
13 | using Label = std::string;
14 | 
15 | // A Map is just a table whose keys are Temp_temps and whose bindings
16 | // are strings. However, one mapping can be layered over another; if σ3 =
17 | // layer(σ1, σ2), this means that look(σ3, t) will first try look(σ1, t), and if
18 | // that fails it will try look(σ2, t).Also, enter(σ3, t, a) will have the effect
19 | // of entering t->a into σ2.
20 | class TempMap {
21 | public:
22 |   void layerOver(TempMap &&under);
23 |   Temporary newTemp();
24 |   boost::optional<std::string> lookup(const Temporary &t);
25 |   friend std::ostream &operator<<(std::ostream &ost, const TempMap &map);
26 | 
27 |   Label newLabel();
28 | 
29 | private:
30 |   std::unordered_map<Temporary, std::string> m_map;
31 |   std::unique_ptr<TempMap> m_under;
32 | };
33 | 
34 | } // namespace tiger
35 | 


--------------------------------------------------------------------------------
/Chapter06/Translator.cpp:
--------------------------------------------------------------------------------
 1 | #include "Translator.h"
 2 | #include "CallingConvention.h"
 3 | #include <boost/dynamic_bitset.hpp>
 4 | #include <cassert>
 5 | 
 6 | namespace tiger {
 7 | 
 8 | Translator::Translator(TempMap &tempMap, CallingConvention &callingConvention) :
 9 |     m_tempMap(tempMap), m_callingConvention(callingConvention) {
10 |   m_frames.push_back(
11 |     m_callingConvention.createFrame(m_tempMap, "start", BoolList{}));
12 | }
13 | 
14 | tiger::Translator::Level Translator::outermost() const { return 0; }
15 | 
16 | tiger::Translator::Level Translator::newLevel(Level /* parent */, Label label,
17 |                                               const BoolList &formals) {
18 |   // add static link
19 |   BoolList withStaticLink = formals;
20 |   withStaticLink.resize(withStaticLink.size() + 1);
21 |   (withStaticLink <<= 1).set(0, true);
22 |   m_frames.push_back(
23 |     m_callingConvention.createFrame(m_tempMap, label, withStaticLink));
24 |   return m_frames.size() - 1;
25 | }
26 | 
27 | tiger::AccessList Translator::formals(Level level) {
28 |   assert(level < m_frames.size());
29 |   return m_frames[level]->formals();
30 | }
31 | 
32 | std::pair<tiger::Translator::Level, tiger::VariableAccess>
33 |   Translator::allocateLocal(Level level, bool escapes) {
34 |   assert(level < m_frames.size());
35 |   return {level, m_frames[level]->allocateLocal(escapes)};
36 | }
37 | 
38 | } // namespace tiger
39 | 


--------------------------------------------------------------------------------
/Chapter06/Translator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Frame.h"
 3 | 
 4 | namespace tiger {
 5 | 
 6 | class CallingConvention;
 7 | 
 8 | class Translator {
 9 | public:
10 |   using Level = size_t;
11 | 
12 |   Translator(TempMap &tempMap, CallingConvention &callingConvention);
13 | 
14 |   Level outermost() const;
15 |   Level newLevel(Level parent, Label label, const BoolList &formals);
16 |   AccessList formals(Level level);
17 |   std::pair<Level, VariableAccess> allocateLocal(Level level, bool escapes);
18 | 
19 | private:
20 |   TempMap &m_tempMap;
21 |   CallingConvention &m_callingConvention;
22 |   std::vector<std::unique_ptr<Frame>> m_frames;
23 | };
24 | } // namespace tiger
25 | 


--------------------------------------------------------------------------------
/Chapter06/Types.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <boost/variant.hpp>
 4 | #include <string>
 5 | #include <unordered_map>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | struct NilType {};
11 | 
12 | struct IntType {};
13 | 
14 | struct StringType {};
15 | 
16 | struct ArrayType;
17 | 
18 | struct RecordType;
19 | 
20 | struct NameType {
21 |   std::string m_name;
22 | };
23 | 
24 | struct VoidType {};
25 | 
26 | using Type =
27 |   boost::variant<NilType, IntType, StringType,
28 |                  boost::recursive_wrapper<ArrayType>,
29 |                  boost::recursive_wrapper<RecordType>, NameType, VoidType>;
30 | 
31 | struct NamedType {
32 |   std::string m_name;
33 |   Type m_type;
34 | };
35 | 
36 | struct ArrayType {
37 |   NamedType m_elementType;
38 | };
39 | 
40 | struct RecordType {
41 |   struct RecordField {
42 |     std::string m_name;
43 |     NamedType m_type;
44 |   };
45 |   std::vector<RecordField> m_fields;
46 | };
47 | 
48 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter06/x64FastCall/CallingConvention.cpp:
--------------------------------------------------------------------------------
 1 | #include "CallingConvention.h"
 2 | #include "Frame.h"
 3 | 
 4 | namespace tiger {
 5 | 
 6 | std::unique_ptr<Frame>
 7 |   x64FastCallCallingConvention::createFrame(TempMap &tempMap, const Label &name,
 8 |                                             const BoolList &formals) {
 9 |   return std::make_unique<x64FastCall::Frame>(tempMap, name, formals);
10 | }
11 | 
12 | } // namespace tiger
13 | 


--------------------------------------------------------------------------------
/Chapter06/x64FastCall/CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../CallingConvention.h"
 4 | 
 5 | namespace tiger {
 6 | class x64FastCallCallingConvention : public CallingConvention {
 7 | public:
 8 |   // Inherited via CallingConvention
 9 |   virtual std::unique_ptr<Frame> createFrame(TempMap &tempMap,
10 |                                              const Label &name,
11 |                                              const BoolList &formals) override;
12 | };
13 | } // namespace tiger
14 | 


--------------------------------------------------------------------------------
/Chapter06/x64FastCall/Frame.cpp:
--------------------------------------------------------------------------------
 1 | #include "Frame.h"
 2 | #include <boost/dynamic_bitset.hpp>
 3 | #include <cassert>
 4 | 
 5 | namespace tiger {
 6 | namespace x64FastCall {
 7 | 
 8 | Frame::Frame(TempMap &tempMap, const Label &name, const BoolList &formals) :
 9 |     m_tempMap(tempMap), m_name(name) {
10 |   for (size_t i = 0; i < formals.size(); ++i) {
11 |     m_formals.push_back(allocateLocal(formals[i]));
12 |   }
13 | }
14 | 
15 | Label Frame::name() const { return m_name; }
16 | 
17 | AccessList Frame::formals() const { return m_formals; }
18 | 
19 | VariableAccess Frame::allocateLocal(bool escapes) {
20 |   if (escapes || m_allocatedRegs == MAX_REGS) {
21 |     auto res = InFrame{m_frameOffset};
22 |     m_frameOffset += FRAME_INC;
23 |     return res;
24 |   }
25 | 
26 |   assert(m_allocatedRegs < MAX_REGS);
27 |   ++m_allocatedRegs;
28 |   return InReg{m_tempMap.newTemp()};
29 | }
30 | 
31 | } // namespace x64FastCall
32 | } // namespace tiger
33 | 


--------------------------------------------------------------------------------
/Chapter06/x64FastCall/Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../Frame.h"
 4 | 
 5 | namespace tiger {
 6 | namespace x64FastCall {
 7 | // implements
 8 | // https://docs.microsoft.com/en-gb/cpp/build/overview-of-x64-calling-conventions
 9 | class Frame : public tiger::Frame {
10 | public:
11 |   Frame(TempMap &tempMap, const Label &name, const BoolList &formals);
12 |   // Inherited via Frame
13 |   virtual Label name() const override;
14 |   virtual AccessList formals() const override;
15 |   virtual VariableAccess allocateLocal(bool escapes) override;
16 | 
17 | private:
18 |   TempMap &m_tempMap;
19 |   Label m_name;
20 |   AccessList m_formals;
21 |   static const int FRAME_INC = 4;
22 |   int m_frameOffset          = -FRAME_INC;
23 |   // The __fastcall convention uses registers for the first four arguments
24 |   static const size_t MAX_REGS = 4;
25 |   size_t m_allocatedRegs       = 0;
26 | };
27 | } // namespace x64FastCall
28 | } // namespace tiger
29 | 


--------------------------------------------------------------------------------
/Chapter07/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES Program.cpp Test.cpp SemanticAnalyzer.cpp TempMap.cpp EscapeAnalyser.cpp Translator.cpp Tree.cpp)
 2 | set(HEADERS Program.h ErrorHandler.h ExpressionParser.h Skipper.h IdentifierParser.h DeclerationParser.h AbstractSyntaxTree.h 
 3 |   Annotation.h StringParser.h SemanticAnalyzer.h Types.h TempMap.h Frame.h CallingConvention.h EscapeAnalyser.h Translator.h Tree.h
 4 |   Fragment.h)
 5 | list(APPEND SOURCES x64FastCall/Frame.cpp x64FastCall/CallingConvention.cpp)
 6 | list(APPEND HEADERS x64FastCall/Frame.h x64FastCall/Frame.cpp)
 7 | 
 8 | add_executable(Chapter07 ${HEADERS} ${SOURCES})
 9 | 
10 | target_compile_definitions(Chapter07 PRIVATE CATCH_CPP14_OR_GREATER)
11 | 
12 | if(MSVC)
13 | 	set_source_files_properties(Program.cpp PROPERTIES COMPILE_FLAGS /bigobj)
14 | endif()
15 | 
16 | target_link_libraries(Chapter07 
17 |     PRIVATE 
18 |         Boost::boost 
19 |         Boost::filesystem 
20 |         Boost::system
21 |         Catch2::Catch 
22 |         includeHeaders
23 | )
24 | 
25 | parse_unit_tests(Chapter07 --timeout 10)
26 | 


--------------------------------------------------------------------------------
/Chapter07/CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #include "Frame.h"
 2 | 
 3 | namespace tiger {
 4 | namespace frame {
 5 | class CallingConvention {
 6 | public:
 7 |   CallingConvention(temp::Map &tempMap) : m_tempMap(tempMap) {}
 8 | 
 9 |   virtual ~CallingConvention() = default;
10 | 
11 |   virtual std::unique_ptr<Frame> createFrame(const temp::Label &name,
12 |                                              const BoolList &formals) = 0;
13 |   virtual int wordSize() const                                        = 0;
14 | 
15 |   virtual temp::Register framePointer() const = 0;
16 | 
17 |   virtual temp::Register returnValue() const = 0;
18 | 
19 |   virtual ir::Expression accessFrame(const VariableAccess &access,
20 |                                      const ir::Expression &framePtr) const = 0;
21 | 
22 |   virtual void allocateString(temp::Label label, const std::string &str) = 0;
23 | 
24 |   virtual ir::Expression
25 |     externalCall(const std::string &name,
26 |                  const std::vector<ir::Expression> &args) = 0;
27 | 
28 | protected:
29 |   temp::Map &m_tempMap;
30 | };
31 | } // namespace frame
32 | } // namespace tiger
33 | 


--------------------------------------------------------------------------------
/Chapter07/ErrorHandler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/spirit/include/classic_position_iterator.hpp>
 3 | #include <iomanip>
 4 | #include <sstream>
 5 | #include <stdexcept>
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator> class ErrorHandler {
 9 | public:
10 |   template <typename, typename, typename> struct result { typedef void type; };
11 | 
12 |   template <typename Message, typename What>
13 |   void operator()(Message const &message, What const &what,
14 |                   Iterator err_pos) const {
15 |     class TigerError : public std::logic_error {
16 |       using std::logic_error::logic_error;
17 |     };
18 |     const auto &pos = err_pos.get_position();
19 |     std::stringstream sst;
20 |     sst << pos.file << "(" << pos.line << "," << pos.column << "): " << message
21 |         << ": " << what << '\n';
22 |     sst << "'";
23 |     std::copy(err_pos.get_currentline_begin(), err_pos.get_currentline_end(),
24 |               std::ostream_iterator<char>(sst));
25 |     sst << "'\n";
26 |     sst << std::setw(pos.column) << " "
27 |         << "^- here\n";
28 |     throw TigerError{sst.str()};
29 |   }
30 | };
31 | } // namespace tiger
32 | 


--------------------------------------------------------------------------------
/Chapter07/Fragment.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Tree.h"
 3 | #include <memory>
 4 | 
 5 | namespace tiger {
 6 | 
 7 | namespace frame {
 8 | class Frame;
 9 | }
10 | 
11 | struct StringFragment {
12 |   temp::Label m_label;
13 |   std::string m_string;
14 | };
15 | 
16 | struct FunctionFragment {
17 |   ir::Statement m_body;
18 |   std::shared_ptr<const frame::Frame> m_frame;
19 | };
20 | 
21 | using Fragment     = boost::variant<StringFragment, FunctionFragment>;
22 | using FragmentList = std::vector<Fragment>;
23 | } // namespace tiger
24 | 


--------------------------------------------------------------------------------
/Chapter07/Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | #include "Tree.h"
 4 | #include <boost/dynamic_bitset_fwd.hpp>
 5 | #include <boost/variant.hpp>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | namespace frame {
11 | 
12 | using BoolList = boost::dynamic_bitset<>;
13 | 
14 | struct InFrame {
15 |   int m_offset;
16 | };
17 | 
18 | struct InReg {
19 |   temp::Register m_reg;
20 | };
21 | 
22 | using VariableAccess = boost::variant<InFrame, InReg>;
23 | using AccessList     = std::vector<VariableAccess>;
24 | 
25 | class Frame {
26 | public:
27 |   Frame(temp::Map &tempMap) : m_tempMap(tempMap) {}
28 | 
29 |   virtual ~Frame() noexcept = default;
30 | 
31 |   virtual temp::Label name() const                                = 0;
32 |   virtual const AccessList &formals() const                       = 0;
33 |   virtual VariableAccess allocateLocal(bool escapes)              = 0;
34 |   virtual ir::Statement procEntryExit1(const ir::Statement &body) = 0;
35 | 
36 | protected:
37 |   temp::Map &m_tempMap;
38 | };
39 | 
40 | } // namespace frame
41 | } // namespace tiger
42 | 


--------------------------------------------------------------------------------
/Chapter07/Program.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Fragment.h"
 3 | #include "Tree.h"
 4 | #include <boost/optional/optional_fwd.hpp>
 5 | #include <string>
 6 | 
 7 | namespace tiger {
 8 | 
 9 | using CompileResult = boost::optional<std::pair<ir::Expression, FragmentList>>;
10 | 
11 | CompileResult compileFile(const std::string &filename);
12 | 
13 | CompileResult compile(const std::string &string);
14 | 
15 | std::ostream &
16 |   operator<<(std::ostream &ost,
17 |              std::pair<ir::Expression, FragmentList> const &compileResult);
18 | 
19 | } // namespace tiger
20 | 


--------------------------------------------------------------------------------
/Chapter07/Skipper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "warning_suppress.h"
 3 | MSC_DIAG_OFF(4996 4459)
 4 | #include <boost/spirit/include/qi.hpp>
 5 | MSC_DIAG_ON()
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator>
 9 | class Skipper : public boost::spirit::qi::grammar<Iterator> {
10 | public:
11 |   Skipper() : Skipper::base_type(skip) {
12 |     namespace ascii = boost::spirit::ascii;
13 | 
14 |     using ascii::char_;
15 |     ascii::space_type space;
16 | 
17 |     skip = space                             // tab/space/cr/lf
18 |            | "/*" >> *(char_ - "*/") >> "*/" // comments
19 |       ;
20 |   }
21 | 
22 | private:
23 |   boost::spirit::qi::rule<Iterator> skip;
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter07/TempMap.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * temp.cpp - functions to create and manipulate Register variables which are
 3 |  *          used in the IR tree representation before it has been determined
 4 |  *          which variables are to go into registers.
 5 |  *
 6 |  */
 7 | 
 8 | #include "TempMap.h"
 9 | #include <boost/optional.hpp>
10 | #include <ostream>
11 | 
12 | namespace tiger {
13 | 
14 | namespace temp {
15 | 
16 | std::ostream &operator<<(std::ostream &ost, const Map &map) {
17 |   for (const auto &it : map.m_map) {
18 |     ost << "t" << it.first << " -> " << it.second << '\n';
19 |   }
20 |   if (map.m_under) {
21 |     ost << "---------\n";
22 |     ost << *map.m_under;
23 |   }
24 | 
25 |   return ost;
26 | }
27 | 
28 | void Map::layerOver(Map &&under) {
29 |   if (m_under) {
30 |     m_under->layerOver(std::move(under));
31 |   } else {
32 |     m_under.reset(&under);
33 |   }
34 | }
35 | 
36 | Register Map::newTemp() {
37 |   Register res{m_nextTemp};
38 |   m_map[res] = std::to_string(m_nextTemp++);
39 |   return res;
40 | }
41 | 
42 | boost::optional<std::string> Map::lookup(const Register &t) {
43 |   auto it = m_map.find(t);
44 |   if (it != m_map.end())
45 |     return it->second;
46 |   if (m_under)
47 |     return m_under->lookup(t);
48 |   return {};
49 | }
50 | 
51 | Label Map::newLabel() {
52 |   static const auto MIN_LABEL = 0;
53 |   static auto labels          = MIN_LABEL;
54 |   return Label{"L" + std::to_string(labels++)};
55 | }
56 | 
57 | Label Map::namedLabel(const std::string &name) { return Label{name}; }
58 | 
59 | } // namespace temp
60 | } // namespace tiger
61 | 


--------------------------------------------------------------------------------
/Chapter07/TempMap.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "strong_typedef.h"
 3 | #include <boost/optional/optional_fwd.hpp>
 4 | #include <iosfwd>
 5 | #include <memory>
 6 | #include <string>
 7 | #include <unordered_map>
 8 | 
 9 | namespace tiger {
10 | 
11 | namespace temp {
12 | 
13 | // a register is just a number
14 | using Register = helpers::strong_typedef<int>;
15 | 
16 | // a label is just a string
17 | using Label = helpers::strong_typedef<std::string>;
18 | 
19 | constexpr auto MIN_TEMP = 100;
20 | 
21 | // A Map is just a table whose keys are Temp_temps and whose bindings
22 | // are strings. However, one mapping can be layered over another; if σ3 =
23 | // layer(σ1, σ2), this means that look(σ3, t) will first try look(σ1, t), and if
24 | // that fails it will try look(σ2, t).Also, enter(σ3, t, a) will have the effect
25 | // of entering t->a into σ2.
26 | class Map {
27 | public:
28 |   void layerOver(Map &&under);
29 |   Register newTemp();
30 |   boost::optional<std::string> lookup(const Register &t);
31 |   friend std::ostream &operator<<(std::ostream &ost, const Map &map);
32 | 
33 |   Label newLabel();
34 |   Label namedLabel(const std::string &name);
35 | 
36 | private:
37 |   std::unordered_map<Register, std::string> m_map;
38 |   std::unique_ptr<Map> m_under;
39 |   int m_nextTemp = MIN_TEMP;
40 | };
41 | 
42 | } // namespace temp
43 | } // namespace tiger
44 | 


--------------------------------------------------------------------------------
/Chapter07/Types.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <boost/variant.hpp>
 4 | #include <string>
 5 | #include <unordered_map>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | struct NilType {};
11 | 
12 | struct IntType {};
13 | 
14 | struct StringType {};
15 | 
16 | struct ArrayType;
17 | 
18 | struct RecordType;
19 | 
20 | struct NameType {
21 |   std::string m_name;
22 | };
23 | 
24 | struct VoidType {};
25 | 
26 | using Type =
27 |   boost::variant<NilType, IntType, StringType,
28 |                  boost::recursive_wrapper<ArrayType>,
29 |                  boost::recursive_wrapper<RecordType>, NameType, VoidType>;
30 | 
31 | struct NamedType {
32 |   std::string m_name;
33 |   Type m_type;
34 | };
35 | 
36 | struct ArrayType {
37 |   NamedType m_elementType;
38 | };
39 | 
40 | struct RecordType {
41 |   struct RecordField {
42 |     std::string m_name;
43 |     NamedType m_type;
44 |   };
45 |   std::vector<RecordField> m_fields;
46 | };
47 | 
48 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter07/x64FastCall/CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../CallingConvention.h"
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | namespace x64FastCall {
 8 | class CallingConvention final : public frame::CallingConvention {
 9 | public:
10 |   CallingConvention(temp::Map &tempMap);
11 | 
12 |   virtual std::unique_ptr<frame::Frame>
13 |     createFrame(const temp::Label &name, const BoolList &formals) override;
14 | 
15 |   virtual int wordSize() const override;
16 | 
17 |   virtual temp::Register framePointer() const override;
18 | 
19 |   virtual temp::Register returnValue() const override;
20 | 
21 |   virtual ir::Expression
22 |     accessFrame(const VariableAccess &access,
23 |                 const ir::Expression &framePtr) const override;
24 | 
25 |   virtual void allocateString(temp::Label label,
26 |                               const std::string &str) override;
27 | 
28 |   virtual ir::Expression
29 |     externalCall(const std::string &name,
30 |                  const std::vector<ir::Expression> &args) override;
31 | };
32 | } // namespace x64FastCall
33 | } // namespace frame
34 | } // namespace tiger
35 | 


--------------------------------------------------------------------------------
/Chapter07/x64FastCall/Frame.cpp:
--------------------------------------------------------------------------------
 1 | #include "Frame.h"
 2 | #include "variantMatch.h"
 3 | #include <boost/dynamic_bitset.hpp>
 4 | #include <cassert>
 5 | 
 6 | namespace tiger {
 7 | namespace frame {
 8 | namespace x64FastCall {
 9 | 
10 | std::array<Registers, Frame::MAX_REGS> Frame::m_regParams = {
11 |   Registers::RCX, Registers::RDX, Registers::R8, Registers::R9};
12 | 
13 | Frame::Frame(temp::Map &tempMap, const temp::Label &name,
14 |              const BoolList &formals) :
15 |     frame::Frame(tempMap),
16 |     m_name(name) {
17 |   for (size_t i = 0; i < formals.size(); ++i) {
18 |     auto varAccess = [this](bool escapes) -> VariableAccess {
19 |       if (escapes || m_allocatedRegs == MAX_REGS) {
20 |         auto res = InFrame{m_frameOffset};
21 |         m_frameOffset -= WORD_SIZE;
22 |         return res;
23 |       }
24 | 
25 |       assert(m_allocatedRegs < MAX_REGS);
26 |       return InReg{reg(m_regParams[m_allocatedRegs++])};
27 |     }(formals[i]);
28 |     m_formals.push_back(varAccess);
29 |   }
30 | }
31 | 
32 | temp::Label Frame::name() const { return m_name; }
33 | 
34 | const AccessList &Frame::formals() const { return m_formals; }
35 | 
36 | VariableAccess Frame::allocateLocal(bool escapes) {
37 |   if (escapes) {
38 |     auto res = InFrame{m_frameOffset};
39 |     m_frameOffset -= WORD_SIZE;
40 |     return res;
41 |   }
42 | 
43 |   return InReg{m_tempMap.newTemp()};
44 | }
45 | 
46 | ir::Statement Frame::procEntryExit1(const ir::Statement &body) { return body; }
47 | 
48 | } // namespace x64FastCall
49 | } // namespace frame
50 | } // namespace tiger
51 | 


--------------------------------------------------------------------------------
/Chapter07/x64FastCall/Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../Frame.h"
 4 | #include "Registers.h"
 5 | #include <array>
 6 | 
 7 | namespace tiger {
 8 | namespace frame {
 9 | namespace x64FastCall {
10 | // implements
11 | // https://docs.microsoft.com/en-gb/cpp/build/overview-of-x64-calling-conventions
12 | class Frame final : public frame::Frame {
13 | public:
14 |   static const int WORD_SIZE = 8;
15 | 
16 |   Frame(temp::Map &tempMap, const temp::Label &name, const BoolList &formals);
17 | 
18 |   // Inherited via Frame
19 |   virtual temp::Label name() const override;
20 | 
21 |   virtual const AccessList &formals() const override;
22 | 
23 |   virtual VariableAccess allocateLocal(bool escapes) override;
24 | 
25 |   virtual ir::Statement procEntryExit1(const ir::Statement &body) override;
26 | 
27 | private:
28 |   temp::Label m_name;
29 |   AccessList m_formals;
30 |   int m_frameOffset = -WORD_SIZE;
31 |   // The __fastcall convention uses registers for the first four arguments
32 |   static const size_t MAX_REGS = 4;
33 |   static std::array<Registers, MAX_REGS> m_regParams;
34 |   size_t m_allocatedRegs = 0;
35 | };
36 | } // namespace x64FastCall
37 | } // namespace frame
38 | } // namespace tiger
39 | 


--------------------------------------------------------------------------------
/Chapter07/x64FastCall/Registers.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "../TempMap.h"
 3 | 
 4 | namespace tiger {
 5 | namespace frame {
 6 | namespace x64FastCall {
 7 | 
 8 | enum class Registers {
 9 |   RAX,
10 |   RDX,
11 |   RCX,
12 |   RBX,
13 |   RSI,
14 |   RDI,
15 |   RBP,
16 |   RSP,
17 |   R8,
18 |   R9,
19 |   R10,
20 |   R11,
21 |   R12,
22 |   R13,
23 |   R14,
24 |   R15,
25 |   RIP,
26 |   MM0,
27 |   MM1,
28 |   MM2,
29 |   MM3,
30 |   MM4,
31 |   MM5,
32 |   MM6,
33 |   MM7,
34 |   FP0,
35 |   FP1,
36 |   FP2,
37 |   FP3,
38 |   FP4,
39 |   FP5,
40 |   FP6,
41 |   FP7,
42 |   XMM8,
43 |   XMM9,
44 |   XMM10,
45 |   XMM11,
46 |   XMM12,
47 |   XMM13,
48 |   XMM14,
49 |   XMM15,
50 |   XMM16,
51 |   XMM17,
52 |   XMM18,
53 |   XMM19,
54 |   XMM20,
55 |   XMM21,
56 |   XMM22,
57 |   XMM23,
58 |   XMM24,
59 |   XMM25,
60 |   XMM26,
61 |   XMM27,
62 |   XMM28,
63 |   XMM29,
64 |   XMM30,
65 |   XMM31,
66 |   Size
67 | };
68 | 
69 | constexpr temp::Register reg(Registers reg) {
70 |   return temp::Register{static_cast<int>(reg)};
71 | }
72 | 
73 | static_assert(static_cast<int>(Registers::Size) <= temp::MIN_TEMP,
74 |               "MIN_TEMP should be greater than the greatest register");
75 | } // namespace x64FastCall
76 | } // namespace frame
77 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter08/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES Program.cpp Test.cpp SemanticAnalyzer.cpp TempMap.cpp EscapeAnalyser.cpp Translator.cpp Tree.cpp Canonicalizer.cpp)
 2 | set(HEADERS Program.h ErrorHandler.h ExpressionParser.h Skipper.h IdentifierParser.h DeclerationParser.h AbstractSyntaxTree.h 
 3 |   Annotation.h StringParser.h SemanticAnalyzer.h Types.h TempMap.h Frame.h CallingConvention.h EscapeAnalyser.h Translator.h Tree.h 
 4 |   Fragment.h  Canonicalizer.h)
 5 | list(APPEND SOURCES x64FastCall/Frame.cpp x64FastCall/CallingConvention.cpp)
 6 | list(APPEND HEADERS x64FastCall/Frame.h x64FastCall/Frame.cpp)
 7 | 
 8 | add_executable(Chapter08 ${HEADERS} ${SOURCES})
 9 | 
10 | target_compile_definitions(Chapter08 PRIVATE CATCH_CPP14_OR_GREATER)
11 | 
12 | if(MSVC)
13 | 	set_source_files_properties(Program.cpp PROPERTIES COMPILE_FLAGS /bigobj)
14 | elseif(CMAKE_CXX_COMPILER_ID STREQUAL Clang)
15 |   # https://stackoverflow.com/a/23376156/621176
16 |   set_source_files_properties(Test.cpp PROPERTIES COMPILE_FLAGS -ftemplate-depth=1024)
17 | endif()
18 | 
19 | target_link_libraries(Chapter08 
20 |     PRIVATE 
21 |         Boost::boost 
22 |         Boost::filesystem 
23 |         Boost::system
24 |         Catch2::Catch 
25 |         includeHeaders
26 | )
27 | 
28 | parse_unit_tests(Chapter08 --timeout 10)
29 | 


--------------------------------------------------------------------------------
/Chapter08/CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #include "Frame.h"
 2 | 
 3 | namespace tiger {
 4 | namespace frame {
 5 | class CallingConvention {
 6 | public:
 7 |   CallingConvention(temp::Map &tempMap) : m_tempMap(tempMap) {}
 8 | 
 9 |   virtual ~CallingConvention() = default;
10 | 
11 |   virtual std::unique_ptr<Frame> createFrame(const temp::Label &name,
12 |                                              const BoolList &formals) = 0;
13 |   virtual int wordSize() const                                        = 0;
14 | 
15 |   virtual temp::Register framePointer() const = 0;
16 | 
17 |   virtual temp::Register returnValue() const = 0;
18 | 
19 |   virtual ir::Expression accessFrame(const VariableAccess &access,
20 |                                      const ir::Expression &framePtr) const = 0;
21 | 
22 |   virtual void allocateString(temp::Label label, const std::string &str) = 0;
23 | 
24 |   virtual ir::Expression
25 |     externalCall(const std::string &name,
26 |                  const std::vector<ir::Expression> &args) = 0;
27 | 
28 | protected:
29 |   temp::Map &m_tempMap;
30 | };
31 | } // namespace frame
32 | } // namespace tiger
33 | 


--------------------------------------------------------------------------------
/Chapter08/ErrorHandler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/spirit/include/classic_position_iterator.hpp>
 3 | #include <iomanip>
 4 | #include <sstream>
 5 | #include <stdexcept>
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator> class ErrorHandler {
 9 | public:
10 |   template <typename, typename, typename> struct result { typedef void type; };
11 | 
12 |   template <typename Message, typename What>
13 |   void operator()(Message const &message, What const &what,
14 |                   Iterator err_pos) const {
15 |     class TigerError : public std::logic_error {
16 |       using std::logic_error::logic_error;
17 |     };
18 |     const auto &pos = err_pos.get_position();
19 |     std::stringstream sst;
20 |     sst << pos.file << "(" << pos.line << "," << pos.column << "): " << message
21 |         << ": " << what << '\n';
22 |     sst << "'";
23 |     std::copy(err_pos.get_currentline_begin(), err_pos.get_currentline_end(),
24 |               std::ostream_iterator<char>(sst));
25 |     sst << "'\n";
26 |     sst << std::setw(pos.column) << " "
27 |         << "^- here\n";
28 |     throw TigerError{sst.str()};
29 |   }
30 | };
31 | } // namespace tiger
32 | 


--------------------------------------------------------------------------------
/Chapter08/Fragment.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Tree.h"
 3 | #include <memory>
 4 | 
 5 | namespace tiger {
 6 | 
 7 | namespace frame {
 8 | class Frame;
 9 | }
10 | 
11 | struct StringFragment {
12 |   temp::Label m_label;
13 |   std::string m_string;
14 | };
15 | 
16 | struct FunctionFragment {
17 |   ir::Statement m_body;
18 |   std::shared_ptr<const frame::Frame> m_frame;
19 | };
20 | 
21 | using Fragment     = boost::variant<StringFragment, FunctionFragment>;
22 | using FragmentList = std::vector<Fragment>;
23 | } // namespace tiger
24 | 


--------------------------------------------------------------------------------
/Chapter08/Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | #include "Tree.h"
 4 | #include <boost/dynamic_bitset_fwd.hpp>
 5 | #include <boost/variant.hpp>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | namespace frame {
11 | 
12 | using BoolList = boost::dynamic_bitset<>;
13 | 
14 | struct InFrame {
15 |   int m_offset;
16 | };
17 | 
18 | struct InReg {
19 |   temp::Register m_reg;
20 | };
21 | 
22 | using VariableAccess = boost::variant<InFrame, InReg>;
23 | using AccessList     = std::vector<VariableAccess>;
24 | 
25 | class Frame {
26 | public:
27 |   Frame(temp::Map &tempMap) : m_tempMap(tempMap) {}
28 | 
29 |   virtual ~Frame() noexcept = default;
30 | 
31 |   virtual temp::Label name() const                                = 0;
32 |   virtual const AccessList &formals() const                       = 0;
33 |   virtual VariableAccess allocateLocal(bool escapes)              = 0;
34 |   virtual ir::Statement procEntryExit1(const ir::Statement &body) = 0;
35 | 
36 | protected:
37 |   temp::Map &m_tempMap;
38 | };
39 | 
40 | } // namespace frame
41 | } // namespace tiger
42 | 


--------------------------------------------------------------------------------
/Chapter08/Program.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Fragment.h"
 3 | #include "Tree.h"
 4 | #include <boost/optional/optional_fwd.hpp>
 5 | #include <string>
 6 | 
 7 | namespace tiger {
 8 | 
 9 | using CompileResult = boost::optional<ir::Statements>;
10 | 
11 | CompileResult compileFile(const std::string &filename);
12 | 
13 | CompileResult compile(const std::string &string);
14 | 
15 | std::ostream &
16 |   operator<<(std::ostream &ost,
17 |              std::pair<ir::Expression, FragmentList> const &compileResult);
18 | 
19 | } // namespace tiger
20 | 


--------------------------------------------------------------------------------
/Chapter08/Skipper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "warning_suppress.h"
 3 | MSC_DIAG_OFF(4996 4459)
 4 | #include <boost/spirit/include/qi.hpp>
 5 | MSC_DIAG_ON()
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator>
 9 | class Skipper : public boost::spirit::qi::grammar<Iterator> {
10 | public:
11 |   Skipper() : Skipper::base_type(skip) {
12 |     namespace ascii = boost::spirit::ascii;
13 | 
14 |     using ascii::char_;
15 |     ascii::space_type space;
16 | 
17 |     skip = space                             // tab/space/cr/lf
18 |            | "/*" >> *(char_ - "*/") >> "*/" // comments
19 |       ;
20 |   }
21 | 
22 | private:
23 |   boost::spirit::qi::rule<Iterator> skip;
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter08/TempMap.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * temp.cpp - functions to create and manipulate Register variables which are
 3 |  *          used in the IR tree representation before it has been determined
 4 |  *          which variables are to go into registers.
 5 |  *
 6 |  */
 7 | 
 8 | #include "TempMap.h"
 9 | #include <boost/optional.hpp>
10 | #include <ostream>
11 | 
12 | namespace tiger {
13 | 
14 | namespace temp {
15 | 
16 | std::ostream &operator<<(std::ostream &ost, const Map &map) {
17 |   for (const auto &it : map.m_map) {
18 |     ost << "t" << it.first << " -> " << it.second << '\n';
19 |   }
20 |   if (map.m_under) {
21 |     ost << "---------\n";
22 |     ost << *map.m_under;
23 |   }
24 | 
25 |   return ost;
26 | }
27 | 
28 | void Map::layerOver(Map &&under) {
29 |   if (m_under) {
30 |     m_under->layerOver(std::move(under));
31 |   } else {
32 |     m_under.reset(&under);
33 |   }
34 | }
35 | 
36 | Register Map::newTemp() {
37 |   Register res{m_nextTemp};
38 |   m_map[res] = std::to_string(m_nextTemp++);
39 |   return res;
40 | }
41 | 
42 | boost::optional<std::string> Map::lookup(const Register &t) {
43 |   auto it = m_map.find(t);
44 |   if (it != m_map.end())
45 |     return it->second;
46 |   if (m_under)
47 |     return m_under->lookup(t);
48 |   return {};
49 | }
50 | 
51 | Label Map::newLabel() {
52 |   static const auto MIN_LABEL = 0;
53 |   static auto labels          = MIN_LABEL;
54 |   return Label{"L" + std::to_string(labels++)};
55 | }
56 | 
57 | Label Map::namedLabel(const std::string &name) { return Label{name}; }
58 | 
59 | } // namespace temp
60 | } // namespace tiger
61 | 


--------------------------------------------------------------------------------
/Chapter08/TempMap.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "strong_typedef.h"
 3 | #include <boost/optional/optional_fwd.hpp>
 4 | #include <iosfwd>
 5 | #include <memory>
 6 | #include <string>
 7 | #include <unordered_map>
 8 | 
 9 | namespace tiger {
10 | 
11 | namespace temp {
12 | 
13 | // a register is just a number
14 | using Register = helpers::strong_typedef<int>;
15 | 
16 | // a label is just a string
17 | using Label = helpers::strong_typedef<std::string>;
18 | 
19 | constexpr auto MIN_TEMP = 100;
20 | 
21 | // A Map is just a table whose keys are Temp_temps and whose bindings
22 | // are strings. However, one mapping can be layered over another; if σ3 =
23 | // layer(σ1, σ2), this means that look(σ3, t) will first try look(σ1, t), and if
24 | // that fails it will try look(σ2, t).Also, enter(σ3, t, a) will have the effect
25 | // of entering t->a into σ2.
26 | class Map {
27 | public:
28 |   void layerOver(Map &&under);
29 |   Register newTemp();
30 |   boost::optional<std::string> lookup(const Register &t);
31 |   friend std::ostream &operator<<(std::ostream &ost, const Map &map);
32 | 
33 |   Label newLabel();
34 |   Label namedLabel(const std::string &name);
35 | 
36 | private:
37 |   std::unordered_map<Register, std::string> m_map;
38 |   std::unique_ptr<Map> m_under;
39 |   int m_nextTemp = MIN_TEMP;
40 | };
41 | 
42 | } // namespace temp
43 | } // namespace tiger
44 | 


--------------------------------------------------------------------------------
/Chapter08/Types.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <boost/variant.hpp>
 4 | #include <string>
 5 | #include <unordered_map>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | struct NilType {};
11 | 
12 | struct IntType {};
13 | 
14 | struct StringType {};
15 | 
16 | struct ArrayType;
17 | 
18 | struct RecordType;
19 | 
20 | struct NameType {
21 |   std::string m_name;
22 | };
23 | 
24 | struct VoidType {};
25 | 
26 | using Type =
27 |   boost::variant<NilType, IntType, StringType,
28 |                  boost::recursive_wrapper<ArrayType>,
29 |                  boost::recursive_wrapper<RecordType>, NameType, VoidType>;
30 | 
31 | struct NamedType {
32 |   std::string m_name;
33 |   Type m_type;
34 | };
35 | 
36 | struct ArrayType {
37 |   NamedType m_elementType;
38 | };
39 | 
40 | struct RecordType {
41 |   struct RecordField {
42 |     std::string m_name;
43 |     NamedType m_type;
44 |   };
45 |   std::vector<RecordField> m_fields;
46 | };
47 | 
48 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter08/x64FastCall/CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../CallingConvention.h"
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | namespace x64FastCall {
 8 | class CallingConvention final : public frame::CallingConvention {
 9 | public:
10 |   CallingConvention(temp::Map &tempMap);
11 | 
12 |   virtual std::unique_ptr<frame::Frame>
13 |     createFrame(const temp::Label &name, const BoolList &formals) override;
14 | 
15 |   virtual int wordSize() const override;
16 | 
17 |   virtual temp::Register framePointer() const override;
18 | 
19 |   virtual temp::Register returnValue() const override;
20 | 
21 |   virtual ir::Expression
22 |     accessFrame(const VariableAccess &access,
23 |                 const ir::Expression &framePtr) const override;
24 | 
25 |   virtual void allocateString(temp::Label label,
26 |                               const std::string &str) override;
27 | 
28 |   virtual ir::Expression
29 |     externalCall(const std::string &name,
30 |                  const std::vector<ir::Expression> &args) override;
31 | };
32 | } // namespace x64FastCall
33 | } // namespace frame
34 | } // namespace tiger
35 | 


--------------------------------------------------------------------------------
/Chapter08/x64FastCall/Frame.cpp:
--------------------------------------------------------------------------------
 1 | #include "Frame.h"
 2 | #include "variantMatch.h"
 3 | #include <boost/dynamic_bitset.hpp>
 4 | #include <cassert>
 5 | 
 6 | namespace tiger {
 7 | namespace frame {
 8 | namespace x64FastCall {
 9 | 
10 | std::array<Registers, Frame::MAX_REGS> Frame::m_regParams = {
11 |   Registers::RCX, Registers::RDX, Registers::R8, Registers::R9};
12 | 
13 | Frame::Frame(temp::Map &tempMap, const temp::Label &name,
14 |              const BoolList &formals) :
15 |     frame::Frame(tempMap),
16 |     m_name(name) {
17 |   for (size_t i = 0; i < formals.size(); ++i) {
18 |     auto varAccess = [this](bool escapes) -> VariableAccess {
19 |       if (escapes || m_allocatedRegs == MAX_REGS) {
20 |         auto res = InFrame{m_frameOffset};
21 |         m_frameOffset -= WORD_SIZE;
22 |         return res;
23 |       }
24 | 
25 |       assert(m_allocatedRegs < MAX_REGS);
26 |       return InReg{reg(m_regParams[m_allocatedRegs++])};
27 |     }(formals[i]);
28 |     m_formals.push_back(varAccess);
29 |   }
30 | }
31 | 
32 | temp::Label Frame::name() const { return m_name; }
33 | 
34 | const AccessList &Frame::formals() const { return m_formals; }
35 | 
36 | VariableAccess Frame::allocateLocal(bool escapes) {
37 |   if (escapes) {
38 |     auto res = InFrame{m_frameOffset};
39 |     m_frameOffset -= WORD_SIZE;
40 |     return res;
41 |   }
42 | 
43 |   return InReg{m_tempMap.newTemp()};
44 | }
45 | 
46 | ir::Statement Frame::procEntryExit1(const ir::Statement &body) { return body; }
47 | 
48 | } // namespace x64FastCall
49 | } // namespace frame
50 | } // namespace tiger
51 | 


--------------------------------------------------------------------------------
/Chapter08/x64FastCall/Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../Frame.h"
 4 | #include "Registers.h"
 5 | #include <array>
 6 | 
 7 | namespace tiger {
 8 | namespace frame {
 9 | namespace x64FastCall {
10 | // implements
11 | // https://docs.microsoft.com/en-gb/cpp/build/overview-of-x64-calling-conventions
12 | class Frame final : public frame::Frame {
13 | public:
14 |   static const int WORD_SIZE = 8;
15 | 
16 |   Frame(temp::Map &tempMap, const temp::Label &name, const BoolList &formals);
17 | 
18 |   // Inherited via Frame
19 |   virtual temp::Label name() const override;
20 | 
21 |   virtual const AccessList &formals() const override;
22 | 
23 |   virtual VariableAccess allocateLocal(bool escapes) override;
24 | 
25 |   virtual ir::Statement procEntryExit1(const ir::Statement &body) override;
26 | 
27 | private:
28 |   temp::Label m_name;
29 |   AccessList m_formals;
30 |   int m_frameOffset = -WORD_SIZE;
31 |   // The __fastcall convention uses registers for the first four arguments
32 |   static const size_t MAX_REGS = 4;
33 |   static std::array<Registers, MAX_REGS> m_regParams;
34 |   size_t m_allocatedRegs = 0;
35 | };
36 | } // namespace x64FastCall
37 | } // namespace frame
38 | } // namespace tiger
39 | 


--------------------------------------------------------------------------------
/Chapter08/x64FastCall/Registers.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "../TempMap.h"
 3 | 
 4 | namespace tiger {
 5 | namespace frame {
 6 | namespace x64FastCall {
 7 | 
 8 | enum class Registers {
 9 |   RAX,
10 |   RDX,
11 |   RCX,
12 |   RBX,
13 |   RSI,
14 |   RDI,
15 |   RBP,
16 |   RSP,
17 |   R8,
18 |   R9,
19 |   R10,
20 |   R11,
21 |   R12,
22 |   R13,
23 |   R14,
24 |   R15,
25 |   RIP,
26 |   MM0,
27 |   MM1,
28 |   MM2,
29 |   MM3,
30 |   MM4,
31 |   MM5,
32 |   MM6,
33 |   MM7,
34 |   FP0,
35 |   FP1,
36 |   FP2,
37 |   FP3,
38 |   FP4,
39 |   FP5,
40 |   FP6,
41 |   FP7,
42 |   XMM8,
43 |   XMM9,
44 |   XMM10,
45 |   XMM11,
46 |   XMM12,
47 |   XMM13,
48 |   XMM14,
49 |   XMM15,
50 |   XMM16,
51 |   XMM17,
52 |   XMM18,
53 |   XMM19,
54 |   XMM20,
55 |   XMM21,
56 |   XMM22,
57 |   XMM23,
58 |   XMM24,
59 |   XMM25,
60 |   XMM26,
61 |   XMM27,
62 |   XMM28,
63 |   XMM29,
64 |   XMM30,
65 |   XMM31,
66 |   Size
67 | };
68 | 
69 | constexpr temp::Register reg(Registers reg) {
70 |   return temp::Register{static_cast<int>(reg)};
71 | }
72 | 
73 | static_assert(static_cast<int>(Registers::Size) <= temp::MIN_TEMP,
74 |               "MIN_TEMP should be greater than the greatest register");
75 | } // namespace x64FastCall
76 | } // namespace frame
77 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(CHAPTER Chapter09)
 2 | 
 3 | macro(add_machine name) 
 4 |   add_subdirectory(${name})
 5 |   list(APPEND MACHINES ${name})
 6 |   list(APPEND MACHINE_LIBRARIES ${CHAPTER}_${name})
 7 | endmacro()
 8 | 
 9 | add_machine(m68k)
10 | add_machine(x64)
11 | 
12 | foreach(machine ${MACHINES})
13 |   string(TOLOWER ${machine} machineLower)
14 |   string(APPEND MACHINE_INCLUDES "#include \"${machine}/${machine}Machine.h\"\n")
15 |   string(APPEND MACHINE_REGISTRATIONS "REGISTER_MACHINE(${machine}, tiger::${machineLower}::Machine)\n")
16 | endforeach()
17 | 
18 | configure_file(MachineRegistration.h.in MachineRegistration.h)
19 | 
20 | set(SOURCES Program.cpp SemanticAnalyzer.cpp TempMap.cpp EscapeAnalyser.cpp Translator.cpp Tree.cpp Canonicalizer.cpp Assembly.cpp 
21 |   CodeGenerator.cpp CallingConvention.cpp)
22 | set(HEADERS Program.h ErrorHandler.h ExpressionParser.h Skipper.h IdentifierParser.h DeclerationParser.h AbstractSyntaxTree.h 
23 |   Annotation.h StringParser.h SemanticAnalyzer.h Types.h TempMap.h Frame.h CallingConvention.h EscapeAnalyser.h Translator.h Tree.h 
24 |   Fragment.h  Canonicalizer.h Assembly.h CodeGenerator.h MachineRegistrar.h)
25 | 
26 | add_library(Chapter09 ${HEADERS} ${SOURCES})
27 | 
28 | target_include_directories(Chapter09 
29 |   PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} 
30 |   PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
31 | )
32 | 
33 | if(MSVC)
34 | 	set_source_files_properties(Program.cpp PROPERTIES COMPILE_FLAGS /bigobj)
35 | endif()
36 | 
37 | target_link_libraries(Chapter09 
38 |   PRIVATE
39 |     ${MACHINE_LIBRARIES}
40 |   PUBLIC
41 |     Boost::boost 
42 |     includeHeaders
43 |     range-v3::range-v3
44 | )
45 | 
46 | add_subdirectory(test)
47 | 


--------------------------------------------------------------------------------
/Chapter09/CallingConvention.cpp:
--------------------------------------------------------------------------------
 1 | #include "CallingConvention.h"
 2 | #include "Assembly.h"
 3 | #include <range/v3/view.hpp>
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | 
 8 | ir::Expression
 9 |   CallingConvention::accessFrame(const VariableAccess &access,
10 |                                  const ir::Expression &framePtr) const {
11 |   using helpers::match;
12 |   return match(access)(
13 |     [](const frame::InReg &inReg) -> ir::Expression { return inReg.m_reg; },
14 |     [&framePtr](const frame::InFrame &inFrame) -> ir::Expression {
15 |       return ir::MemoryAccess{
16 |         ir::BinaryOperation{ir::BinOp::PLUS, framePtr, inFrame.m_offset}};
17 |     });
18 | }
19 | 
20 | ir::Expression
21 |   CallingConvention::externalCall(const temp::Label &name,
22 |                                   const std::vector<ir::Expression> &args) {
23 |   return ir::Call{name, args};
24 | }
25 | 
26 | assembly::Instructions
27 |   CallingConvention::procEntryExit2(const assembly::Instructions &body) const {
28 |   // appends a “sink” instruction to the function body to tell the
29 |   // register allocator that certain registers are live at procedure exit
30 |   namespace rv     = ranges::view;
31 |   auto calleeSaved = calleeSavedRegisters();
32 |   auto liveAtExit  = rv::concat(calleeSaved, rv::single(returnValue()),
33 |                                rv::single(stackPointer()));
34 | #ifdef _MSC_VER
35 |   auto res = body;
36 |   res.push_back(assembly::Operation{{}, {}, liveAtExit});
37 |   return res;
38 | #else
39 |   return ranges::view::concat(
40 |     body, rv::single(assembly::Operation{{}, {}, liveAtExit}));
41 | #endif
42 | }
43 | 
44 | } // namespace frame
45 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Frame.h"
 3 | 
 4 | namespace tiger {
 5 | namespace assembly {
 6 | struct Instruction;
 7 | using Instructions = std::vector<Instruction>;
 8 | using Registers    = std::vector<temp::Register>;
 9 | } // namespace assembly
10 | 
11 | namespace frame {
12 | class CallingConvention {
13 | public:
14 |   virtual ~CallingConvention() = default;
15 | 
16 |   virtual std::unique_ptr<Frame> createFrame(temp::Map &tempMap,
17 |                                              const temp::Label &name,
18 |                                              const BoolList &formals) = 0;
19 |   virtual int wordSize() const                                        = 0;
20 | 
21 |   virtual temp::Register framePointer() const = 0;
22 | 
23 |   virtual temp::Register returnValue() const = 0;
24 | 
25 |   virtual temp::Register stackPointer() const = 0;
26 | 
27 |   virtual assembly::Registers callDefinedRegisters() const = 0;
28 | 
29 |   virtual assembly::Registers calleeSavedRegisters() const = 0;
30 | 
31 |   virtual assembly::Registers argumentRegisters() const = 0;
32 | 
33 |   ir::Expression accessFrame(const VariableAccess &access,
34 |                              const ir::Expression &framePtr) const;
35 | 
36 |   ir::Expression externalCall(const temp::Label &name,
37 |                               const std::vector<ir::Expression> &args);
38 | 
39 |   // calculate register liveness
40 |   assembly::Instructions
41 |     procEntryExit2(const assembly::Instructions &body) const;
42 | };
43 | } // namespace frame
44 | } // namespace tiger
45 | 


--------------------------------------------------------------------------------
/Chapter09/ErrorHandler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/spirit/include/classic_position_iterator.hpp>
 3 | #include <iomanip>
 4 | #include <sstream>
 5 | #include <stdexcept>
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator> class ErrorHandler {
 9 | public:
10 |   template <typename, typename, typename> struct result { typedef void type; };
11 | 
12 |   template <typename Message, typename What>
13 |   void operator()(Message const &message, What const &what,
14 |                   Iterator err_pos) const {
15 |     class TigerError : public std::logic_error {
16 |       using std::logic_error::logic_error;
17 |     };
18 |     const auto &pos = err_pos.get_position();
19 |     std::stringstream sst;
20 |     sst << pos.file << "(" << pos.line << "," << pos.column << "): " << message
21 |         << ": " << what << '\n';
22 |     sst << "'";
23 |     std::copy(err_pos.get_currentline_begin(), err_pos.get_currentline_end(),
24 |               std::ostream_iterator<char>(sst));
25 |     sst << "'\n";
26 |     sst << std::setw(pos.column) << " "
27 |         << "^- here\n";
28 |     throw TigerError{sst.str()};
29 |   }
30 | };
31 | } // namespace tiger
32 | 


--------------------------------------------------------------------------------
/Chapter09/Fragment.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Tree.h"
 3 | #include <memory>
 4 | 
 5 | namespace tiger {
 6 | 
 7 | namespace frame {
 8 | class Frame;
 9 | }
10 | 
11 | struct StringFragment {
12 |   temp::Label m_label;
13 |   std::string m_string;
14 | };
15 | 
16 | struct FunctionFragment {
17 |   ir::Statement m_body;
18 |   std::shared_ptr<const frame::Frame> m_frame;
19 | };
20 | 
21 | using Fragment     = boost::variant<StringFragment, FunctionFragment>;
22 | using FragmentList = std::vector<Fragment>;
23 | } // namespace tiger
24 | 


--------------------------------------------------------------------------------
/Chapter09/Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | #include "Tree.h"
 4 | #include <boost/dynamic_bitset_fwd.hpp>
 5 | #include <boost/variant.hpp>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | namespace assembly {
11 | struct Instruction;
12 | using Instructions = std::vector<Instruction>;
13 | } // namespace assembly
14 | 
15 | namespace frame {
16 | 
17 | using BoolList = boost::dynamic_bitset<>;
18 | 
19 | struct InFrame {
20 |   int m_offset;
21 | };
22 | 
23 | struct InReg {
24 |   temp::Register m_reg;
25 | };
26 | 
27 | using VariableAccess = boost::variant<InFrame, InReg>;
28 | using AccessList     = std::vector<VariableAccess>;
29 | 
30 | class Frame {
31 | public:
32 |   Frame(temp::Map &tempMap) : m_tempMap(tempMap) {}
33 | 
34 |   virtual ~Frame() noexcept = default;
35 | 
36 |   virtual temp::Label name() const                   = 0;
37 |   virtual const AccessList &formals() const          = 0;
38 |   virtual VariableAccess allocateLocal(bool escapes) = 0;
39 |   // move input parameters to the function frame
40 |   // store and restore callee saved registers
41 |   virtual ir::Statement procEntryExit1(const ir::Statement &body) const = 0;
42 |   // add prolog and epilog
43 |   virtual assembly::Instructions
44 |     procEntryExit3(const assembly::Instructions &body) const = 0;
45 | 
46 | protected:
47 |   temp::Map &m_tempMap;
48 | };
49 | 
50 | } // namespace frame
51 | } // namespace tiger
52 | 


--------------------------------------------------------------------------------
/Chapter09/Machine.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | #include <vector>
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | class CallingConvention;
 8 | }
 9 | 
10 | namespace assembly {
11 | class CodeGenerator;
12 | } // namespace assembly
13 | 
14 | class Machine {
15 | public:
16 |   virtual ~Machine() = default;
17 | 
18 |   virtual temp::PredefinedRegisters predefinedRegisters() = 0;
19 | 
20 |   virtual frame::CallingConvention &callingConvention()             = 0;
21 |   virtual const frame::CallingConvention &callingConvention() const = 0;
22 | 
23 |   virtual assembly::CodeGenerator &codeGenerator()             = 0;
24 |   virtual const assembly::CodeGenerator &codeGenerator() const = 0;
25 | };
26 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/MachineRegistrar.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Machine.h"
 3 | #include <functional>
 4 | #include <map>
 5 | #include <stdexcept>
 6 | 
 7 | #define REGISTER_MACHINE(name, type)                                           \
 8 |                                                                                \
 9 |   namespace {                                                                  \
10 |   tiger::AutoRegistrar<type> registered_##name(#name);                         \
11 |   }
12 | 
13 | namespace tiger {
14 | 
15 | using MachineRegistrar =
16 |   std::map<std::string, std::function<std::unique_ptr<Machine>()>>;
17 | 
18 | MachineRegistrar &machineRegistrar() {
19 |   static MachineRegistrar registrar;
20 |   return registrar;
21 | }
22 | 
23 | struct NoSuchArchError : std::logic_error {
24 |   using std::logic_error::logic_error;
25 | };
26 | 
27 | template <typename Creator>
28 | inline void registerMachine(const std::string &arch, Creator &&creator) {
29 |   machineRegistrar()[arch] = std::forward<Creator>(creator);
30 | }
31 | 
32 | template <typename ArchMachine> struct AutoRegistrar {
33 |   AutoRegistrar(const std::string &arch) {
34 |     registerMachine(arch, []() { return std::make_unique<ArchMachine>(); });
35 |   }
36 | };
37 | 
38 | inline std::unique_ptr<Machine> createMachine(const std::string &arch) {
39 |   auto it = machineRegistrar().find(arch);
40 |   if (it == machineRegistrar().end()) {
41 |     throw NoSuchArchError{"no machine named " + arch};
42 |   }
43 |   return it->second();
44 | }
45 | 
46 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/MachineRegistration.h.in:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include "MachineRegistrar.h"
3 | @MACHINE_INCLUDES@
4 | 
5 | @MACHINE_REGISTRATIONS@


--------------------------------------------------------------------------------
/Chapter09/Program.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Assembly.h"
 3 | #include "Fragment.h"
 4 | #include <boost/optional/optional_fwd.hpp>
 5 | #include <string>
 6 | 
 7 | namespace tiger {
 8 | 
 9 | using CompileResult = boost::optional<std::string>;
10 | 
11 | CompileResult compileFile(const std::string &arch, const std::string &filename);
12 | 
13 | CompileResult compile(const std::string &arch, const std::string &string);
14 | 
15 | } // namespace tiger
16 | 


--------------------------------------------------------------------------------
/Chapter09/Skipper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "warning_suppress.h"
 3 | MSC_DIAG_OFF(4996 4459)
 4 | #include <boost/spirit/include/qi.hpp>
 5 | MSC_DIAG_ON()
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator>
 9 | class Skipper : public boost::spirit::qi::grammar<Iterator> {
10 | public:
11 |   Skipper() : Skipper::base_type(skip) {
12 |     namespace ascii = boost::spirit::ascii;
13 | 
14 |     using ascii::char_;
15 |     ascii::space_type space;
16 | 
17 |     skip = space                             // tab/space/cr/lf
18 |            | "/*" >> *(char_ - "*/") >> "*/" // comments
19 |       ;
20 |   }
21 | 
22 | private:
23 |   boost::spirit::qi::rule<Iterator> skip;
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/TempMap.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "strong_typedef.h"
 3 | #include <boost/optional/optional_fwd.hpp>
 4 | #include <iosfwd>
 5 | #include <memory>
 6 | #include <string>
 7 | #include <unordered_map>
 8 | #include <vector>
 9 | 
10 | namespace tiger {
11 | 
12 | namespace temp {
13 | 
14 | // a register is just a number
15 | using Register = helpers::strong_typedef<int>;
16 | 
17 | // a label is just a string
18 | using Label = helpers::strong_typedef<std::string>;
19 | 
20 | using PredefinedRegisters = std::vector<std::pair<Register, std::string>>;
21 | 
22 | constexpr auto MIN_TEMP = 100;
23 | 
24 | // A Map is just a table whose keys are Temp_temps and whose bindings
25 | // are strings. However, one mapping can be layered over another; if σ3 =
26 | // layer(σ1, σ2), this means that look(σ3, t) will first try look(σ1, t), and if
27 | // that fails it will try look(σ2, t).Also, enter(σ3, t, a) will have the effect
28 | // of entering t->a into σ2.
29 | class Map {
30 | public:
31 |   Map(const PredefinedRegisters &predefinedRegisters = {});
32 |   void layerOver(Map &&under);
33 |   Register newTemp();
34 |   boost::optional<std::string> lookup(const Register &t) const;
35 |   friend std::ostream &operator<<(std::ostream &ost, const Map &map);
36 | 
37 |   Label newLabel();
38 |   Label namedLabel(const std::string &name);
39 | 
40 | private:
41 |   std::unordered_map<Register, std::string> m_map;
42 |   std::unique_ptr<Map> m_under;
43 |   int m_nextTemp = MIN_TEMP;
44 | };
45 | 
46 | } // namespace temp
47 | } // namespace tiger
48 | 


--------------------------------------------------------------------------------
/Chapter09/Types.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <boost/variant.hpp>
 4 | #include <string>
 5 | #include <unordered_map>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | struct NilType {};
11 | 
12 | struct IntType {};
13 | 
14 | struct StringType {};
15 | 
16 | struct ArrayType;
17 | 
18 | struct RecordType;
19 | 
20 | struct NameType {
21 |   std::string m_name;
22 | };
23 | 
24 | struct VoidType {};
25 | 
26 | using Type =
27 |   boost::variant<NilType, IntType, StringType,
28 |                  boost::recursive_wrapper<ArrayType>,
29 |                  boost::recursive_wrapper<RecordType>, NameType, VoidType>;
30 | 
31 | struct NamedType {
32 |   std::string m_name;
33 |   Type m_type;
34 | };
35 | 
36 | struct ArrayType {
37 |   NamedType m_elementType;
38 | };
39 | 
40 | struct RecordType {
41 |   struct RecordField {
42 |     std::string m_name;
43 |     NamedType m_type;
44 |   };
45 |   std::vector<RecordField> m_fields;
46 | };
47 | 
48 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/m68k/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES m68kFrame.cpp m68kCallingConvention.cpp m68kCodeGenerator.cpp m68kMachine.cpp)
 2 | set(HEADERS m68kFrame.h m68kCallingConvention.h m68kCodeGenerator.h m68kRegisters.h m68kMachine.h)
 3 | 
 4 | add_library(${CHAPTER}_m68k ${HEADERS} ${SOURCES})
 5 | 
 6 | set_target_properties(${CHAPTER}_m68k PROPERTIES OUTPUT_NAME m68k)
 7 | 
 8 | target_include_directories(${CHAPTER}_m68k PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/..)
 9 | 
10 | target_link_libraries(${CHAPTER}_m68k 
11 |   PRIVATE 
12 |     includeHeaders 
13 |     Boost::boost
14 | )


--------------------------------------------------------------------------------
/Chapter09/m68k/m68kCallingConvention.cpp:
--------------------------------------------------------------------------------
 1 | #include "m68kCallingConvention.h"
 2 | #include "Assembly.h"
 3 | #include "m68kFrame.h"
 4 | #include "m68kRegisters.h"
 5 | #include "variantMatch.h"
 6 | 
 7 | namespace tiger {
 8 | namespace frame {
 9 | namespace m68k {
10 | 
11 | std::unique_ptr<frame::Frame>
12 |   CallingConvention::createFrame(temp::Map &tempMap, const temp::Label &name,
13 |                                  const BoolList &formals) {
14 |   return std::make_unique<m68k::Frame>(tempMap, name, formals);
15 | }
16 | 
17 | int CallingConvention::wordSize() const { return Frame::WORD_SIZE; }
18 | 
19 | temp::Register CallingConvention::framePointer() const {
20 |   return reg(Registers::A6);
21 | }
22 | 
23 | temp::Register CallingConvention::returnValue() const {
24 |   return reg(Registers::D0);
25 | }
26 | 
27 | temp::Register CallingConvention::stackPointer() const {
28 |   return reg(Registers::A7);
29 | }
30 | 
31 | assembly::Registers CallingConvention::callDefinedRegisters() const {
32 |   return {reg(Registers::A0), reg(Registers::A1), reg(Registers::D0),
33 |           reg(Registers::D1)};
34 | }
35 | 
36 | assembly::Registers CallingConvention::calleeSavedRegisters() const {
37 |   return {reg(Registers::A2), reg(Registers::A3), reg(Registers::A4),
38 |           reg(Registers::A5), reg(Registers::A6), reg(Registers::A7),
39 |           reg(Registers::D2), reg(Registers::D3), reg(Registers::D4),
40 |           reg(Registers::D5), reg(Registers::D6), reg(Registers::D7)};
41 | }
42 | 
43 | assembly::Registers CallingConvention::argumentRegisters() const { return {}; }
44 | 
45 | } // namespace m68k
46 | } // namespace frame
47 | } // namespace tiger
48 | 


--------------------------------------------------------------------------------
/Chapter09/m68k/m68kCallingConvention.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "CallingConvention.h"
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | namespace m68k {
 8 | class CallingConvention final : public frame::CallingConvention {
 9 | public:
10 |   std::unique_ptr<frame::Frame> createFrame(temp::Map &tempMap,
11 |                                             const temp::Label &name,
12 |                                             const BoolList &formals) override;
13 | 
14 |   int wordSize() const override;
15 | 
16 |   temp::Register framePointer() const override;
17 | 
18 |   temp::Register returnValue() const override;
19 | 
20 |   temp::Register stackPointer() const override;
21 | 
22 |   assembly::Registers callDefinedRegisters() const override;
23 | 
24 |   assembly::Registers calleeSavedRegisters() const override;
25 | 
26 |   assembly::Registers argumentRegisters() const override;
27 | };
28 | } // namespace m68k
29 | } // namespace frame
30 | } // namespace tiger
31 | 


--------------------------------------------------------------------------------
/Chapter09/m68k/m68kCodeGenerator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "CodeGenerator.h"
 3 | 
 4 | namespace tiger {
 5 | namespace assembly {
 6 | namespace m68k {
 7 | class CodeGenerator : public assembly::CodeGenerator {
 8 | public:
 9 |   CodeGenerator(frame::CallingConvention &callingConvention);
10 | 
11 |   Instructions translateString(const temp::Label &label,
12 |                                const std::string &string,
13 |                                temp::Map &tempMap) override;
14 | 
15 | private:
16 |   Instructions translateArgs(const std::vector<ir::Expression> &args,
17 |                              const temp::Map &tempMap) const override;
18 | };
19 | } // namespace m68k
20 | } // namespace assembly
21 | } // namespace tiger
22 | 


--------------------------------------------------------------------------------
/Chapter09/m68k/m68kFrame.cpp:
--------------------------------------------------------------------------------
 1 | #include "m68kFrame.h"
 2 | #include "Assembly.h"
 3 | #include "variantMatch.h"
 4 | #include <boost/dynamic_bitset.hpp>
 5 | #include <cassert>
 6 | 
 7 | namespace tiger {
 8 | namespace frame {
 9 | namespace m68k {
10 | 
11 | Frame::Frame(temp::Map &tempMap, const temp::Label &name,
12 |              const BoolList &formals) :
13 |     frame::Frame(tempMap),
14 |     m_name(name) {
15 |   for (size_t i = 0; i < formals.size(); ++i) {
16 |     m_formals.push_back(InFrame{m_frameOffset});
17 |     m_frameOffset -= WORD_SIZE;
18 |   }
19 | }
20 | 
21 | temp::Label Frame::name() const { return m_name; }
22 | 
23 | const AccessList &Frame::formals() const { return m_formals; }
24 | 
25 | VariableAccess Frame::allocateLocal(bool escapes) {
26 |   if (escapes) {
27 |     auto res = InFrame{m_frameOffset};
28 |     m_frameOffset -= WORD_SIZE;
29 |     return res;
30 |   }
31 | 
32 |   return InReg{m_tempMap.newTemp()};
33 | }
34 | 
35 | ir::Statement Frame::procEntryExit1(const ir::Statement &body) const {
36 |   return body;
37 | }
38 | 
39 | assembly::Instructions
40 |   Frame::procEntryExit3(const assembly::Instructions &body) const {
41 |   return body;
42 | }
43 | 
44 | } // namespace m68k
45 | } // namespace frame
46 | } // namespace tiger
47 | 


--------------------------------------------------------------------------------
/Chapter09/m68k/m68kFrame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Frame.h"
 4 | #include "m68kRegisters.h"
 5 | #include <array>
 6 | 
 7 | namespace tiger {
 8 | namespace frame {
 9 | namespace m68k {
10 | // implements
11 | // https://docs.microsoft.com/en-gb/cpp/build/overview-of-x64-calling-conventions
12 | class Frame final : public frame::Frame {
13 | public:
14 |   static const int WORD_SIZE = 4;
15 | 
16 |   Frame(temp::Map &tempMap, const temp::Label &name, const BoolList &formals);
17 | 
18 |   // Inherited via Frame
19 |   temp::Label name() const override;
20 | 
21 |   const AccessList &formals() const override;
22 | 
23 |   VariableAccess allocateLocal(bool escapes) override;
24 | 
25 |   ir::Statement procEntryExit1(const ir::Statement &body) const override;
26 | 
27 |   assembly::Instructions
28 |     procEntryExit3(const assembly::Instructions &body) const override;
29 | 
30 | private:
31 |   temp::Label m_name;
32 |   AccessList m_formals;
33 |   int m_frameOffset = -WORD_SIZE;
34 | };
35 | } // namespace m68k
36 | } // namespace frame
37 | } // namespace tiger
38 | 


--------------------------------------------------------------------------------
/Chapter09/m68k/m68kMachine.cpp:
--------------------------------------------------------------------------------
 1 | #include "m68kMachine.h"
 2 | #include "Tree.h"
 3 | #include "m68kRegisters.h"
 4 | 
 5 | namespace tiger {
 6 | namespace m68k {
 7 | 
 8 | frame::CallingConvention &Machine::callingConvention() {
 9 |   return m_callingConvention;
10 | }
11 | const frame::CallingConvention &Machine::callingConvention() const {
12 |   return m_callingConvention;
13 | }
14 | assembly::CodeGenerator &Machine::codeGenerator() { return m_codeGenerator; }
15 | const assembly::CodeGenerator &Machine::codeGenerator() const {
16 |   return m_codeGenerator;
17 | }
18 | temp::PredefinedRegisters Machine::predefinedRegisters() {
19 |   using namespace tiger::frame::m68k;
20 |   return {{reg(Registers::D0), "D0"},
21 |           {reg(Registers::D1), "D1"},
22 |           {reg(Registers::D2), "D2"},
23 |           {reg(Registers::D3), "D3"},
24 |           {reg(Registers::D4), "D4"},
25 |           {reg(Registers::D5), "D5"},
26 |           {reg(Registers::D6), "D6"},
27 |           {reg(Registers::D7), "D7"},
28 |           {reg(Registers::A0), "A0"},
29 |           {reg(Registers::A1), "A1"},
30 |           {reg(Registers::A2), "A2"},
31 |           {reg(Registers::A3), "A3"},
32 |           {reg(Registers::A4), "A4"},
33 |           {reg(Registers::A5), "A5"},
34 |           {reg(Registers::A6), "A6"},
35 |           {reg(Registers::A7), "A7"}
36 | 
37 |   };
38 | }
39 | } // namespace m68k
40 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/m68k/m68kMachine.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Machine.h"
 4 | #include "m68kCallingConvention.h"
 5 | #include "m68kCodeGenerator.h"
 6 | 
 7 | namespace tiger {
 8 | namespace m68k {
 9 | 
10 | class Machine : public tiger::Machine {
11 | public:
12 |   // Inherited via Machine
13 |   virtual frame::CallingConvention &callingConvention() override;
14 |   virtual const frame::CallingConvention &callingConvention() const override;
15 | 
16 |   virtual assembly::CodeGenerator &codeGenerator() override;
17 |   virtual const assembly::CodeGenerator &codeGenerator() const override;
18 | 
19 | private:
20 |   frame::m68k::CallingConvention m_callingConvention;
21 |   assembly::m68k::CodeGenerator m_codeGenerator{m_callingConvention};
22 | 
23 |   // Inherited via Machine
24 |   virtual temp::PredefinedRegisters predefinedRegisters() override;
25 | };
26 | } // namespace m68k
27 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/m68k/m68kRegisters.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | 
 4 | namespace tiger {
 5 | namespace frame {
 6 | namespace m68k {
 7 | 
 8 | enum class Registers {
 9 |   D0,
10 |   D1,
11 |   D2,
12 |   D3,
13 |   D4,
14 |   D5,
15 |   D6,
16 |   D7,
17 |   A0,
18 |   A1,
19 |   A2,
20 |   A3,
21 |   A4,
22 |   A5,
23 |   A6,
24 |   A7,
25 |   Size
26 | };
27 | 
28 | constexpr temp::Register reg(Registers reg) {
29 |   return temp::Register{static_cast<int>(reg)};
30 | }
31 | 
32 | static_assert(static_cast<int>(Registers::Size) <= temp::MIN_TEMP,
33 |               "MIN_TEMP should be greater than the greatest register");
34 | } // namespace m68k
35 | } // namespace frame
36 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | add_library(${CHAPTER}_testMain STATIC Test.h TestMain.cpp checkedCompile.cpp)
 2 | 
 3 | set_target_properties(${CHAPTER}_testMain PROPERTIES OUTPUT_NAME testMain)
 4 | 
 5 | target_link_libraries(${CHAPTER}_testMain PUBLIC 
 6 |   Catch2::Catch
 7 |   Microsoft.GSL::GSL
 8 |   Boost::filesystem
 9 |   Boost::system 
10 |   includeHeaders
11 |   ${CHAPTER}
12 | )
13 | 
14 | function(add_chapter_test name)
15 |   add_executable(${CHAPTER}_${name} ${name}.cpp)
16 | 
17 |   set_target_properties(${CHAPTER}_${name} PROPERTIES OUTPUT_NAME ${name})
18 | 
19 |   target_link_libraries(${CHAPTER}_${name}
20 |     PRIVATE
21 |       ${CHAPTER}_testMain
22 |   )
23 |   
24 |   parse_unit_tests(${CHAPTER}_${name} --timeout 20 ARCHS m68k x64)
25 | endfunction()
26 | 
27 | add_chapter_test(compileFiles)
28 | add_chapter_test(lvalue)
29 | add_chapter_test(for)
30 | add_chapter_test(integer)
31 | add_chapter_test(comparison)
32 | add_chapter_test(typeDeclarations)
33 | add_chapter_test(boolean)
34 | add_chapter_test(array)
35 | add_chapter_test(nil)
36 | add_chapter_test(functionCall)
37 | add_chapter_test(string)
38 | add_chapter_test(assignment)
39 | add_chapter_test(arithmetic)
40 | add_chapter_test(ifThen)
41 | add_chapter_test(while)
42 | add_chapter_test(library)
43 | add_chapter_test(record)
44 | add_chapter_test(sequence)
45 | add_chapter_test(functionDeclarations)
46 | add_chapter_test(break)


--------------------------------------------------------------------------------
/Chapter09/test/TestMain.cpp:
--------------------------------------------------------------------------------
 1 | #define CATCH_CONFIG_RUNNER
 2 | #include <catch/catch.hpp>
 3 | 
 4 | std::string arch;
 5 | 
 6 | int main(int argc, char *argv[]) {
 7 |   Catch::Session session; // There must be exactly one instance
 8 | 
 9 |   // Build a new parser on top of Catch's
10 |   using namespace Catch::clara;
11 |   auto cli =
12 |     session.cli() // Get Catch's composite command line parser
13 |     | Opt(
14 |         [&](const std::string &val) {
15 |           if (val == "m68k" || val == "x64") {
16 |             arch = val;
17 |             return detail::ParserResult::ok(detail::ParseResultType::Matched);
18 |           }
19 | 
20 |           return detail::ParserResult::runtimeError("unknown architecture "
21 |                                                     + val);
22 |         },
23 |         "architecture") // bind variable to a new option, with a hint string
24 |         ["--arch"]      // the option names it will respond to
25 |       ("target architecture: x64/m68k")
26 |         .required(); // description string for the help
27 |                      // output
28 | 
29 |   // Now pass the new composite back to Catch so it uses that
30 |   session.cli(cli);
31 | 
32 |   return session.run(argc, argv);
33 | }


--------------------------------------------------------------------------------
/Chapter09/test/arithmetic.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | #include <boost/format.hpp>
 3 | 
 4 | TEST_CASE("arithmetic") {
 5 |   static const std::pair<std::string, ir::BinOp> operations[] = {
 6 |     {"+", ir::BinOp::PLUS},
 7 |     {"-", ir::BinOp::MINUS},
 8 |     {"*", ir::BinOp::MUL},
 9 |     {"/", ir::BinOp::DIV}};
10 | 
11 |   for (const auto &op : operations) {
12 |     SECTION(Catch::StringMaker<ir::BinOp>::convert(op.second)) {
13 |       auto program = checkedCompile(boost::str(boost::format(R"(
14 |  let
15 |    var i : int := 2 %1% 3
16 |  in
17 |    i
18 |  end
19 |  )") % op.first));
20 |       OptReg regs[4];
21 |       OptLabel end;
22 |       checkProgram(program, checkMain(),
23 |                    checkMove(checkReg(regs[0]), checkImm(2)),
24 |                    checkMove(checkReg(regs[1]), checkImm(3)),
25 |                    checkBinaryOperation(op.second, checkReg(regs[0]),
26 |                                         checkReg(regs[1]), regs[2]),
27 |                    checkMove(checkReg(regs[3]), // move result of 2 op 3 to r
28 |                              checkReg(regs[2])),
29 |                    checkMove( // return i
30 |                      returnReg(), checkReg(regs[3])),
31 |                    branchToEnd(end));
32 |     }
33 |   }
34 | }


--------------------------------------------------------------------------------
/Chapter09/test/array.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE("array") {
 4 |   auto program = checkedCompile(R"(
 5 | let
 6 |  type t = array of int
 7 | in
 8 |  t[2] of 3
 9 | end
10 | )");
11 |   OptReg regs[4];
12 |   OptLabel end;
13 |   checkProgram(
14 |     program, checkMain(), checkMove(checkReg(regs[0]), checkImm(wordSize())),
15 |     checkMove(checkReg(regs[1]), checkImm(2)),
16 |     checkBinaryOperation(ir::BinOp::MUL, checkReg(regs[0]), checkReg(regs[1]),
17 |                          regs[2]),
18 |     checkCall("malloc", checkArg(0, checkReg(regs[2]))),
19 |     checkMove( // move result of malloc(array_size) to r
20 |       checkReg(regs[3]), returnReg()),
21 |     checkCall( // call initArray(array_size, init_val)
22 |       "initArray", checkArg(0, checkImm(2)) > checkArg(1, checkImm(3))),
23 |     checkMove(returnReg(), checkReg(regs[3])), branchToEnd(end));
24 | }


--------------------------------------------------------------------------------
/Chapter09/test/assignment.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE("assignment") {
 4 |   auto program = checkedCompile(R"(
 5 | let
 6 |  var a := 3
 7 |  var b := 0
 8 | in
 9 |  b := a
10 | end
11 | )");
12 |   OptReg a, b;
13 |   OptLabel end;
14 |   checkProgram(program, checkMain(),
15 |                checkMove( // move 3 to a
16 |                  checkReg(a), checkImm(3)),
17 |                checkMove( // move 0 to b
18 |                  checkReg(b), checkImm(0)),
19 |                checkMove( // move a to b
20 |                  checkReg(b), checkReg(a)),
21 |                checkMove( // return 0
22 |                  returnReg(), checkImm(0)),
23 |                branchToEnd(end));
24 | }


--------------------------------------------------------------------------------
/Chapter09/test/checkedCompile.cpp:
--------------------------------------------------------------------------------
1 | #include "Test.h"
2 | #include "Program.h"
3 | #include <catch/catch.hpp>
4 | 
5 | std::string checkedCompile(const std::string &string) {
6 |   auto res = tiger::compile(arch, string);
7 |   REQUIRE(res);
8 |   return *res;
9 | }


--------------------------------------------------------------------------------
/Chapter09/test/compileFiles.cpp:
--------------------------------------------------------------------------------
 1 | #include "Program.h"
 2 | #include "testsHelper.h"
 3 | #include <boost/optional/optional_io.hpp>
 4 | #include <catch/catch.hpp>
 5 | 
 6 | extern std::string arch;
 7 | 
 8 | TEST_CASE("compile test files") {
 9 |   namespace fs = boost::filesystem;
10 |   tiger::forEachTigerTest(
11 |     [](const fs::path &filepath, bool parseError, bool compilationError) {
12 |       SECTION(filepath.filename().string()) {
13 |         if (parseError || compilationError) {
14 |           REQUIRE_FALSE(tiger::compileFile(arch, filepath.string()));
15 |         } else {
16 |           REQUIRE(tiger::compileFile(arch, filepath.string()));
17 |         }
18 |       }
19 |     });
20 | }


--------------------------------------------------------------------------------
/Chapter09/test/for.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE("for") {
 4 |   auto program = checkedCompile(R"(
 5 | let
 6 |   function f(a: int) = ()
 7 | in
 8 |   for a := 0 to 4 do f(a)
 9 | end
10 | )");
11 |   OptReg regs[4], staticLink, temps[2];
12 |   OptLabel functionLabel, loopStart, loopDone, functionEnd, end;
13 |   checkProgram(
14 |     program, checkLabel(functionLabel), ':', // function label
15 |     checkMove(                               // body
16 |       returnReg(), checkImm(0)),
17 |     branchToEnd(functionEnd), checkMain(),
18 |     checkMove( // move 0 to a
19 |       checkReg(regs[0]), checkImm(0)),
20 |     checkMove( // move 4 to limit
21 |       checkReg(regs[1]), checkImm(4)),
22 |     checkConditionalJump( // skip the loop if a , limit
23 |       ir::RelOp::GT, regs[0], regs[1], loopDone),
24 |     checkLabel(loopStart), ':',
25 |     checkStaticLink(staticLink, temps),
26 |     checkCall(checkLabel(functionLabel), checkArg(0, checkReg(staticLink))
27 |                                            > checkArg(1, checkReg(regs[0]))),
28 |     checkMove(checkReg(regs[2]), checkImm(1)),
29 |     checkBinaryOperation(ir::BinOp::PLUS, checkReg(regs[0]), checkReg(regs[2]),
30 |                          regs[3]),
31 |     checkMove( // a := a + 1
32 |       checkReg(regs[0]), checkReg(regs[3])),
33 |     checkConditionalJump(ir::RelOp::LT, regs[0], regs[1], loopStart),
34 |     checkLabel(loopDone), ':', checkMove(returnReg(), checkImm(0)),
35 |     branchToEnd(end));
36 | }


--------------------------------------------------------------------------------
/Chapter09/test/functionCall.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE("function call") {
 4 |   OptLabel functionLabel, functionEnd, end;
 5 |   OptReg temps[2];
 6 |   OptReg staticLink;
 7 | 
 8 |   SECTION("with no arguments") {
 9 |     auto program = checkedCompile(R"(
10 | let
11 |  function f() = ()
12 | in
13 |  f()
14 | end
15 | )");
16 | 
17 |     checkProgram(program, checkLabel(functionLabel), ':', // function label
18 |                  checkMove(                               // body
19 |                    returnReg(), checkImm(0)),
20 |                  branchToEnd(functionEnd), checkMain(),
21 |                  checkStaticLink(staticLink, temps),
22 |                  checkCall(//call
23 |                    checkLabel(functionLabel), checkArg(0, checkReg(staticLink))),
24 |                  branchToEnd(end));
25 |   }
26 | 
27 |   SECTION("with arguments") {
28 |     auto program = checkedCompile(R"(
29 |   let
30 |    function f(a: int) = ()
31 |   in
32 |    f(2)
33 |   end
34 |   )");
35 |     checkProgram(
36 |       program, checkLabel(functionLabel), ':', // function label,
37 |       checkMove(                               // body
38 |         returnReg(), checkImm(0)),
39 |       branchToEnd(functionEnd), checkMain(),
40 |       checkStaticLink(staticLink, temps),
41 |       checkCall( // call
42 |         checkLabel(functionLabel), checkArg(0, checkReg(staticLink)) > checkArg(1, checkImm(2))),
43 |       branchToEnd(end));
44 |   }
45 | }


--------------------------------------------------------------------------------
/Chapter09/test/integer.cpp:
--------------------------------------------------------------------------------
1 | #include "Test.h"
2 | 
3 | TEST_CASE("integer") {
4 |   OptLabel end;
5 |   auto program = checkedCompile("42");
6 |   checkProgram(program, checkMain(), checkMove(returnReg(), checkImm(42)),
7 |                branchToEnd(end));
8 | }


--------------------------------------------------------------------------------
/Chapter09/test/nil.cpp:
--------------------------------------------------------------------------------
1 | #include "Test.h"
2 | 
3 | TEST_CASE("nil") {
4 |   OptLabel end;
5 |   auto program = checkedCompile("nil");
6 |   checkProgram(program, checkMain(), checkMove(returnReg(), checkImm(0)),
7 |                branchToEnd(end));
8 | }


--------------------------------------------------------------------------------
/Chapter09/test/record.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE("record") {
 4 |   OptLabel end;
 5 |   SECTION("empty") {
 6 |     auto program = checkedCompile(R"(
 7 | let
 8 |  type t = {}
 9 | in
10 |  t{}
11 | end
12 | )");
13 |     OptReg regs[2];
14 |     checkProgram(program, checkMain(),
15 |                  checkCall("malloc", checkArg(0, checkImm(0))),
16 |                  checkMove( // move result of malloc(record_size) to
17 |                    checkReg(regs[1]), returnReg()),
18 |                  checkMove(returnReg(), checkReg(regs[1])), branchToEnd(end));
19 |   }
20 | 
21 |   SECTION("not empty") {
22 |     auto program = checkedCompile(R"(
23 | let
24 |  type t = {a: int, b: string}
25 | in
26 |  t{a = 2, b = "hello"}
27 | end
28 | )");
29 | 
30 |     OptReg regs[4], temps[2][4];
31 |     OptLabel stringLabel;
32 |     checkProgram(
33 |       program, checkStringInit(stringLabel, R"("hello")"), checkMain(),
34 |       checkCall("malloc", checkArg(0, checkImm(2 * wordSize()))),
35 |       checkMove(checkReg(regs[1]), // move result of malloc(record_size) to r
36 |                 returnReg()),
37 |       checkMemberAccess(regs[1], 0, regs[2], temps[0]),
38 |       checkMove(checkReg(regs[2]), // init first member with 2
39 |                 checkImm(2)),
40 |       checkMemberAccess(regs[1], 1, regs[3], temps[1]),
41 |       checkMove(checkReg(regs[3]), // init second member with "hello"
42 |                 checkString(stringLabel)),
43 |       checkMove(returnReg(), checkReg(regs[1])),
44 |       branchToEnd(end));
45 |   }
46 | }


--------------------------------------------------------------------------------
/Chapter09/test/sequence.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE("sequence") {
 4 |   OptLabel end;
 5 |   SECTION("empty") {
 6 |     auto program = checkedCompile("()");
 7 |     checkProgram(program, checkMain(), checkMove(returnReg(), checkImm(0)),
 8 |                  branchToEnd(end));
 9 |   }
10 | 
11 |   SECTION("single") {
12 |     auto program = checkedCompile("(42)");
13 |     checkProgram(program, checkMain(), checkMove(returnReg(), checkImm(42)),
14 |                  branchToEnd(end));
15 |   }
16 | 
17 |   SECTION("multiple") {
18 |     // no-op expressions are removed
19 |     auto program = checkedCompile(R"((1;"two";flush()))");
20 |     OptReg temps[2];
21 |     OptLabel strLabel;
22 |     OptReg staticLink;
23 |     checkProgram(program, checkStringInit(strLabel, R"("two")"), checkMain(),
24 |                  checkStaticLink(staticLink, temps),
25 |                  checkCall("flush", checkArg(0, checkReg(staticLink))),
26 |                  branchToEnd(end));
27 |   }
28 | }


--------------------------------------------------------------------------------
/Chapter09/test/string.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE("string") {
 4 |   auto str     = R"("\tHello \"World\"!\n")";
 5 |   auto program = checkedCompile(str);
 6 |   OptLabel stringLabel, end;
 7 |   checkProgram(program, checkStringInit(stringLabel, str), checkMain(),
 8 |                checkMove(returnReg(), checkString(stringLabel)),
 9 |                branchToEnd(end));
10 | }


--------------------------------------------------------------------------------
/Chapter09/x64/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES x64Frame.cpp x64CallingConvention.cpp x64CodeGenerator.cpp x64Machine.cpp)
 2 | set(HEADERS x64Frame.h x64CallingConvention.h x64CodeGenerator.h x64Registers.h x64Machine.h)
 3 | 
 4 | add_library(${CHAPTER}_x64 ${HEADERS} ${SOURCES})
 5 | 
 6 | set_target_properties(${CHAPTER}_x64 PROPERTIES OUTPUT_NAME x64)
 7 | 
 8 | target_include_directories(${CHAPTER}_x64 PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/..)
 9 | 
10 | target_link_libraries(${CHAPTER}_x64 
11 |   PRIVATE 
12 |     includeHeaders 
13 |     Boost::boost
14 | )


--------------------------------------------------------------------------------
/Chapter09/x64/x64CallingConvention.cpp:
--------------------------------------------------------------------------------
 1 | #include "x64CallingConvention.h"
 2 | #include "x64Frame.h"
 3 | #include "x64Registers.h"
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | namespace x64 {
 8 | 
 9 | std::unique_ptr<frame::Frame>
10 |   CallingConvention::createFrame(temp::Map &tempMap, const temp::Label &name,
11 |                                  const BoolList &formals) {
12 |   return std::make_unique<x64::Frame>(tempMap, name, formals);
13 | }
14 | 
15 | int CallingConvention::wordSize() const { return Frame::WORD_SIZE; }
16 | 
17 | temp::Register CallingConvention::framePointer() const {
18 |   return reg(Registers::RBP);
19 | }
20 | 
21 | temp::Register CallingConvention::returnValue() const {
22 |   return reg(Registers::RAX);
23 | }
24 | 
25 | temp::Register CallingConvention::stackPointer() const {
26 |   return reg(Registers::RSP);
27 | }
28 | 
29 | std::vector<temp::Register> CallingConvention::callDefinedRegisters() const {
30 |   return {reg(Registers::RAX), reg(Registers::RCX), reg(Registers::RDX),
31 |           reg(Registers::R8),  reg(Registers::R9),  reg(Registers::R10),
32 |           reg(Registers::R11)};
33 | }
34 | 
35 | assembly::Registers CallingConvention::calleeSavedRegisters() const {
36 |   return {reg(Registers::RBX), reg(Registers::RBP), reg(Registers::RDI),
37 |           reg(Registers::RSI), reg(Registers::R12), reg(Registers::R13),
38 |           reg(Registers::R14), reg(Registers::R15)};
39 | }
40 | 
41 | assembly::Registers CallingConvention::argumentRegisters() const {
42 |   return {reg(Registers::RCX), reg(Registers::RDX), reg(Registers::R8),
43 |           reg(Registers::R9)};
44 | }
45 | 
46 | } // namespace x64
47 | } // namespace frame
48 | } // namespace tiger
49 | 


--------------------------------------------------------------------------------
/Chapter09/x64/x64CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "CallingConvention.h"
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | namespace x64 {
 8 | class CallingConvention final : public frame::CallingConvention {
 9 | public:
10 |   std::unique_ptr<frame::Frame> createFrame(temp::Map &tempMap,
11 |                                             const temp::Label &name,
12 |                                             const BoolList &formals) override;
13 | 
14 |   int wordSize() const override;
15 | 
16 |   temp::Register framePointer() const override;
17 | 
18 |   temp::Register returnValue() const override;
19 | 
20 |   temp::Register stackPointer() const override;
21 | 
22 |   std::vector<temp::Register> callDefinedRegisters() const override;
23 | 
24 |   assembly::Registers calleeSavedRegisters() const override;
25 | 
26 |   assembly::Registers argumentRegisters() const override;
27 | };
28 | } // namespace x64
29 | } // namespace frame
30 | } // namespace tiger
31 | 


--------------------------------------------------------------------------------
/Chapter09/x64/x64CodeGenerator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "CodeGenerator.h"
 3 | 
 4 | namespace tiger {
 5 | namespace assembly {
 6 | namespace x64 {
 7 | class CodeGenerator : public assembly::CodeGenerator {
 8 | public:
 9 |   CodeGenerator(frame::CallingConvention &callingConvention);
10 | 
11 |   Instructions translateString(const temp::Label &label,
12 |                                const std::string &string,
13 |                                temp::Map &tempMap) override;
14 | 
15 |   Instructions translateArgs(const std::vector<ir::Expression> &args,
16 |                              const temp::Map &tempMap) const override;
17 | };
18 | } // namespace x64
19 | } // namespace assembly
20 | } // namespace tiger
21 | 


--------------------------------------------------------------------------------
/Chapter09/x64/x64Frame.cpp:
--------------------------------------------------------------------------------
 1 | #include "x64Frame.h"
 2 | #include "Assembly.h"
 3 | #include "variantMatch.h"
 4 | #include <boost/dynamic_bitset.hpp>
 5 | #include <cassert>
 6 | 
 7 | namespace tiger {
 8 | namespace frame {
 9 | namespace x64 {
10 | 
11 | Frame::Frame(temp::Map &tempMap, const temp::Label &name,
12 |              const BoolList &formals) :
13 |     frame::Frame(tempMap),
14 |     m_name(name) {
15 |   for (size_t i = 0; i < formals.size(); ++i) {
16 |     auto varAccess = [this](bool escapes) -> VariableAccess {
17 |       if (escapes || m_allocatedRegs == MAX_REGS) {
18 |         auto res = InFrame{m_frameOffset};
19 |         m_frameOffset -= WORD_SIZE;
20 |         return res;
21 |       }
22 | 
23 |       assert(m_allocatedRegs < MAX_REGS);
24 |       return InReg{m_tempMap.newTemp()};
25 |     }(formals[i]);
26 |     m_formals.push_back(varAccess);
27 |   }
28 | }
29 | 
30 | temp::Label Frame::name() const { return m_name; }
31 | 
32 | const AccessList &Frame::formals() const { return m_formals; }
33 | 
34 | VariableAccess Frame::allocateLocal(bool escapes) {
35 |   if (escapes) {
36 |     auto res = InFrame{m_frameOffset};
37 |     m_frameOffset -= WORD_SIZE;
38 |     return res;
39 |   }
40 | 
41 |   return InReg{m_tempMap.newTemp()};
42 | }
43 | 
44 | ir::Statement Frame::procEntryExit1(const ir::Statement &body) const {
45 |   return body;
46 | }
47 | 
48 | assembly::Instructions
49 |   Frame::procEntryExit3(const assembly::Instructions &body) const {
50 |   return body;
51 | }
52 | 
53 | } // namespace x64
54 | } // namespace frame
55 | } // namespace tiger
56 | 


--------------------------------------------------------------------------------
/Chapter09/x64/x64Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Frame.h"
 4 | #include "x64Registers.h"
 5 | #include <array>
 6 | 
 7 | namespace tiger {
 8 | namespace frame {
 9 | namespace x64 {
10 | // implements
11 | // https://docs.microsoft.com/en-gb/cpp/build/overview-of-x64-calling-conventions
12 | class Frame final : public frame::Frame {
13 | public:
14 |   static const int WORD_SIZE = 8;
15 | 
16 |   Frame(temp::Map &tempMap, const temp::Label &name, const BoolList &formals);
17 | 
18 |   // Inherited via Frame
19 |   virtual temp::Label name() const override;
20 | 
21 |   virtual const AccessList &formals() const override;
22 | 
23 |   virtual VariableAccess allocateLocal(bool escapes) override;
24 | 
25 |   virtual ir::Statement
26 |     procEntryExit1(const ir::Statement &body) const override;
27 | 
28 |   assembly::Instructions
29 |     procEntryExit3(const assembly::Instructions &body) const override;
30 | 
31 | private:
32 |   temp::Label m_name;
33 |   AccessList m_formals;
34 |   int m_frameOffset = -WORD_SIZE;
35 |   // The __fastcall convention uses registers for the first four arguments
36 |   static const size_t MAX_REGS = 4;
37 |   size_t m_allocatedRegs       = 0;
38 | };
39 | } // namespace x64
40 | } // namespace frame
41 | } // namespace tiger
42 | 


--------------------------------------------------------------------------------
/Chapter09/x64/x64Machine.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Machine.h"
 4 | #include "x64CallingConvention.h"
 5 | #include "x64CodeGenerator.h"
 6 | 
 7 | namespace tiger {
 8 | namespace x64 {
 9 | 
10 | class Machine : public tiger::Machine {
11 | public:
12 |   // Inherited via Machine
13 |   virtual frame::CallingConvention &callingConvention() override;
14 |   virtual const frame::CallingConvention &callingConvention() const override;
15 |   virtual assembly::CodeGenerator &codeGenerator() override;
16 |   virtual const assembly::CodeGenerator &codeGenerator() const override;
17 | 
18 | private:
19 |   frame::x64::CallingConvention m_callingConvention;
20 |   assembly::x64::CodeGenerator m_codeGenerator{m_callingConvention};
21 | 
22 |   // Inherited via Machine
23 |   virtual temp::PredefinedRegisters predefinedRegisters() override;
24 | };
25 | } // namespace x64
26 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter09/x64/x64Registers.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | 
 4 | namespace tiger {
 5 | namespace frame {
 6 | namespace x64 {
 7 | 
 8 | enum class Registers {
 9 |   RAX,
10 |   RDX,
11 |   RCX,
12 |   RBX,
13 |   RSI,
14 |   RDI,
15 |   RBP,
16 |   RSP,
17 |   R8,
18 |   R9,
19 |   R10,
20 |   R11,
21 |   R12,
22 |   R13,
23 |   R14,
24 |   R15,
25 |   RIP,
26 |   MM0,
27 |   MM1,
28 |   MM2,
29 |   MM3,
30 |   MM4,
31 |   MM5,
32 |   MM6,
33 |   MM7,
34 |   FP0,
35 |   FP1,
36 |   FP2,
37 |   FP3,
38 |   FP4,
39 |   FP5,
40 |   FP6,
41 |   FP7,
42 |   XMM8,
43 |   XMM9,
44 |   XMM10,
45 |   XMM11,
46 |   XMM12,
47 |   XMM13,
48 |   XMM14,
49 |   XMM15,
50 |   XMM16,
51 |   XMM17,
52 |   XMM18,
53 |   XMM19,
54 |   XMM20,
55 |   XMM21,
56 |   XMM22,
57 |   XMM23,
58 |   XMM24,
59 |   XMM25,
60 |   XMM26,
61 |   XMM27,
62 |   XMM28,
63 |   XMM29,
64 |   XMM30,
65 |   XMM31,
66 |   Size
67 | };
68 | 
69 | constexpr temp::Register reg(Registers reg) {
70 |   return temp::Register{static_cast<int>(reg)};
71 | }
72 | 
73 | static_assert(static_cast<int>(Registers::Size) <= temp::MIN_TEMP,
74 |               "MIN_TEMP should be greater than the greatest register");
75 | } // namespace x64
76 | } // namespace frame
77 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Frame.h"
 3 | 
 4 | namespace tiger {
 5 | namespace assembly {
 6 | class Instruction;
 7 | using Instructions = std::vector<Instruction>;
 8 | } // namespace assembly
 9 | 
10 | namespace frame {
11 | class CallingConvention {
12 | public:
13 |   virtual ~CallingConvention() = default;
14 | 
15 |   virtual std::unique_ptr<Frame> createFrame(temp::Map &tempMap,
16 |                                              const temp::Label &name,
17 |                                              const BoolList &formals) = 0;
18 |   virtual int wordSize() const                                        = 0;
19 | 
20 |   virtual temp::Register framePointer() const = 0;
21 | 
22 |   virtual temp::Register returnValue() const = 0;
23 | 
24 |   virtual temp::Register stackPointer() const = 0;
25 | 
26 |   virtual const temp::Registers &callDefinedRegisters() const = 0;
27 | 
28 |   virtual const temp::Registers &calleeSavedRegisters() const = 0;
29 | 
30 |   virtual const temp::Registers &argumentRegisters() const = 0;
31 | 
32 |   ir::Expression accessFrame(const VariableAccess &access,
33 |                              const ir::Expression &framePtr) const;
34 | 
35 |   ir::Expression externalCall(const temp::Label &name,
36 |                               const std::vector<ir::Expression> &args);
37 | 
38 |   temp::Registers liveAtExitRegisters() const;
39 | 
40 |   // calculate register liveness
41 |   assembly::Instructions
42 |     procEntryExit2(const assembly::Instructions &body) const;
43 | };
44 | } // namespace frame
45 | } // namespace tiger
46 | 


--------------------------------------------------------------------------------
/Chapter10/ErrorHandler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/spirit/include/classic_position_iterator.hpp>
 3 | #include <iomanip>
 4 | #include <sstream>
 5 | #include <stdexcept>
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator> class ErrorHandler {
 9 | public:
10 |   template <typename, typename, typename> struct result { typedef void type; };
11 | 
12 |   template <typename Message, typename What>
13 |   void operator()(Message const &message, What const &what,
14 |                   Iterator err_pos) const {
15 |     class TigerError : public std::logic_error {
16 |       using std::logic_error::logic_error;
17 |     };
18 |     const auto &pos = err_pos.get_position();
19 |     std::stringstream sst;
20 |     sst << pos.file << "(" << pos.line << "," << pos.column << "): " << message
21 |         << ": " << what << '\n';
22 |     sst << "'";
23 |     std::copy(err_pos.get_currentline_begin(), err_pos.get_currentline_end(),
24 |               std::ostream_iterator<char>(sst));
25 |     sst << "'\n";
26 |     sst << std::setw(pos.column) << " "
27 |         << "^- here\n";
28 |     throw TigerError{sst.str()};
29 |   }
30 | };
31 | } // namespace tiger
32 | 


--------------------------------------------------------------------------------
/Chapter10/FlowGraph.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempRegister.h"
 3 | #include "Assembly.h"
 4 | #include <boost/graph/adjacency_list.hpp>
 5 | #include <boost/dynamic_bitset.hpp>
 6 | 
 7 | namespace tiger {
 8 | 
 9 | namespace regalloc {
10 | 
11 | using LiveRegisters = std::vector<temp::Registers>;
12 | 
13 | class FlowGraph
14 |     : public boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS,
15 |                                    assembly::Instruction>
16 | {
17 | public:
18 |   FlowGraph(const assembly::Instructions &instructions);
19 | 
20 |   const temp::Registers &uses(vertex_descriptor v) const;
21 |   const temp::Registers &defs(vertex_descriptor v) const;
22 |   bool isMove(vertex_descriptor v) const;
23 | 
24 | private:
25 |   using base = boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS,
26 |                                      assembly::Instruction>;
27 |   LiveRegisters m_uses;
28 |   LiveRegisters m_defs;
29 |   boost::dynamic_bitset<> m_isMove;
30 | };
31 | 
32 | } // namespace regalloc
33 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/Fragment.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Tree.h"
 3 | #include <memory>
 4 | 
 5 | namespace tiger {
 6 | 
 7 | namespace frame {
 8 | class Frame;
 9 | }
10 | 
11 | struct StringFragment {
12 |   temp::Label m_label;
13 |   std::string m_string;
14 | };
15 | 
16 | struct FunctionFragment {
17 |   ir::Statement m_body;
18 |   std::shared_ptr<const frame::Frame> m_frame;
19 | };
20 | 
21 | using Fragment     = boost::variant<StringFragment, FunctionFragment>;
22 | using FragmentList = std::vector<Fragment>;
23 | } // namespace tiger
24 | 


--------------------------------------------------------------------------------
/Chapter10/Frame.cpp:
--------------------------------------------------------------------------------
 1 | #include "Frame.h"
 2 | #include "Assembly.h"
 3 | #include <range/v3/view/concat.hpp>
 4 | #include <range/v3/view/single.hpp>
 5 | 
 6 | namespace tiger {
 7 | namespace frame {
 8 | 
 9 | Frame::Frame(temp::Map &tempMap, const CallingConvention &callingConvention) :
10 |     m_tempMap{tempMap}, m_callingConvention{callingConvention} {}
11 | 
12 | ir::Statement Frame::procEntryExit1(const ir::Statement &body) const {
13 |   return ir::Sequence{
14 |     ranges::view::concat(m_parameterMoves, ranges::view::single(body))};
15 | }
16 | 
17 | assembly::Instructions
18 |   Frame::procEntryExit3(const assembly::Instructions &body) const {
19 |   return body;
20 | }
21 | 
22 | } // namespace frame
23 | } // namespace tiger
24 | 


--------------------------------------------------------------------------------
/Chapter10/Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | #include "Tree.h"
 4 | #include <boost/dynamic_bitset_fwd.hpp>
 5 | #include <boost/variant.hpp>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | namespace assembly {
11 | class Instruction;
12 | using Instructions = std::vector<Instruction>;
13 | } // namespace assembly
14 | 
15 | namespace frame {
16 | 
17 | class CallingConvention;
18 | 
19 | using BoolList = boost::dynamic_bitset<>;
20 | 
21 | struct InFrame {
22 |   int m_offset;
23 | };
24 | 
25 | struct InReg {
26 |   temp::Register m_reg;
27 | };
28 | 
29 | using VariableAccess = boost::variant<InFrame, InReg>;
30 | using AccessList     = std::vector<VariableAccess>;
31 | 
32 | class Frame {
33 | public:
34 |   Frame(temp::Map &tempMap, const CallingConvention &callingConvention);
35 | 
36 |   virtual ~Frame() noexcept = default;
37 | 
38 |   virtual temp::Label name() const                   = 0;
39 |   virtual const AccessList &formals() const          = 0;
40 |   virtual VariableAccess allocateLocal(bool escapes) = 0;
41 |   // move input parameters to the function frame
42 |   // store and restore callee saved registers
43 |   ir::Statement procEntryExit1(const ir::Statement &body) const;
44 |   // add prolog and epilog
45 |   assembly::Instructions
46 |     procEntryExit3(const assembly::Instructions &body) const;
47 | 
48 | protected:
49 |     
50 |   temp::Map &m_tempMap;
51 |   const CallingConvention &m_callingConvention;
52 |   ir::Statements m_parameterMoves;
53 | };
54 | 
55 | } // namespace frame
56 | } // namespace tiger
57 | 


--------------------------------------------------------------------------------
/Chapter10/Machine.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | #include <vector>
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | class CallingConvention;
 8 | }
 9 | 
10 | namespace assembly {
11 | class CodeGenerator;
12 | } // namespace assembly
13 | 
14 | class Machine {
15 | public:
16 |   virtual ~Machine() = default;
17 | 
18 |   virtual temp::PredefinedRegisters predefinedRegisters() const = 0;
19 | 
20 |   virtual frame::CallingConvention &callingConvention()             = 0;
21 |   virtual const frame::CallingConvention &callingConvention() const = 0;
22 | 
23 |   virtual assembly::CodeGenerator &codeGenerator()             = 0;
24 |   virtual const assembly::CodeGenerator &codeGenerator() const = 0;
25 | };
26 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/MachineRegistrar.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Machine.h"
 3 | #include <functional>
 4 | #include <unordered_map>
 5 | #include <stdexcept>
 6 | 
 7 | #define REGISTER_MACHINE(name, type)                                           \
 8 |                                                                                \
 9 |   namespace {                                                                  \
10 |   tiger::AutoRegistrar<type> registered_##name(#name);                         \
11 |   }
12 | 
13 | namespace tiger {
14 | 
15 | using MachineRegistrar =
16 |   std::unordered_map<std::string, std::function<std::unique_ptr<Machine>()>>;
17 | 
18 | inline MachineRegistrar &machineRegistrar() {
19 |   static MachineRegistrar registrar;
20 |   return registrar;
21 | }
22 | 
23 | struct NoSuchArchError : std::logic_error {
24 |   using std::logic_error::logic_error;
25 | };
26 | 
27 | template <typename Creator>
28 | inline void registerMachine(const std::string &arch, Creator &&creator) {
29 |   machineRegistrar()[arch] = std::forward<Creator>(creator);
30 | }
31 | 
32 | template <typename ArchMachine> struct AutoRegistrar {
33 |   AutoRegistrar(const std::string &arch) {
34 |     registerMachine(arch, []() { return std::make_unique<ArchMachine>(); });
35 |   }
36 | };
37 | 
38 | inline std::unique_ptr<Machine> createMachine(const std::string &arch) {
39 |   auto it = machineRegistrar().find(arch);
40 |   if (it == machineRegistrar().end()) {
41 |     throw NoSuchArchError{"no machine named " + arch};
42 |   }
43 |   return it->second();
44 | }
45 | 
46 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/MachineRegistration.h.in:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include "MachineRegistrar.h"
3 | @MACHINE_INCLUDES@
4 | 
5 | @MACHINE_REGISTRATIONS@


--------------------------------------------------------------------------------
/Chapter10/Program.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempRegister.h"
 3 | #include <boost/optional/optional_fwd.hpp>
 4 | #include <map>
 5 | #include <ostream>
 6 | #include <set>
 7 | #include <string>
 8 | #include <vector>
 9 | 
10 | namespace tiger {
11 | 
12 | struct CompileResults {
13 |   std::string m_assembly;
14 |   using InterferenceGraph = std::map<std::string, std::set<std::string>>;
15 |   std::vector<InterferenceGraph> m_interferenceGraphs;
16 | 
17 |   friend std::ostream &operator<<(std::ostream &ost,
18 |                                   const CompileResults &results);
19 | };
20 | 
21 | using CompileResult = boost::optional<CompileResults>;
22 | 
23 | CompileResult compileFile(const std::string &arch, const std::string &filename);
24 | 
25 | CompileResult compile(const std::string &arch, const std::string &string);
26 | 
27 | } // namespace tiger
28 | 


--------------------------------------------------------------------------------
/Chapter10/Skipper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "warning_suppress.h"
 3 | MSC_DIAG_OFF(4996 4459)
 4 | #include <boost/spirit/include/qi.hpp>
 5 | MSC_DIAG_ON()
 6 | 
 7 | namespace tiger {
 8 | template <typename Iterator>
 9 | class Skipper : public boost::spirit::qi::grammar<Iterator> {
10 | public:
11 |   Skipper() : Skipper::base_type(skip) {
12 |     namespace ascii = boost::spirit::ascii;
13 | 
14 |     using ascii::char_;
15 |     ascii::space_type space;
16 | 
17 |     skip = space                             // tab/space/cr/lf
18 |            | "/*" >> *(char_ - "*/") >> "*/" // comments
19 |       ;
20 |   }
21 | 
22 | private:
23 |   boost::spirit::qi::rule<Iterator> skip;
24 | };
25 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/TempLabel.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_safe/strong_typedef.hpp>
 3 | #include <vector>
 4 | 
 5 | namespace tiger {
 6 | namespace temp {
 7 | 
 8 | // a label is just a string
 9 | struct Label : type_safe::strong_typedef<Label, std::string>,
10 |                type_safe::strong_typedef_op::equality_comparison<Label>,
11 |                type_safe::strong_typedef_op::output_operator<Label> {
12 |   using strong_typedef::strong_typedef;
13 | 
14 |   std::string& get() {
15 |     return type_safe::get(*this);
16 |   }
17 | 
18 |   const std::string& get() const {
19 |     return type_safe::get(*this);
20 |   }
21 | };
22 | 
23 | using Labels = std::vector<temp::Label>;
24 | 
25 | } // namespace temp
26 | } // namespace tiger
27 | 
28 | namespace std {
29 | // we want to use it with the std::unordered_* containers
30 | template <>
31 | struct hash<tiger::temp::Label>
32 |     : type_safe::hashable<tiger::temp::Label> {};
33 | } // namespace std
34 | 


--------------------------------------------------------------------------------
/Chapter10/TempMap.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * temp.cpp - functions to create and manipulate Register variables which are
 3 |  *          used in the IR tree representation before it has been determined
 4 |  *          which variables are to go into registers.
 5 |  *
 6 |  */
 7 | 
 8 | #include "TempMap.h"
 9 | #include "warning_suppress.h"
10 | #include <boost/optional.hpp>
11 | #include <ostream>
12 | 
13 | namespace tiger {
14 | 
15 | namespace temp {
16 | 
17 | std::ostream &operator<<(std::ostream &ost, const Map &map) {
18 |   for (const auto &it : map.m_map) {
19 |     ost << "t" << it.first << " -> " << it.second << '\n';
20 |   }
21 |   if (map.m_under) {
22 |     ost << "---------\n";
23 |     ost << *map.m_under;
24 |   }
25 | 
26 |   return ost;
27 | }
28 | 
29 | Map::Map(const PredefinedRegisters &predefinedRegisters /*= {}*/) :
30 |     m_map{predefinedRegisters} {}
31 | 
32 | void Map::layerOver(Map &&under) {
33 |   if (m_under) {
34 |     m_under->layerOver(std::move(under));
35 |   } else {
36 |     m_under.reset(&under);
37 |   }
38 | }
39 | 
40 | Register Map::newTemp() {
41 |   Register res{m_nextTemp};
42 |   m_map[res] = "t" + std::to_string(m_nextTemp++);
43 |   return res;
44 | }
45 | 
46 | boost::optional<std::string> Map::lookup(const Register &t) const {
47 |   auto it = m_map.find(t);
48 |   if (it != m_map.end())
49 |     return it->second;
50 |   if (m_under)
51 |     return m_under->lookup(t);
52 |   return {};
53 | }
54 | 
55 | Label Map::newLabel() {
56 |   static const auto MIN_LABEL = 0;
57 |   static auto labels          = MIN_LABEL;
58 |   return Label{"L" + std::to_string(labels++)};
59 | }
60 | 
61 | Label Map::namedLabel(const std::string &name) { return Label{name}; }
62 | 
63 | } // namespace temp
64 | } // namespace tiger
65 | 


--------------------------------------------------------------------------------
/Chapter10/TempMap.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/optional/optional_fwd.hpp>
 3 | #include <iosfwd>
 4 | #include <memory>
 5 | #include <string>
 6 | #include <unordered_map>
 7 | #include <vector>
 8 | #include "TempRegister.h"
 9 | #include "TempLabel.h"
10 | 
11 | namespace tiger {
12 | namespace temp {
13 | 
14 | using PredefinedRegisters = std::unordered_map<Register, std::string>;
15 | 
16 | constexpr auto MIN_TEMP = 100;
17 | 
18 | // A Map is just a table whose keys are Temp_temps and whose bindings
19 | // are strings. However, one mapping can be layered over another; if σ3 =
20 | // layer(σ1, σ2), this means that look(σ3, t) will first try look(σ1, t), and if
21 | // that fails it will try look(σ2, t).Also, enter(σ3, t, a) will have the effect
22 | // of entering t->a into σ2.
23 | class Map {
24 | public:
25 |   Map(const PredefinedRegisters &predefinedRegisters = {});
26 |   void layerOver(Map &&under);
27 |   Register newTemp();
28 |   boost::optional<std::string> lookup(const Register &t) const;
29 |   friend std::ostream &operator<<(std::ostream &ost, const Map &map);
30 | 
31 |   Label newLabel();
32 |   Label namedLabel(const std::string &name);
33 | 
34 | private:
35 |   std::unordered_map<Register, std::string> m_map;
36 |   std::unique_ptr<Map> m_under;
37 |   int m_nextTemp = MIN_TEMP;
38 | };
39 | 
40 | } // namespace temp
41 | } // namespace tiger
42 | 


--------------------------------------------------------------------------------
/Chapter10/TempRegister.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_safe/strong_typedef.hpp>
 3 | #include <vector>
 4 | 
 5 | namespace tiger {
 6 | namespace temp {
 7 | 
 8 | // a register is just a number
 9 | struct Register : type_safe::strong_typedef<Register, int>,
10 |                   type_safe::strong_typedef_op::equality_comparison<Register>,
11 |                   type_safe::strong_typedef_op::relational_comparison<Register>,
12 |                   type_safe::strong_typedef_op::output_operator<Register> {
13 |   using strong_typedef::strong_typedef;
14 | };
15 | 
16 | using Registers = std::vector<temp::Register>;
17 | 
18 | } // namespace temp
19 | } // namespace tiger
20 | 
21 | namespace std {
22 | // we want to use it with the std::unordered_* containers
23 | template <>
24 | struct hash<tiger::temp::Register>
25 |     : type_safe::hashable<tiger::temp::Register> {};
26 | } // namespace std
27 | 


--------------------------------------------------------------------------------
/Chapter10/Types.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <boost/variant.hpp>
 4 | #include <string>
 5 | #include <unordered_map>
 6 | #include <vector>
 7 | 
 8 | namespace tiger {
 9 | 
10 | struct NilType {};
11 | 
12 | struct IntType {};
13 | 
14 | struct StringType {};
15 | 
16 | struct ArrayType;
17 | 
18 | struct RecordType;
19 | 
20 | struct NameType {
21 |   std::string m_name;
22 | };
23 | 
24 | struct VoidType {};
25 | 
26 | using Type =
27 |   boost::variant<NilType, IntType, StringType,
28 |                  boost::recursive_wrapper<ArrayType>,
29 |                  boost::recursive_wrapper<RecordType>, NameType, VoidType>;
30 | 
31 | struct NamedType {
32 |   std::string m_name;
33 |   Type m_type;
34 | };
35 | 
36 | struct ArrayType {
37 |   NamedType m_elementType;
38 | };
39 | 
40 | struct RecordType {
41 |   struct RecordField {
42 |     std::string m_name;
43 |     NamedType m_type;
44 |   };
45 |   std::vector<RecordField> m_fields;
46 | };
47 | 
48 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/m68k/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES m68kFrame.cpp m68kCallingConvention.cpp m68kCodeGenerator.cpp m68kMachine.cpp)
 2 | set(HEADERS m68kFrame.h m68kCallingConvention.h m68kCodeGenerator.h m68kRegisters.h m68kMachine.h)
 3 | 
 4 | add_library(${CHAPTER}_m68k ${HEADERS} ${SOURCES})
 5 | 
 6 | set_target_properties(${CHAPTER}_m68k PROPERTIES OUTPUT_NAME m68k)
 7 | 
 8 | target_include_directories(${CHAPTER}_m68k PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/..)
 9 | 
10 | target_link_libraries(${CHAPTER}_m68k 
11 |   PRIVATE 
12 |     includeHeaders 
13 |     Boost::boost
14 | )


--------------------------------------------------------------------------------
/Chapter10/m68k/m68kCallingConvention.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "CallingConvention.h"
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | namespace m68k {
 8 | class CallingConvention final : public frame::CallingConvention {
 9 | public:
10 |   std::unique_ptr<frame::Frame> createFrame(temp::Map &tempMap,
11 |                                             const temp::Label &name,
12 |                                             const BoolList &formals) override;
13 | 
14 |   int wordSize() const override;
15 | 
16 |   temp::Register framePointer() const override;
17 | 
18 |   temp::Register returnValue() const override;
19 | 
20 |   temp::Register stackPointer() const override;
21 | 
22 |   const temp::Registers &callDefinedRegisters() const override;
23 | 
24 |   const temp::Registers &calleeSavedRegisters() const override;
25 | 
26 |   const temp::Registers &argumentRegisters() const override;
27 | };
28 | } // namespace m68k
29 | } // namespace frame
30 | } // namespace tiger
31 | 


--------------------------------------------------------------------------------
/Chapter10/m68k/m68kCodeGenerator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "CodeGenerator.h"
 3 | 
 4 | namespace tiger {
 5 | namespace assembly {
 6 | namespace m68k {
 7 | class CodeGenerator : public assembly::CodeGenerator {
 8 | public:
 9 |   CodeGenerator(frame::CallingConvention &callingConvention);
10 | 
11 |   Instructions translateString(const temp::Label &label,
12 |                                const std::string &string,
13 |                                temp::Map &tempMap) override;
14 | 
15 | private:
16 |   Instructions translateArgs(const std::vector<ir::Expression> &args,
17 |                              const temp::Map &tempMap) const override;
18 | };
19 | } // namespace m68k
20 | } // namespace assembly
21 | } // namespace tiger
22 | 


--------------------------------------------------------------------------------
/Chapter10/m68k/m68kFrame.cpp:
--------------------------------------------------------------------------------
 1 | #include "m68kFrame.h"
 2 | #include "Assembly.h"
 3 | #include "CallingConvention.h"
 4 | #include "variantMatch.h"
 5 | #include <boost/dynamic_bitset.hpp>
 6 | #include <cassert>
 7 | 
 8 | namespace tiger {
 9 | namespace frame {
10 | namespace m68k {
11 | 
12 | Frame::Frame(temp::Map &tempMap,
13 |              const frame::CallingConvention &callingConvention,
14 |              const temp::Label &name, const BoolList &formals) :
15 |     frame::Frame{tempMap, callingConvention},
16 |     m_name(name), m_wordSize{callingConvention.wordSize()}, m_frameOffset{
17 |                                                               -m_wordSize} {
18 |   for (size_t i = 0; i < formals.size(); ++i) {
19 |     auto const varAccess = InFrame{m_frameOffset};
20 |     m_formals.emplace_back(varAccess);
21 |     m_frameOffset -= m_wordSize;
22 | 
23 |     m_parameterMoves.emplace_back(ir::Move{
24 |       ir::MemoryAccess{ir::BinaryOperation{ir::BinOp::PLUS,
25 |                                            m_callingConvention.stackPointer(),
26 |                                            static_cast<int>(i * m_wordSize)}},
27 |       m_callingConvention.accessFrame(varAccess,
28 |                                       m_callingConvention.framePointer())});
29 |   }
30 | }
31 | 
32 | temp::Label Frame::name() const { return m_name; }
33 | 
34 | const AccessList &Frame::formals() const { return m_formals; }
35 | 
36 | VariableAccess Frame::allocateLocal(bool escapes) {
37 |   if (escapes) {
38 |     auto res = InFrame{m_frameOffset};
39 |     m_frameOffset -= m_wordSize;
40 |     return res;
41 |   }
42 | 
43 |   return InReg{m_tempMap.newTemp()};
44 | }
45 | 
46 | } // namespace m68k
47 | } // namespace frame
48 | } // namespace tiger
49 | 


--------------------------------------------------------------------------------
/Chapter10/m68k/m68kFrame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Frame.h"
 4 | #include "m68kRegisters.h"
 5 | #include <array>
 6 | 
 7 | namespace tiger {
 8 | namespace frame {
 9 | namespace m68k {
10 | // implements
11 | // https://docs.microsoft.com/en-gb/cpp/build/overview-of-x64-calling-conventions
12 | class Frame final : public frame::Frame {
13 | public:
14 | 
15 |   Frame(temp::Map &tempMap, const frame::CallingConvention &callingConvention,
16 |         const temp::Label &name, const BoolList &formals);
17 | 
18 |   // Inherited via Frame
19 |   temp::Label name() const override;
20 | 
21 |   const AccessList &formals() const override;
22 | 
23 |   VariableAccess allocateLocal(bool escapes) override;
24 | 
25 | private:
26 |   temp::Label m_name;
27 |   AccessList m_formals;
28 |   int m_wordSize;
29 |   int m_frameOffset;
30 | };
31 | } // namespace m68k
32 | } // namespace frame
33 | } // namespace tiger
34 | 


--------------------------------------------------------------------------------
/Chapter10/m68k/m68kMachine.cpp:
--------------------------------------------------------------------------------
 1 | #include "m68kMachine.h"
 2 | #include "Tree.h"
 3 | #include "m68kRegisters.h"
 4 | 
 5 | namespace tiger {
 6 | namespace m68k {
 7 | 
 8 | frame::CallingConvention &Machine::callingConvention() {
 9 |   return m_callingConvention;
10 | }
11 | const frame::CallingConvention &Machine::callingConvention() const {
12 |   return m_callingConvention;
13 | }
14 | assembly::CodeGenerator &Machine::codeGenerator() { return m_codeGenerator; }
15 | const assembly::CodeGenerator &Machine::codeGenerator() const {
16 |   return m_codeGenerator;
17 | }
18 | temp::PredefinedRegisters Machine::predefinedRegisters() const {
19 |   using namespace tiger::frame::m68k;
20 |   return {{reg(Registers::D0), "D0"},
21 |           {reg(Registers::D1), "D1"},
22 |           {reg(Registers::D2), "D2"},
23 |           {reg(Registers::D3), "D3"},
24 |           {reg(Registers::D4), "D4"},
25 |           {reg(Registers::D5), "D5"},
26 |           {reg(Registers::D6), "D6"},
27 |           {reg(Registers::D7), "D7"},
28 |           {reg(Registers::A0), "A0"},
29 |           {reg(Registers::A1), "A1"},
30 |           {reg(Registers::A2), "A2"},
31 |           {reg(Registers::A3), "A3"},
32 |           {reg(Registers::A4), "A4"},
33 |           {reg(Registers::A5), "A5"},
34 |           {reg(Registers::A6), "A6"},
35 |           {reg(Registers::A7), "A7"}
36 | 
37 |   };
38 | }
39 | } // namespace m68k
40 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/m68k/m68kMachine.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Machine.h"
 4 | #include "m68kCallingConvention.h"
 5 | #include "m68kCodeGenerator.h"
 6 | 
 7 | namespace tiger {
 8 | namespace m68k {
 9 | 
10 | class Machine : public tiger::Machine {
11 | public:
12 |   // Inherited via Machine
13 |   virtual frame::CallingConvention &callingConvention() override;
14 |   virtual const frame::CallingConvention &callingConvention() const override;
15 | 
16 |   virtual assembly::CodeGenerator &codeGenerator() override;
17 |   virtual const assembly::CodeGenerator &codeGenerator() const override;
18 | 
19 | private:
20 |   frame::m68k::CallingConvention m_callingConvention;
21 |   assembly::m68k::CodeGenerator m_codeGenerator{m_callingConvention};
22 | 
23 |   // Inherited via Machine
24 |   virtual temp::PredefinedRegisters predefinedRegisters() const override;
25 | };
26 | } // namespace m68k
27 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/m68k/m68kRegisters.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | 
 4 | namespace tiger {
 5 | namespace frame {
 6 | namespace m68k {
 7 | 
 8 | enum class Registers {
 9 |   D0,
10 |   D1,
11 |   D2,
12 |   D3,
13 |   D4,
14 |   D5,
15 |   D6,
16 |   D7,
17 |   A0,
18 |   A1,
19 |   A2,
20 |   A3,
21 |   A4,
22 |   A5,
23 |   A6,
24 |   A7,
25 |   Size
26 | };
27 | 
28 | constexpr temp::Register reg(Registers reg) {
29 |   return temp::Register{static_cast<int>(reg)};
30 | }
31 | 
32 | static_assert(static_cast<int>(Registers::Size) <= temp::MIN_TEMP,
33 |               "MIN_TEMP should be greater than the greatest register");
34 | } // namespace m68k
35 | } // namespace frame
36 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | add_library(${CHAPTER}_testMain STATIC Test.h TestMain.cpp Test.cpp)
 2 | 
 3 | set_target_properties(${CHAPTER}_testMain PROPERTIES OUTPUT_NAME testMain)
 4 | 
 5 | target_link_libraries(${CHAPTER}_testMain PUBLIC 
 6 |   Catch2::Catch
 7 |   Microsoft.GSL::GSL
 8 |   Boost::filesystem
 9 |   Boost::system 
10 |   includeHeaders
11 |   ${CHAPTER}
12 | )
13 | 
14 | function(add_chapter_test name)
15 | 
16 |   if(MSVC)
17 | 	  set_source_files_properties(${name}.cpp PROPERTIES COMPILE_FLAGS /bigobj)
18 |   endif()
19 | 
20 |   add_executable(${CHAPTER}_${name} ${name}.cpp)
21 | 
22 |   set_target_properties(${CHAPTER}_${name} PROPERTIES OUTPUT_NAME ${name})
23 | 
24 |   target_link_libraries(${CHAPTER}_${name}
25 |     PRIVATE
26 |       ${CHAPTER}_testMain
27 |   )
28 |   
29 |   parse_unit_tests(${CHAPTER}_${name} ARCHS m68k x64)
30 | endfunction()
31 | 
32 | add_chapter_test(compileFiles)
33 | add_chapter_test(lvalue)
34 | add_chapter_test(for)
35 | add_chapter_test(integer)
36 | add_chapter_test(comparison)
37 | add_chapter_test(typeDeclarations)
38 | add_chapter_test(boolean)
39 | add_chapter_test(array)
40 | add_chapter_test(nil)
41 | add_chapter_test(functionCall)
42 | add_chapter_test(string)
43 | add_chapter_test(assignment)
44 | add_chapter_test(arithmetic)
45 | add_chapter_test(ifThen)
46 | add_chapter_test(while)
47 | add_chapter_test(library)
48 | add_chapter_test(record)
49 | add_chapter_test(sequence)
50 | add_chapter_test(functionDeclarations)
51 | add_chapter_test(break)


--------------------------------------------------------------------------------
/Chapter10/test/TestMain.cpp:
--------------------------------------------------------------------------------
 1 | #define CATCH_CONFIG_RUNNER
 2 | #include <catch/catch.hpp>
 3 | 
 4 | std::string arch;
 5 | 
 6 | int main(int argc, char *argv[]) {
 7 |   Catch::Session session; // There must be exactly one instance
 8 | 
 9 |   // Build a new parser on top of Catch's
10 |   using namespace Catch::clara;
11 |   auto cli =
12 |     session.cli() // Get Catch's composite command line parser
13 |     | Opt(
14 |         [&](const std::string &val) {
15 |           if (val == "m68k" || val == "x64") {
16 |             arch = val;
17 |             return detail::ParserResult::ok(detail::ParseResultType::Matched);
18 |           }
19 | 
20 |           return detail::ParserResult::runtimeError("unknown architecture "
21 |                                                     + val);
22 |         },
23 |         "architecture") // bind variable to a new option, with a hint string
24 |         ["--arch"]      // the option names it will respond to
25 |     ("target architecture: x64/m68k. Defaults to m68k");
26 | 
27 |   // Now pass the new composite back to Catch so it uses that
28 |   session.cli(cli);
29 | 
30 |   auto return_code = session.applyCommandLine(argc, argv);
31 | 
32 |   if (return_code) {
33 |     return return_code;
34 |   }
35 | 
36 |   if (arch.empty()) {
37 |     arch = "m68k";
38 |   }
39 | 
40 |   return session.run();
41 | }


--------------------------------------------------------------------------------
/Chapter10/test/arithmetic.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | MSC_DIAG_OFF(4459)
 3 | #include <range/v3/action/sort.hpp>
 4 | #include <range/v3/action/unique.hpp>
 5 | MSC_DIAG_ON()
 6 | #include <boost/format.hpp>
 7 | 
 8 | TEST_CASE_METHOD(TestFixture, "arithmetic") {
 9 |   static const std::pair<std::string, ir::BinOp> operations[] = {
10 |     {"+", ir::BinOp::PLUS},
11 |     {"-", ir::BinOp::MINUS},
12 |     {"*", ir::BinOp::MUL},
13 |     {"/", ir::BinOp::DIV}};
14 | 
15 |   for (const auto &op : operations) {
16 |     SECTION(Catch::StringMaker<ir::BinOp>::convert(op.second)) {
17 |       auto results = checkedCompile(boost::str(boost::format(R"(
18 |  let
19 |    var i : int := 2 %1% 3
20 |  in
21 |    i
22 |  end
23 |  )") % op.first));
24 |       OptReg regs[4];
25 |       OptLabel end;
26 |       OptIndex endIndex;
27 |       checkProgram(results, checkMain(), checkMove(regs[0], 2),
28 |                    checkMove(regs[1], 3, {regs[0]}),
29 |                    checkBinaryOperation(op.second, regs[0], regs[1], regs[2]),
30 |                    checkMove(regs[3], regs[2]), // move result of 2 op 3 to r
31 |                    checkMove(returnReg(), regs[3]), // return i
32 |                    branchToEnd(end, endIndex), checkFunctionExit());
33 |     }
34 |   }
35 | }


--------------------------------------------------------------------------------
/Chapter10/test/array.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE_METHOD(TestFixture, "array") {
 4 |   auto results = checkedCompile(R"(
 5 | let
 6 |  type t = array of int
 7 | in
 8 |  t[2] of 3
 9 | end
10 | )");
11 |   OptReg regs[4];
12 |   OptLabel end;
13 |   OptIndex endIndex;
14 |   checkProgram(
15 |     results, checkMain(), checkMove(regs[0], wordSize()), checkMove(regs[1], 2, {regs[0]}),
16 |     checkBinaryOperation(ir::BinOp::MUL, regs[0], regs[1], regs[2]),
17 |     checkCall("malloc", {returnReg()}, regs[2]),
18 |     checkMove(regs[3], returnReg()), // move result of malloc(array_size) to r
19 |     checkCall("initArray", {regs[3]}, 2, 3),    // call initArray(array_size, init_val),
20 |     checkMove(returnReg(), regs[3]), branchToEnd(end, endIndex),
21 |     checkFunctionExit());
22 | }


--------------------------------------------------------------------------------
/Chapter10/test/assignment.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE_METHOD(TestFixture, "assignment") {
 4 |   auto results = checkedCompile(R"(
 5 | let
 6 |  var a := 3
 7 |  var b := 0
 8 | in
 9 |  b := a
10 | end
11 | )");
12 |   OptReg a, b;
13 |   OptLabel end;
14 |   OptIndex endIndex;
15 |   checkProgram(results, checkMain(), checkMove(a, 3), // move 3 to a
16 |                checkMove(b, 0, {a}),                       // move 0 to b
17 |                checkMove(b, a),                       // move a to b
18 |                checkMove(returnReg(), 0),             // return 0
19 |                branchToEnd(end, endIndex), checkFunctionExit());
20 | }


--------------------------------------------------------------------------------
/Chapter10/test/compileFiles.cpp:
--------------------------------------------------------------------------------
 1 | #include "Program.h"
 2 | #include "testsHelper.h"
 3 | #include <boost/optional/optional_io.hpp>
 4 | #include <catch/catch.hpp>
 5 | 
 6 | extern std::string arch;
 7 | 
 8 | TEST_CASE("compile test files") {
 9 |   namespace fs = boost::filesystem;
10 |   tiger::forEachTigerTest(
11 |     [](const fs::path &filepath, bool parseError, bool compilationError) {
12 |       SECTION(filepath.filename().string()) {
13 |         if (parseError || compilationError) {
14 |           REQUIRE_FALSE(tiger::compileFile(arch, filepath.string()));
15 |         } else {
16 |           REQUIRE(tiger::compileFile(arch, filepath.string()));
17 |         }
18 |       }
19 |     });
20 | }


--------------------------------------------------------------------------------
/Chapter10/test/for.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE_METHOD(TestFixture, "for") {
 4 |   auto results = checkedCompile(R"(
 5 | let
 6 |   function f(a: int) = ()
 7 | in
 8 |   for a := 0 to 4 do f(a)
 9 | end
10 | )");
11 |   OptReg regs[4], staticLink, a, temps[2], functionStartTemps[10];
12 |   OptLabel functionLabel, loopStart, loopDone, functionEnd, end;
13 |   OptIndex functionLabelIndex, loopStartIndex, loopDoneIndex, functionEndIndex,
14 |     endIndex;
15 |   checkProgram(
16 |     results,
17 |     checkFunctionStart(functionLabel, functionLabelIndex, functionStartTemps, escapes{staticLink}, a), // function label
18 |     checkMove(returnReg(), 0),                             // body
19 |     branchToEnd(functionEnd, functionEndIndex), checkFunctionExit(),
20 |     checkMain(), checkMove(regs[0], 0), // move 0 to a
21 |     checkMove(regs[1], 4, {regs[0]}),   // move 4 to limit
22 |     checkConditionalJump(ir::RelOp::GT, regs[0], regs[1], loopDone,
23 |                          loopDoneIndex, loopStartIndex,
24 |                          {regs[1]}), // skip the loop if a , limit
25 |     checkLabel(loopStart, loopStartIndex), checkStaticLink(staticLink, temps, {regs[0], regs[1]}),
26 |     checkCall(checkLabel(functionLabel), {regs[0], regs[1]}, staticLink, regs[0]),
27 |     checkMove(regs[2], 1, {regs[0], regs[1]}),
28 |     checkBinaryOperation(ir::BinOp::PLUS, regs[0], regs[2], regs[3], {regs[1]}),
29 |     checkMove(regs[0], regs[3], {regs[1]}), // a := a + 1
30 |     checkConditionalJump(ir::RelOp::LT, regs[0], regs[1], loopStart,
31 |                          loopStartIndex, loopDoneIndex),
32 |     checkLabel(loopDone, loopDoneIndex), checkMove(returnReg(), 0),
33 |     branchToEnd(end, endIndex), checkFunctionExit());
34 | }


--------------------------------------------------------------------------------
/Chapter10/test/functionCall.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE_METHOD(TestFixture, "function call") {
 4 |   OptLabel functionLabel, functionEnd, end;
 5 |   OptIndex functionLabelIndex, functionEndIndex, endIndex;
 6 |   OptReg staticLink, temps[2];
 7 | 
 8 |   SECTION("with no arguments") {
 9 |     OptReg functionStartTemps[5];
10 |     auto results = checkedCompile(R"(
11 | let
12 |  function f() = ()
13 | in
14 |  f()
15 | end
16 | )");
17 | 
18 |     checkProgram(
19 |       results,
20 |       checkFunctionStart(functionLabel, functionLabelIndex, functionStartTemps,
21 |                          escapes{staticLink}), // function label
22 |       checkMove(returnReg(), 0),              // body
23 |       branchToEnd(functionEnd, functionEndIndex), checkFunctionExit(),
24 |       checkMain(), checkStaticLink(staticLink, temps),
25 |       checkCall(checkLabel(functionLabel), {}, staticLink), // call
26 |       branchToEnd(end, endIndex), checkFunctionExit());
27 |   }
28 | 
29 |   SECTION("with arguments") {
30 |     OptReg a, functionStartTemps[10];
31 |     auto results = checkedCompile(R"(
32 |   let
33 |    function f(a: int) = ()
34 |   in
35 |    f(2)
36 |   end
37 |   )");
38 |     checkProgram(
39 |       results,
40 |       checkFunctionStart(functionLabel, functionLabelIndex, functionStartTemps,
41 |                          escapes{staticLink}, a), // function label,
42 |       checkMove(returnReg(), 0),                 // body
43 |       branchToEnd(functionEnd, functionEndIndex), checkFunctionExit(),
44 |       checkMain(), checkStaticLink(staticLink, temps),
45 |       checkCall(checkLabel(functionLabel), {}, staticLink, 2), // call
46 |       branchToEnd(end, endIndex), checkFunctionExit());
47 |   }
48 | }


--------------------------------------------------------------------------------
/Chapter10/test/integer.cpp:
--------------------------------------------------------------------------------
1 | #include "Test.h"
2 | 
3 | TEST_CASE_METHOD(TestFixture, "integer") {
4 |   OptLabel end;
5 |   OptIndex endIndex;
6 |   auto results = checkedCompile("42");
7 |   checkProgram(results, checkMain(), checkMove(returnReg(), 42),
8 |                branchToEnd(end, endIndex), checkFunctionExit());
9 | }


--------------------------------------------------------------------------------
/Chapter10/test/nil.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE_METHOD(TestFixture, "nil") {
 4 |   OptReg rv = returnReg();
 5 |   OptLabel end;
 6 |   OptIndex endIndex;
 7 |   auto results  = checkedCompile("nil");
 8 |   checkProgram(results, checkMain(), checkMove(rv, 0), branchToEnd(end, endIndex),
 9 |     checkFunctionExit());
10 |   checkInterference(results.m_interferenceGraphs);
11 | }


--------------------------------------------------------------------------------
/Chapter10/test/record.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE_METHOD(TestFixture, "record") {
 4 |   OptLabel end;
 5 |   OptIndex endIndex;
 6 | 
 7 |   SECTION("empty") {
 8 |     auto results = checkedCompile(R"(
 9 | let
10 |  type t = {}
11 | in
12 |  t{}
13 | end
14 | )");
15 |     OptReg regs[2];
16 |     checkProgram(
17 |       results, checkMain(), checkCall("malloc", {returnReg()}, 0),
18 |       checkMove(regs[1], returnReg()), // move result of malloc(record_size) to
19 |       checkMove(returnReg(), regs[1]), branchToEnd(end, endIndex),
20 |       checkFunctionExit());
21 |   }
22 | 
23 |   SECTION("not empty") {
24 |     auto results = checkedCompile(R"(
25 | let
26 |  type t = {a: int, b: string}
27 | in
28 |  t{a = 2, b = "hello"}
29 | end
30 | )");
31 | 
32 |     OptReg regs[4], temps[2][4];
33 |     OptLabel stringLabel;
34 |     OptIndex stringLabelIndex;
35 |     checkProgram(
36 |       results, checkStringInit(stringLabel, R"("hello")", stringLabelIndex), checkMain(),
37 |       checkCall("malloc", {returnReg()}, 2 * wordSize()),
38 |       checkMove(regs[1], returnReg()),// move result of malloc(record_size) to r
39 |       checkMemberAccess(regs[1], 0, regs[2], temps[0], {regs[1]}),
40 |       checkMove(regs[2], 2, {regs[1]}), // init first member with 2
41 |       checkMemberAccess(regs[1], 1, regs[3], temps[1], {regs[1]}),
42 |       checkMove(checkReg(regs[3]), checkString(stringLabel), {}, {regs[3]}, false,
43 |                 {regs[1]}), // init second member with "hello"
44 |       checkMove(returnReg(), regs[1]),
45 |       branchToEnd(end, endIndex), checkFunctionExit());
46 |   }
47 |   }


--------------------------------------------------------------------------------
/Chapter10/test/sequence.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE_METHOD(TestFixture, "sequence") {
 4 |   OptLabel end;
 5 |   OptIndex endIndex;
 6 |   SECTION("empty") {
 7 |     auto results = checkedCompile("()");
 8 |     checkProgram(results, checkMain(), checkMove(returnReg(), 0),
 9 |                  branchToEnd(end, endIndex), checkFunctionExit());
10 |   }
11 | 
12 |   SECTION("single") {
13 |     auto results = checkedCompile("(42)");
14 |     checkProgram(results, checkMain(), checkMove(returnReg(), 42),
15 |                  branchToEnd(end, endIndex), checkFunctionExit());
16 |   }
17 | 
18 |   SECTION("multiple") {
19 |     // no-op expressions are removed
20 |     auto results = checkedCompile(R"((1;"two";flush()))");
21 |     OptReg temps[2], staticLink;
22 |     OptLabel strLabel;
23 |     OptIndex stringLabelIndex;
24 |     checkProgram(results,
25 |                  checkStringInit(strLabel, R"("two")", stringLabelIndex),
26 |                  checkMain(), checkStaticLink(staticLink, temps),
27 |                  checkCall("flush", {}, staticLink), branchToEnd(end, endIndex),
28 |                  checkFunctionExit());
29 |   }
30 | }


--------------------------------------------------------------------------------
/Chapter10/test/string.cpp:
--------------------------------------------------------------------------------
 1 | #include "Test.h"
 2 | 
 3 | TEST_CASE_METHOD(TestFixture, "string") {
 4 |   auto str     = R"("\tHello \"World\"!\n")";
 5 |   auto results = checkedCompile(str);
 6 |   OptLabel stringLabel, end;
 7 |   OptIndex stringLabelIndex, endIndex;
 8 |   checkProgram(results, checkStringInit(stringLabel, str, stringLabelIndex), checkMain(),
 9 |                checkMove(checkReg(returnReg()), checkString(stringLabel), {}, {returnReg()}),
10 |                branchToEnd(end, endIndex), checkFunctionExit());
11 | }


--------------------------------------------------------------------------------
/Chapter10/x64/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(SOURCES x64Frame.cpp x64CallingConvention.cpp x64CodeGenerator.cpp x64Machine.cpp)
 2 | set(HEADERS x64Frame.h x64CallingConvention.h x64CodeGenerator.h x64Registers.h x64Machine.h)
 3 | 
 4 | add_library(${CHAPTER}_x64 ${HEADERS} ${SOURCES})
 5 | 
 6 | set_target_properties(${CHAPTER}_x64 PROPERTIES OUTPUT_NAME x64)
 7 | 
 8 | target_include_directories(${CHAPTER}_x64 PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/..)
 9 | 
10 | target_link_libraries(${CHAPTER}_x64 
11 |   PRIVATE 
12 |     includeHeaders 
13 |     Boost::boost
14 | )


--------------------------------------------------------------------------------
/Chapter10/x64/x64CallingConvention.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "CallingConvention.h"
 4 | 
 5 | namespace tiger {
 6 | namespace frame {
 7 | namespace x64 {
 8 | class CallingConvention final : public frame::CallingConvention {
 9 | public:
10 |   std::unique_ptr<frame::Frame> createFrame(temp::Map &tempMap,
11 |                                             const temp::Label &name,
12 |                                             const BoolList &formals) override;
13 | 
14 |   int wordSize() const override;
15 | 
16 |   temp::Register framePointer() const override;
17 | 
18 |   temp::Register returnValue() const override;
19 | 
20 |   temp::Register stackPointer() const override;
21 | 
22 |   const temp::Registers &callDefinedRegisters() const override;
23 | 
24 |   const temp::Registers &calleeSavedRegisters() const override;
25 | 
26 |   const temp::Registers &argumentRegisters() const override;
27 | };
28 | } // namespace x64
29 | } // namespace frame
30 | } // namespace tiger
31 | 


--------------------------------------------------------------------------------
/Chapter10/x64/x64CodeGenerator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "CodeGenerator.h"
 3 | 
 4 | namespace tiger {
 5 | namespace assembly {
 6 | namespace x64 {
 7 | class CodeGenerator : public assembly::CodeGenerator {
 8 | public:
 9 |   CodeGenerator(frame::CallingConvention &callingConvention);
10 | 
11 |   Instructions translateString(const temp::Label &label,
12 |                                const std::string &string,
13 |                                temp::Map &tempMap) override;
14 | 
15 |   Instructions translateArgs(const std::vector<ir::Expression> &args,
16 |                              const temp::Map &tempMap) const override;
17 | };
18 | } // namespace x64
19 | } // namespace assembly
20 | } // namespace tiger
21 | 


--------------------------------------------------------------------------------
/Chapter10/x64/x64Frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Frame.h"
 4 | #include "x64Registers.h"
 5 | #include <array>
 6 | 
 7 | namespace tiger {
 8 | namespace frame {
 9 | namespace x64 {
10 | // implements
11 | // https://docs.microsoft.com/en-gb/cpp/build/overview-of-x64-calling-conventions
12 | class Frame final : public frame::Frame {
13 | public:
14 | 
15 |   Frame(temp::Map &tempMap, const frame::CallingConvention &callingConvention,
16 |         const temp::Label &name, const BoolList &formals);
17 | 
18 |   // Inherited via Frame
19 |   virtual temp::Label name() const override;
20 | 
21 |   virtual const AccessList &formals() const override;
22 | 
23 |   virtual VariableAccess allocateLocal(bool escapes) override;
24 | 
25 | private:
26 |   temp::Label m_name;
27 |   AccessList m_formals;
28 |   int m_wordSize;
29 |   int m_frameOffset;
30 | };
31 | } // namespace x64
32 | } // namespace frame
33 | } // namespace tiger
34 | 


--------------------------------------------------------------------------------
/Chapter10/x64/x64Machine.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Machine.h"
 4 | #include "x64CallingConvention.h"
 5 | #include "x64CodeGenerator.h"
 6 | 
 7 | namespace tiger {
 8 | namespace x64 {
 9 | 
10 | class Machine : public tiger::Machine {
11 | public:
12 |   // Inherited via Machine
13 |   virtual frame::CallingConvention &callingConvention() override;
14 |   virtual const frame::CallingConvention &callingConvention() const override;
15 |   virtual assembly::CodeGenerator &codeGenerator() override;
16 |   virtual const assembly::CodeGenerator &codeGenerator() const override;
17 | 
18 | private:
19 |   frame::x64::CallingConvention m_callingConvention;
20 |   assembly::x64::CodeGenerator m_codeGenerator{m_callingConvention};
21 | 
22 |   // Inherited via Machine
23 |   virtual temp::PredefinedRegisters predefinedRegisters() const override;
24 | };
25 | } // namespace x64
26 | } // namespace tiger


--------------------------------------------------------------------------------
/Chapter10/x64/x64Registers.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "TempMap.h"
 3 | 
 4 | namespace tiger {
 5 | namespace frame {
 6 | namespace x64 {
 7 | 
 8 | enum class Registers {
 9 |   RAX,
10 |   RDX,
11 |   RCX,
12 |   RBX,
13 |   RSI,
14 |   RDI,
15 |   RBP,
16 |   RSP,
17 |   R8,
18 |   R9,
19 |   R10,
20 |   R11,
21 |   R12,
22 |   R13,
23 |   R14,
24 |   R15,
25 |   RIP,
26 |   MM0,
27 |   MM1,
28 |   MM2,
29 |   MM3,
30 |   MM4,
31 |   MM5,
32 |   MM6,
33 |   MM7,
34 |   FP0,
35 |   FP1,
36 |   FP2,
37 |   FP3,
38 |   FP4,
39 |   FP5,
40 |   FP6,
41 |   FP7,
42 |   XMM8,
43 |   XMM9,
44 |   XMM10,
45 |   XMM11,
46 |   XMM12,
47 |   XMM13,
48 |   XMM14,
49 |   XMM15,
50 |   XMM16,
51 |   XMM17,
52 |   XMM18,
53 |   XMM19,
54 |   XMM20,
55 |   XMM21,
56 |   XMM22,
57 |   XMM23,
58 |   XMM24,
59 |   XMM25,
60 |   XMM26,
61 |   XMM27,
62 |   XMM28,
63 |   XMM29,
64 |   XMM30,
65 |   XMM31,
66 |   Size
67 | };
68 | 
69 | constexpr temp::Register reg(Registers reg) {
70 |   return temp::Register{static_cast<int>(reg)};
71 | }
72 | 
73 | static_assert(static_cast<int>(Registers::Size) <= temp::MIN_TEMP,
74 |               "MIN_TEMP should be greater than the greatest register");
75 | } // namespace x64
76 | } // namespace frame
77 | } // namespace tiger


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # GreenTiger
 2 | Solutions to exercises of [Modern Compiler Implementation in C](https://www.amazon.com/Modern-Compiler-Implementation-Andrew-Appel/dp/0521607655) book
 3 | 
 4 | ## Build status
 5 | [![AppVeyor](https://ci.appveyor.com/api/projects/status/f2d26mo5vi2ds2sl?svg=true)](https://ci.appveyor.com/project/dvirtz/greentiger)
 6 | [![Travis CI](https://travis-ci.org/dvirtz/GreenTiger.svg?branch=master)](https://travis-ci.org/dvirtz/GreenTiger)
 7 | 
 8 | ## Overview
 9 | Each chapter contains a program which is a step towards building a compiler for the [Tiger](https://www.lrde.epita.fr/~tiger/tiger.html#Tiger-Language-Reference-Manual)
10 | programming language as well as some solutions to other exercises from the book.
11 | 
12 | The compiler is written in C++ and uses [Boost Spirit](http://www.boost.org/doc/libs/1_64_0/libs/spirit/doc/html/index.html) to parse source code and genarate AST.
13 | 


--------------------------------------------------------------------------------
/book/Modern Compiler Implementation in C.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dvirtz/GreenTiger/add89b6a999c35657e024b4152c9592277ac8b15/book/Modern Compiler Implementation in C.pdf


--------------------------------------------------------------------------------
/cmake/CompilerWarnings.cmake:
--------------------------------------------------------------------------------
 1 | 
 2 | option(TREAT_WARNINGS_AS_ERRORS "Treat warnings as errors" TRUE)
 3 | if(MSVC)
 4 |     if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
 5 |         string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 6 |     else()
 7 |         string(APPEND CMAKE_CXX_FLAGS " /W4")
 8 |     endif()
 9 |     string(APPEND CMAKE_CXX_FLAGS " /DBOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE /D_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS")
10 |     if(TREAT_WARNINGS_AS_ERRORS)
11 |       string(APPEND CMAKE_CXX_FLAGS " /WX")
12 |     endif()
13 |     # string(APPEND CMAKE_CXX_FLAGS " /permissive-")
14 | elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
15 |     string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -pedantic -Wno-unused-function -Wno-missing-field-initializers -Wno-missing-braces")
16 |     string(APPEND CMAKE_C_FLAGS " -Wall -Wextra -pedantic -Wmissing-prototypes -Wstrict-prototypes -Wold-style-definition -Wno-unused-function")
17 |     if(TREAT_WARNINGS_AS_ERRORS)
18 |       string(APPEND CMAKE_CXX_FLAGS " -Werror")
19 |     endif()
20 | else()
21 |     message(WARNING "Unable to set warning level: Unknown compiler ${CMAKE_CXX_COMPILER_ID}")
22 | endif()
23 | 


--------------------------------------------------------------------------------
/include/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(HEADERS testsHelper.h.in overload_set.h variantMatch.h fusionAccumulate.h strong_typedef.h vectorApply.h type_traits.h warning_suppress.h)
 2 | 
 3 | add_custom_target(include SOURCES ${HEADERS})
 4 | 
 5 | add_library(includeHeaders INTERFACE)
 6 | 
 7 | set(TESTS_LOCATION ${CMAKE_SOURCE_DIR}/module_bundle/testcases)
 8 | configure_file(testsHelper.h.in ${CMAKE_CURRENT_BINARY_DIR}/testsHelper.h)
 9 | 
10 | target_include_directories(includeHeaders INTERFACE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})


--------------------------------------------------------------------------------
/include/fusionAccumulate.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "overload_set.h"
 3 | #include <boost/fusion/include/accumulate.hpp>
 4 | 
 5 | namespace helpers {
 6 | 
 7 | namespace detail {
 8 | 
 9 | // a function object which calls one of the given overloads depending on the
10 | // variants value
11 | template <typename Sequence, typename State> struct FusionMatcher {
12 |   FusionMatcher(Sequence &sequence, State initState)
13 |       : m_sequence(sequence), m_initState(initState) {}
14 | 
15 |   template <typename... Funcs> auto operator()(Funcs &&... fs) const {
16 |     auto visitor = overload(std::forward<Funcs>(fs)...);
17 |     return boost::fusion::accumulate(m_sequence, m_initState, visitor);
18 |   }
19 | 
20 |   Sequence &m_sequence;
21 |   State m_initState;
22 | };
23 | 
24 | } // namespace detail
25 | 
26 | template <typename Sequence, typename State>
27 | auto accumulate(Sequence &&sequence, State initState) {
28 |   return detail::FusionMatcher<Sequence, State>{
29 |       std::forward<Sequence>(sequence), initState};
30 | }
31 | 
32 | } // namespace helpers
33 | 


--------------------------------------------------------------------------------
/include/irange.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <tuple>
 3 | #ifdef _MSC_VER
 4 | #include <boost/range/iterator_range.hpp>
 5 | #else
 6 | #include <range/v3/iterator_range.hpp>
 7 | #endif
 8 | 
 9 | namespace tiger {
10 | 
11 | template <typename I, typename S> constexpr auto irange(I begin, S end) {
12 | #ifdef _MSC_VER
13 |   return boost::make_iterator_range(begin, end);
14 | #else
15 |   return ranges::make_iterator_range(begin, end);
16 | #endif
17 | }
18 | 
19 | template <typename I, typename S> constexpr auto irange(std::pair<I, S> iterator_pair) {
20 |   return tiger::irange(iterator_pair.first, iterator_pair.second);
21 | }
22 | 
23 | } // namespace tiger


--------------------------------------------------------------------------------
/include/overload_set.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_traits>
 3 | #include <utility>
 4 | 
 5 | namespace helpers {
 6 | 
 7 | namespace detail {
 8 | 
 9 | // https://www.youtube.com/watch?v=mqei4JJRQ7s
10 | // make an overload of multiple function objects
11 | template <typename...> struct overload_set {
12 |   void operator()() {}
13 | };
14 | 
15 | template <typename Func, typename... Funcs>
16 | struct overload_set<Func, Funcs...> : Func, overload_set<Funcs...> {
17 |   using Func::operator();
18 |   using overload_set<Funcs...>::operator();
19 | 
20 |   overload_set(const overload_set &) = default;
21 |   overload_set &operator=(const overload_set &) = default;
22 | 
23 |   overload_set(const Func &f, const Funcs &... fs)
24 |       : Func(f), overload_set<Funcs...>(fs...) {}
25 | };
26 | 
27 | } // namespace detail
28 | 
29 | template <typename... Funcs>
30 | auto
31 | overload(Funcs &&... fs) {
32 |   using os = detail::overload_set<typename std::remove_reference<Funcs>::type...>;
33 |   return os(std::forward<Funcs>(fs)...);
34 | }
35 | 
36 | } // namespace helpers
37 | 


--------------------------------------------------------------------------------
/include/printRange.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "warning_suppress.h"
 3 | #include <ostream>
 4 | MSC_DIAG_OFF(4913)
 5 | #include <range/v3/algorithm/copy.hpp>
 6 | MSC_DIAG_ON()
 7 | MSC_DIAG_OFF(4100)
 8 | #include <range/v3/view/intersperse.hpp>
 9 | MSC_DIAG_ON()
10 | #include <range/v3/view/transform.hpp>
11 | 
12 | namespace helpers {
13 | template <typename R, typename ElementToString>
14 | void printRange(std::ostream &ost, const R &rng,
15 |                 ElementToString &&elementToString) {
16 |   using namespace ranges;
17 |   ost << "{";
18 |   copy(rng | view::transform(std::forward<ElementToString>(elementToString))
19 |          | view::intersperse(", "),
20 |        ostream_iterator<std::string>(ost));
21 |   ost << "}";
22 | }
23 | 
24 | } // namespace helpers


--------------------------------------------------------------------------------
/include/strong_typedef.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <iostream>
 3 | 
 4 | namespace helpers {
 5 | template <typename T> struct strong_typedef {
 6 |   strong_typedef() = default;
 7 |   template<typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
 8 |   constexpr explicit strong_typedef(U u) : m_val(std::move(u)) {}
 9 | 
10 |   explicit operator T() const noexcept { return m_val; }
11 | 
12 |   const T &get() const { return m_val; }
13 | 
14 |   T &get() { return m_val; }
15 | 
16 |   friend std::ostream &operator<<(std::ostream &ost, const strong_typedef &sd) {
17 |     return ost << sd.m_val;
18 |   }
19 | 
20 |   friend bool operator==(const strong_typedef &lhs, const strong_typedef &rhs) {
21 |     return lhs.m_val == rhs.m_val;
22 |   }
23 | 
24 |   friend bool operator==(const strong_typedef &lhs, const T &rhs) {
25 |     return lhs.m_val == rhs;
26 |   }
27 | 
28 | private:
29 |   T m_val;
30 | };
31 | } // namespace helpers
32 | 
33 | namespace std {
34 | template <typename T> struct hash<helpers::strong_typedef<T>> {
35 |   size_t operator()(const helpers::strong_typedef<T> &sd) const {
36 |     return m_hash(static_cast<T>(sd));
37 |   }
38 | 
39 | private:
40 |   hash<T> m_hash;
41 | };
42 | } // namespace std
43 | 


--------------------------------------------------------------------------------
/include/testsHelper.h.in:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | #include <boost/filesystem.hpp>
 4 | 
 5 | namespace tiger {
 6 | 
 7 | template<typename F>
 8 | void forEachTigerTest(F&& f) {
 9 |   namespace fs = boost::filesystem;
10 |   static const fs::path testsLocation = "@TESTS_LOCATION@";
11 |   auto iterateTests = [&f](const fs::path& folder, bool parseError, bool compilationError)
12 |   {
13 |     for (fs::directory_entry& file : fs::directory_iterator(folder))
14 |     {
15 |       if (file.path().extension() == ".tig")
16 |       {
17 |         f(file.path(), parseError, compilationError);
18 |       }
19 |     }
20 |   };
21 | 
22 |   iterateTests(testsLocation, false, false);
23 |   iterateTests(testsLocation / "compilation_error", false, true);
24 |   iterateTests(testsLocation / "parse_error", true, true);
25 | }
26 | 
27 | } // namespace tiger


--------------------------------------------------------------------------------
/include/type_traits.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_traits>
 3 | #include <iterator>
 4 | 
 5 | namespace helpers {
 6 | 
 7 | template <typename T> using void_t = void;
 8 | 
 9 | // check if type is a sequence
10 | template<typename T, typename = void>
11 | struct is_sequence : std::false_type {};
12 | 
13 | template<typename T>
14 | struct is_sequence<T, void_t<typename T::value_type>> : std::true_type {};
15 | 
16 | // check if type is an iterator
17 | template<typename T, typename = void>
18 | struct is_iterator : std::false_type {};
19 | 
20 | template<typename T>
21 | struct is_iterator<T, void_t<typename std::iterator_traits<T>::value_type>> : std::true_type {};
22 | 
23 | } // namespace helpers
24 | 


--------------------------------------------------------------------------------
/include/variantMatch.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "overload_set.h"
 3 | #include <boost/variant/apply_visitor.hpp>
 4 | #include <boost/variant/get.hpp>
 5 | #include <cassert>
 6 | 
 7 | namespace helpers {
 8 | 
 9 | template <typename... Variants> auto match(Variants &&... variants) {
10 |   return [&](auto &&... funcs) {
11 |     auto visitor = overload(std::forward<decltype(funcs)>(funcs)...);
12 |     return boost::apply_visitor(visitor, std::forward<Variants>(variants)...);
13 |   };
14 | }
15 | 
16 | template <typename T, typename Variant> bool hasType(const Variant &variant) {
17 |   return boost::get<T>(&variant) != nullptr;
18 | }
19 | 
20 | template <typename Variant, typename... Types>
21 | void assertTypes(const Variant &variant) {
22 |   bool result = false;
23 |   (void)std::initializer_list<int>{(result |= hasType<Types>(variant), 0)...};
24 |   assert(result && "variant should have one of the listed types");
25 | }
26 | 
27 | } // namespace helpers
28 | 


--------------------------------------------------------------------------------
/include/vectorApply.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <tuple>
 3 | #include <vector>
 4 | 
 5 | namespace helpers {
 6 | namespace detail {
 7 | 
 8 | template <typename... Funcs, typename T, std::size_t... I>
 9 | void applyFunctionTupleToVector(const std::vector<T> &v,
10 |                                 const std::tuple<Funcs...> &funcs,
11 |                                 std::index_sequence<I...>) {
12 | #ifdef __clang__
13 | #pragma clang diagnostic push
14 | #pragma clang diagnostic ignored "-Wunused-value"
15 | #endif
16 |   std::initializer_list<int>{(std::get<I>(funcs)(v[I]), 0)...};
17 | #ifdef __clang__
18 | #pragma clang diagnostic pop
19 | #endif
20 | }
21 | } // namespace detail
22 | 
23 | // apply function i to the i-th element of v
24 | template <typename... Funcs, typename T>
25 | void applyFunctionsToVector(const std::vector<T> &v, Funcs &&... funcs) {
26 |   detail::applyFunctionTupleToVector(
27 |       v, std::forward_as_tuple(funcs...),
28 |       std::make_index_sequence<sizeof...(Funcs)>());
29 | }
30 | 
31 | // apply function i to the i-th element of v
32 | template <typename... Funcs, typename T>
33 | void applyFunctionTupleToVector(const std::vector<T> &v,
34 |                                 const std::tuple<Funcs...> &funcs) {
35 |   detail::applyFunctionTupleToVector(
36 |       v, funcs, std::make_index_sequence<sizeof...(Funcs)>());
37 | }
38 | } // namespace helpers
39 | 


--------------------------------------------------------------------------------
/module_bundle/chap1/main.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dvirtz/GreenTiger/add89b6a999c35657e024b4152c9592277ac8b15/module_bundle/chap1/main.c


--------------------------------------------------------------------------------
/module_bundle/chap1/makefile:
--------------------------------------------------------------------------------
 1 | a.out: main.o prog1.o slp.o util.o
 2 | 	cc -g main.o prog1.o slp.o util.o
 3 | 
 4 | main.o: main.c slp.h util.h
 5 | 	cc -g -c main.c
 6 | 
 7 | prog1.o: prog1.c slp.h util.h
 8 | 	cc -g -c prog1.c
 9 | 
10 | slp.o: slp.c slp.h util.h
11 | 	cc -g -c slp.c
12 | 
13 | util.o: util.c util.h
14 | 	cc -g -c util.c
15 | 
16 | clean: 
17 | 	rm -f a.out util.o prog1.o slp.o main.o
18 | 


--------------------------------------------------------------------------------
/module_bundle/chap1/prog1.c:
--------------------------------------------------------------------------------
 1 | #include "util.h"
 2 | #include "slp.h"
 3 | 
 4 | A_stm prog(void) {
 5 | 
 6 | return 
 7 |  A_CompoundStm(A_AssignStm("a",
 8 |                  A_OpExp(A_NumExp(5), A_plus, A_NumExp(3))),
 9 |   A_CompoundStm(A_AssignStm("b",
10 |       A_EseqExp(A_PrintStm(A_PairExpList(A_IdExp("a"),
11 |                  A_LastExpList(A_OpExp(A_IdExp("a"), A_minus, 
12 |                                        A_NumExp(1))))),
13 |               A_OpExp(A_NumExp(10), A_times, A_IdExp("a")))),
14 |    A_PrintStm(A_LastExpList(A_IdExp("b")))));
15 | }
16 | 


--------------------------------------------------------------------------------
/module_bundle/chap1/prog1.h:
--------------------------------------------------------------------------------
1 | A_stm prog(void);
2 | 


--------------------------------------------------------------------------------
/module_bundle/chap1/slp.c:
--------------------------------------------------------------------------------
 1 | #include "util.h"
 2 | #include "slp.h"
 3 | 
 4 | A_stm A_CompoundStm(A_stm stm1, A_stm stm2) {
 5 |   A_stm s = checked_malloc(sizeof *s);
 6 |   s->kind=A_compoundStm; s->u.compound.stm1=stm1; s->u.compound.stm2=stm2;
 7 |   return s;
 8 | }
 9 | 
10 | 
11 | A_stm A_AssignStm(string id, A_exp exp) {
12 |   A_stm s = checked_malloc(sizeof *s);
13 |   s->kind=A_assignStm; s->u.assign.id=id; s->u.assign.exp=exp;
14 |   return s;
15 | }
16 | 
17 | A_stm A_PrintStm(A_expList exps) {
18 |   A_stm s = checked_malloc(sizeof *s);
19 |   s->kind=A_printStm; s->u.print.exps=exps;
20 |   return s;
21 | }
22 | 
23 | A_exp A_IdExp(string id) {
24 |   A_exp e = checked_malloc(sizeof *e);
25 |   e->kind=A_idExp; e->u.id=id;
26 |   return e;
27 | }
28 | 
29 | A_exp A_NumExp(int num) {
30 |   A_exp e = checked_malloc(sizeof *e);
31 |   e->kind=A_numExp; e->u.num=num;
32 |   return e;
33 | }
34 | 
35 | A_exp A_OpExp(A_exp left, A_binop oper, A_exp right) {
36 |   A_exp e = checked_malloc(sizeof *e);
37 |   e->kind=A_opExp; e->u.op.left=left; e->u.op.oper=oper; e->u.op.right=right;
38 |   return e;
39 | }
40 | 
41 | A_exp A_EseqExp(A_stm stm, A_exp exp) {
42 |   A_exp e = checked_malloc(sizeof *e);
43 |   e->kind=A_eseqExp; e->u.eseq.stm=stm; e->u.eseq.exp=exp;
44 |   return e;
45 | }
46 | 
47 | A_expList A_PairExpList(A_exp head, A_expList tail) {
48 |   A_expList e = checked_malloc(sizeof *e);
49 |   e->kind=A_pairExpList; e->u.pair.head=head; e->u.pair.tail=tail;
50 |   return e;
51 | }
52 | 
53 | A_expList A_LastExpList(A_exp last) {
54 |   A_expList e = checked_malloc(sizeof *e);
55 |   e->kind=A_lastExpList; e->u.last=last;
56 |   return e;
57 | }
58 | 
59 | 
60 | 
61 | 


--------------------------------------------------------------------------------
/module_bundle/chap1/slp.h:
--------------------------------------------------------------------------------
 1 | typedef struct A_stm_ *A_stm;
 2 | typedef struct A_exp_ *A_exp;
 3 | typedef struct A_expList_ *A_expList;
 4 | typedef enum {A_plus,A_minus,A_times,A_div} A_binop;
 5 | 
 6 | struct A_stm_ {enum {A_compoundStm, A_assignStm, A_printStm} kind;
 7 |              union {struct {A_stm stm1, stm2;} compound;
 8 |                     struct {string id; A_exp exp;} assign;
 9 |                     struct {A_expList exps;} print;
10 |                    } u;
11 |             };
12 | A_stm A_CompoundStm(A_stm stm1, A_stm stm2);
13 | A_stm A_AssignStm(string id, A_exp exp);
14 | A_stm A_PrintStm(A_expList exps);
15 | 
16 | struct A_exp_ {enum {A_idExp, A_numExp, A_opExp, A_eseqExp} kind;
17 |              union {string id;
18 |                     int num;
19 |                     struct {A_exp left; A_binop oper; A_exp right;} op;
20 |                     struct {A_stm stm; A_exp exp;} eseq;
21 |                    } u;
22 |             };
23 | A_exp A_IdExp(string id);
24 | A_exp A_NumExp(int num);
25 | A_exp A_OpExp(A_exp left, A_binop oper, A_exp right);
26 | A_exp A_EseqExp(A_stm stm, A_exp exp);
27 | 
28 | struct A_expList_ {enum {A_pairExpList, A_lastExpList} kind;
29 |                    union {struct {A_exp head; A_expList tail;} pair;
30 |                           A_exp last;
31 |                          } u;
32 |                   };
33 | 
34 | A_expList A_PairExpList(A_exp head, A_expList tail);
35 | A_expList A_LastExpList(A_exp last);
36 | 
37 | 


--------------------------------------------------------------------------------
/module_bundle/chap1/util.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * util.c - commonly used utility functions.
 3 |  */
 4 | 
 5 | #include <stdio.h>
 6 | #include <stdlib.h>
 7 | #include <string.h>
 8 | #include "util.h"
 9 | void *checked_malloc(int len)
10 | {void *p = malloc(len);
11 |  if (!p) {
12 |     fprintf(stderr,"\nRan out of memory!\n");
13 |     exit(1);
14 |  }
15 |  return p;
16 | }
17 | 
18 | string String(char *s)
19 | {string p = checked_malloc(strlen(s)+1);
20 |  strcpy(p,s);
21 |  return p;
22 | }
23 | 
24 | U_boolList U_BoolList(bool head, U_boolList tail)
25 | { U_boolList list = checked_malloc(sizeof(*list));
26 |   list->head = head;
27 |   list->tail = tail;
28 |   return list;
29 | }
30 | 


--------------------------------------------------------------------------------
/module_bundle/chap1/util.h:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | 
 3 | typedef char *string;
 4 | typedef char bool;
 5 | 
 6 | #define TRUE 1
 7 | #define FALSE 0
 8 | 
 9 | void *checked_malloc(int);
10 | string String(char *);
11 | 
12 | typedef struct U_boolList_ *U_boolList;
13 | struct U_boolList_ {bool head; U_boolList tail;};
14 | U_boolList U_BoolList(bool head, U_boolList tail);
15 | 
16 | 


--------------------------------------------------------------------------------
/module_bundle/chap10/flowgraph.h:
--------------------------------------------------------------------------------
1 | /*
2 |  * flowgraph.h - Function prototypes to represent control flow graphs.
3 |  */
4 | 
5 | Temp_tempList FG_def(G_node n);
6 | Temp_tempList FG_use(G_node n);
7 | bool FG_isMove(G_node n);
8 | G_graph FG_AssemFlowGraph(AS_instrList il);
9 | 


--------------------------------------------------------------------------------
/module_bundle/chap11/color.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * color.h - Data structures and function prototypes for coloring algorithm
 3 |  *             to determine register allocation.
 4 |  */
 5 | 
 6 | struct COL_result {Temp_map coloring; Temp_tempList spills;};
 7 | struct COL_result COL_color(G_graph ig, Temp_map initial, Temp_tempList regs);
 8 | 
 9 | 
10 | 


--------------------------------------------------------------------------------
/module_bundle/chap11/regalloc.h:
--------------------------------------------------------------------------------
1 | /* function prototype from regalloc.c */
2 | struct RA_result {Temp_map coloring; AS_instrList il;};
3 | struct RA_result RA_regAlloc(F_frame f, AS_instrList il);
4 | 


--------------------------------------------------------------------------------
/module_bundle/chap2/driver.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include "util.h"
 3 | #include "errormsg.h"
 4 | #include "tokens.h"
 5 | 
 6 | YYSTYPE yylval;
 7 | 
 8 | int yylex(void); /* prototype for the lexing function */
 9 | 
10 | 
11 | 
12 | string toknames[] = {
13 | "ID", "STRING", "INT", "COMMA", "COLON", "SEMICOLON", "LPAREN",
14 | "RPAREN", "LBRACK", "RBRACK", "LBRACE", "RBRACE", "DOT", "PLUS",
15 | "MINUS", "TIMES", "DIVIDE", "EQ", "NEQ", "LT", "LE", "GT", "GE",
16 | "AND", "OR", "ASSIGN", "ARRAY", "IF", "THEN", "ELSE", "WHILE", "FOR",
17 | "TO", "DO", "LET", "IN", "END", "OF", "BREAK", "NIL", "FUNCTION",
18 | "VAR", "TYPE"
19 | };
20 | 
21 | 
22 | string tokname(tok) {
23 |   return tok<257 || tok>299 ? "BAD_TOKEN" : toknames[tok-257];
24 | }
25 | 
26 | int main(int argc, char **argv) {
27 |  string fname; int tok;
28 |  if (argc!=2) {fprintf(stderr,"usage: a.out filename\n"); exit(1);}
29 |  fname=argv[1];
30 |  EM_reset(fname);
31 |  for(;;) {
32 |    tok=yylex();
33 |    if (tok==0) break;
34 |    switch(tok) {
35 |    case ID: case STRING:
36 |      printf("%10s %4d %s\n",tokname(tok),EM_tokPos,yylval.sval);
37 |      break;
38 |    case INT:
39 |      printf("%10s %4d %d\n",tokname(tok),EM_tokPos,yylval.ival);
40 |      break;
41 |    default:
42 |      printf("%10s %4d\n",tokname(tok),EM_tokPos);
43 |    }
44 |  }
45 |  return 0;
46 | }
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/module_bundle/chap2/errormsg.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * errormsg.c - functions used in all phases of the compiler to give
 3 |  *              error messages about the Tiger program.
 4 |  *
 5 |  */
 6 | 
 7 | #include <stdio.h>
 8 | #include <stdlib.h>
 9 | #include <stdarg.h>
10 | #include "util.h"
11 | #include "errormsg.h"
12 | 
13 | 
14 | bool anyErrors= FALSE;
15 | 
16 | static string fileName = "";
17 | 
18 | static int lineNum = 1;
19 | 
20 | int EM_tokPos=0;
21 | 
22 | extern FILE *yyin;
23 | 
24 | typedef struct intList {int i; struct intList *rest;} *IntList;
25 | 
26 | static IntList intList(int i, IntList rest) 
27 | {IntList l= checked_malloc(sizeof *l);
28 |  l->i=i; l->rest=rest;
29 |  return l;
30 | }
31 | 
32 | static IntList linePos=NULL;
33 | 
34 | void EM_newline(void)
35 | {lineNum++;
36 |  linePos = intList(EM_tokPos, linePos);
37 | }
38 | 
39 | void EM_error(int pos, char *message,...)
40 | {va_list ap;
41 |  IntList lines = linePos; 
42 |  int num=lineNum;
43 |  
44 | 
45 |   anyErrors=TRUE;
46 |   while (lines && lines->i >= pos) 
47 |        {lines=lines->rest; num--;}
48 | 
49 |   if (fileName) fprintf(stderr,"%s:",fileName);
50 |   if (lines) fprintf(stderr,"%d.%d: ", num, pos-lines->i);
51 |   va_start(ap,message);
52 |   vfprintf(stderr, message, ap);
53 |   va_end(ap);
54 |   fprintf(stderr,"\n");
55 | 
56 | }
57 | 
58 | void EM_reset(string fname)
59 | {
60 |  anyErrors=FALSE; fileName=fname; lineNum=1;
61 |  linePos=intList(0,NULL);
62 |  yyin = fopen(fname,"r");
63 |  if (!yyin) {EM_error(0,"cannot open"); exit(1);}
64 | }
65 | 
66 | 


--------------------------------------------------------------------------------
/module_bundle/chap2/errormsg.h:
--------------------------------------------------------------------------------
 1 | extern bool EM_anyErrors;
 2 | 
 3 | void EM_newline(void);
 4 | 
 5 | extern int EM_tokPos;
 6 | 
 7 | void EM_error(int, string,...);
 8 | void EM_impossible(string,...);
 9 | void EM_reset(string filename);
10 | 


--------------------------------------------------------------------------------
/module_bundle/chap2/makefile:
--------------------------------------------------------------------------------
 1 | lextest: driver.o lex.yy.o errormsg.o util.o
 2 | 	cc -g -o lextest driver.o lex.yy.o errormsg.o util.o
 3 | 
 4 | driver.o: driver.c tokens.h errormsg.h util.h
 5 | 	cc -g -c driver.c
 6 | 
 7 | errormsg.o: errormsg.c errormsg.h util.h
 8 | 	cc -g -c errormsg.c
 9 | 
10 | lex.yy.o: lex.yy.c tokens.h errormsg.h util.h
11 | 	cc -g -c lex.yy.c
12 | 
13 | lex.yy.c: tiger.lex
14 | 	lex tiger.lex
15 | 
16 | util.o: util.c util.h
17 | 	cc -g -c util.c
18 | 
19 | clean: 
20 | 	rm -f a.out util.o driver.o lex.yy.o lex.yy.c errormsg.o
21 | 


--------------------------------------------------------------------------------
/module_bundle/chap2/tiger.lex:
--------------------------------------------------------------------------------
 1 | %{
 2 | #include <string.h>
 3 | #include "util.h"
 4 | #include "tokens.h"
 5 | #include "errormsg.h"
 6 | 
 7 | int charPos=1;
 8 | 
 9 | int yywrap(void)
10 | {
11 |  charPos=1;
12 |  return 1;
13 | }
14 | 
15 | 
16 | void adjust(void)
17 | {
18 |  EM_tokPos=charPos;
19 |  charPos+=yyleng;
20 | }
21 | 
22 | %}
23 | 
24 | %%
25 | " "	 {adjust(); continue;}
26 | \n	 {adjust(); EM_newline(); continue;}
27 | ","	 {adjust(); return COMMA;}
28 | for  	 {adjust(); return FOR;}
29 | [0-9]+	 {adjust(); yylval.ival=atoi(yytext); return INT;}
30 | .	 {adjust(); EM_error(EM_tokPos,"illegal token");}
31 | 
32 | 
33 | 


--------------------------------------------------------------------------------
/module_bundle/chap2/tokens.h:
--------------------------------------------------------------------------------
 1 | typedef union  {
 2 | 	int pos;
 3 | 	int ival;
 4 | 	string sval;
 5 | 	} YYSTYPE;
 6 | extern YYSTYPE yylval;
 7 | 
 8 | # define ID 257
 9 | # define STRING 258
10 | # define INT 259
11 | # define COMMA 260
12 | # define COLON 261
13 | # define SEMICOLON 262
14 | # define LPAREN 263
15 | # define RPAREN 264
16 | # define LBRACK 265
17 | # define RBRACK 266
18 | # define LBRACE 267
19 | # define RBRACE 268
20 | # define DOT 269
21 | # define PLUS 270
22 | # define MINUS 271
23 | # define TIMES 272
24 | # define DIVIDE 273
25 | # define EQ 274
26 | # define NEQ 275
27 | # define LT 276
28 | # define LE 277
29 | # define GT 278
30 | # define GE 279
31 | # define AND 280
32 | # define OR 281
33 | # define ASSIGN 282
34 | # define ARRAY 283
35 | # define IF 284
36 | # define THEN 285
37 | # define ELSE 286
38 | # define WHILE 287
39 | # define FOR 288
40 | # define TO 289
41 | # define DO 290
42 | # define LET 291
43 | # define IN 292
44 | # define END 293
45 | # define OF 294
46 | # define BREAK 295
47 | # define NIL 296
48 | # define FUNCTION 297
49 | # define VAR 298
50 | # define TYPE 299
51 | 
52 | 


--------------------------------------------------------------------------------
/module_bundle/chap2/util.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * util.c - commonly used utility functions.
 3 |  */
 4 | 
 5 | #include <stdio.h>
 6 | #include <stdlib.h>
 7 | #include <string.h>
 8 | #include "util.h"
 9 | void *checked_malloc(int len)
10 | {void *p = malloc(len);
11 |  if (!p) {
12 |     fprintf(stderr,"\nRan out of memory!\n");
13 |     exit(1);
14 |  }
15 |  return p;
16 | }
17 | 
18 | string String(char *s)
19 | {string p = checked_malloc(strlen(s)+1);
20 |  strcpy(p,s);
21 |  return p;
22 | }
23 | 
24 | U_boolList U_BoolList(bool head, U_boolList tail)
25 | { U_boolList list = checked_malloc(sizeof(*list));
26 |   list->head = head;
27 |   list->tail = tail;
28 |   return list;
29 | }
30 | 


--------------------------------------------------------------------------------
/module_bundle/chap2/util.h:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | 
 3 | typedef char *string;
 4 | typedef char bool;
 5 | 
 6 | #define TRUE 1
 7 | #define FALSE 0
 8 | 
 9 | void *checked_malloc(int);
10 | string String(char *);
11 | 
12 | typedef struct U_boolList_ *U_boolList;
13 | struct U_boolList_ {bool head; U_boolList tail;};
14 | U_boolList U_BoolList(bool head, U_boolList tail);
15 | 
16 | 


--------------------------------------------------------------------------------
/module_bundle/chap3/errormsg.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * errormsg.c - functions used in all phases of the compiler to give
 3 |  *              error messages about the Tiger program.
 4 |  *
 5 |  */
 6 | 
 7 | #include <stdio.h>
 8 | #include <stdlib.h>
 9 | #include <stdarg.h>
10 | #include "util.h"
11 | #include "errormsg.h"
12 | 
13 | 
14 | bool anyErrors= FALSE;
15 | 
16 | static string fileName = "";
17 | 
18 | static int lineNum = 1;
19 | 
20 | int EM_tokPos=0;
21 | 
22 | extern FILE *yyin;
23 | 
24 | typedef struct intList {int i; struct intList *rest;} *IntList;
25 | 
26 | static IntList intList(int i, IntList rest) 
27 | {IntList l= checked_malloc(sizeof *l);
28 |  l->i=i; l->rest=rest;
29 |  return l;
30 | }
31 | 
32 | static IntList linePos=NULL;
33 | 
34 | void EM_newline(void)
35 | {lineNum++;
36 |  linePos = intList(EM_tokPos, linePos);
37 | }
38 | 
39 | void EM_error(int pos, char *message,...)
40 | {va_list ap;
41 |  IntList lines = linePos; 
42 |  int num=lineNum;
43 |  
44 | 
45 |   anyErrors=TRUE;
46 |   while (lines && lines->i >= pos) 
47 |        {lines=lines->rest; num--;}
48 | 
49 |   if (fileName) fprintf(stderr,"%s:",fileName);
50 |   if (lines) fprintf(stderr,"%d.%d: ", num, pos-lines->i);
51 |   va_start(ap,message);
52 |   vfprintf(stderr, message, ap);
53 |   va_end(ap);
54 |   fprintf(stderr,"\n");
55 | 
56 | }
57 | 
58 | void EM_reset(string fname)
59 | {
60 |  anyErrors=FALSE; fileName=fname; lineNum=1;
61 |  linePos=intList(0,NULL);
62 |  yyin = fopen(fname,"r");
63 |  if (!yyin) {EM_error(0,"cannot open"); exit(1);}
64 | }
65 | 
66 | 


--------------------------------------------------------------------------------
/module_bundle/chap3/errormsg.h:
--------------------------------------------------------------------------------
 1 | extern bool EM_anyErrors;
 2 | 
 3 | void EM_newline(void);
 4 | 
 5 | extern int EM_tokPos;
 6 | 
 7 | void EM_error(int, string,...);
 8 | void EM_impossible(string,...);
 9 | void EM_reset(string filename);
10 | 


--------------------------------------------------------------------------------
/module_bundle/chap3/makefile:
--------------------------------------------------------------------------------
 1 | a.out: parsetest.o y.tab.o lex.yy.o errormsg.o util.o
 2 | 	cc -g parsetest.o y.tab.o lex.yy.o errormsg.o util.o
 3 | 
 4 | parsetest.o: parsetest.c errormsg.h util.h
 5 | 	cc -g -c parsetest.c
 6 | 
 7 | y.tab.o: y.tab.c
 8 | 	cc -g -c y.tab.c
 9 | 
10 | y.tab.c: tiger.grm
11 | 	yacc -dv tiger.grm
12 | 
13 | y.tab.h: y.tab.c
14 | 	echo "y.tab.h was created at the same time as y.tab.c"
15 | 
16 | errormsg.o: errormsg.c errormsg.h util.h
17 | 	cc -g -c errormsg.c
18 | 
19 | lex.yy.o: lex.yy.c y.tab.h errormsg.h util.h
20 | 	cc -g -c lex.yy.c
21 | 
22 | #lex.yy.c: tiger.lex
23 | #	lex tiger.lex
24 | 
25 | util.o: util.c util.h
26 | 	cc -g -c util.c
27 | 
28 | clean: 
29 | 	rm -f a.out util.o parsetest.o lex.yy.o errormsg.o y.tab.c y.tab.h y.tab.o
30 | 


--------------------------------------------------------------------------------
/module_bundle/chap3/parsetest.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include "util.h"
 3 | #include "errormsg.h"
 4 | 
 5 | extern int yyparse(void);
 6 | 
 7 | void parse(string fname) 
 8 | {EM_reset(fname);
 9 |  if (yyparse() == 0) /* parsing worked */
10 |    fprintf(stderr,"Parsing successful!\n");
11 |  else fprintf(stderr,"Parsing failed\n");
12 | }
13 | 
14 | 
15 | int main(int argc, char **argv) {
16 |  if (argc!=2) {fprintf(stderr,"usage: a.out filename\n"); exit(1);}
17 |  parse(argv[1]);
18 |  return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/module_bundle/chap3/tiger.grm:
--------------------------------------------------------------------------------
 1 | %{
 2 | #include <stdio.h>
 3 | #include "util.h"
 4 | #include "errormsg.h"
 5 | 
 6 | int yylex(void); /* function prototype */
 7 | 
 8 | void yyerror(char *s)
 9 | {
10 |  EM_error(EM_tokPos, "%s", s);
11 | }
12 | %}
13 | 
14 | 
15 | %union {
16 | 	int pos;
17 | 	int ival;
18 | 	string sval;
19 | 	}
20 | 
21 | %token <sval> ID STRING
22 | %token <ival> INT
23 | 
24 | %token 
25 |   COMMA COLON SEMICOLON LPAREN RPAREN LBRACK RBRACK 
26 |   LBRACE RBRACE DOT 
27 |   PLUS MINUS TIMES DIVIDE EQ NEQ LT LE GT GE
28 |   AND OR ASSIGN
29 |   ARRAY IF THEN ELSE WHILE FOR TO DO LET IN END OF 
30 |   BREAK NIL
31 |   FUNCTION VAR TYPE 
32 | 
33 | %start program
34 | 
35 | %%
36 | 
37 | program:	exp
38 | 
39 | exp:   ID
40 | 
41 | 
42 | 
43 | 	
44 | 


--------------------------------------------------------------------------------
/module_bundle/chap3/util.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * util.c - commonly used utility functions.
 3 |  */
 4 | 
 5 | #include <stdio.h>
 6 | #include <stdlib.h>
 7 | #include <string.h>
 8 | #include "util.h"
 9 | void *checked_malloc(int len)
10 | {void *p = malloc(len);
11 |  if (!p) {
12 |     fprintf(stderr,"\nRan out of memory!\n");
13 |     exit(1);
14 |  }
15 |  return p;
16 | }
17 | 
18 | string String(char *s)
19 | {string p = checked_malloc(strlen(s)+1);
20 |  strcpy(p,s);
21 |  return p;
22 | }
23 | 
24 | U_boolList U_BoolList(bool head, U_boolList tail)
25 | { U_boolList list = checked_malloc(sizeof(*list));
26 |   list->head = head;
27 |   list->tail = tail;
28 |   return list;
29 | }
30 | 


--------------------------------------------------------------------------------
/module_bundle/chap3/util.h:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | 
 3 | typedef char *string;
 4 | typedef char bool;
 5 | 
 6 | #define TRUE 1
 7 | #define FALSE 0
 8 | 
 9 | void *checked_malloc(int);
10 | string String(char *);
11 | 
12 | typedef struct U_boolList_ *U_boolList;
13 | struct U_boolList_ {bool head; U_boolList tail;};
14 | U_boolList U_BoolList(bool head, U_boolList tail);
15 | 
16 | 


--------------------------------------------------------------------------------
/module_bundle/chap3/y.output:
--------------------------------------------------------------------------------
 1 | 
 2 | state 0
 3 | 	$accept : _program $end 
 4 | 
 5 | 	ID  shift 3
 6 | 	.  error
 7 | 
 8 | 	program  goto 1
 9 | 	exp  goto 2
10 | 
11 | state 1
12 | 	$accept :  program_$end 
13 | 
14 | 	$end  accept
15 | 	.  error
16 | 
17 | 
18 | state 2
19 | 	program :  exp_    (1)
20 | 
21 | 	.  reduce 1
22 | 
23 | 
24 | state 3
25 | 	exp :  ID_    (2)
26 | 
27 | 	.  reduce 2
28 | 
29 | 
30 | 45/3000 terminals, 2/1000 nonterminals
31 | 3/2000 grammar rules, 4/5000 states
32 | 0 shift/reduce, 0 reduce/reduce conflicts reported
33 | 3/1400 working sets used
34 | memory: states,etc. 30/40000, parser 1/70000
35 | 3/600 distinct lookahead sets
36 | 0 extra closures
37 | 1 shift entries, 1 exceptions
38 | 2 goto entries
39 | 0 entries saved by goto default
40 | Optimizer space used: input 6/40000, output 3/70000
41 | 3 table entries, 0 zero
42 | maximum spread: 257, maximum offset: 257
43 | 


--------------------------------------------------------------------------------
/module_bundle/chap4/makefile:
--------------------------------------------------------------------------------
 1 | a.out: parsetest.o y.tab.o lex.yy.o errormsg.o util.o
 2 | 	cc -g parsetest.o y.tab.o lex.yy.o errormsg.o util.o
 3 | 
 4 | parsetest.o: parsetest.c errormsg.h util.h
 5 | 	cc -g -c parsetest.c
 6 | 
 7 | y.tab.o: y.tab.c
 8 | 	cc -g -c y.tab.c
 9 | 
10 | y.tab.c: tiger.grm
11 | 	yacc -dv tiger.grm
12 | 
13 | y.tab.h: y.tab.c
14 | 	echo "y.tab.h was created at the same time as y.tab.c"
15 | 
16 | errormsg.o: errormsg.c errormsg.h util.h
17 | 	cc -g -c errormsg.c
18 | 
19 | lex.yy.o: lex.yy.c y.tab.h errormsg.h util.h
20 | 	cc -g -c lex.yy.c
21 | 
22 | #lex.yy.c: tiger.lex
23 | #	lex tiger.lex
24 | 
25 | util.o: util.c util.h
26 | 	cc -g -c util.c
27 | 
28 | clean: 
29 | 	rm -f a.out util.o parsetest.o lex.yy.o errormsg.o y.tab.c y.tab.h y.tab.o
30 | 


--------------------------------------------------------------------------------
/module_bundle/chap4/parse.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * parse.c - Parse source file.
 3 |  */
 4 | 
 5 | #include <stdio.h>
 6 | #include "util.h"
 7 | #include "symbol.h"
 8 | #include "absyn.h"
 9 | #include "errormsg.h"
10 | #include "parse.h"
11 | 
12 | extern int yyparse(void);
13 | extern A_exp absyn_root;
14 | 
15 | /* parse source file fname; 
16 |    return abstract syntax data structure */
17 | A_exp parse(string fname) 
18 | {EM_reset(fname);
19 |  if (yyparse() == 0) /* parsing worked */
20 |    return absyn_root;
21 |  else return NULL;
22 | }
23 | 


--------------------------------------------------------------------------------
/module_bundle/chap4/parse.h:
--------------------------------------------------------------------------------
1 | /* function prototype from parse.c */
2 | A_exp parse(string fname);
3 | 
4 | 


--------------------------------------------------------------------------------
/module_bundle/chap4/prabsyn.h:
--------------------------------------------------------------------------------
1 | /* function prototype from prabsyn.c */
2 | void pr_exp(FILE *out, A_exp v, int d);
3 | 
4 | 


--------------------------------------------------------------------------------
/module_bundle/chap4/symbol.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include "util.h"
 4 | #include "symbol.h"
 5 | #include "table.h"
 6 | 
 7 | struct S_symbol_ {string name; S_symbol next;};
 8 | 
 9 | static S_symbol mksymbol(string name, S_symbol next)
10 | {S_symbol s=checked_malloc(sizeof(*s));
11 |  s->name=name; s->next=next;
12 |  return s;
13 | }
14 | 
15 | #define SIZE 109  /* should be prime */
16 | 
17 | static S_symbol hashtable[SIZE];
18 | 
19 | static unsigned int hash(char *s0)
20 | {unsigned int h=0; char *s;
21 |  for(s=s0; *s; s++)  
22 |        h = h*65599 + *s;
23 |  return h;
24 | }
25 |  
26 | static int streq(string a, string b)
27 | {
28 |  return !strcmp(a,b);
29 | }
30 | 
31 | S_symbol S_Symbol(string name)
32 | {int index= hash(name) % SIZE;
33 |  S_symbol syms = hashtable[index], sym;
34 |  for(sym=syms; sym; sym=sym->next)
35 |    if (streq(sym->name,name)) return sym;
36 |  sym = mksymbol(name,syms);
37 |  hashtable[index]=sym;
38 |  return sym;
39 | }
40 |  
41 | string S_name(S_symbol sym)
42 | {
43 |  return sym->name;
44 | }
45 | 
46 | S_table S_empty(void) 
47 | { 
48 |  return TAB_empty();
49 | }
50 | 
51 | void S_enter(S_table t, S_symbol sym, void *value) {
52 |   TAB_enter(t,sym,value);
53 | }
54 | 
55 | void *S_look(S_table t, S_symbol sym) {
56 |   return TAB_look(t,sym);
57 | }
58 | 
59 | static struct S_symbol_ marksym = {"<mark>",0};
60 | 
61 | void S_beginScope(S_table t)
62 | { S_enter(t,&marksym,NULL);
63 | }
64 | 
65 | void S_endScope(S_table t)
66 | {S_symbol s;
67 |   do s=TAB_pop(t);
68 |   while (s != &marksym);
69 | }
70 | 
71 | void S_dump(S_table t, void (*show)(S_symbol sym, void *binding)) {
72 |   TAB_dump(t, (void (*)(void *, void *)) show);
73 | }
74 | 
75 | 


--------------------------------------------------------------------------------
/module_bundle/chap4/symbol.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * symbol.h - Symbols and symbol-tables
 3 |  *
 4 |  */
 5 | 
 6 | typedef struct S_symbol_ *S_symbol;
 7 | 
 8 | /* Make a unique symbol from a given string.  
 9 |  *  Different calls to S_Symbol("foo") will yield the same S_symbol
10 |  *  value, even if the "foo" strings are at different locations. */
11 | S_symbol S_Symbol(string);
12 | 
13 | /* Extract the underlying string from a symbol */
14 | string S_name(S_symbol);
15 | 
16 | /* S_table is a mapping from S_symbol->any, where "any" is represented
17 |  *     here by void*  */
18 | typedef struct TAB_table_ *S_table;
19 | 
20 | /* Make a new table */
21 | S_table S_empty(void);
22 | 
23 | /* Enter a binding "sym->value" into "t", shadowing but not deleting
24 |  *    any previous binding of "sym". */
25 | void S_enter(S_table t, S_symbol sym, void *value);
26 | 
27 | /* Look up the most recent binding of "sym" in "t", or return NULL
28 |  *    if sym is unbound. */
29 | void *S_look(S_table t, S_symbol sym);
30 | 
31 | /* Start a new "scope" in "t".  Scopes are nested. */
32 | void S_beginScope(S_table t);
33 | 
34 | /* Remove any bindings entered since the current scope began,
35 |    and end the current scope. */
36 | void S_endScope(S_table t);
37 | 
38 | 


--------------------------------------------------------------------------------
/module_bundle/chap4/table.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * table.h - generic hash table
 3 |  *
 4 |  * No algorithm should use these functions directly, because
 5 |  *  programming with void* is too error-prone.  Instead,
 6 |  *  each module should make "wrapper" functions that take
 7 |  *  well-typed arguments and call the TAB_ functions.
 8 |  */
 9 | 
10 | typedef struct TAB_table_ *TAB_table;
11 | 
12 | /* Make a new table mapping "keys" to "values". */
13 | TAB_table TAB_empty(void);
14 | 
15 | /* Enter the mapping "key"->"value" into table "t", 
16 |  *    shadowing but not destroying any previous binding for "key". */
17 | void TAB_enter(TAB_table t, void *key, void *value);
18 | 
19 | /* Look up the most recent binding for "key" in table "t" */
20 | void *TAB_look(TAB_table t, void *key);
21 | 
22 | /* Pop the most recent binding and return its key.
23 |  * This may expose another binding for the same key, if there was one. */
24 | void *TAB_pop(TAB_table t);
25 | 
26 | 
27 | /* Call "show" on every "key"->"value" pair in the table,
28 |  *  including shadowed bindings, in order from the most 
29 |  *  recent binding of any key to the oldest binding in the table */
30 | void TAB_dump(TAB_table t, void (*show)(void *key, void *value));
31 | 
32 | 
33 | 


--------------------------------------------------------------------------------
/module_bundle/chap4/tiger.grm:
--------------------------------------------------------------------------------
 1 | %{
 2 | #include <stdio.h>
 3 | #include "util.h"
 4 | #include "symbol.h" 
 5 | #include "errormsg.h"
 6 | #include "absyn.h"
 7 | 
 8 | int yylex(void); /* function prototype */
 9 | 
10 | A_exp absyn_root;
11 | 
12 | void yyerror(char *s)
13 | {
14 |  EM_error(EM_tokPos, "%s", s);
15 | }
16 | %}
17 | 
18 | 
19 | %union {
20 | 	int pos;
21 | 	int ival;
22 | 	string sval;
23 | 	A_var var;
24 | 	A_exp exp;
25 | 	/* et cetera */
26 | 	}
27 | 
28 | %token <sval> ID STRING
29 | %token <ival> INT
30 | 
31 | %token 
32 |   COMMA COLON SEMICOLON LPAREN RPAREN LBRACK RBRACK 
33 |   LBRACE RBRACE DOT 
34 |   PLUS MINUS TIMES DIVIDE EQ NEQ LT LE GT GE
35 |   AND OR ASSIGN
36 |   ARRAY IF THEN ELSE WHILE FOR TO DO LET IN END OF 
37 |   BREAK NIL
38 |   FUNCTION VAR TYPE 
39 | 
40 | %type <exp> exp program
41 | /* et cetera */
42 | 
43 | %start program
44 | 
45 | %%
46 | 
47 | program:   exp    {absyn_root=$1;}
48 | 
49 | exp:   ID         {$$=A_VarExp(EM_tokPos,A_SimpleVar(EM_tokPos,S_Symbol($1)));}
50 | 
51 | 
52 | 
53 | 	
54 | 


--------------------------------------------------------------------------------
/module_bundle/chap5/types.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * types.h - 
 3 |  *
 4 |  * All types and functions declared in this header file begin with "Ty_"
 5 |  * Linked list types end with "..list"
 6 |  */
 7 | 
 8 | typedef struct Ty_ty_ *Ty_ty;
 9 | typedef struct Ty_tyList_ *Ty_tyList;
10 | typedef struct Ty_field_ *Ty_field;
11 | typedef struct Ty_fieldList_ *Ty_fieldList;
12 | 
13 | struct Ty_ty_ {enum {Ty_record, Ty_nil, Ty_int, Ty_string, Ty_array,
14 | 		       Ty_name, Ty_void} kind;
15 | 	       union {Ty_fieldList record;
16 | 		      Ty_ty array;
17 | 		      struct {S_symbol sym; Ty_ty ty;} name;
18 | 		    } u;
19 | 	     };
20 | 
21 | struct Ty_tyList_ {Ty_ty head; Ty_tyList tail;};
22 | struct Ty_field_ {S_symbol name; Ty_ty ty;};
23 | struct Ty_fieldList_ {Ty_field head; Ty_fieldList tail;};
24 | 
25 | Ty_ty Ty_Nil(void);
26 | Ty_ty Ty_Int(void);
27 | Ty_ty Ty_String(void);
28 | Ty_ty Ty_Void(void);
29 | 
30 | Ty_ty Ty_Record(Ty_fieldList fields);
31 | Ty_ty Ty_Array(Ty_ty ty);
32 | Ty_ty Ty_Name(S_symbol sym, Ty_ty ty);
33 | 
34 | Ty_tyList Ty_TyList(Ty_ty head, Ty_tyList tail);
35 | Ty_field Ty_Field(S_symbol name, Ty_ty ty);
36 | Ty_fieldList Ty_FieldList(Ty_field head, Ty_fieldList tail);
37 | 
38 | void Ty_print(Ty_ty t);
39 | void TyList_print(Ty_tyList list);
40 | 


--------------------------------------------------------------------------------
/module_bundle/chap6/temp.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * temp.h 
 3 |  *
 4 |  */
 5 | 
 6 | typedef struct Temp_temp_ *Temp_temp;
 7 | Temp_temp Temp_newtemp(void);
 8 | 
 9 | typedef struct Temp_tempList_ *Temp_tempList;
10 | struct Temp_tempList_ { Temp_temp head; Temp_tempList tail;};
11 | Temp_tempList Temp_TempList(Temp_temp h, Temp_tempList t);
12 | 
13 | typedef S_symbol Temp_label;
14 | Temp_label Temp_newlabel(void);
15 | Temp_label Temp_namedlabel(string name);
16 | string Temp_labelstring(Temp_label s);
17 | 
18 | typedef struct Temp_labelList_ *Temp_labelList;
19 | struct Temp_labelList_ { Temp_label head; Temp_labelList tail;};
20 | Temp_labelList Temp_LabelList(Temp_label h, Temp_labelList t);
21 | 
22 | typedef struct Temp_map_ *Temp_map;
23 | Temp_map Temp_empty(void);
24 | Temp_map Temp_layerMap(Temp_map over, Temp_map under);
25 | void Temp_enter(Temp_map m, Temp_temp t, string s);
26 | string Temp_look(Temp_map m, Temp_temp t);
27 | void Temp_dumpMap(FILE *out, Temp_map m);
28 | 
29 | Temp_map Temp_name(void);
30 | 
31 | 


--------------------------------------------------------------------------------
/module_bundle/chap7/printtree.h:
--------------------------------------------------------------------------------
1 | /* function prototype from printtree.c */
2 | void printStmList (FILE *out, T_stmList stmList) ;
3 | 
4 | 


--------------------------------------------------------------------------------
/module_bundle/chap9/assem.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * assem.h - Function prototypes to translate to Assem-instructions
 3 |  *             using Maximal Munch.
 4 |  */
 5 | 
 6 | typedef struct {Temp_labelList labels;} *AS_targets;
 7 | AS_targets AS_Targets(Temp_labelList labels);
 8 | 
 9 | typedef struct AS_instr_ *AS_instr;
10 | struct AS_instr_ { enum {I_OPER, I_LABEL, I_MOVE} kind;
11 | 	       union {struct {string assem; Temp_tempList dst, src; 
12 | 			      AS_targets jumps;} OPER;
13 | 		      struct {string assem; Temp_label label;} LABEL;
14 | 		      struct {string assem; Temp_tempList dst, src;} MOVE;
15 | 		    } u;
16 | 	      };
17 | 
18 | AS_instr AS_Oper(string a, Temp_tempList d, Temp_tempList s, AS_targets j);
19 | AS_instr AS_Label(string a, Temp_label label);
20 | AS_instr AS_Move(string a, Temp_tempList d, Temp_tempList s);
21 | 
22 | void AS_print(FILE *out, AS_instr i, Temp_map m);
23 | 
24 | typedef struct AS_instrList_ *AS_instrList;
25 | struct AS_instrList_ { AS_instr head; AS_instrList tail;};
26 | AS_instrList AS_InstrList(AS_instr head, AS_instrList tail);
27 | 
28 | AS_instrList AS_splice(AS_instrList a, AS_instrList b);
29 | void AS_printInstrList (FILE *out, AS_instrList iList, Temp_map m);
30 | 
31 | typedef struct AS_proc_ *AS_proc;
32 | struct AS_proc_ {
33 |   string prolog;
34 |   AS_instrList body;
35 |   string epilog;
36 | };
37 | 
38 | AS_proc AS_Proc(string p, AS_instrList b, string e);
39 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test10.tig:
--------------------------------------------------------------------------------
1 | /* error : body of while not unit */
2 | while(10 > 5) do 5+6
3 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test11.tig:
--------------------------------------------------------------------------------
1 | /* error hi expr is not int, and index variable erroneously assigned to.  */
2 | for i:=10 to " " do 
3 | 	i := i - 1
4 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test13.tig:
--------------------------------------------------------------------------------
1 | /* error: comparison of incompatible types */
2 | 
3 | 3 > "df"
4 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test14.tig:
--------------------------------------------------------------------------------
 1 | /* error : compare rec with array */
 2 | 
 3 | let
 4 | 
 5 | 	type arrtype = array of int
 6 | 	type rectype = {name:string, id: int}
 7 | 
 8 | 	var rec := rectype {name="aname", id=0}
 9 | 	var arr := arrtype [3] of 0
10 | 
11 | in
12 | 	if rec <> arr then 3 else 4
13 | end
14 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test15.tig:
--------------------------------------------------------------------------------
1 | /* error : if-then returns non unit */
2 | 
3 | if 20 then 3
4 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test16.tig:
--------------------------------------------------------------------------------
 1 | /* error: mutually recursive types thet do not pass through record or array */
 2 | let 
 3 | 
 4 | type a=c
 5 | type b=a
 6 | type c=d
 7 | type d=a
 8 | 
 9 | in
10 |  ""
11 | end
12 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test17.tig:
--------------------------------------------------------------------------------
 1 | /* error: definition of recursive types is interrupted */
 2 | let
 3 | /* define a tree */
 4 | type tree ={key: int, children: treelist}
 5 | var d:int :=0
 6 | type treelist = {hd: tree, tl: treelist}
 7 | 
 8 | in
 9 | 	d
10 | end
11 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test18.tig:
--------------------------------------------------------------------------------
 1 | /* error : definition of recursive functions is interrupted */
 2 | let
 3 | 
 4 | function do_nothing1(a: int, b: string):int=
 5 | 		(do_nothing2(a+1);0)
 6 | 
 7 | var d:=0
 8 | 
 9 | function do_nothing2(d: int):string =
10 | 		(do_nothing1(d, "str");" ")
11 | 
12 | in
13 | 	do_nothing1(0, "str2")
14 | end
15 | 
16 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test19.tig:
--------------------------------------------------------------------------------
 1 | /* error : second function uses variables local to the first one, undeclared variable */
 2 | let
 3 | 
 4 | function do_nothing1(a: int, b: string):int=
 5 | 		(do_nothing2(a+1);0)
 6 | 
 7 | function do_nothing2(d: int):string =
 8 | 		(do_nothing1(a, "str");" ")
 9 | 
10 | in
11 | 	do_nothing1(0, "str2")
12 | end
13 | 
14 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test20.tig:
--------------------------------------------------------------------------------
1 | /* error: undeclared variable i */
2 | 
3 | while 10 > 5 do (i+1;())
4 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test21.tig:
--------------------------------------------------------------------------------
 1 | /* error : procedure returns value  and procedure is used in arexpr */
 2 | let
 3 | 
 4 | /* calculate n! */
 5 | function nfactor(n: int) =
 6 | 		if  n = 0 
 7 | 			then 1
 8 | 			else n * nfactor(n-1)
 9 | 
10 | in
11 | 	nfactor(10)
12 | end
13 | 
14 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test22.tig:
--------------------------------------------------------------------------------
1 | /* error : field not in record type */
2 | 
3 | let 
4 | 	type rectype = {name:string , id:int}
5 | 	var rec1 := rectype {name="Name", id=0}
6 | in
7 | 	rec1.nam := "asd"
8 | end
9 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test23.tig:
--------------------------------------------------------------------------------
 1 | /* error : type mismatch */
 2 | 
 3 | let 
 4 | 	type rectype = {name:string , id:int}
 5 | 	var rec1 := rectype {name="aname", id=0}
 6 | in
 7 | 	rec1.name := 3;
 8 | 	rec1.id := "" 
 9 | end
10 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test24.tig:
--------------------------------------------------------------------------------
1 | /* error : variable not array */
2 | let 
3 | 	var d:=0
4 | in
5 | 	d[3]
6 | end
7 | 
8 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test25.tig:
--------------------------------------------------------------------------------
1 | /* error : variable not record */
2 | let 
3 | 	var d:=0
4 | in
5 | 	d.f 
6 | end
7 | 
8 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test26.tig:
--------------------------------------------------------------------------------
1 | /* error : integer required */
2 | 
3 | 3 + "var"
4 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test28.tig:
--------------------------------------------------------------------------------
 1 | /* error : different record types */
 2 | 
 3 | let
 4 | 	type rectype1 = {name:string , id:int}
 5 | 	type rectype2 = {name:string , id:int}
 6 | 
 7 | 	var rec1: rectype1 := rectype2 {name="Name", id=0}
 8 | in
 9 | 	rec1
10 | end
11 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test29.tig:
--------------------------------------------------------------------------------
 1 | /* error : different array types */
 2 | 
 3 | let
 4 | 	type arrtype1 = array of int
 5 | 	type arrtype2 = array of int
 6 | 
 7 | 	var arr1: arrtype1 := arrtype2 [10] of 0
 8 | in
 9 | 	arr1
10 | end
11 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test31.tig:
--------------------------------------------------------------------------------
1 | /* error : type constraint and init value differ */
2 | let 
3 | 	var a:int := " "
4 | in
5 | 	a
6 | end
7 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test32.tig:
--------------------------------------------------------------------------------
 1 | /* error : initializing exp and array type differ */
 2 | 
 3 | let
 4 | 	type arrayty = array of int
 5 | 
 6 | 	var a := arrayty [10] of " "
 7 | in
 8 | 	0
 9 | end
10 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test33.tig:
--------------------------------------------------------------------------------
1 | /* error : unknown type */
2 | let
3 | 	var a:= rectype {}
4 | in
5 | 	0
6 | end
7 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test34.tig:
--------------------------------------------------------------------------------
1 | /* error : formals and actuals have different types */
2 | let
3 | 	function g (a:int , b:string):int = a
4 | in
5 | 	g("one", "two")
6 | end
7 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test35.tig:
--------------------------------------------------------------------------------
1 | /* error : formals are more then actuals */
2 | let
3 | 	function g (a:int , b:string):int = a
4 | in
5 | 	g("one")
6 | end
7 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test36.tig:
--------------------------------------------------------------------------------
1 | /* error : formals are fewer then actuals */
2 | let
3 | 	function g (a:int , b:string):int = a
4 | in
5 | 	g(3,"one",5)
6 | end
7 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test40.tig:
--------------------------------------------------------------------------------
1 | /* error : procedure returns value */
2 | let
3 | 	function g(a:int) = a
4 | in 
5 | 	g(2)
6 | end
7 | 
8 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test43.tig:
--------------------------------------------------------------------------------
1 | /* initialize with unit and causing type mismatch in addition */
2 | 
3 | let 
4 | 	var a := ()
5 | in
6 | 	a + 3
7 | end
8 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test45.tig:
--------------------------------------------------------------------------------
1 | /* error: initializing nil expressions not constrained by record type */
2 | let 
3 | 	type rectype = {name:string, id:int}
4 | 
5 | 	var a:= nil
6 | in
7 | 	a
8 | end
9 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/compilation_error/test9.tig:
--------------------------------------------------------------------------------
1 | /* error : types of then - else differ */
2 | 
3 | if (5>4) then 13 else  " "
4 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/merge.tig:
--------------------------------------------------------------------------------
 1 | let 
 2 | 
 3 |  type any = {any : int}
 4 |  var buffer := getchar()
 5 | 
 6 | function readint(any: any) : int =
 7 |  let var i := 0
 8 |      function isdigit(s : string) : int = 
 9 | 		  ord(buffer)>=ord("0") & ord(buffer)<=ord("9")
10 |      function skipto() =
11 |        while buffer=" " | buffer="\n"
12 |          do buffer := getchar()
13 |   in skipto();
14 |      any.any := isdigit(buffer);
15 |      while isdigit(buffer)
16 |        do (i := i*10+ord(buffer)-ord("0"); buffer := getchar());
17 |      i
18 |  end
19 | 
20 |  type list = {first: int, rest: list}
21 | 
22 |  function readlist() : list =
23 |     let var any := any{any=0}
24 |         var i := readint(any)
25 |      in if any.any
26 |          then list{first=i,rest=readlist()}
27 |          else nil
28 |     end
29 | 
30 |  function merge(a: list, b: list) : list =
31 |    if a=nil then b
32 |    else if b=nil then a
33 |    else if a.first < b.first 
34 |       then list{first=a.first,rest=merge(a.rest,b)}
35 |       else list{first=b.first,rest=merge(a,b.rest)}
36 | 
37 |  function printint(i: int) =
38 |   let function f(i:int) = if i>0 
39 | 	     then (f(i/10); print(chr(i-i/10*10+ord("0"))))
40 |    in if i<0 then (print("-"); f(-i))
41 |       else if i>0 then f(i)
42 |       else print("0")
43 |   end
44 | 
45 |  function printlist(l: list) =
46 |    if l=nil then print("\n")
47 |    else (printint(l.first); print(" "); printlist(l.rest))
48 | 
49 |    var list1 := readlist()
50 |    var list2 := (buffer:=getchar(); readlist())
51 | 
52 | 
53 |   /* BODY OF MAIN PROGRAM */
54 |  in printlist(merge(list1,list2))
55 | end
56 | 
57 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/parse_error/test49.tig:
--------------------------------------------------------------------------------
1 | /* error: syntax error, nil should not be preceded by type-id.  */
2 | let 
3 | 	type rectype = {name:string, id:int}
4 | 
5 | 	var a:= rectype nil
6 | in
7 | 	a
8 | end
9 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/queens.tig:
--------------------------------------------------------------------------------
 1 | /* A program to solve the 8-queens problem */
 2 | 
 3 | let
 4 |     var N := 8
 5 | 
 6 |     type intArray = array of int
 7 | 
 8 |     var row := intArray [ N ] of 0
 9 |     var col := intArray [ N ] of 0
10 |     var diag1 := intArray [N+N-1] of 0
11 |     var diag2 := intArray [N+N-1] of 0
12 | 
13 |     function printboard() =
14 |        (for i := 0 to N-1
15 | 	 do (for j := 0 to N-1 
16 | 	      do print(if col[i]=j then " O" else " .");
17 | 	     print("\n"));
18 |          print("\n"))
19 | 
20 |     function try(c:int) = 
21 | ( /*  for i:= 0 to c do print("."); print("\n"); flush();*/
22 |      if c=N
23 |      then printboard()
24 |      else for r := 0 to N-1
25 | 	   do if row[r]=0 & diag1[r+c]=0 & diag2[r+7-c]=0
26 | 	           then (row[r]:=1; diag1[r+c]:=1; diag2[r+7-c]:=1;
27 | 		         col[c]:=r;
28 | 	                 try(c+1);
29 | 			 row[r]:=0; diag1[r+c]:=0; diag2[r+7-c]:=0)
30 | 
31 | )
32 |  in try(0)
33 | end
34 | 	


--------------------------------------------------------------------------------
/module_bundle/testcases/test1.tig:
--------------------------------------------------------------------------------
1 | /* an array type and an array variable */
2 | let
3 | 	type  arrtype = array of int
4 | 	var arr1:arrtype := arrtype [10] of 0
5 | in
6 | 	arr1
7 | end
8 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test12.tig:
--------------------------------------------------------------------------------
1 | /* valid for and let */
2 | 
3 | let
4 | 	var a:= 0
5 | in 
6 | 	for i:=0 to 100 do (a:=a+1;())
7 | end
8 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test2.tig:
--------------------------------------------------------------------------------
 1 | /* arr1 is valid since expression 0 is int = myint */
 2 | let
 3 | 	type myint = int
 4 | 	type  arrtype = array of myint
 5 | 
 6 | 	var arr1:arrtype := arrtype [10] of 0
 7 | in
 8 | 	arr1
 9 | end
10 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test27.tig:
--------------------------------------------------------------------------------
1 | /* locals hide globals */
2 | let
3 | 	var a:=0
4 | 
5 | 	function g(a:int):int = a 
6 | in
7 |  g(2)
8 | end
9 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test3.tig:
--------------------------------------------------------------------------------
1 | /* a record type and a record variable */
2 | let
3 | 	type  rectype = {name:string, age:int}
4 | 	var rec1:rectype := rectype {name="Nobody", age=1000}
5 | in
6 | 	rec1.name := "Somebody";
7 | 	rec1
8 | end
9 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test30.tig:
--------------------------------------------------------------------------------
 1 | /* synonyms are fine */
 2 | 
 3 | let 
 4 | 		type a = array of int
 5 | 		type b = a
 6 | 
 7 | 		var arr1:a := b [10] of 0
 8 | in
 9 | 		arr1[2]
10 | end
11 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test37.tig:
--------------------------------------------------------------------------------
1 | /* redeclaration of variable; this is legal, there are two different
2 |    variables with the same name.  The second one hides the first.  */
3 | let
4 | 	var a := 0
5 | 	var a := " "
6 | in
7 | 	0
8 | end
9 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test38.tig:
--------------------------------------------------------------------------------
 1 | /* This is illegal, since there are two types with the same name
 2 |     in the same (consecutive) batch of mutually recursive types. 
 3 |     See also test47  */
 4 | let
 5 | 	type a = int
 6 | 	type a = string
 7 | in
 8 | 	0
 9 | end
10 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test39.tig:
--------------------------------------------------------------------------------
 1 | /* This is illegal, since there are two functions with the same name
 2 |     in the same (consecutive) batch of mutually recursive functions.
 3 |    See also test48 */
 4 | let
 5 | 	function g(a:int):int = a
 6 | 	function g(a:int):int = a
 7 | in
 8 | 	0
 9 | end
10 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test4.tig:
--------------------------------------------------------------------------------
 1 | /* define a recursive function */
 2 | let
 3 | 
 4 | /* calculate n! */
 5 | function nfactor(n: int): int =
 6 | 		if  n = 0 
 7 | 			then 1
 8 | 			else n * nfactor(n-1)
 9 | 
10 | in
11 | 	nfactor(10)
12 | end
13 | 
14 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test41.tig:
--------------------------------------------------------------------------------
 1 | /* local types hide global */
 2 | let
 3 | 	type a = int
 4 | in
 5 | 	let
 6 | 		type a = string
 7 | 	in
 8 | 		0
 9 | 	end
10 | end
11 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test42.tig:
--------------------------------------------------------------------------------
 1 | /* correct declarations */
 2 | let 
 3 | 
 4 | type arrtype1 = array of int
 5 | type rectype1 = {name:string, address:string, id: int , age: int}
 6 | type arrtype2 = array of rectype1
 7 | type rectype2 = {name : string, dates: arrtype1}
 8 | 
 9 | type arrtype3 = array of string
10 | 
11 | var arr1 := arrtype1 [10] of 0
12 | var arr2  := arrtype2 [5] of rectype1 {name="aname", address="somewhere", id=0, age=0}
13 | var arr3:arrtype3 := arrtype3 [100] of ""
14 | 
15 | var rec1 := rectype1 {name="Kapoios", address="Kapou", id=02432, age=44}
16 | var rec2 := rectype2 {name="Allos", dates= arrtype1 [3] of 1900}
17 | 
18 | in
19 | 
20 | arr1[0] := 1; 
21 | arr1[9] := 3;
22 | arr2[3].name := "kati";
23 | arr2[1].age := 23;
24 | arr3[34] := "sfd";
25 | 
26 | rec1.name := "sdf";
27 | rec2.dates[0] := 2323;
28 | rec2.dates[2] := 2323
29 | 
30 | end
31 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test44.tig:
--------------------------------------------------------------------------------
 1 | /* valid nil initialization and assignment */
 2 | let 
 3 | 
 4 | 	type rectype = {name:string, id:int}
 5 | 	var b:rectype := nil
 6 | 
 7 | in
 8 | 
 9 | 	b := nil
10 | 
11 | end
12 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test46.tig:
--------------------------------------------------------------------------------
1 | /* valid rec comparisons */
2 | let 
3 | 	type rectype = {name:string, id:int}
4 | 	var b:rectype := nil
5 | in
6 | 	b = nil;
7 | 	b <> nil
8 | end
9 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test47.tig:
--------------------------------------------------------------------------------
 1 | /* This is legal.  The second type "a" simply hides the first one.
 2 |    Because of the intervening variable declaration, the two "a" types
 3 |    are not in the same  batch of mutually recursive types.
 4 |    See also test38 */
 5 | let
 6 | 	type a = int
 7 | 	var b := 4
 8 | 	type a = string
 9 | in
10 | 	0
11 | end
12 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test48.tig:
--------------------------------------------------------------------------------
 1 | /* This is legal.  The second function "g" simply hides the first one.
 2 |    Because of the intervening variable declaration, the two "g" functions
 3 |    are not in the same  batch of mutually recursive functions. 
 4 |    See also test39 */
 5 | let
 6 | 	function g(a:int):int = a
 7 | 	type t = int
 8 | 	function g(a:int):int = a
 9 | in
10 | 	0
11 | end
12 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test5.tig:
--------------------------------------------------------------------------------
 1 | /* define valid recursive types */
 2 | let
 3 | /* define a list */
 4 | type intlist = {hd: int, tl: intlist} 
 5 | 
 6 | /* define a tree */
 7 | type tree ={key: int, children: treelist}
 8 | type treelist = {hd: tree, tl: treelist}
 9 | 
10 | var lis:intlist := intlist { hd=0, tl= nil } 
11 | 
12 | in
13 | 	lis
14 | end
15 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test6.tig:
--------------------------------------------------------------------------------
 1 | /* define valid mutually recursive procedures */
 2 | let
 3 | 
 4 | function do_nothing1(a: int, b: string)=
 5 | 		do_nothing2(a+1)
 6 | 
 7 | function do_nothing2(d: int) =
 8 | 		do_nothing1(d, "str")
 9 | 
10 | in
11 | 	do_nothing1(0, "str2")
12 | end
13 | 
14 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test7.tig:
--------------------------------------------------------------------------------
 1 | /* define valid mutually recursive functions */
 2 | let
 3 | 
 4 | function do_nothing1(a: int, b: string):int=
 5 | 		(do_nothing2(a+1);0)
 6 | 
 7 | function do_nothing2(d: int):string =
 8 | 		(do_nothing1(d, "str");" ")
 9 | 
10 | in
11 | 	do_nothing1(0, "str2")
12 | end
13 | 
14 | 


--------------------------------------------------------------------------------
/module_bundle/testcases/test8.tig:
--------------------------------------------------------------------------------
1 | /* correct if */
2 | if (10 > 20) then 30 else 40	
3 | 


--------------------------------------------------------------------------------