diff --git a/.gitattributes b/.gitattributes index c8d8395f44fa5a333f9e3130493a6dc03669c9aa..b45c1b352b35339b527a1dbe2b3aa352846605c4 100644 --- a/.gitattributes +++ b/.gitattributes @@ -5356,3 +5356,34 @@ cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/host-windows-x64/TimelineUIU cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/host-windows-x64/TimelineWidget.dll filter=lfs diff=lfs merge=lfs -text cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/host-windows-x64/ucrtbase.dll filter=lfs diff=lfs merge=lfs -text cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/concrt140.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140_2.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/ucrtbase.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/vccorlib140.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/concrt140.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140_2.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/ucrtbase.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/vccorlib140.dll filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/CudaGpuInfoDumper filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.0 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.1 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.2 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.0 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.1 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.2 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.3 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.4 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.5 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.6 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.7 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.8 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.12.4 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.0.187 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.1 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libLinuxKeyboardInterceptorProxy.so filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvlog.so filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvperf_grfx_host.so filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libsqlite3.so.0 filter=lfs diff=lfs merge=lfs -text +cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libToolsInjection64.so filter=lfs diff=lfs merge=lfs -text diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/bottom-view-selector.png b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/bottom-view-selector.png new file mode 100644 index 0000000000000000000000000000000000000000..07dcef436aaf2f354da7d42f9c96b18cadc20aac --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/bottom-view-selector.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d6f9ae2592a48ac7af34a7e85b0744d5bb3b8c790c995a454a662b6f0d1e0fe9 +size 1553 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/collect_thread_activity.png b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/collect_thread_activity.png new file mode 100644 index 0000000000000000000000000000000000000000..1b9e944c0ed0181f12074c35f88187b9932b1e39 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/collect_thread_activity.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:605e61fa77fcea0d99c5fc56c64b8c0117c56ae9c37d86669929af9fbb005cb9 +size 49075 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-cuda-python-backtrace.png b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-cuda-python-backtrace.png new file mode 100644 index 0000000000000000000000000000000000000000..1db52054ff9f3627e2527cc126924cef7a0879bb --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-cuda-python-backtrace.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8f4c57d94af621f92f9cea50cfdde60eaf44bf17f6f87e03555e67dc57fa86e3 +size 175194 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-cuda-trace-x86.png b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-cuda-trace-x86.png new file mode 100644 index 0000000000000000000000000000000000000000..67afddbd251f5f1811800a5e6a4053682c2c7ecb --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-cuda-trace-x86.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:572076cc1fe33075e6826122d3c88b5b0eba10b654b53b13a84050aac14b32bf +size 121297 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-cuda-trace.png b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-cuda-trace.png new file mode 100644 index 0000000000000000000000000000000000000000..9c9e829bbd8bb4a033bdf5b551c1949d16a9e7e4 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-cuda-trace.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:388665884dace1c548a06c377792d7cd0dbd6530aee1879e7d56b65e4fb0e37d +size 3092 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-opengl-functions.png b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-opengl-functions.png new file mode 100644 index 0000000000000000000000000000000000000000..b0ecb4d981bd02129c1cc7c432069faf9bb73afd --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-opengl-functions.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2447a5155eac5d5ef74000db50f81853bff915c9173bbd04dbd96d2cb5d227cd +size 11170 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-opengl-trace.png b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-opengl-trace.png new file mode 100644 index 0000000000000000000000000000000000000000..329f5380d287df750d708e99d6af0c5464c857e4 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-opengl-trace.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4acb47dca5b24d7977e0eb9c72afc2ba83d3e6cee62fe296665e14c5e2fb5df2 +size 4168 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-os-runtime-trace.png b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-os-runtime-trace.png new file mode 100644 index 0000000000000000000000000000000000000000..5e55e395079cd5c96cb830f6ee6bcc392093f6e3 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/documentation/_images/configure-os-runtime-trace.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca18f6c85185e645f6230c070a7f3619293a6e834a05908caf4dd5d4fd75b5fd +size 22312 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140.dll b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140.dll new file mode 100644 index 0000000000000000000000000000000000000000..12a2deec69b91ffd6c527c98f201b61ae612c499 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:02c7259456eac8cbadfb460377ba68e98282400c7a4a9d0bf49b3313ef6d554d +size 450320 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140_2.dll b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140_2.dll new file mode 100644 index 0000000000000000000000000000000000000000..af33b7438fa6a4ee43c854569602f2f053b01b76 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140_2.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:459cb496aebf1bfc40405e8eb98f43cc360b9ba7b0fc0d71851a0bdf6487132d +size 173336 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/ucrtbase.dll b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/ucrtbase.dll new file mode 100644 index 0000000000000000000000000000000000000000..185d1f0f1605d9b50fc9f550de1cca21a4db9bd0 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/ucrtbase.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7651d3749a2c2b2231117c958919db8fd018dfebe5909b58d8b176d70103aff1 +size 922392 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/vccorlib140.dll b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/vccorlib140.dll new file mode 100644 index 0000000000000000000000000000000000000000..c4a733d7fa19703e283e741b81a7dfff2ca2f2f1 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/vccorlib140.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f7e17bc746abf55122ee1d2608db7240de4b4428be13dfee8c3e03db6f9b360 +size 269080 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/concrt140.dll b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/concrt140.dll new file mode 100644 index 0000000000000000000000000000000000000000..6dfb5a0b0401cc622665eb69da5fa7d3bdb16f28 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/concrt140.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dabdb0732b2fc14040cedbbfd369d9eb3c7a2e66b38a79892e1c05e6d6a8526d +size 333592 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140.dll b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140.dll new file mode 100644 index 0000000000000000000000000000000000000000..161d2019c5e00f4ae93adca60762aaa19ff56e32 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f87819ae8c6f7c90d3237a1abb9809e8cba9dcd0c80ac3f0969a5e68ef652ca4 +size 618264 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140_2.dll b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140_2.dll new file mode 100644 index 0000000000000000000000000000000000000000..957afd09ea37e6ebecd55eccf19d51fbba2eb856 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140_2.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7d5d180c8e41b1964835b2550191e2d9054d8f4beff898ade67b3d5dd25b5101 +size 203544 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/ucrtbase.dll b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/ucrtbase.dll new file mode 100644 index 0000000000000000000000000000000000000000..dfdf06ae6bece34ef9ab8b6d92c2b58fb377af54 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/ucrtbase.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8a80137b08dad99c22af911b84a20639b74009462a99cc35af911cc6749218be +size 994072 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/vccorlib140.dll b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/vccorlib140.dll new file mode 100644 index 0000000000000000000000000000000000000000..d275a1b71d37a564430da2b7b8902a05b21f2309 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/vccorlib140.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41b6af9484c860804c69e00c9d7fee22efe5f769c51355936fc9de248221de94 +size 366360 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/CudaGpuInfoDumper b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/CudaGpuInfoDumper new file mode 100644 index 0000000000000000000000000000000000000000..0d5c6b2382629ed89735d386a65dbc19432480ba --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/CudaGpuInfoDumper @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f4badf962ea422e15939f6a8ae41894072081a1b30b48672f9af9065869e6377 +size 2142688 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libLinuxKeyboardInterceptorProxy.so b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libLinuxKeyboardInterceptorProxy.so new file mode 100644 index 0000000000000000000000000000000000000000..98a43f9474af289a3805766f597b9bf98ba66137 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libLinuxKeyboardInterceptorProxy.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ac380f9af9921379ba436e78660e511e71d5c95bc746ffeeff868ed1a3712db6 +size 142288 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libToolsInjection64.so b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libToolsInjection64.so new file mode 100644 index 0000000000000000000000000000000000000000..57229672cc35e2418cb13932dfe7c5d4b2d8b24c --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libToolsInjection64.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0bc0293da97d1a1a2489757884eca82993016d9e90b39fe2376a4196b1837aba +size 14918384 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.0 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.0 new file mode 100644 index 0000000000000000000000000000000000000000..90c4b8e2aa1ce47ca8596c224692a53379f38676 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:620e3d3cf47ec6007c58781586eb23dd81e9083f1a54f26cabc1ca44679dc116 +size 6210840 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.1 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.1 new file mode 100644 index 0000000000000000000000000000000000000000..beabd13b90a6387c25b25c5ad6defd7005c2953c --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.1 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6cb672b29ce621251186e63b492f0732f1f105c9933af450115c5c07b1539bca +size 6225144 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.2 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.2 new file mode 100644 index 0000000000000000000000000000000000000000..c4d293d6aea529854a3361bda9fee574f805933e --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d01298144b9e8c8f0b89a8dc06c81fa8179a043292c293c8e5b00db2bffccde5 +size 5984336 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.0 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.0 new file mode 100644 index 0000000000000000000000000000000000000000..aa36ef1e2256f456b12e901e616508fb5a9ef564 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:acfd1a0ab0e1c7c1abfa85e6b98a923e2ce88757e9a83086874f0444c04ddf3d +size 6539088 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.1 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.1 new file mode 100644 index 0000000000000000000000000000000000000000..0706f8efdc6c704e76cec6e0a845f1814b541f1c --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.1 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ed3e6588a0df9adb0158f13039ebfb0ce60f84924e23de80991d7dcb829f8fe0 +size 6572976 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.2 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.2 new file mode 100644 index 0000000000000000000000000000000000000000..ad054b1eb72b45ec1c3cc99d8ac1187b4863776e --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e961d8214b9de1cd0db8e9235ac319188dadfe9cc1e4ea12b8a3f463b8973e88 +size 6664624 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.3 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.3 new file mode 100644 index 0000000000000000000000000000000000000000..9d40d24312666903d4693865a46ee7f7b414c8b3 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.3 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f8bd623f3a1da4c37491019cbef5fb7e852dae66ba5db97b1bdfffb0f70611f1 +size 6748816 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.4 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.4 new file mode 100644 index 0000000000000000000000000000000000000000..5630054677affa5f7c7da85b20bb3e96049bd019 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.4 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e0b9ce7c149aa4e933a047d0ccec542ac1ee20261208add88cb1e0a8dfc83654 +size 6755312 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.5 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.5 new file mode 100644 index 0000000000000000000000000000000000000000..c7fe6114221e94be98b8d4bb5f8dfacfe6aac7cd --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.5 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c1ae9cbccac742548e2cdffb364b31618733dd117ac38b5a17b590cbf146ccca +size 6759504 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.6 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.6 new file mode 100644 index 0000000000000000000000000000000000000000..c7fe6114221e94be98b8d4bb5f8dfacfe6aac7cd --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.6 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c1ae9cbccac742548e2cdffb364b31618733dd117ac38b5a17b590cbf146ccca +size 6759504 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.7 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.7 new file mode 100644 index 0000000000000000000000000000000000000000..7121643623bc741d204998b6a02e7487a60e5f1b --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.7 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e2fc5d89063863adbf1a6081fbe95b15d235aa8f520170f5eac320e27544e1d +size 7099760 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.8 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.8 new file mode 100644 index 0000000000000000000000000000000000000000..b664bf1f3cb11cd8942f92747872f2da8b456c4c --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.8 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f084994fbae5004fa43fe7eae3fa1861960ded46c7b38a3152df41d9a312e9fc +size 7199856 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.12.4 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.12.4 new file mode 100644 index 0000000000000000000000000000000000000000..1cdd057722d388dd909bb76d148c61b2766f3e77 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.12.4 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5086e51ba2422dccda90a764cf400b11f29d5e68418512ceb51fe9dc9c22f9dd +size 6614096 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so new file mode 100644 index 0000000000000000000000000000000000000000..48a506ab7263969d55784e5020989317e0c2c9e2 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e892281fa9e30e5210ea7750630283be6231840c1147dc687ef96c06d692f92b +size 100848 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.0.187 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.0.187 new file mode 100644 index 0000000000000000000000000000000000000000..48a506ab7263969d55784e5020989317e0c2c9e2 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.0.187 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e892281fa9e30e5210ea7750630283be6231840c1147dc687ef96c06d692f92b +size 100848 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.1 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.1 new file mode 100644 index 0000000000000000000000000000000000000000..48a506ab7263969d55784e5020989317e0c2c9e2 --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.1 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e892281fa9e30e5210ea7750630283be6231840c1147dc687ef96c06d692f92b +size 100848 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvlog.so b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvlog.so new file mode 100644 index 0000000000000000000000000000000000000000..b3cd591c14ed2f4c2d9194347405aec3013f33ce --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvlog.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7659ce40aeef63f2abef999851f55b2d5aed0e3a6cd7975f21ffb8f3d9c22ad +size 170752 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvperf_grfx_host.so b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvperf_grfx_host.so new file mode 100644 index 0000000000000000000000000000000000000000..cb2809f045f9449e89c8ebe72fd545c8dbf05f7b --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvperf_grfx_host.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddbb3414090b5fa30a759e4408b56f9af7d013e56d8680c5c6027a97bad8b44c +size 28084320 diff --git a/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libsqlite3.so.0 b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libsqlite3.so.0 new file mode 100644 index 0000000000000000000000000000000000000000..15fb6c6d31e1a2c115dfb17491d14398c6c05c2e --- /dev/null +++ b/cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libsqlite3.so.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b193efedaf858b437c056898807570837e873c03c4ba4d6bf44f5ca53a99b802 +size 1002584 diff --git a/git/usr/share/perl5/core_perl/Tie/Memoize.pm b/git/usr/share/perl5/core_perl/Tie/Memoize.pm new file mode 100644 index 0000000000000000000000000000000000000000..dbe14428280b5925b316892e0803b0b6e585704d --- /dev/null +++ b/git/usr/share/perl5/core_perl/Tie/Memoize.pm @@ -0,0 +1,128 @@ +use strict; +package Tie::Memoize; +use Tie::Hash; +our @ISA = 'Tie::ExtraHash'; +our $VERSION = '1.1'; + +our $exists_token = \undef; + +sub croak {require Carp; goto &Carp::croak} + +# Format: [0: STORAGE, 1: EXISTS-CACHE, 2: FETCH_function; +# 3: EXISTS_function, 4: DATA, 5: EXISTS_different ] + +sub FETCH { + my ($h,$key) = ($_[0][0], $_[1]); + my $res = $h->{$key}; + return $res if defined $res; # Shortcut if accessible + return $res if exists $h->{$key}; # Accessible, but undef + my $cache = $_[0][1]{$key}; + return if defined $cache and not $cache; # Known to not exist + my @res = $_[0][2]->($key, $_[0][4]); # Autoload + $_[0][1]{$key} = 0, return unless @res; # Cache non-existence + delete $_[0][1]{$key}; # Clear existence cache, not needed any more + $_[0][0]{$key} = $res[0]; # Store data and return +} + +sub EXISTS { + my ($a,$key) = (shift, shift); + return 1 if exists $a->[0]{$key}; # Have data + my $cache = $a->[1]{$key}; + return $cache if defined $cache; # Existence cache + my @res = $a->[3]($key,$a->[4]); + $a->[1]{$key} = 0, return unless @res; # Cache non-existence + # Now we know it exists + return ($a->[1]{$key} = 1) if $a->[5]; # Only existence reported + # Now know the value + $a->[0]{$key} = $res[0]; # Store data + return 1 +} + +sub TIEHASH { + croak 'syntax: tie %hash, \'Tie::AutoLoad\', \&fetch_subr' if @_ < 2; + croak 'syntax: tie %hash, \'Tie::AutoLoad\', \&fetch_subr, $data, \&exists_subr, \%data_cache, \%existence_cache' if @_ > 6; + push @_, undef if @_ < 3; # Data + push @_, $_[1] if @_ < 4; # exists + push @_, {} while @_ < 6; # initial value and caches + bless [ @_[4,5,1,3,2], $_[1] ne $_[3]], $_[0] +} + +1; + +=head1 NAME + +Tie::Memoize - add data to hash when needed + +=head1 SYNOPSIS + + require Tie::Memoize; + tie %hash, 'Tie::Memoize', + \&fetch, # The rest is optional + $DATA, \&exists, + {%ini_value}, {%ini_existence}; + +=head1 DESCRIPTION + +This package allows a tied hash to autoload its values on the first access, +and to use the cached value on the following accesses. + +Only read-accesses (via fetching the value or C) result in calls to +the functions; the modify-accesses are performed as on a normal hash. + +The required arguments during C are the hash, the package, and +the reference to the Cing function. The optional arguments are +an arbitrary scalar $data, the reference to the C function, +and initial values of the hash and of the existence cache. + +Both the Cing function and the C functions have the +same signature: the arguments are C<$key, $data>; $data is the same +value as given as argument during tie()ing. Both functions should +return an empty list if the value does not exist. If C +function is different from the Cing function, it should return +a TRUE value on success. The Cing function should return the +intended value if the key is valid. + +=head1 Inheriting from B + +The structure of the tied() data is an array reference with elements + + 0: cache of known values + 1: cache of known existence of keys + 2: FETCH function + 3: EXISTS function + 4: $data + +The rest is for internal usage of this package. In particular, if +TIEHASH is overwritten, it should call SUPER::TIEHASH. + +=head1 EXAMPLE + + sub slurp { + my ($key, $dir) = shift; + open my $h, '<', "$dir/$key" or return; + local $/; <$h> # slurp it all + } + sub exists { my ($key, $dir) = shift; return -f "$dir/$key" } + + tie %hash, 'Tie::Memoize', \&slurp, $directory, \&exists, + { fake_file1 => $content1, fake_file2 => $content2 }, + { pretend_does_not_exists => 0, known_to_exist => 1 }; + +This example treats the slightly modified contents of $directory as a +hash. The modifications are that the keys F and +F fetch values $content1 and $content2, and +F will never be accessed. Additionally, the +existence of F is never checked (so if it does not +exists when its content is needed, the user of %hash may be confused). + +=head1 BUGS + +FIRSTKEY and NEXTKEY methods go through the keys which were already read, +not all the possible keys of the hash. + +=head1 AUTHOR + +Ilya Zakharevich L. + +=cut + diff --git a/git/usr/share/perl5/core_perl/Tie/RefHash.pm b/git/usr/share/perl5/core_perl/Tie/RefHash.pm new file mode 100644 index 0000000000000000000000000000000000000000..0717ad6994ce1ec86d0de0075038b503ec5c27ba --- /dev/null +++ b/git/usr/share/perl5/core_perl/Tie/RefHash.pm @@ -0,0 +1,367 @@ +package Tie::RefHash; # git description: v1.40-9-g23812d9 +# ABSTRACT: Use references as hash keys + +our $VERSION = '1.41'; + +#pod =head1 SYNOPSIS +#pod +#pod require 5.004; +#pod use Tie::RefHash; +#pod tie HASHVARIABLE, 'Tie::RefHash', LIST; +#pod tie HASHVARIABLE, 'Tie::RefHash::Nestable', LIST; +#pod +#pod untie HASHVARIABLE; +#pod +#pod =head1 DESCRIPTION +#pod +#pod This module provides the ability to use references as hash keys if you +#pod first C the hash variable to this module. Normally, only the +#pod keys of the tied hash itself are preserved as references; to use +#pod references as keys in hashes-of-hashes, use Tie::RefHash::Nestable, +#pod included as part of Tie::RefHash. +#pod +#pod It is implemented using the standard perl TIEHASH interface. Please +#pod see the C entry in perlfunc(1) and perltie(1) for more information. +#pod +#pod The Nestable version works by looking for hash references being stored +#pod and converting them to tied hashes so that they too can have +#pod references as keys. This will happen without warning whenever you +#pod store a reference to one of your own hashes in the tied hash. +#pod +#pod =head1 EXAMPLE +#pod +#pod use Tie::RefHash; +#pod tie %h, 'Tie::RefHash'; +#pod $a = []; +#pod $b = {}; +#pod $c = \*main; +#pod $d = \"gunk"; +#pod $e = sub { 'foo' }; +#pod %h = ($a => 1, $b => 2, $c => 3, $d => 4, $e => 5); +#pod $a->[0] = 'foo'; +#pod $b->{foo} = 'bar'; +#pod for (keys %h) { +#pod print ref($_), "\n"; +#pod } +#pod +#pod tie %h, 'Tie::RefHash::Nestable'; +#pod $h{$a}->{$b} = 1; +#pod for (keys %h, keys %{$h{$a}}) { +#pod print ref($_), "\n"; +#pod } +#pod +#pod =head1 THREAD SUPPORT +#pod +#pod L fully supports threading using the C method. +#pod +#pod =head1 STORABLE SUPPORT +#pod +#pod L hooks are provided for semantically correct serialization and +#pod cloning of tied refhashes. +#pod +#pod =head1 AUTHORS +#pod +#pod Gurusamy Sarathy +#pod +#pod Tie::RefHash::Nestable by Ed Avis +#pod +#pod =head1 SEE ALSO +#pod +#pod perl(1), perlfunc(1), perltie(1) +#pod +#pod =cut + +use Tie::Hash; +our @ISA = qw(Tie::Hash); +use strict; +use Carp (); + +# Tie::RefHash::Weak (until at least 0.09) assumes we define a refaddr() +# function, so just import the one from Scalar::Util +use Scalar::Util qw(refaddr); + +BEGIN { + # determine whether we need to take care of threads + use Config (); + my $usethreads = $Config::Config{usethreads}; # && exists $INC{"threads.pm"} + *_HAS_THREADS = $usethreads ? sub () { 1 } : sub () { 0 }; + *_HAS_WEAKEN = defined(&Scalar::Util::weaken) ? sub () { 1 } : sub () { 0 }; +} + +my (@thread_object_registry, $count); # used by the CLONE method to rehash the keys after their refaddr changed + +sub TIEHASH { + my $c = shift; + my $s = []; + bless $s, $c; + while (@_) { + $s->STORE(shift, shift); + } + + if (_HAS_THREADS ) { + + if ( _HAS_WEAKEN ) { + # remember the object so that we can rekey it on CLONE + push @thread_object_registry, $s; + # but make this a weak reference, so that there are no leaks + Scalar::Util::weaken( $thread_object_registry[-1] ); + + if ( ++$count > 1000 ) { + # this ensures we don't fill up with a huge array dead weakrefs + @thread_object_registry = grep defined, @thread_object_registry; + Scalar::Util::weaken( $_ ) for @thread_object_registry; + $count = 0; + } + } else { + $count++; # used in the warning + } + } + + return $s; +} + +my $storable_format_version = join("/", __PACKAGE__, "0.01"); + +sub STORABLE_freeze { + my ( $self, $is_cloning ) = @_; + my ( $refs, $reg ) = @$self; + return ( $storable_format_version, [ values %$refs ], $reg || {} ); +} + +sub STORABLE_thaw { + my ( $self, $is_cloning, $version, $refs, $reg ) = @_; + Carp::croak "incompatible versions of Tie::RefHash between freeze and thaw" + unless $version eq $storable_format_version; + + @$self = ( {}, $reg ); + $self->_reindex_keys( $refs ); +} + +sub CLONE { + my $pkg = shift; + + if ( $count and not _HAS_WEAKEN ) { + warn "Tie::RefHash is not threadsafe without Scalar::Util::weaken"; + } + + # when the thread has been cloned all the objects need to be updated. + # dead weakrefs are undefined, so we filter them out + @thread_object_registry = grep defined && do { $_->_reindex_keys; 1 }, @thread_object_registry; + Scalar::Util::weaken( $_ ) for @thread_object_registry; + $count = 0; # we just cleaned up +} + +sub _reindex_keys { + my ( $self, $extra_keys ) = @_; + # rehash all the ref keys based on their new StrVal + %{ $self->[0] } = map +(refaddr($_->[0]) => $_), (values(%{ $self->[0] }), @{ $extra_keys || [] }); +} + +sub FETCH { + my($s, $k) = @_; + if (ref $k) { + my $kstr = refaddr($k); + if (defined $s->[0]{$kstr}) { + $s->[0]{$kstr}[1]; + } + else { + undef; + } + } + else { + $s->[1]{$k}; + } +} + +sub STORE { + my($s, $k, $v) = @_; + if (ref $k) { + $s->[0]{refaddr($k)} = [$k, $v]; + } + else { + $s->[1]{$k} = $v; + } + $v; +} + +sub DELETE { + my($s, $k) = @_; + (ref $k) + ? (delete($s->[0]{refaddr($k)}) || [])->[1] + : delete($s->[1]{$k}); +} + +sub EXISTS { + my($s, $k) = @_; + (ref $k) ? exists($s->[0]{refaddr($k)}) : exists($s->[1]{$k}); +} + +sub FIRSTKEY { + my $s = shift; + keys %{$s->[0]}; # reset iterator + keys %{$s->[1]}; # reset iterator + $s->[2] = 0; # flag for iteration, see NEXTKEY + $s->NEXTKEY; +} + +sub NEXTKEY { + my $s = shift; + my ($k, $v); + if (!$s->[2]) { + if (($k, $v) = each %{$s->[0]}) { + return $v->[0]; + } + else { + $s->[2] = 1; + } + } + return each %{$s->[1]}; +} + +sub CLEAR { + my $s = shift; + $s->[2] = 0; + %{$s->[0]} = (); + %{$s->[1]} = (); +} + +package # hide from PAUSE + Tie::RefHash::Nestable; +our @ISA = 'Tie::RefHash'; + +sub STORE { + my($s, $k, $v) = @_; + if (ref($v) eq 'HASH' and not tied %$v) { + my @elems = %$v; + tie %$v, ref($s), @elems; + } + $s->SUPER::STORE($k, $v); +} + +1; + +__END__ + +=pod + +=encoding UTF-8 + +=head1 NAME + +Tie::RefHash - Use references as hash keys + +=head1 VERSION + +version 1.41 + +=head1 SYNOPSIS + + require 5.004; + use Tie::RefHash; + tie HASHVARIABLE, 'Tie::RefHash', LIST; + tie HASHVARIABLE, 'Tie::RefHash::Nestable', LIST; + + untie HASHVARIABLE; + +=head1 DESCRIPTION + +This module provides the ability to use references as hash keys if you +first C the hash variable to this module. Normally, only the +keys of the tied hash itself are preserved as references; to use +references as keys in hashes-of-hashes, use Tie::RefHash::Nestable, +included as part of Tie::RefHash. + +It is implemented using the standard perl TIEHASH interface. Please +see the C entry in perlfunc(1) and perltie(1) for more information. + +The Nestable version works by looking for hash references being stored +and converting them to tied hashes so that they too can have +references as keys. This will happen without warning whenever you +store a reference to one of your own hashes in the tied hash. + +=head1 EXAMPLE + + use Tie::RefHash; + tie %h, 'Tie::RefHash'; + $a = []; + $b = {}; + $c = \*main; + $d = \"gunk"; + $e = sub { 'foo' }; + %h = ($a => 1, $b => 2, $c => 3, $d => 4, $e => 5); + $a->[0] = 'foo'; + $b->{foo} = 'bar'; + for (keys %h) { + print ref($_), "\n"; + } + + tie %h, 'Tie::RefHash::Nestable'; + $h{$a}->{$b} = 1; + for (keys %h, keys %{$h{$a}}) { + print ref($_), "\n"; + } + +=head1 THREAD SUPPORT + +L fully supports threading using the C method. + +=head1 STORABLE SUPPORT + +L hooks are provided for semantically correct serialization and +cloning of tied refhashes. + +=head1 SEE ALSO + +perl(1), perlfunc(1), perltie(1) + +=head1 SUPPORT + +Bugs may be submitted through L +(or L). + +=head1 AUTHORS + +Gurusamy Sarathy + +Tie::RefHash::Nestable by Ed Avis + +=head1 CONTRIBUTORS + +=for stopwords Yuval Kogman Karen Etheridge Florian Ragwitz Lukas Mai Jerry D. Hedden tusooa + +=over 4 + +=item * + +Yuval Kogman + +=item * + +Karen Etheridge + +=item * + +Florian Ragwitz + +=item * + +Lukas Mai + +=item * + +Jerry D. Hedden + +=item * + +tusooa + +=back + +=head1 COPYRIGHT AND LICENCE + +This software is copyright (c) 2006 by יובל קוג'מן (Yuval Kogman) . + +This is free software; you can redistribute it and/or modify it under +the same terms as the Perl 5 programming language system itself. + +=cut diff --git a/git/usr/share/perl5/core_perl/Tie/Scalar.pm b/git/usr/share/perl5/core_perl/Tie/Scalar.pm new file mode 100644 index 0000000000000000000000000000000000000000..b8d6e8ffcee59b10f574f1b2ee3facc984f97a5d --- /dev/null +++ b/git/usr/share/perl5/core_perl/Tie/Scalar.pm @@ -0,0 +1,164 @@ +package Tie::Scalar; + +our $VERSION = '1.06'; + +=head1 NAME + +Tie::Scalar, Tie::StdScalar - base class definitions for tied scalars + +=head1 SYNOPSIS + + package NewScalar; + require Tie::Scalar; + + @ISA = qw(Tie::Scalar); + + sub FETCH { ... } # Provide a needed method + sub TIESCALAR { ... } # Overrides inherited method + + + package NewStdScalar; + require Tie::Scalar; + + @ISA = qw(Tie::StdScalar); + + # All methods provided by default, so define + # only what needs be overridden + sub FETCH { ... } + + + package main; + + tie $new_scalar, 'NewScalar'; + tie $new_std_scalar, 'NewStdScalar'; + +=head1 DESCRIPTION + +This module provides some skeletal methods for scalar-tying classes. See +L for a list of the functions required in tying a scalar to a +package. The basic B package provides a C method, as well +as methods C, C and C. The B +package provides all the methods specified in L. It inherits from +B and causes scalars tied to it to behave exactly like the +built-in scalars, allowing for selective overloading of methods. The C +method is provided as a means of legacy support for classes that forget to +provide their own C method. + +For developers wishing to write their own tied-scalar classes, the methods +are summarized below. The L section not only documents these, but +has sample code as well: + +=over 4 + +=item TIESCALAR classname, LIST + +The method invoked by the command C. Associates a new +scalar instance with the specified class. C would represent additional +arguments (along the lines of L and compatriots) needed to +complete the association. + +=item FETCH this + +Retrieve the value of the tied scalar referenced by I. + +=item STORE this, value + +Store data I in the tied scalar referenced by I. + +=item DESTROY this + +Free the storage associated with the tied scalar referenced by I. +This is rarely needed, as Perl manages its memory quite well. But the +option exists, should a class wish to perform specific actions upon the +destruction of an instance. + +=back + +=head2 Tie::Scalar vs Tie::StdScalar + +C<< Tie::Scalar >> provides all the necessary methods, but one should realize +they do not do anything useful. Calling C<< Tie::Scalar::FETCH >> or +C<< Tie::Scalar::STORE >> results in a (trappable) croak. And if you inherit +from C<< Tie::Scalar >>, you I provide either a C<< new >> or a +C<< TIESCALAR >> method. + +If you are looking for a class that does everything for you that you don't +define yourself, use the C<< Tie::StdScalar >> class, not the +C<< Tie::Scalar >> one. + +=head1 MORE INFORMATION + +The L section uses a good example of tying scalars by associating +process IDs with priority. + +=cut + +use Carp; +use warnings::register; + +sub new { + my $pkg = shift; + $pkg->TIESCALAR(@_); +} + +# Legacy support for new(), a la Tie::Hash + +sub TIESCALAR { + my $pkg = shift; + my $pkg_new = $pkg -> can ('new'); + + if ($pkg_new and $pkg ne __PACKAGE__) { + my $my_new = __PACKAGE__ -> can ('new'); + if ($pkg_new == $my_new) { + # + # Prevent recursion + # + croak "$pkg must define either a TIESCALAR() or a new() method"; + } + + warnings::warnif ("WARNING: calling ${pkg}->new since " . + "${pkg}->TIESCALAR is missing"); + $pkg -> new (@_); + } + else { + croak "$pkg doesn't define a TIESCALAR method"; + } +} + +sub FETCH { + my $pkg = ref $_[0]; + croak "$pkg doesn't define a FETCH method"; +} + +sub STORE { + my $pkg = ref $_[0]; + croak "$pkg doesn't define a STORE method"; +} + +# +# The Tie::StdScalar package provides scalars that behave exactly like +# Perl's built-in scalars. Good base to inherit from, if you're only going to +# tweak a small bit. +# +package Tie::StdScalar; +@ISA = qw(Tie::Scalar); + +sub TIESCALAR { + my $class = shift; + my $instance = @_ ? shift : undef; + return bless \$instance => $class; +} + +sub FETCH { + return ${$_[0]}; +} + +sub STORE { + ${$_[0]} = $_[1]; +} + +sub DESTROY { + undef ${$_[0]}; +} + +1; diff --git a/git/usr/share/perl5/core_perl/Tie/StdHandle.pm b/git/usr/share/perl5/core_perl/Tie/StdHandle.pm new file mode 100644 index 0000000000000000000000000000000000000000..fb79a986c6bf77335bec46010f7752c5fb854b46 --- /dev/null +++ b/git/usr/share/perl5/core_perl/Tie/StdHandle.pm @@ -0,0 +1,71 @@ +package Tie::StdHandle; + +use strict; + +use Tie::Handle; +our @ISA = 'Tie::Handle'; +our $VERSION = '4.6'; + +=head1 NAME + +Tie::StdHandle - base class definitions for tied handles + +=head1 SYNOPSIS + + package NewHandle; + require Tie::Handle; + + @ISA = qw(Tie::Handle); + + sub READ { ... } # Provide a needed method + sub TIEHANDLE { ... } # Overrides inherited method + + + package main; + + tie *FH, 'NewHandle'; + +=head1 DESCRIPTION + +The B package provide most methods for file handles described +in L (the exceptions are C and C). It causes tied +file handles to behave exactly like standard file handles and allow for +selective overwriting of methods. + +=cut + +sub TIEHANDLE +{ + my $class = shift; + my $fh = \do { local *HANDLE}; + bless $fh,$class; + $fh->OPEN(@_) if (@_); + return $fh; +} + +sub EOF { eof($_[0]) } +sub TELL { tell($_[0]) } +sub FILENO { fileno($_[0]) } +sub SEEK { seek($_[0],$_[1],$_[2]) } +sub CLOSE { close($_[0]) } +sub BINMODE { &CORE::binmode(shift, @_) } + +sub OPEN +{ + $_[0]->CLOSE if defined($_[0]->FILENO); + @_ == 2 ? open($_[0], $_[1]) : open($_[0], $_[1], $_[2]); +} + +sub READ { &CORE::read(shift, \shift, @_) } +sub READLINE { my $fh = $_[0]; <$fh> } +sub GETC { getc($_[0]) } + +sub WRITE +{ + my $fh = $_[0]; + local $\; # don't print any line terminator + print $fh substr($_[1], $_[3], $_[2]); +} + + +1; diff --git a/git/usr/share/perl5/core_perl/Tie/SubstrHash.pm b/git/usr/share/perl5/core_perl/Tie/SubstrHash.pm new file mode 100644 index 0000000000000000000000000000000000000000..f2677a616f8812ee078fcece0b355807a2758681 --- /dev/null +++ b/git/usr/share/perl5/core_perl/Tie/SubstrHash.pm @@ -0,0 +1,211 @@ +package Tie::SubstrHash 1.01; + +=head1 NAME + +Tie::SubstrHash - Fixed-table-size, fixed-key-length hashing + +=head1 SYNOPSIS + + require Tie::SubstrHash; + + tie %myhash, 'Tie::SubstrHash', $key_len, $value_len, $table_size; + +=head1 DESCRIPTION + +The B package provides a hash-table-like interface to +an array of determinate size, with constant key size and record size. + +Upon tying a new hash to this package, the developer must specify the +size of the keys that will be used, the size of the value fields that the +keys will index, and the size of the overall table (in terms of key-value +pairs, not size in hard memory). I. The newly-allocated hash table may now have +data stored and retrieved. Efforts to store more than C<$table_size> +elements will result in a fatal error, as will efforts to store a value +not exactly C<$value_len> characters in length, or reference through a +key not exactly C<$key_len> characters in length. While these constraints +may seem excessive, the result is a hash table using much less internal +memory than an equivalent freely-allocated hash table. + +=head1 CAVEATS + +Because the current implementation uses the table and key sizes for the +hashing algorithm, there is no means by which to dynamically change the +value of any of the initialization parameters. + +The hash does not support exists(). + +=cut + +use strict; +use warnings; +no warnings 'experimental::builtin'; + +use Carp; + +sub TIEHASH { + my ($pack, $klen, $vlen, $tsize) = @_; + my $rlen = 1 + $klen + $vlen; + $tsize = [$tsize, findgteprime($tsize * 1.1)]; # Allow 10% empty. + my $self = bless ["\0", $klen, $vlen, $tsize, $rlen, 0, -1]; + $self->[0] x= $rlen * $tsize->[1]; + $self; +} + +sub CLEAR { + my ($self) = @_; + $self->[0] = "\0" x ($self->[4] * $self->[3][1]); + $self->[5] = 0; + $self->[6] = -1; +} + +sub FETCH { + my ($self, $key) = @_; + my (undef, $klen, $vlen, $tsize, $rlen) = @$self; + my $hashbase = my $hash = hashkey($key, $klen, $tsize); + while (1) { + my $offset = $hash * $rlen; + my $record = substr($self->[0], $offset, $rlen); + if (ord($record) == 0) { + return undef; + } + elsif (ord($record) == 1) { + } + elsif (substr($record, 1, $klen) eq $key) { + return substr($record, 1+$klen, $vlen); + } + $hash = rehash($hash, $hashbase, $tsize); + } +} + +sub STORE { + my ($self, $key, $val) = @_; + my (undef, $klen, $vlen, $tsize, $rlen) = @$self; + croak("Table is full ($tsize->[0] elements)") if $self->[5] > $tsize->[0]; + croak(qq/Value "$val" is not $vlen characters long/) + if length($val) != $vlen; + my $writeoffset; + + my $hashbase = my $hash = hashkey($key, $klen, $tsize); + while (1) { + my $offset = $hash * $rlen; + my $record = substr($self->[0], $offset, $rlen); + if (ord($record) == 0) { + $record = "\2". $key . $val; + die "panic" unless length($record) == $rlen; + $writeoffset //= $offset; + substr($self->[0], $writeoffset, $rlen) = $record; + ++$self->[5]; + return; + } + elsif (ord($record) == 1) { + $writeoffset //= $offset; + } + elsif (substr($record, 1, $klen) eq $key) { + $record = "\2". $key . $val; + die "panic" unless length($record) == $rlen; + substr($self->[0], $offset, $rlen) = $record; + return; + } + $hash = rehash($hash, $hashbase, $tsize); + } +} + +sub DELETE { + my ($self, $key) = @_; + my (undef, $klen, $vlen, $tsize, $rlen) = @$self; + my $hashbase = my $hash = hashkey($key, $klen, $tsize); + while (1) { + my $offset = $hash * $rlen; + my $record = substr($self->[0], $offset, $rlen); + if (ord($record) == 0) { + return undef; + } + elsif (ord($record) == 1) { + } + elsif (substr($record, 1, $klen) eq $key) { + substr($self->[0], $offset, 1) = "\1"; + return substr($record, 1+$klen, $vlen); + --$self->[5]; + } + $hash = rehash($hash, $hashbase, $tsize); + } +} + +sub FIRSTKEY { + my ($self) = @_; + $self->[6] = -1; + goto &NEXTKEY; +} + +sub NEXTKEY { + my ($self) = @_; + my (undef, $klen, $vlen, $tsize, $rlen, $entries, $iterix) = @$self; + for (++$iterix; $iterix < $tsize->[1]; ++$iterix) { + next unless substr($self->[0], $iterix * $rlen, 1) eq "\2"; + $self->[6] = $iterix; + return substr($self->[0], $iterix * $rlen + 1, $klen); + } + $self->[6] = -1; + undef; +} + +sub EXISTS { + croak "Tie::SubstrHash does not support exists()"; +} + +sub hashkey { + my ($key, $klen, $tsize) = @_; + croak(qq/Key "$key" is not $klen characters long/) + if length($key) != $klen; + my $hash = 2; + for (unpack('C*', $key)) { + $hash = $hash * 33 + $_; + $hash = _hashwrap($hash, $tsize) if $hash >= 1e13; + } + $hash = _hashwrap($hash, $tsize) if $hash >= $tsize->[1]; + $hash ||= 1; + return $hash; +} + +sub _hashwrap { + my ($hash, $tsize) = @_; + return $hash - int($hash / $tsize->[1]) * $tsize->[1]; +} + +sub rehash { + my ($hash, $hashbase, $tsize) = @_; + $hash += $hashbase; + $hash -= $tsize->[1] if $hash >= $tsize->[1]; + return $hash; +} + +# See: +# +# http://www-groups.dcs.st-andrews.ac.uk/~history/HistTopics/Prime_numbers.html +# + +sub findgteprime { # find the smallest prime integer greater than or equal to + use integer; + + my $num = builtin::ceil(shift); + return 2 if $num <= 2; + + $num++ unless $num % 2; + my $sqrtnum = int sqrt $num; + my $sqrtnumsquared = $sqrtnum * $sqrtnum; + + NUM: + for (;; $num += 2) { + if ($sqrtnumsquared < $num) { + $sqrtnum++; + $sqrtnumsquared = $sqrtnum * $sqrtnum; + } + for (my $i = 3; $i <= $sqrtnum; $i += 2) { + next NUM unless $num % $i; + } + return $num; + } +} + +1; diff --git a/git/usr/share/perl5/core_perl/Time/Local.pm b/git/usr/share/perl5/core_perl/Time/Local.pm new file mode 100644 index 0000000000000000000000000000000000000000..7cd8c5204d52f4fcda0796d79c7e4a70d9fb372b --- /dev/null +++ b/git/usr/share/perl5/core_perl/Time/Local.pm @@ -0,0 +1,547 @@ +package Time::Local; + +use strict; + +use Carp (); +use Exporter; + +our $VERSION = '1.35'; + +use parent 'Exporter'; + +our @EXPORT = qw( timegm timelocal ); +our @EXPORT_OK = qw( + timegm_modern + timelocal_modern + timegm_nocheck + timelocal_nocheck + timegm_posix + timelocal_posix +); + +my @MonthDays = ( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ); + +# Determine breakpoint for rolling century +my $ThisYear = ( localtime() )[5]; +my $Breakpoint = ( $ThisYear + 50 ) % 100; +my $NextCentury = $ThisYear - $ThisYear % 100; +$NextCentury += 100 if $Breakpoint < 50; +my $Century = $NextCentury - 100; +my $SecOff = 0; + +my ( %Options, %Cheat ); + +use constant SECS_PER_MINUTE => 60; +use constant SECS_PER_HOUR => 3600; +use constant SECS_PER_DAY => 86400; + +my $MaxDay; +if ( $] < 5.012000 ) { + require Config; + ## no critic (Variables::ProhibitPackageVars) + + my $MaxInt; + if ( $^O eq 'MacOS' ) { + + # time_t is unsigned... + $MaxInt = ( 1 << ( 8 * $Config::Config{ivsize} ) ) + - 1; ## no critic qw(ProhibitPackageVars) + } + else { + $MaxInt + = ( ( 1 << ( 8 * $Config::Config{ivsize} - 2 ) ) - 1 ) * 2 + + 1; ## no critic qw(ProhibitPackageVars) + } + + $MaxDay = int( ( $MaxInt - ( SECS_PER_DAY / 2 ) ) / SECS_PER_DAY ) - 1; +} +else { + # recent localtime()'s limit is the year 2**31 + $MaxDay = 365 * ( 2**31 ); + + # On (some?) 32-bit platforms this overflows and we end up with a negative + # $MaxDay, which totally breaks this module. This is the old calculation + # we used from the days before Perl always had 64-bit time_t. + if ( $MaxDay < 0 ) { + require Config; + ## no critic (Variables::ProhibitPackageVars) + my $max_int + = ( ( 1 << ( 8 * $Config::Config{intsize} - 2 ) ) - 1 ) * 2 + 1; + $MaxDay + = int( ( $max_int - ( SECS_PER_DAY / 2 ) ) / SECS_PER_DAY ) - 1; + } +} + +# Determine the EPOC day for this machine +my $Epoc = 0; +if ( $^O eq 'vos' ) { + + # work around posix-977 -- VOS doesn't handle dates in the range + # 1970-1980. + $Epoc = _daygm( 0, 0, 0, 1, 0, 70, 4, 0 ); +} +elsif ( $^O eq 'MacOS' ) { + $MaxDay *= 2; # time_t unsigned ... quick hack? + # MacOS time() is seconds since 1 Jan 1904, localtime + # so we need to calculate an offset to apply later + $Epoc = 693901; + $SecOff = timelocal( localtime(0) ) - timelocal( gmtime(0) ); + $Epoc += _daygm( gmtime(0) ); +} +else { + $Epoc = _daygm( gmtime(0) ); +} + +%Cheat = (); # clear the cache as epoc has changed + +sub _daygm { + + # This is written in such a byzantine way in order to avoid + # lexical variables and sub calls, for speed + return $_[3] + ( + $Cheat{ pack( 'ss', @_[ 4, 5 ] ) } ||= do { + my $month = ( $_[4] + 10 ) % 12; + my $year = $_[5] + 1900 - int( $month / 10 ); + + ( ( 365 * $year ) + + int( $year / 4 ) + - int( $year / 100 ) + + int( $year / 400 ) + + int( ( ( $month * 306 ) + 5 ) / 10 ) ) + - $Epoc; + } + ); +} + +sub _timegm { + my $sec + = $SecOff + $_[0] + + ( SECS_PER_MINUTE * $_[1] ) + + ( SECS_PER_HOUR * $_[2] ); + + return $sec + ( SECS_PER_DAY * &_daygm ); +} + +sub timegm { + my ( $sec, $min, $hour, $mday, $month, $year ) = @_; + my $subsec = $sec - int($sec); + $sec = int($sec); + + if ( $Options{no_year_munging} ) { + $year -= 1900; + } + elsif ( !$Options{posix_year} ) { + if ( $year >= 1000 ) { + $year -= 1900; + } + elsif ( $year < 100 and $year >= 0 ) { + $year += ( $year > $Breakpoint ) ? $Century : $NextCentury; + } + } + + unless ( $Options{no_range_check} ) { + Carp::croak("Month '$month' out of range 0..11") + if $month > 11 + or $month < 0; + + my $md = $MonthDays[$month]; + ++$md + if $month == 1 && _is_leap_year( $year + 1900 ); + + Carp::croak("Day '$mday' out of range 1..$md") + if $mday > $md or $mday < 1; + Carp::croak("Hour '$hour' out of range 0..23") + if $hour > 23 or $hour < 0; + Carp::croak("Minute '$min' out of range 0..59") + if $min > 59 or $min < 0; + Carp::croak("Second '$sec' out of range 0..59") + if $sec >= 60 or $sec < 0; + } + + my $days = _daygm( undef, undef, undef, $mday, $month, $year ); + + if ( abs($days) > $MaxDay && !$Options{no_range_check} ) { + my $msg = "Day too big - abs($days) > $MaxDay\n"; + + $year += 1900; + $msg + .= "Cannot handle date ($sec, $min, $hour, $mday, $month, $year)"; + + Carp::croak($msg); + } + + # Adding in the $subsec value last seems to prevent floating point errors + # from creeping in. + return ( + ( + $sec + $SecOff + + ( SECS_PER_MINUTE * $min ) + + ( SECS_PER_HOUR * $hour ) + + ( SECS_PER_DAY * $days ) + ) + $subsec + ); +} + +sub _is_leap_year { + return 0 if $_[0] % 4; + return 1 if $_[0] % 100; + return 0 if $_[0] % 400; + + return 1; +} + +sub timegm_nocheck { + local $Options{no_range_check} = 1; + return &timegm; +} + +sub timegm_modern { + local $Options{no_year_munging} = 1; + return &timegm; +} + +sub timegm_posix { + local $Options{posix_year} = 1; + return &timegm; +} + +sub timelocal { + my $sec = shift; + my $subsec = $sec - int($sec); + $sec = int($sec); + unshift @_, $sec; + + my $ref_t = &timegm; + my $loc_for_ref_t = _timegm( localtime($ref_t) ); + + my $zone_off = $loc_for_ref_t - $ref_t + or return $loc_for_ref_t + $subsec; + + # Adjust for timezone + my $loc_t = $ref_t - $zone_off; + + # Are we close to a DST change or are we done + my $dst_off = $ref_t - _timegm( localtime($loc_t) ); + + # If this evaluates to true, it means that the value in $loc_t is + # the _second_ hour after a DST change where the local time moves + # backward. + if ( + !$dst_off + && ( ( $ref_t - SECS_PER_HOUR ) + - _timegm( localtime( $loc_t - SECS_PER_HOUR ) ) < 0 ) + ) { + return ( $loc_t - SECS_PER_HOUR ) + $subsec; + } + + # Adjust for DST change + $loc_t += $dst_off; + + return $loc_t + $subsec if $dst_off > 0; + + # If the original date was a non-existent gap in a forward DST jump, we + # should now have the wrong answer - undo the DST adjustment + my ( $s, $m, $h ) = localtime($loc_t); + $loc_t -= $dst_off if $s != $_[0] || $m != $_[1] || $h != $_[2]; + + return $loc_t + $subsec; +} + +sub timelocal_nocheck { + local $Options{no_range_check} = 1; + return &timelocal; +} + +sub timelocal_modern { + local $Options{no_year_munging} = 1; + return &timelocal; +} + +sub timelocal_posix { + local $Options{posix_year} = 1; + return &timelocal; +} + +1; + +# ABSTRACT: Efficiently compute time from local and GMT time + +__END__ + +=pod + +=encoding UTF-8 + +=head1 NAME + +Time::Local - Efficiently compute time from local and GMT time + +=head1 VERSION + +version 1.35 + +=head1 SYNOPSIS + + use Time::Local qw( timelocal_posix timegm_posix ); + + my $time = timelocal_posix( $sec, $min, $hour, $mday, $mon, $year ); + my $time = timegm_posix( $sec, $min, $hour, $mday, $mon, $year ); + +=head1 DESCRIPTION + +This module provides functions that are the inverse of built-in perl functions +C and C. They accept a date as a six-element array, and +return the corresponding C value in seconds since the system epoch +(Midnight, January 1, 1970 GMT on Unix, for example). This value can be +positive or negative, though POSIX only requires support for positive values, +so dates before the system's epoch may not work on all operating systems. + +It is worth drawing particular attention to the expected ranges for the values +provided. The value for the day of the month is the actual day (i.e. 1..31), +while the month is the number of months since January (0..11). This is +consistent with the values returned from C and C. + +=head1 FUNCTIONS + +=head2 C and C + +I + +These functions are the exact inverse of Perl's built-in C and +C functions. That means that calling C<< timelocal_posix( +localtime($value) ) >> will always give you the same C<$value> you started +with. The same applies to C<< timegm_posix( gmtime($value) ) >>. + +The one exception is when the value returned from C represents an +ambiguous local time because of a DST change. See the documentation below for +more details. + +These functions expect the year value to be the number of years since 1900, +which is what the C and C built-ins returns. + +They perform range checking by default on the input C<$sec>, C<$min>, C<$hour>, +C<$mday>, and C<$mon> values and will croak (using C) if given a +value outside the allowed ranges. + +While it would be nice to make this the default behavior, that would almost +certainly break a lot of code, so you must explicitly import these functions +and use them instead of the default C and C. + +You are B encouraged to use these functions in any new code which +uses this module. It will almost certainly make your code's behavior less +surprising. + +=head2 C and C + +I + +When C was first written, it was a common practice to represent +years as a two-digit value like C<99> for C<1999> or C<1> for C<2001>. This +caused all sorts of problems (google "Y2K problem" if you're very young) and +developers eventually realized that this was a terrible idea. + +The default exports of C and C do a complicated +calculation when given a year value less than 1000. This leads to surprising +results in many cases. See L for details. + +The C functions do not do this year munging and simply take the +year value as provided. + +They perform range checking by default on the input C<$sec>, C<$min>, C<$hour>, +C<$mday>, and C<$mon> values and will croak (using C) if given a +value outside the allowed ranges. + +=head2 C and C + +This module exports two functions by default, C and C. + +They perform range checking by default on the input C<$sec>, C<$min>, C<$hour>, +C<$mday>, and C<$mon> values and will croak (using C) if given a +value outside the allowed ranges. + +B or C<*_modern> +functions if possible.> + +=head2 C and C + +If you are working with data you know to be valid, you can use the "nocheck" +variants, C and C. These variants must +be explicitly imported. + +If you supply data which is not valid (month 27, second 1,000) the results will +be unpredictable (so don't do that). + +Note that my benchmarks show that this is just a 3% speed increase over the +checked versions, so unless calling C is the hottest spot in your +application, using these nocheck variants is unlikely to have much impact on +your application. + +=head2 Year Value Interpretation + +B or C<*_modern> functions. Use those +exports if you want to ensure consistent behavior as your code ages.> + +Strictly speaking, the year should be specified in a form consistent with +C, i.e. the offset from 1900. In order to make the interpretation +of the year easier for humans, however, who are more accustomed to seeing years +as two-digit or four-digit values, the following conventions are followed: + +=over 4 + +=item * + +Years greater than 999 are interpreted as being the actual year, rather than +the offset from 1900. Thus, 1964 would indicate the year Martin Luther King won +the Nobel prize, not the year 3864. + +=item * + +Years in the range 100..999 are interpreted as offset from 1900, so that 112 +indicates 2012. This rule also applies to years less than zero (but see note +below regarding date range). + +=item * + +Years in the range 0..99 are interpreted as shorthand for years in the rolling +"current century," defined as 50 years on either side of the current year. +Thus, today, in 1999, 0 would refer to 2000, and 45 to 2045, but 55 would refer +to 1955. Twenty years from now, 55 would instead refer to 2055. This is messy, +but matches the way people currently think about two digit dates. Whenever +possible, use an absolute four digit year instead. + +=back + +The scheme above allows interpretation of a wide range of dates, particularly +if 4-digit years are used. But it also means that the behavior of your code +changes as time passes, because the rolling "current century" changes each +year. + +=head2 Limits of time_t + +On perl versions older than 5.12.0, the range of dates that can be actually be +handled depends on the size of C (usually a signed integer) on the +given platform. Currently, this is 32 bits for most systems, yielding an +approximate range from Dec 1901 to Jan 2038. + +Both C and C croak if given dates outside the supported +range. + +As of version 5.12.0, perl has stopped using the time implementation of the +operating system it's running on. Instead, it has its own implementation of +those routines with a safe range of at least +/- 2**52 (about 142 million +years) + +=head2 Ambiguous Local Times (DST) + +Because of DST changes, there are many time zones where the same local time +occurs for two different GMT times on the same day. For example, in the +"Europe/Paris" time zone, the local time of 2001-10-28 02:30:00 can represent +either 2001-10-28 00:30:00 GMT, B 2001-10-28 01:30:00 GMT. + +When given an ambiguous local time, the timelocal() function will always return +the epoch for the I of the two possible GMT times. + +=head2 Non-Existent Local Times (DST) + +When a DST change causes a locale clock to skip one hour forward, there will be +an hour's worth of local times that don't exist. Again, for the "Europe/Paris" +time zone, the local clock jumped from 2001-03-25 01:59:59 to 2001-03-25 +03:00:00. + +If the C function is given a non-existent local time, it will +simply return an epoch value for the time one hour later. + +=head2 Negative Epoch Values + +On perl version 5.12.0 and newer, negative epoch values are fully supported. + +On older versions of perl, negative epoch (C) values, which are not +officially supported by the POSIX standards, are known not to work on some +systems. These include MacOS (pre-OSX) and Win32. + +On systems which do support negative epoch values, this module should be able +to cope with dates before the start of the epoch, down the minimum value of +time_t for the system. + +=head1 IMPLEMENTATION + +These routines are quite efficient and yet are always guaranteed to agree with +C and C. We manage this by caching the start times of +any months we've seen before. If we know the start time of the month, we can +always calculate any time within the month. The start times are calculated +using a mathematical formula. Unlike other algorithms that do multiple calls to +C. + +The C function is implemented using the same cache. We just assume +that we're translating a GMT time, and then fudge it when we're done for the +timezone and daylight savings arguments. Note that the timezone is evaluated +for each date because countries occasionally change their official timezones. +Assuming that C corrects for these changes, this routine will also +be correct. + +=head1 AUTHORS EMERITUS + +This module is based on a Perl 4 library, timelocal.pl, that was included with +Perl 4.036, and was most likely written by Tom Christiansen. + +The current version was written by Graham Barr. + +=head1 BUGS + +The whole scheme for interpreting two-digit years can be considered a bug. + +Bugs may be submitted at L. + +There is a mailing list available for users of this distribution, +L. + +=head1 SOURCE + +The source code repository for Time-Local can be found at L. + +=head1 AUTHOR + +Dave Rolsky + +=head1 CONTRIBUTORS + +=for stopwords Florian Ragwitz Gregory Oschwald J. Nick Koston Tom Wyant Unknown + +=over 4 + +=item * + +Florian Ragwitz + +=item * + +Gregory Oschwald + +=item * + +J. Nick Koston + +=item * + +Tom Wyant + +=item * + +Unknown + +=back + +=head1 COPYRIGHT AND LICENSE + +This software is copyright (c) 1997 - 2023 by Graham Barr & Dave Rolsky. + +This is free software; you can redistribute it and/or modify it under +the same terms as the Perl 5 programming language system itself. + +The full text of the license can be found in the +F file included with this distribution. + +=cut diff --git a/git/usr/share/perl5/core_perl/Time/gmtime.pm b/git/usr/share/perl5/core_perl/Time/gmtime.pm new file mode 100644 index 0000000000000000000000000000000000000000..7a9bf4f407ba5a61872e692afb044e20ccf88d70 --- /dev/null +++ b/git/usr/share/perl5/core_perl/Time/gmtime.pm @@ -0,0 +1,88 @@ +package Time::gmtime 1.05; +use v5.38; + +use parent 'Time::tm'; + +our ( $tm_sec, $tm_min, $tm_hour, $tm_mday, + $tm_mon, $tm_year, $tm_wday, $tm_yday, + $tm_isdst, +); + +use Exporter 'import'; +our @EXPORT = qw(gmtime gmctime); +our @EXPORT_OK = qw( + $tm_sec $tm_min $tm_hour $tm_mday + $tm_mon $tm_year $tm_wday $tm_yday + $tm_isdst + ); +our %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] ); + +sub populate { + return unless @_; + my $tmob = Time::tm->new(); + @$tmob = ( + $tm_sec, $tm_min, $tm_hour, $tm_mday, + $tm_mon, $tm_year, $tm_wday, $tm_yday, + $tm_isdst ) + = @_; + return $tmob; +} + +sub gmtime :prototype(;$) { populate CORE::gmtime(@_ ? shift : time) } +sub gmctime :prototype(;$) { scalar CORE::gmtime(@_ ? shift : time) } + +__END__ + +=head1 NAME + +Time::gmtime - by-name interface to Perl's built-in gmtime() function + +=head1 SYNOPSIS + + use Time::gmtime; + $gm = gmtime(); + printf "The day in Greenwich is %s\n", + (qw(Sun Mon Tue Wed Thu Fri Sat Sun))[ $gm->wday() ]; + + use Time::gmtime qw(:FIELDS); + gmtime(); + printf "The day in Greenwich is %s\n", + (qw(Sun Mon Tue Wed Thu Fri Sat Sun))[ $tm_wday ]; + + $now = gmctime(); + + use Time::gmtime; + use File::stat; + $date_string = gmctime(stat($file)->mtime); + +=head1 DESCRIPTION + +This module's default exports override the core gmtime() function, +replacing it with a version that returns "Time::tm" objects. +This object has methods that return the similarly named structure field +name from the C's tm structure from F; namely sec, min, hour, +mday, mon, year, wday, yday, and isdst. + +You may also import all the structure fields directly into your namespace +as regular variables using the :FIELDS import tag. (Note that this +still overrides your core functions.) Access these fields as variables +named with a preceding C in front their method names. Thus, +C<$tm_obj-Emday()> corresponds to $tm_mday if you import the fields. + +The gmctime() function provides a way of getting at the +scalar sense of the original CORE::gmtime() function. + +To access this functionality without the core overrides, +pass the C an empty import list, and then access +function functions with their full qualified names. +On the other hand, the built-ins are still available +via the C pseudo-package. + +=head1 NOTE + +While this class is currently implemented using the Class::Struct +module to build a struct-like class, you shouldn't rely upon this. + +=head1 AUTHOR + +Tom Christiansen diff --git a/git/usr/share/perl5/core_perl/Time/localtime.pm b/git/usr/share/perl5/core_perl/Time/localtime.pm new file mode 100644 index 0000000000000000000000000000000000000000..58ffaa4a770583349210ee7ef0d82b84e7ff1243 --- /dev/null +++ b/git/usr/share/perl5/core_perl/Time/localtime.pm @@ -0,0 +1,83 @@ +package Time::localtime 1.04; +use v5.38; + +use parent 'Time::tm'; + +our ( + $tm_sec, $tm_min, $tm_hour, $tm_mday, + $tm_mon, $tm_year, $tm_wday, $tm_yday, + $tm_isdst +); + +use Exporter 'import'; +our @EXPORT = qw(localtime ctime); +our @EXPORT_OK = qw( + $tm_sec $tm_min $tm_hour $tm_mday + $tm_mon $tm_year $tm_wday $tm_yday + $tm_isdst + ); +our %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] ); + +sub populate { + return unless @_; + my $tmob = Time::tm->new(); + @$tmob = ( + $tm_sec, $tm_min, $tm_hour, $tm_mday, + $tm_mon, $tm_year, $tm_wday, $tm_yday, + $tm_isdst ) + = @_; + return $tmob; +} + +sub localtime :prototype(;$) { populate CORE::localtime(@_ ? shift : time) } +sub ctime :prototype(;$) { scalar CORE::localtime(@_ ? shift : time) } + +__END__ + +=head1 NAME + +Time::localtime - by-name interface to Perl's built-in localtime() function + +=head1 SYNOPSIS + + use Time::localtime; + printf "Year is %d\n", localtime->year() + 1900; + + $now = ctime(); + + use Time::localtime; + use File::stat; + $date_string = ctime(stat($file)->mtime); + +=head1 DESCRIPTION + +This module's default exports override the core localtime() function, +replacing it with a version that returns "Time::tm" objects. +This object has methods that return the similarly named structure field +name from the C's tm structure from F; namely sec, min, hour, +mday, mon, year, wday, yday, and isdst. + +You may also import all the structure fields directly into your namespace +as regular variables using the :FIELDS import tag. (Note that this still +overrides your core functions.) Access these fields as +variables named with a preceding C in front their method names. +Thus, C<$tm_obj-Emday()> corresponds to $tm_mday if you import +the fields. + +The ctime() function provides a way of getting at the +scalar sense of the original CORE::localtime() function. + +To access this functionality without the core overrides, +pass the C an empty import list, and then access +function functions with their full qualified names. +On the other hand, the built-ins are still available +via the C pseudo-package. + +=head1 NOTE + +While this class is currently implemented using the Class::Struct +module to build a struct-like class, you shouldn't rely upon this. + +=head1 AUTHOR + +Tom Christiansen diff --git a/git/usr/share/perl5/core_perl/Time/tm.pm b/git/usr/share/perl5/core_perl/Time/tm.pm new file mode 100644 index 0000000000000000000000000000000000000000..4e22f1eb8e502d5d9a360d29872401a09c712a10 --- /dev/null +++ b/git/usr/share/perl5/core_perl/Time/tm.pm @@ -0,0 +1,30 @@ +package Time::tm 1.01; +use v5.38; + +use Class::Struct qw(struct); +struct('Time::tm' => [ + map { $_ => '$' } qw{ sec min hour mday mon year wday yday isdst } +]); + +__END__ + +=head1 NAME + +Time::tm - internal object used by Time::gmtime and Time::localtime + +=head1 SYNOPSIS + +Don't use this module directly. + +=head1 DESCRIPTION + +This module is used internally as a base class by Time::localtime And +Time::gmtime functions. It creates a Time::tm struct object which is +addressable just like's C's tm structure from F; namely with sec, +min, hour, mday, mon, year, wday, yday, and isdst. + +This class is an internal interface only. + +=head1 AUTHOR + +Tom Christiansen diff --git a/git/usr/share/perl5/core_perl/unicore/Blocks.txt b/git/usr/share/perl5/core_perl/unicore/Blocks.txt new file mode 100644 index 0000000000000000000000000000000000000000..1517dde0cec2f75bbaa774c3221390a202a29f69 --- /dev/null +++ b/git/usr/share/perl5/core_perl/unicore/Blocks.txt @@ -0,0 +1,375 @@ +# Blocks-16.0.0.txt +# Date: 2024-02-02 +# © 2024 Unicode®, Inc. +# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries. +# For terms of use and license, see https://www.unicode.org/terms_of_use.html +# +# Unicode Character Database +# For documentation, see https://www.unicode.org/reports/tr44/ +# +# Format: +# Start Code..End Code; Block Name + +# ================================================ + +# Note: When comparing block names, casing, whitespace, hyphens, +# and underbars are ignored. +# For example, "Latin Extended-A" and "latin extended a" are equivalent. +# For more information on the comparison of property values, +# see UAX #44: https://www.unicode.org/reports/tr44/ +# +# All block ranges start with a value where (cp MOD 16) = 0, +# and end with a value where (cp MOD 16) = 15. In other words, +# the last hexadecimal digit of the start of range is ...0 +# and the last hexadecimal digit of the end of range is ...F. +# This constraint on block ranges guarantees that allocations +# are done in terms of whole columns, and that code chart display +# never involves splitting columns in the charts. +# +# All code points not explicitly listed for Block +# have the value No_Block. + +# Property: Block +# +# @missing: 0000..10FFFF; No_Block + +0000..007F; Basic Latin +0080..00FF; Latin-1 Supplement +0100..017F; Latin Extended-A +0180..024F; Latin Extended-B +0250..02AF; IPA Extensions +02B0..02FF; Spacing Modifier Letters +0300..036F; Combining Diacritical Marks +0370..03FF; Greek and Coptic +0400..04FF; Cyrillic +0500..052F; Cyrillic Supplement +0530..058F; Armenian +0590..05FF; Hebrew +0600..06FF; Arabic +0700..074F; Syriac +0750..077F; Arabic Supplement +0780..07BF; Thaana +07C0..07FF; NKo +0800..083F; Samaritan +0840..085F; Mandaic +0860..086F; Syriac Supplement +0870..089F; Arabic Extended-B +08A0..08FF; Arabic Extended-A +0900..097F; Devanagari +0980..09FF; Bengali +0A00..0A7F; Gurmukhi +0A80..0AFF; Gujarati +0B00..0B7F; Oriya +0B80..0BFF; Tamil +0C00..0C7F; Telugu +0C80..0CFF; Kannada +0D00..0D7F; Malayalam +0D80..0DFF; Sinhala +0E00..0E7F; Thai +0E80..0EFF; Lao +0F00..0FFF; Tibetan +1000..109F; Myanmar +10A0..10FF; Georgian +1100..11FF; Hangul Jamo +1200..137F; Ethiopic +1380..139F; Ethiopic Supplement +13A0..13FF; Cherokee +1400..167F; Unified Canadian Aboriginal Syllabics +1680..169F; Ogham +16A0..16FF; Runic +1700..171F; Tagalog +1720..173F; Hanunoo +1740..175F; Buhid +1760..177F; Tagbanwa +1780..17FF; Khmer +1800..18AF; Mongolian +18B0..18FF; Unified Canadian Aboriginal Syllabics Extended +1900..194F; Limbu +1950..197F; Tai Le +1980..19DF; New Tai Lue +19E0..19FF; Khmer Symbols +1A00..1A1F; Buginese +1A20..1AAF; Tai Tham +1AB0..1AFF; Combining Diacritical Marks Extended +1B00..1B7F; Balinese +1B80..1BBF; Sundanese +1BC0..1BFF; Batak +1C00..1C4F; Lepcha +1C50..1C7F; Ol Chiki +1C80..1C8F; Cyrillic Extended-C +1C90..1CBF; Georgian Extended +1CC0..1CCF; Sundanese Supplement +1CD0..1CFF; Vedic Extensions +1D00..1D7F; Phonetic Extensions +1D80..1DBF; Phonetic Extensions Supplement +1DC0..1DFF; Combining Diacritical Marks Supplement +1E00..1EFF; Latin Extended Additional +1F00..1FFF; Greek Extended +2000..206F; General Punctuation +2070..209F; Superscripts and Subscripts +20A0..20CF; Currency Symbols +20D0..20FF; Combining Diacritical Marks for Symbols +2100..214F; Letterlike Symbols +2150..218F; Number Forms +2190..21FF; Arrows +2200..22FF; Mathematical Operators +2300..23FF; Miscellaneous Technical +2400..243F; Control Pictures +2440..245F; Optical Character Recognition +2460..24FF; Enclosed Alphanumerics +2500..257F; Box Drawing +2580..259F; Block Elements +25A0..25FF; Geometric Shapes +2600..26FF; Miscellaneous Symbols +2700..27BF; Dingbats +27C0..27EF; Miscellaneous Mathematical Symbols-A +27F0..27FF; Supplemental Arrows-A +2800..28FF; Braille Patterns +2900..297F; Supplemental Arrows-B +2980..29FF; Miscellaneous Mathematical Symbols-B +2A00..2AFF; Supplemental Mathematical Operators +2B00..2BFF; Miscellaneous Symbols and Arrows +2C00..2C5F; Glagolitic +2C60..2C7F; Latin Extended-C +2C80..2CFF; Coptic +2D00..2D2F; Georgian Supplement +2D30..2D7F; Tifinagh +2D80..2DDF; Ethiopic Extended +2DE0..2DFF; Cyrillic Extended-A +2E00..2E7F; Supplemental Punctuation +2E80..2EFF; CJK Radicals Supplement +2F00..2FDF; Kangxi Radicals +2FF0..2FFF; Ideographic Description Characters +3000..303F; CJK Symbols and Punctuation +3040..309F; Hiragana +30A0..30FF; Katakana +3100..312F; Bopomofo +3130..318F; Hangul Compatibility Jamo +3190..319F; Kanbun +31A0..31BF; Bopomofo Extended +31C0..31EF; CJK Strokes +31F0..31FF; Katakana Phonetic Extensions +3200..32FF; Enclosed CJK Letters and Months +3300..33FF; CJK Compatibility +3400..4DBF; CJK Unified Ideographs Extension A +4DC0..4DFF; Yijing Hexagram Symbols +4E00..9FFF; CJK Unified Ideographs +A000..A48F; Yi Syllables +A490..A4CF; Yi Radicals +A4D0..A4FF; Lisu +A500..A63F; Vai +A640..A69F; Cyrillic Extended-B +A6A0..A6FF; Bamum +A700..A71F; Modifier Tone Letters +A720..A7FF; Latin Extended-D +A800..A82F; Syloti Nagri +A830..A83F; Common Indic Number Forms +A840..A87F; Phags-pa +A880..A8DF; Saurashtra +A8E0..A8FF; Devanagari Extended +A900..A92F; Kayah Li +A930..A95F; Rejang +A960..A97F; Hangul Jamo Extended-A +A980..A9DF; Javanese +A9E0..A9FF; Myanmar Extended-B +AA00..AA5F; Cham +AA60..AA7F; Myanmar Extended-A +AA80..AADF; Tai Viet +AAE0..AAFF; Meetei Mayek Extensions +AB00..AB2F; Ethiopic Extended-A +AB30..AB6F; Latin Extended-E +AB70..ABBF; Cherokee Supplement +ABC0..ABFF; Meetei Mayek +AC00..D7AF; Hangul Syllables +D7B0..D7FF; Hangul Jamo Extended-B +D800..DB7F; High Surrogates +DB80..DBFF; High Private Use Surrogates +DC00..DFFF; Low Surrogates +E000..F8FF; Private Use Area +F900..FAFF; CJK Compatibility Ideographs +FB00..FB4F; Alphabetic Presentation Forms +FB50..FDFF; Arabic Presentation Forms-A +FE00..FE0F; Variation Selectors +FE10..FE1F; Vertical Forms +FE20..FE2F; Combining Half Marks +FE30..FE4F; CJK Compatibility Forms +FE50..FE6F; Small Form Variants +FE70..FEFF; Arabic Presentation Forms-B +FF00..FFEF; Halfwidth and Fullwidth Forms +FFF0..FFFF; Specials +10000..1007F; Linear B Syllabary +10080..100FF; Linear B Ideograms +10100..1013F; Aegean Numbers +10140..1018F; Ancient Greek Numbers +10190..101CF; Ancient Symbols +101D0..101FF; Phaistos Disc +10280..1029F; Lycian +102A0..102DF; Carian +102E0..102FF; Coptic Epact Numbers +10300..1032F; Old Italic +10330..1034F; Gothic +10350..1037F; Old Permic +10380..1039F; Ugaritic +103A0..103DF; Old Persian +10400..1044F; Deseret +10450..1047F; Shavian +10480..104AF; Osmanya +104B0..104FF; Osage +10500..1052F; Elbasan +10530..1056F; Caucasian Albanian +10570..105BF; Vithkuqi +105C0..105FF; Todhri +10600..1077F; Linear A +10780..107BF; Latin Extended-F +10800..1083F; Cypriot Syllabary +10840..1085F; Imperial Aramaic +10860..1087F; Palmyrene +10880..108AF; Nabataean +108E0..108FF; Hatran +10900..1091F; Phoenician +10920..1093F; Lydian +10980..1099F; Meroitic Hieroglyphs +109A0..109FF; Meroitic Cursive +10A00..10A5F; Kharoshthi +10A60..10A7F; Old South Arabian +10A80..10A9F; Old North Arabian +10AC0..10AFF; Manichaean +10B00..10B3F; Avestan +10B40..10B5F; Inscriptional Parthian +10B60..10B7F; Inscriptional Pahlavi +10B80..10BAF; Psalter Pahlavi +10C00..10C4F; Old Turkic +10C80..10CFF; Old Hungarian +10D00..10D3F; Hanifi Rohingya +10D40..10D8F; Garay +10E60..10E7F; Rumi Numeral Symbols +10E80..10EBF; Yezidi +10EC0..10EFF; Arabic Extended-C +10F00..10F2F; Old Sogdian +10F30..10F6F; Sogdian +10F70..10FAF; Old Uyghur +10FB0..10FDF; Chorasmian +10FE0..10FFF; Elymaic +11000..1107F; Brahmi +11080..110CF; Kaithi +110D0..110FF; Sora Sompeng +11100..1114F; Chakma +11150..1117F; Mahajani +11180..111DF; Sharada +111E0..111FF; Sinhala Archaic Numbers +11200..1124F; Khojki +11280..112AF; Multani +112B0..112FF; Khudawadi +11300..1137F; Grantha +11380..113FF; Tulu-Tigalari +11400..1147F; Newa +11480..114DF; Tirhuta +11580..115FF; Siddham +11600..1165F; Modi +11660..1167F; Mongolian Supplement +11680..116CF; Takri +116D0..116FF; Myanmar Extended-C +11700..1174F; Ahom +11800..1184F; Dogra +118A0..118FF; Warang Citi +11900..1195F; Dives Akuru +119A0..119FF; Nandinagari +11A00..11A4F; Zanabazar Square +11A50..11AAF; Soyombo +11AB0..11ABF; Unified Canadian Aboriginal Syllabics Extended-A +11AC0..11AFF; Pau Cin Hau +11B00..11B5F; Devanagari Extended-A +11BC0..11BFF; Sunuwar +11C00..11C6F; Bhaiksuki +11C70..11CBF; Marchen +11D00..11D5F; Masaram Gondi +11D60..11DAF; Gunjala Gondi +11EE0..11EFF; Makasar +11F00..11F5F; Kawi +11FB0..11FBF; Lisu Supplement +11FC0..11FFF; Tamil Supplement +12000..123FF; Cuneiform +12400..1247F; Cuneiform Numbers and Punctuation +12480..1254F; Early Dynastic Cuneiform +12F90..12FFF; Cypro-Minoan +13000..1342F; Egyptian Hieroglyphs +13430..1345F; Egyptian Hieroglyph Format Controls +13460..143FF; Egyptian Hieroglyphs Extended-A +14400..1467F; Anatolian Hieroglyphs +16100..1613F; Gurung Khema +16800..16A3F; Bamum Supplement +16A40..16A6F; Mro +16A70..16ACF; Tangsa +16AD0..16AFF; Bassa Vah +16B00..16B8F; Pahawh Hmong +16D40..16D7F; Kirat Rai +16E40..16E9F; Medefaidrin +16F00..16F9F; Miao +16FE0..16FFF; Ideographic Symbols and Punctuation +17000..187FF; Tangut +18800..18AFF; Tangut Components +18B00..18CFF; Khitan Small Script +18D00..18D7F; Tangut Supplement +1AFF0..1AFFF; Kana Extended-B +1B000..1B0FF; Kana Supplement +1B100..1B12F; Kana Extended-A +1B130..1B16F; Small Kana Extension +1B170..1B2FF; Nushu +1BC00..1BC9F; Duployan +1BCA0..1BCAF; Shorthand Format Controls +1CC00..1CEBF; Symbols for Legacy Computing Supplement +1CF00..1CFCF; Znamenny Musical Notation +1D000..1D0FF; Byzantine Musical Symbols +1D100..1D1FF; Musical Symbols +1D200..1D24F; Ancient Greek Musical Notation +1D2C0..1D2DF; Kaktovik Numerals +1D2E0..1D2FF; Mayan Numerals +1D300..1D35F; Tai Xuan Jing Symbols +1D360..1D37F; Counting Rod Numerals +1D400..1D7FF; Mathematical Alphanumeric Symbols +1D800..1DAAF; Sutton SignWriting +1DF00..1DFFF; Latin Extended-G +1E000..1E02F; Glagolitic Supplement +1E030..1E08F; Cyrillic Extended-D +1E100..1E14F; Nyiakeng Puachue Hmong +1E290..1E2BF; Toto +1E2C0..1E2FF; Wancho +1E4D0..1E4FF; Nag Mundari +1E5D0..1E5FF; Ol Onal +1E7E0..1E7FF; Ethiopic Extended-B +1E800..1E8DF; Mende Kikakui +1E900..1E95F; Adlam +1EC70..1ECBF; Indic Siyaq Numbers +1ED00..1ED4F; Ottoman Siyaq Numbers +1EE00..1EEFF; Arabic Mathematical Alphabetic Symbols +1F000..1F02F; Mahjong Tiles +1F030..1F09F; Domino Tiles +1F0A0..1F0FF; Playing Cards +1F100..1F1FF; Enclosed Alphanumeric Supplement +1F200..1F2FF; Enclosed Ideographic Supplement +1F300..1F5FF; Miscellaneous Symbols and Pictographs +1F600..1F64F; Emoticons +1F650..1F67F; Ornamental Dingbats +1F680..1F6FF; Transport and Map Symbols +1F700..1F77F; Alchemical Symbols +1F780..1F7FF; Geometric Shapes Extended +1F800..1F8FF; Supplemental Arrows-C +1F900..1F9FF; Supplemental Symbols and Pictographs +1FA00..1FA6F; Chess Symbols +1FA70..1FAFF; Symbols and Pictographs Extended-A +1FB00..1FBFF; Symbols for Legacy Computing +20000..2A6DF; CJK Unified Ideographs Extension B +2A700..2B73F; CJK Unified Ideographs Extension C +2B740..2B81F; CJK Unified Ideographs Extension D +2B820..2CEAF; CJK Unified Ideographs Extension E +2CEB0..2EBEF; CJK Unified Ideographs Extension F +2EBF0..2EE5F; CJK Unified Ideographs Extension I +2F800..2FA1F; CJK Compatibility Ideographs Supplement +30000..3134F; CJK Unified Ideographs Extension G +31350..323AF; CJK Unified Ideographs Extension H +E0000..E007F; Tags +E0100..E01EF; Variation Selectors Supplement +F0000..FFFFF; Supplementary Private Use Area-A +100000..10FFFF; Supplementary Private Use Area-B + +# EOF diff --git a/git/usr/share/perl5/core_perl/unicore/CombiningClass.pl b/git/usr/share/perl5/core_perl/unicore/CombiningClass.pl new file mode 100644 index 0000000000000000000000000000000000000000..e10d826ea944450d93d91e943e1059ee7de9bf50 --- /dev/null +++ b/git/usr/share/perl5/core_perl/unicore/CombiningClass.pl @@ -0,0 +1,413 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is machine-generated by lib/unicore/mktables from the Unicode +# database, Version 16.0.0. Any changes made here will be lost! + +# !!!!!!! INTERNAL PERL USE ONLY !!!!!!! +# This file is for internal use by core Perl only. The format and even the +# name or existence of this file are subject to change without notice. Don't +# use it directly. Use Unicode::UCD to access the Unicode character data +# base. + + + +# The name this table is to be known by, with the format of the mappings in +# the main body of the table, and what all code points missing from this file +# map to. +$Unicode::UCD::SwashInfo{'ToCombiningClass'}{'format'} = 'i'; # integer +$Unicode::UCD::SwashInfo{'ToCombiningClass'}{'missing'} = '0'; + +return <<'END'; +300 314 230 +315 232 +316 319 220 +31A 232 +31B 216 +31C 320 220 +321 322 202 +323 326 220 +327 328 202 +329 333 220 +334 338 1 +339 33C 220 +33D 344 230 +345 240 +346 230 +347 349 220 +34A 34C 230 +34D 34E 220 +350 352 230 +353 356 220 +357 230 +358 232 +359 35A 220 +35B 230 +35C 233 +35D 35E 234 +35F 233 +360 361 234 +362 233 +363 36F 230 +483 487 230 +591 220 +592 595 230 +596 220 +597 599 230 +59A 222 +59B 220 +59C 5A1 230 +5A2 5A7 220 +5A8 5A9 230 +5AA 220 +5AB 5AC 230 +5AD 222 +5AE 228 +5AF 230 +5B0 10 +5B1 11 +5B2 12 +5B3 13 +5B4 14 +5B5 15 +5B6 16 +5B7 17 +5B8 18 +5B9 5BA 19 +5BB 20 +5BC 21 +5BD 22 +5BF 23 +5C1 24 +5C2 25 +5C4 230 +5C5 220 +5C7 18 +610 617 230 +618 30 +619 31 +61A 32 +64B 27 +64C 28 +64D 29 +64E 30 +64F 31 +650 32 +651 33 +652 34 +653 654 230 +655 656 220 +657 65B 230 +65C 220 +65D 65E 230 +65F 220 +670 35 +6D6 6DC 230 +6DF 6E2 230 +6E3 220 +6E4 230 +6E7 6E8 230 +6EA 220 +6EB 6EC 230 +6ED 220 +711 36 +730 230 +731 220 +732 733 230 +734 220 +735 736 230 +737 739 220 +73A 230 +73B 73C 220 +73D 230 +73E 220 +73F 741 230 +742 220 +743 230 +744 220 +745 230 +746 220 +747 230 +748 220 +749 74A 230 +7EB 7F1 230 +7F2 220 +7F3 230 +7FD 220 +816 819 230 +81B 823 230 +825 827 230 +829 82D 230 +859 85B 220 +897 898 230 +899 89B 220 +89C 89F 230 +8CA 8CE 230 +8CF 8D3 220 +8D4 8E1 230 +8E3 220 +8E4 8E5 230 +8E6 220 +8E7 8E8 230 +8E9 220 +8EA 8EC 230 +8ED 8EF 220 +8F0 27 +8F1 28 +8F2 29 +8F3 8F5 230 +8F6 220 +8F7 8F8 230 +8F9 8FA 220 +8FB 8FF 230 +93C 7 +94D 9 +951 230 +952 220 +953 954 230 +9BC 7 +9CD 9 +9FE 230 +A3C 7 +A4D 9 +ABC 7 +ACD 9 +B3C 7 +B4D 9 +BCD 9 +C3C 7 +C4D 9 +C55 84 +C56 91 +CBC 7 +CCD 9 +D3B D3C 9 +D4D 9 +DCA 9 +E38 E39 103 +E3A 9 +E48 E4B 107 +EB8 EB9 118 +EBA 9 +EC8 ECB 122 +F18 F19 220 +F35 220 +F37 220 +F39 216 +F71 129 +F72 130 +F74 132 +F7A F7D 130 +F80 130 +F82 F83 230 +F84 9 +F86 F87 230 +FC6 220 +1037 7 +1039 103A 9 +108D 220 +135D 135F 230 +1714 1715 9 +1734 9 +17D2 9 +17DD 230 +18A9 228 +1939 222 +193A 230 +193B 220 +1A17 230 +1A18 220 +1A60 9 +1A75 1A7C 230 +1A7F 220 +1AB0 1AB4 230 +1AB5 1ABA 220 +1ABB 1ABC 230 +1ABD 220 +1ABF 1AC0 220 +1AC1 1AC2 230 +1AC3 1AC4 220 +1AC5 1AC9 230 +1ACA 220 +1ACB 1ACE 230 +1B34 7 +1B44 9 +1B6B 230 +1B6C 220 +1B6D 1B73 230 +1BAA 1BAB 9 +1BE6 7 +1BF2 1BF3 9 +1C37 7 +1CD0 1CD2 230 +1CD4 1 +1CD5 1CD9 220 +1CDA 1CDB 230 +1CDC 1CDF 220 +1CE0 230 +1CE2 1CE8 1 +1CED 220 +1CF4 230 +1CF8 1CF9 230 +1DC0 1DC1 230 +1DC2 220 +1DC3 1DC9 230 +1DCA 220 +1DCB 1DCC 230 +1DCD 234 +1DCE 214 +1DCF 220 +1DD0 202 +1DD1 1DF5 230 +1DF6 232 +1DF7 1DF8 228 +1DF9 220 +1DFA 218 +1DFB 230 +1DFC 233 +1DFD 220 +1DFE 230 +1DFF 220 +20D0 20D1 230 +20D2 20D3 1 +20D4 20D7 230 +20D8 20DA 1 +20DB 20DC 230 +20E1 230 +20E5 20E6 1 +20E7 230 +20E8 220 +20E9 230 +20EA 20EB 1 +20EC 20EF 220 +20F0 230 +2CEF 2CF1 230 +2D7F 9 +2DE0 2DFF 230 +302A 218 +302B 228 +302C 232 +302D 222 +302E 302F 224 +3099 309A 8 +A66F 230 +A674 A67D 230 +A69E A69F 230 +A6F0 A6F1 230 +A806 9 +A82C 9 +A8C4 9 +A8E0 A8F1 230 +A92B A92D 220 +A953 9 +A9B3 7 +A9C0 9 +AAB0 230 +AAB2 AAB3 230 +AAB4 220 +AAB7 AAB8 230 +AABE AABF 230 +AAC1 230 +AAF6 9 +ABED 9 +FB1E 26 +FE20 FE26 230 +FE27 FE2D 220 +FE2E FE2F 230 +101FD 220 +102E0 220 +10376 1037A 230 +10A0D 220 +10A0F 230 +10A38 230 +10A39 1 +10A3A 220 +10A3F 9 +10AE5 230 +10AE6 220 +10D24 10D27 230 +10D69 10D6D 230 +10EAB 10EAC 230 +10EFD 10EFF 220 +10F46 10F47 220 +10F48 10F4A 230 +10F4B 220 +10F4C 230 +10F4D 10F50 220 +10F82 230 +10F83 220 +10F84 230 +10F85 220 +11046 9 +11070 9 +1107F 9 +110B9 9 +110BA 7 +11100 11102 230 +11133 11134 9 +11173 7 +111C0 9 +111CA 7 +11235 9 +11236 7 +112E9 7 +112EA 9 +1133B 1133C 7 +1134D 9 +11366 1136C 230 +11370 11374 230 +113CE 113D0 9 +11442 9 +11446 7 +1145E 230 +114C2 9 +114C3 7 +115BF 9 +115C0 7 +1163F 9 +116B6 9 +116B7 7 +1172B 9 +11839 9 +1183A 7 +1193D 1193E 9 +11943 7 +119E0 9 +11A34 9 +11A47 9 +11A99 9 +11C3F 9 +11D42 7 +11D44 11D45 9 +11D97 9 +11F41 11F42 9 +1612F 9 +16AF0 16AF4 1 +16B30 16B36 230 +16FF0 16FF1 6 +1BC9E 1 +1D165 1D166 216 +1D167 1D169 1 +1D16D 226 +1D16E 1D172 216 +1D17B 1D182 220 +1D185 1D189 230 +1D18A 1D18B 220 +1D1AA 1D1AD 230 +1D242 1D244 230 +1E000 1E006 230 +1E008 1E018 230 +1E01B 1E021 230 +1E023 1E024 230 +1E026 1E02A 230 +1E08F 230 +1E130 1E136 230 +1E2AE 230 +1E2EC 1E2EF 230 +1E4EC 1E4ED 232 +1E4EE 220 +1E4EF 230 +1E5EE 230 +1E5EF 220 +1E8D0 1E8D6 220 +1E944 1E949 230 +1E94A 7 +END