Merge main branch

Author: haruki7049

README.md

@@ -73,12 +73,6 @@ If you'd like your name, company, or logo here, you can
   </a>
 </p>
 
-<p align="center">
-  <a href="https://devcarbon.com/">
-    devcarbon.com
-  </a>
-</p>
-
 <p align="center">
   <a href="https://pitch.com/">
     Misha Karpenko

compiler+runtime/CMakeLists.txt

@@ -95,6 +95,9 @@ set(
 set(
   jank_linker_flags
   #-stdlib=libc++ -lc++abi
+  $<$<PLATFORM_ID:Darwin>:-L/opt/homebrew/lib>
+  $<$<PLATFORM_ID:Darwin>:${CMAKE_BINARY_DIR}/llvm-install/usr/local/lib/libunwind.a>
+  $<$<PLATFORM_ID:Darwin>:${CMAKE_BINARY_DIR}/llvm-install/usr/local/lib/libc++abi.a>
   )
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
   list(APPEND jank_common_compiler_flags #-Werror
@@ -244,7 +247,7 @@ target_link_libraries(
   readline
   clangInterpreter
   Boost::boost
-  OpenSSL::SSL
+  $<$<PLATFORM_ID:Darwin>:crypto>
 )
 
 jank_hook_llvm(jank_lib)
@@ -255,20 +258,27 @@ list(JOIN jank_jit_compile_flags_list " " jank_jit_compile_flags_str)
 
 # Build a string of all include flags for jank. This will be used for building the PCH at build
 # time as well as building the PCH on first run, after installation.
-get_target_property(jank_lib_includes jank_lib INCLUDE_DIRECTORIES)
-set(jank_lib_includes_str "")
-foreach(dir ${jank_lib_includes})
+get_target_property(jank_lib_includes_prop jank_lib INCLUDE_DIRECTORIES)
+set(jank_lib_includes "")
+foreach(dir ${jank_lib_includes_prop})
   # System includes are just the path, but normal includes have this format:
   # $<BUILD_INTERFACE:/home/jeaye/projects/jank/compiler+runtime/include/cpp>
   # We need to strip all of that out.
   if(${dir} MATCHES "BUILD_INTERFACE:")
     string(REGEX REPLACE "\\$<BUILD_INTERFACE:(.*)>" "\\1" dir_path ${dir})
-    string(APPEND jank_lib_includes_str "-I${dir_path} ")
+    list(APPEND jank_lib_includes -I${dir_path})
   else()
-    string(APPEND jank_lib_includes_str "-isystem ${dir} ")
+    list(APPEND jank_lib_includes -isystem ${dir})
   endif()
 endforeach()
 
+target_include_directories(
+    jank_lib
+    SYSTEM
+    PUBLIC
+    "$<$<PLATFORM_ID:Darwin>:/opt/homebrew/include>"
+)
+
 target_compile_options(
   jank_lib
   PUBLIC
@@ -340,6 +350,7 @@ set(
   third-party/folly/folly/synchronization/SanitizeThread.cpp
   third-party/folly/folly/lang/SafeAssert.cpp
   third-party/folly/folly/lang/ToAscii.cpp
+  third-party/folly/folly/lang/Exception.cpp
   third-party/folly/folly/system/ThreadId.cpp
   third-party/folly/folly/system/AtFork.cpp
   third-party/folly/folly/detail/Futex.cpp
@@ -465,10 +476,24 @@ set(jank_pch_compile_flags_list ${jank_common_compiler_flags} -w)
 list(JOIN jank_pch_compile_flags_list " " jank_pch_compile_flags_str)
 
 set(jank_incremental_pch_flag ${CMAKE_BINARY_DIR}/incremental.pch)
+
+separate_arguments(jank_incremental_pch_cxx_flags UNIX_COMMAND ${CMAKE_CXX_FLAGS})
+list(REMOVE_ITEM jank_incremental_pch_cxx_flags -fPIC)
 add_custom_command(
-  DEPENDS ${CMAKE_BINARY_DIR}/jank ${CMAKE_SOURCE_DIR}/bin/build-pch
+  DEPENDS ${CMAKE_BINARY_DIR}/jank
   OUTPUT ${jank_incremental_pch_flag}
-  COMMAND "${CMAKE_SOURCE_DIR}/bin/build-pch" "${CLANG_INSTALL_PREFIX}" "${CMAKE_SOURCE_DIR}/include" "${jank_incremental_pch_flag}" "${jank_pch_compile_flags_str}" "${jank_lib_includes_str}"
+  COMMAND_EXPAND_LISTS
+  VERBATIM
+  COMMAND ${CMAKE_CXX_COMPILER}
+          ${jank_incremental_pch_cxx_flags}
+          ${jank_common_compiler_flags} ${jank_aot_compiler_flags}
+          ${jank_lib_includes}
+          -Xclang -fincremental-extensions
+          -Xclang -emit-pch
+          -x c++-header
+          -w
+          -c ${PROJECT_SOURCE_DIR}/include/cpp/jank/prelude.hpp
+          -o ${jank_incremental_pch_flag}
 )
 add_custom_target(
   jank_incremental_pch

compiler+runtime/bin/build-clang

@@ -54,6 +54,7 @@ function build()
   cd "${srcdir}/llvm-build"
 
   cmake -DCMAKE_BUILD_TYPE=Release \
+        -DLLVM_ENABLE_RUNTIMES=all \
         -DCMAKE_CXX_STANDARD=20 \
         -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra" \
         -DLLVM_TARGETS_TO_BUILD="host" \

compiler+runtime/bin/build-pch

@@ -26,10 +26,6 @@ pkgs.llvmPackages_19.stdenv.mkDerivation {
     ninja
   ];
 
-  patchPhase = ''
-    patchShebangs --host "${pkgs.bash}" bin/build-pch
-  '';
-
   buildInputs = [
     boost
     boehmgc

compiler+runtime/default.nix

@@ -41,6 +41,11 @@ cd -
 export CC=$PWD/build/llvm-install/usr/local/bin/clang; export CXX=$PWD/build/llvm-install/usr/local/bin/clang++
 ```
 
+On macOS also do this:
+```
+export SDKROOT=$(xcrun --sdk macosx --show-sdk-path)
+```
+
 At this point, you're ready to build jank.
 
 
@@ -65,6 +70,12 @@ To make a debug build, specify the build type when configuring.
 ./bin/watch ./bin/test
 ```
 
+# Run jank
+To run jank's repl, inside of /compiler+runtime, do
+```bash
+./build/jank repl
+```
+
 ## Packaging
 There's also a script for installing jank and all its necessary dependencies.
 Note that this includes a lot of header files, which are necessary for jank's

compiler+runtime/doc/build.md

@@ -42,13 +42,23 @@ namespace jank::read::lex
     integer,
     /* Has double data. */
     real,
+    /* Has two integer data. */
+    ratio,
     /* Has string data. */
     string,
     /* Has string data. */
     escaped_string,
     eof,
   };
 
+  struct ratio
+  {
+    native_integer numerator{};
+    native_integer denominator{};
+    native_bool operator==(ratio const &rhs) const;
+    native_bool operator!=(ratio const &rhs) const;
+  };
+
   struct token
   {
     token() = default;
@@ -65,6 +75,7 @@ namespace jank::read::lex
     token(size_t const p, size_t const s, token_kind const k, native_persistent_string_view const);
     token(size_t const p, size_t const s, token_kind const k, char const * const);
     token(size_t const p, size_t const s, token_kind const k, native_bool const);
+    token(size_t const p, size_t const s, token_kind const k, ratio const);
 
     native_bool operator==(token const &rhs) const;
     native_bool operator!=(token const &rhs) const;
@@ -81,12 +92,18 @@ namespace jank::read::lex
     size_t pos{ ignore_pos };
     size_t size{ 1 };
     token_kind kind{ token_kind::eof };
-    boost::variant<no_data, native_integer, native_real, native_persistent_string_view, native_bool>
+    boost::variant<no_data,
+                   native_integer,
+                   native_real,
+                   native_persistent_string_view,
+                   native_bool,
+                   ratio>
       data;
   };
 
   std::ostream &operator<<(std::ostream &os, token const &t);
   std::ostream &operator<<(std::ostream &os, token::no_data const &t);
+  std::ostream &operator<<(std::ostream &os, ratio const &t);
 }
 
 namespace jank::read
@@ -142,6 +159,8 @@ namespace jank::read::lex
     size_t pos{};
     /* Whether or not the previous token requires a space after it. */
     native_bool require_space{};
+    /* True when seeing a '/' following a number. */
+    native_bool found_slash_after_number{};
     native_persistent_string_view file;
   };
 }

compiler+runtime/include/cpp/jank/read/lex.hpp

@@ -12,6 +12,40 @@ namespace jank::runtime
 /* TODO: Rename file to processor. */
 namespace jank::read::parse
 {
+  static option<char> get_char_from_literal(native_persistent_string const &sv)
+  {
+    if(sv.size() == 2)
+    {
+      return sv[1];
+    }
+    else if(sv == R"(\newline)")
+    {
+      return '\n';
+    }
+    else if(sv == R"(\space)")
+    {
+      return ' ';
+    }
+    else if(sv == R"(\tab)")
+    {
+      return '\t';
+    }
+    else if(sv == R"(\backspace)")
+    {
+      return '\b';
+    }
+    else if(sv == R"(\formfeed)")
+    {
+      return '\f';
+    }
+    else if(sv == R"(\return)")
+    {
+      return '\r';
+    }
+
+    return none;
+  }
+
   struct processor
   {
     struct object_source_info
@@ -73,6 +107,7 @@ namespace jank::read::parse
     object_result parse_boolean();
     object_result parse_keyword();
     object_result parse_integer();
+    object_result parse_ratio();
     object_result parse_real();
     object_result parse_string();
     object_result parse_escaped_string();

compiler+runtime/include/cpp/jank/read/parse.hpp

@@ -4,7 +4,7 @@ namespace jank::runtime::behavior
 {
   template <typename T>
   concept comparable = requires(T * const t) {
-      /* Returns how this object compares to the specified object. Comparison, unlike equality,
+    /* Returns how this object compares to the specified object. Comparison, unlike equality,
        * can only be done for objects of the same type. If there's a type mismatch, this function
        * is expected to throw. There are three cases to handle:
        *
@@ -14,6 +14,6 @@ namespace jank::runtime::behavior
        *
        * For sequences, all values need to be considered for comparison.
        */
-      { t->compare(std::declval<object const &>()) } -> std::convertible_to<native_integer>;
+    { t->compare(std::declval<object const &>()) } -> std::convertible_to<native_integer>;
   };
 }

compiler+runtime/include/cpp/jank/runtime/behavior/comparable.hpp

@@ -6,6 +6,10 @@ namespace jank::runtime
   void to_string(char ch, fmt::memory_buffer &buff);
   void to_string(object_ptr o, fmt::memory_buffer &buff);
 
+  native_persistent_string to_code_string(object const *o);
+  void to_code_string(char ch, fmt::memory_buffer &buff);
+  void to_code_string(object_ptr o, fmt::memory_buffer &buff);
+
   template <typename It>
   void to_string(It const &begin,
                  It const &end,
@@ -63,4 +67,62 @@ namespace jank::runtime
     runtime::to_string(s, buff);
     return native_persistent_string{ buff.data(), buff.size() };
   }
+
+  template <typename It>
+  void to_code_string(It const &begin,
+                      It const &end,
+                      native_persistent_string_view const open,
+                      char const close,
+                      fmt::memory_buffer &buff)
+  {
+    auto inserter(std::back_inserter(buff));
+    for(auto const c : open)
+    {
+      inserter = c;
+    }
+    for(auto i(begin); i != end; ++i)
+    {
+      runtime::to_code_string(*i, buff);
+      auto n(i);
+      if(++n != end)
+      {
+        inserter = ' ';
+      }
+    }
+    inserter = close;
+  }
+
+  template <typename T>
+  requires behavior::sequenceable<T>
+  void to_code_string(native_box<T> const s, fmt::memory_buffer &buff)
+  {
+    auto inserter(std::back_inserter(buff));
+    if(!s)
+    {
+      fmt::format_to(inserter, "()");
+      return;
+    }
+
+    fmt::format_to(inserter, "(");
+    native_bool needs_space{};
+    for(auto i(s->fresh_seq()); i != nullptr; i = i->next_in_place())
+    {
+      if(needs_space)
+      {
+        fmt::format_to(inserter, " ");
+      }
+      runtime::to_code_string(i->first(), buff);
+      needs_space = true;
+    }
+    fmt::format_to(inserter, ")");
+  }
+
+  template <typename T>
+  requires behavior::sequenceable<T>
+  native_persistent_string to_code_string(native_box<T> const s)
+  {
+    fmt::memory_buffer buff;
+    runtime::to_code_string(s, buff);
+    return native_persistent_string{ buff.data(), buff.size() };
+  }
 }