Add support for erlang:localtime/0 and introduce erlang:localtime/1

`erlang:localtime/1` returns the local time for a given timezone in a thread
safe way by using POSIX TZ environment variable.

Signed-off-by: Paul Guyot <[email protected]>

Author: pguyot

src/libAtomVM/globalcontext.c

@@ -146,6 +146,8 @@ GlobalContext *globalcontext_new()
     glb->online_schedulers = smp_get_online_processors();
     glb->running_schedulers = 0;
     glb->waiting_scheduler = false;
+
+    smp_spinlock_init(&glb->env_spinlock);
 #endif
     glb->scheduler_stop_all = false;
 

src/libAtomVM/globalcontext.h

@@ -116,6 +116,10 @@ struct GlobalContext
     bool scheduler_stop_all;
 #endif
 
+#ifndef AVM_NO_SMP
+    SpinLock env_spinlock;
+#endif
+
     void *platform_data;
 };
 

src/libAtomVM/nifs.c

@@ -132,6 +132,7 @@ static term nif_erlang_system_time_1(Context *ctx, int argc, term argv[]);
 static term nif_erlang_tuple_to_list_1(Context *ctx, int argc, term argv[]);
 static term nif_erlang_list_to_tuple_1(Context *ctx, int argc, term argv[]);
 static term nif_erlang_universaltime_0(Context *ctx, int argc, term argv[]);
+static term nif_erlang_localtime(Context *ctx, int argc, term argv[]);
 static term nif_erlang_timestamp_0(Context *ctx, int argc, term argv[]);
 static term nif_erts_debug_flat_size(Context *ctx, int argc, term argv[]);
 static term nif_erlang_process_flag(Context *ctx, int argc, term argv[]);
@@ -470,6 +471,12 @@ static const struct Nif universaltime_nif =
     .nif_ptr = nif_erlang_universaltime_0
 };
 
+static const struct Nif localtime_nif =
+{
+    .base.type = NIFFunctionType,
+    .nif_ptr = nif_erlang_localtime
+};
+
 static const struct Nif timestamp_nif =
 {
     .base.type = NIFFunctionType,
@@ -1382,12 +1389,8 @@ term nif_erlang_system_time_1(Context *ctx, int argc, term argv[])
     }
 }
 
-term nif_erlang_universaltime_0(Context *ctx, int argc, term argv[])
+static term build_datetime_from_tm(Context *ctx, struct tm *broken_down_time)
 {
-    UNUSED(ctx);
-    UNUSED(argc);
-    UNUSED(argv);
-
     // 4 = size of date/time tuple, 3 size of date time tuple
     if (UNLIKELY(memory_ensure_free_opt(ctx, 3 + 4 + 4, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
         RAISE_ERROR(OUT_OF_MEMORY_ATOM);
@@ -1396,24 +1399,75 @@ term nif_erlang_universaltime_0(Context *ctx, int argc, term argv[])
     term time_tuple = term_alloc_tuple(3, &ctx->heap);
     term date_time_tuple = term_alloc_tuple(2, &ctx->heap);
 
+    term_put_tuple_element(date_tuple, 0, term_from_int32(1900 + broken_down_time->tm_year));
+    term_put_tuple_element(date_tuple, 1, term_from_int32(broken_down_time->tm_mon + 1));
+    term_put_tuple_element(date_tuple, 2, term_from_int32(broken_down_time->tm_mday));
+
+    term_put_tuple_element(time_tuple, 0, term_from_int32(broken_down_time->tm_hour));
+    term_put_tuple_element(time_tuple, 1, term_from_int32(broken_down_time->tm_min));
+    term_put_tuple_element(time_tuple, 2, term_from_int32(broken_down_time->tm_sec));
+
+    term_put_tuple_element(date_time_tuple, 0, date_tuple);
+    term_put_tuple_element(date_time_tuple, 1, time_tuple);
+
+    return date_time_tuple;
+}
+
+term nif_erlang_universaltime_0(Context *ctx, int argc, term argv[])
+{
+    UNUSED(argc);
+    UNUSED(argv);
+
     struct timespec ts;
     sys_time(&ts);
 
     struct tm broken_down_time;
-    gmtime_r(&ts.tv_sec, &broken_down_time);
+    return build_datetime_from_tm(ctx, gmtime_r(&ts.tv_sec, &broken_down_time));
+}
 
-    term_put_tuple_element(date_tuple, 0, term_from_int32(1900 + broken_down_time.tm_year));
-    term_put_tuple_element(date_tuple, 1, term_from_int32(broken_down_time.tm_mon + 1));
-    term_put_tuple_element(date_tuple, 2, term_from_int32(broken_down_time.tm_mday));
+term nif_erlang_localtime(Context *ctx, int argc, term argv[])
+{
+    char *tz;
+    if (argc == 1) {
+        int ok;
+        tz = interop_term_to_string(argv[0], &ok);
+        if (UNLIKELY(!ok)) {
+            RAISE_ERROR(BADARG_ATOM);
+        }
+    } else {
+        tz = NULL;
+    }
 
-    term_put_tuple_element(time_tuple, 0, term_from_int32(broken_down_time.tm_hour));
-    term_put_tuple_element(time_tuple, 1, term_from_int32(broken_down_time.tm_min));
-    term_put_tuple_element(time_tuple, 2, term_from_int32(broken_down_time.tm_sec));
+    struct timespec ts;
+    sys_time(&ts);
 
-    term_put_tuple_element(date_time_tuple, 0, date_tuple);
-    term_put_tuple_element(date_time_tuple, 1, time_tuple);
+    struct tm storage;
+    struct tm *localtime;
 
-    return date_time_tuple;
+#ifndef AVM_NO_SMP
+    smp_spinlock_lock(&ctx->global->env_spinlock);
+#endif
+    if (tz) {
+        char *oldtz = getenv("TZ");
+        setenv("TZ", tz, 1);
+        tzset();
+        localtime = localtime_r(&ts.tv_sec, &storage);
+        if (oldtz) {
+            setenv("TZ", oldtz, 1);
+        } else {
+            unsetenv("TZ");
+        }
+    } else {
+        // Call tzset to handle DST changes
+        tzset();
+        localtime = localtime_r(&ts.tv_sec, &storage);
+    }
+#ifndef AVM_NO_SMP
+    smp_spinlock_unlock(&ctx->global->env_spinlock);
+#endif
+
+    free(tz);
+    return build_datetime_from_tm(ctx, localtime);
 }
 
 term nif_erlang_timestamp_0(Context *ctx, int argc, term argv[])

src/libAtomVM/nifs.gperf

@@ -92,6 +92,8 @@ erlang:monotonic_time/1, &monotonic_time_nif
 erlang:system_time/1, &system_time_nif
 erlang:tuple_to_list/1, &tuple_to_list_nif
 erlang:universaltime/0, &universaltime_nif
+erlang:localtime/0, &localtime_nif
+erlang:localtime/1, &localtime_nif
 erlang:timestamp/0, &timestamp_nif
 erlang:process_flag/2, &process_flag_nif
 erlang:process_flag/3, &process_flag_nif

src/platforms/esp32/test/main/test_erl_sources/CMakeLists.txt

@@ -38,17 +38,20 @@ endfunction()
 
 compile_erlang(test_socket)
 compile_erlang(test_time_and_processes)
+compile_erlang(test_tz)
 
 add_custom_command(
     OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/esp32_test_modules.avm"
     COMMAND HostAtomVM-prefix/src/HostAtomVM-build/tools/packbeam/PackBEAM -i esp32_test_modules.avm
         HostAtomVM-prefix/src/HostAtomVM-build/libs/atomvmlib.avm
         test_socket.beam
         test_time_and_processes.beam
+        test_tz.beam
     DEPENDS
         HostAtomVM
         "${CMAKE_CURRENT_BINARY_DIR}/test_socket.beam"
         "${CMAKE_CURRENT_BINARY_DIR}/test_time_and_processes.beam"
+        "${CMAKE_CURRENT_BINARY_DIR}/test_tz.beam"
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     VERBATIM
 )

src/platforms/esp32/test/main/test_erl_sources/test_tz.erl

@@ -0,0 +1,32 @@
+%
+% This file is part of AtomVM.
+%
+% Copyright 2023 Paul Guyot <[email protected]>
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%    http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+%
+% SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
+%
+
+-module(test_tz).
+-export([start/0]).
+
+start() ->
+    UTCTime1 = erlang:universaltime(),
+    LocalTimeUTC = erlang:localtime("UTC"),
+    UTCTime2 = erlang:universaltime(),
+    true = UTCTime1 =< LocalTimeUTC andalso LocalTimeUTC =< UTCTime2,
+    ParisTime = erlang:localtime("CET-1CEST,M3.5.0,M10.5.0/3"),
+    UTCTime3 = erlang:universaltime(),
+    true = UTCTime2 =/= ParisTime andalso UTCTime3 =/= ParisTime,
+    ok.

src/platforms/esp32/test/main/test_main.c

@@ -183,6 +183,12 @@ TEST_CASE("test_time_and_processes", "[test_run]")
     TEST_ASSERT(term_to_int(ret_value) == 6);
 }
 
+TEST_CASE("test_tz", "[test_run]")
+{
+    term ret_value = avm_test_case("test_tz.beam");
+    TEST_ASSERT(ret_value == OK_ATOM);
+}
+
 #ifndef AVM_NO_SMP
 TEST_CASE("atomvm_smp_0", "[smp]")
 {

tests/erlang_tests/datetime.erl

@@ -23,10 +23,35 @@
 -export([start/0]).
 
 start() ->
+    3 = test_localtime(),
+    3 = test_universaltime(),
+    case erlang:system_info(machine) of
+        "BEAM" ->
+            % BEAM currently has no API to get the localtime for a given TZ
+            % https://github.com/erlang/otp/issues/7228
+            ok;
+        _ ->
+            ok = test_timezone()
+    end,
+    3.
+
+test_localtime() ->
+    {Date, Time} = erlang:localtime(),
+    test_date(Date) + test_time(Time).
+
+test_universaltime() ->
     {Date, Time} = erlang:universaltime(),
     test_date(Date) + test_time(Time).
 
-test_date({Y, M, D}) when Y >= 2018 andalso M >= 1 andalso M =< 12 andalso D >= 1 andalso D =< 31 ->
+test_timezone() ->
+    UTCDate = erlang:universaltime(),
+    ParisDate = erlang:localtime("Europe/Paris"),
+    LondonDate = erlang:localtime("Europe/London"),
+    true = ParisDate =/= UTCDate,
+    true = ParisDate =/= LondonDate,
+    ok.
+
+test_date({Y, M, D}) when Y >= 2023 andalso M >= 1 andalso M =< 12 andalso D >= 1 andalso D =< 31 ->
     1.
 
 test_time({HOUR, MIN, SEC}) when