Added C++20 <source_location> and tests for std::swap

Author: ZERICO2005

src/libcxx/header_test.cpp

@@ -29,6 +29,9 @@
 #include <memory>
 #include <new>
 #include <numbers>
+#if __cplusplus >= 201907L
+#include <source_location>
+#endif // __cplusplus >= 201907L
 #include <type_traits>
 #include <typeinfo>
 #include <utility>

src/libcxx/include/source_location

@@ -0,0 +1,63 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _EZCXX_SOURCE_LOCATION
+#define _EZCXX_SOURCE_LOCATION
+
+#include <__config>
+#include <cstdint>
+
+#pragma clang system_header
+
+namespace std {
+
+class source_location {
+    // The names source_location::__impl, _M_file_name, _M_function_name, _M_line, and _M_column
+    // are hard-coded in the compiler and must not be changed here.
+    struct __impl {
+        const char* _M_file_name;
+        const char* _M_function_name;
+        unsigned _M_line;
+        unsigned _M_column;
+    };
+    const __impl* __ptr_ = nullptr;
+    // GCC returns the type 'const void*' from the builtin, while clang returns
+    // `const __impl*`. Per C++ [expr.const], casts from void* are not permitted
+    // in constant evaluation, so we don't want to use `void*` as the argument
+    // type unless the builtin returned that, anyhow, and the invalid cast is
+    // unavoidable.
+    using __bsl_ty _EZCXX_NODEBUG = decltype(__builtin_source_location());
+  
+public:
+    // The defaulted __ptr argument is necessary so that the builtin is evaluated
+    // in the context of the caller. An explicit value should never be provided.
+    static consteval source_location current(__bsl_ty __ptr = __builtin_source_location()) noexcept {
+        source_location __sl;
+        __sl.__ptr_ = static_cast<const __impl*>(__ptr);
+        return __sl;
+    }
+    _EZCXX_HIDE_FROM_ABI constexpr source_location() noexcept = default;
+  
+    _EZCXX_HIDE_FROM_ABI constexpr uint_least32_t line() const noexcept {
+        return __ptr_ != nullptr ? __ptr_->_M_line : 0;
+    }
+    _EZCXX_HIDE_FROM_ABI constexpr uint_least32_t column() const noexcept {
+        return __ptr_ != nullptr ? __ptr_->_M_column : 0;
+    }
+    _EZCXX_HIDE_FROM_ABI constexpr const char* file_name() const noexcept {
+        return __ptr_ != nullptr ? __ptr_->_M_file_name : "";
+    }
+    _EZCXX_HIDE_FROM_ABI constexpr const char* function_name() const noexcept {
+        return __ptr_ != nullptr ? __ptr_->_M_function_name : "";
+    }
+};
+
+} // namespace std
+
+#endif // _EZCXX_SOURCE_LOCATION

src/libcxx/include/version

@@ -149,7 +149,7 @@
 // # define __cpp_lib_shared_ptr_arrays                    201707L
 // # define __cpp_lib_shift                                201806L
 // # define __cpp_lib_smart_ptr_for_overwrite              202002L
-// # define __cpp_lib_source_location                      201907L
+# define __cpp_lib_source_location                      201907L
 // # define __cpp_lib_span                                 202002L
 // # define __cpp_lib_ssize                                201902L
 // # define __cpp_lib_starts_ends_with                     201711L

test/standalone/concepts/src/main.cpp

@@ -1,8 +1,26 @@
+#include <cstdio>
+#include <source_location>
+#include <cinttypes>
+
+// Do not change the location of this function
+int source_location_test(char *buf) {
+    const std::source_location location = std::source_location::current();
+    char const * const file_name = location.file_name();
+    uint_least32_t line = location.line();
+    uint_least32_t column = location.column();
+    char const * const function_name = location.function_name();
+    int ret = std::sprintf(buf,
+        "%s(%" PRIuLEAST32 ":%" PRIuLEAST32 ") `%s`\n",
+        file_name, line, column, function_name
+    );
+    return ret;
+}
+
 #include <ti/screen.h>
 #include <ti/getcsc.h>
 #include <sys/util.h>
-#include <stdio.h>
-
+#include <cstring>
+#include <type_traits>
 #include <concepts>
 
 // test derived_from
@@ -47,17 +65,82 @@ namespace test_floating_point {
     static_assert(std::is_same_v<int const, decltype(i)>);
 }
 
+constexpr int text_len = 54;
+static char const * const text =
+"src/main.cpp(7:43) `int source_location_test(char *)`\n";
+
+static const int swap_truth[] = {
+    5, 3, 3, 5, 6, 9, 9, 6
+};
+
+namespace test_swap {
+    namespace Ns {
+        class A {
+            int id {};
+     
+            friend void swap(A& lhs, A& rhs) {
+                std::swap(lhs.id, rhs.id);
+            }
+     
+        public:
+            A(int i) : id {i} {}
+            A(A const&) = delete;
+            A& operator = (A const&) = delete;
+            int get_val(void) { return id; }
+        };
+    }
+     
+    void swap_test(int *arr) {
+        int a = 5, b = 3;
+        *arr++ = a;
+        *arr++ = b;
+        std::swap(a, b);
+        *arr++ = a;
+        *arr++ = b;
+     
+        Ns::A p {6}, q {9};
+        *arr++ = p.get_val();
+        *arr++ = q.get_val();
+        swap(p, q);
+        *arr++ = p.get_val();
+        *arr++ = q.get_val();
+    }
+}
+
 int run_tests(void) {
+    {
+        char buf[64];
+        int ret = source_location_test(buf);
+        int cmp = std::strcmp(buf, text);
+        if (ret != text_len || cmp != 0) {
+            std::printf(
+                "ret: %d != %d\nstrcmp(buf, text) == %d\n",
+                ret, text_len, cmp
+            );
+            std::fputs(buf, stdout);
+            return __LINE__;
+        }
+    }
+    {
+        int arr[sizeof(swap_truth) / sizeof(int)];
+        test_swap::swap_test(arr);
+        for (size_t i = 0; i < sizeof(swap_truth) / sizeof(int); i++) {
+            if (arr[i] != swap_truth[i]) {
+                printf("%d: %d != %d", i, arr[i], swap_truth[i]);
+                return __LINE__;
+            }
+        }
+    }
     return 0;
 }
 
 int main(void) {
     os_ClrHome();
     int failed_test = run_tests();
     if (failed_test != 0) {
-        printf("Failed test L%d\n", failed_test);
+        std::printf("Failed test L%d\n", failed_test);
     } else {
-        printf("All tests passed");
+        std::printf("All tests passed");
     }
 
     while (!os_GetCSC());