Skip to content

Latest commit

 

History

History
101 lines (72 loc) · 2.91 KB

README.md

File metadata and controls

101 lines (72 loc) · 2.91 KB
Raw

Lang Compiler (Name TBD)

This project is an LLVM-based compiler for a custom programming language called "Lang".

Prerequisites

  • CMake (version 3.15 or higher)
  • LLVM (version 14.0.0 or higher)
  • A C++17 compatible compiler

Building the Project

You can use the provided build.sh script to configure, clean, and build the project:

  1. Clone the repository:

    git clone https://github.com/jsilll/lang.git
cd lang

  2. Make the build script executable:

    chmod +x build.sh

  3. Configure the project:

    ./build.sh configure

  4. Build the project:

    ./build.sh build

Alternatively, you can run all steps at once:

./build.sh all

The build.sh script supports several options:

  • --llvm-dir <path>: Set LLVM_DIR (default: /usr/lib/llvm-14)
  • --build-type <type>: Set CMAKE_BUILD_TYPE (default: Debug)
  • --c-compiler <path>: Set CMAKE_C_COMPILER (default: clang)
  • --cxx-compiler <path>: Set CMAKE_CXX_COMPILER (default: clang++)
  • --ccache <path>: Set CMAKE_CXX_COMPILER_LAUNCHER (default: ccache)

Running the Compiler

After building, you can run the compiler using:

./src/compiler <input_file> [options]

Available options:

  • --until=<stage>: Run the compiler until a specific stage
    • lex: Run until the lexing stage
    • ast: Run until the parsing stage
  • --emit=<output>: Select the kind of output desired
    • lex: Dump the lexed tokens of the input file
    • src: Dump the original source code of the input file (not implemented yet)
    • ast: Dump the abstract syntax tree of the input file

Design Decisions

  1. Memory Management: The project uses an Arena allocator for efficient memory management of AST nodes.

  2. Error Reporting: The compiler implements a robust error reporting system that provides detailed information about lexing and parsing errors.

  3. LLVM Integration: The project leverages LLVM libraries for code generation and optimization.

  4. Modular Architecture: The compiler is divided into distinct phases (lexing, parsing, etc.) for better maintainability and extensibility.

  5. Type System: A basic type system is implemented, with a TypeContext for managing types.

  6. Resolver: A resolver stage is implemented to perform semantic analysis on the AST.

Project Structure

  • src/: Contains the main source files
    • Alloc/: Custom allocators
    • AST/: Abstract Syntax Tree related code
    • Lex/: Lexer implementation
    • Parse/: Parser implementations
    • Sema/: Semantic analysis code
    • Support/: Utility classes and functions
    • main.cpp: Entry point of the compiler
  • include/: Header files
    • ADT/: Abstract Data Types
  • CMakeLists.txt: CMake configuration files

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

This project is licensed under the MIT License - see the LICENSE file for details.