pkgsrc-WIP-changes archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]
pharo-vm10: Update to 10.3.0
Module Name: pkgsrc-wip
Committed By: Atsushi Toyokura <asteria.at%gmail.com@localhost>
Pushed By: steleto
Date: Sat Aug 10 10:41:27 2024 +0900
Changeset: 943394db7303305c030d42ad9d6968d4829978cc
Modified Files:
pharo-vm10/Makefile
pharo-vm10/PLIST
pharo-vm10/distinfo
Added Files:
pharo-vm10/patches/patch-cmake_OpenBSD.cmake
pharo-vm10/patches/patch-extracted_vm_src_unix_aio__select.c
pharo-vm10/patches/patch-tty_tty.c
Log Message:
pharo-vm10: Update to 10.3.0
v10.3.0
- New harmonize rule by @RenaudFondeur in #817
- Ignoring EAGAIN in epoll_wait by @tesonep in #818
- Extend macOS implementation of SqueakSSL plugin to support setting a
certificate on the SSL session context by @Rinzwind in #816
- Adding macro for win32. by @tesonep in #814
To see a diff of this commit:
https://wip.pkgsrc.org/cgi-bin/gitweb.cgi?p=pkgsrc-wip.git;a=commitdiff;h=943394db7303305c030d42ad9d6968d4829978cc
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
diffstat:
pharo-vm10/Makefile | 6 +-
pharo-vm10/PLIST | 1 +
pharo-vm10/distinfo | 9 +-
pharo-vm10/patches/patch-cmake_OpenBSD.cmake | 15 +
.../patch-extracted_vm_src_unix_aio__select.c | 478 +++++++++++++++++++++
pharo-vm10/patches/patch-tty_tty.c | 16 +
6 files changed, 520 insertions(+), 5 deletions(-)
diffs:
diff --git a/pharo-vm10/Makefile b/pharo-vm10/Makefile
index 5f919659c1..266df6b407 100644
--- a/pharo-vm10/Makefile
+++ b/pharo-vm10/Makefile
@@ -1,7 +1,7 @@
# $NetBSD$
-PHAROVM_VER= 10.1.0
-PHAROVM_HASH= 55f077d
+PHAROVM_VER= 10.3.0
+PHAROVM_HASH= 51626b1
DISTNAME= PharoVM-${PHAROVM_VER}-${PHAROVM_HASH}-Linux-x86_64-c-src
PKGNAME= pharo-vm10-${PHAROVM_VER}
@@ -25,6 +25,8 @@ CMAKE_ARGS+= -DALWAYS_INTERACTIVE=1
CMAKE_ARGS+= -DGENERATE_SOURCES=OFF
CMAKE_ARGS+= -DPHARO_BIN_LOCATION=${PREFIX}/lib/pharo10
+TOOL_DEPENDS+= graphviz-[0-9]*:../../graphics/graphviz
+
SUBST_CLASSES+= fix-paths
SUBST_STAGE.fix-paths= pre-build
SUBST_MESSAGE.fix-paths= Fixing absolute paths.
diff --git a/pharo-vm10/PLIST b/pharo-vm10/PLIST
index e129aad4c0..3a4abc00d9 100644
--- a/pharo-vm10/PLIST
+++ b/pharo-vm10/PLIST
@@ -18,4 +18,5 @@ lib/pharo10/libSurfacePlugin.so
lib/pharo10/libTestLibrary.so
lib/pharo10/libUUIDPlugin.so
lib/pharo10/libUnixOSProcessPlugin.so
+lib/pharo10/libtty.so
lib/pharo10/pharo
diff --git a/pharo-vm10/distinfo b/pharo-vm10/distinfo
index 0025a72492..fa8188efa2 100644
--- a/pharo-vm10/distinfo
+++ b/pharo-vm10/distinfo
@@ -1,12 +1,15 @@
$NetBSD$
-BLAKE2s (PharoVM-10.1.0-55f077d-Linux-x86_64-c-src.zip) = 97846eb412139efeb7f1f75845dda3b9277bcbaaef266fe637cd4d20e4e87eb9
-SHA512 (PharoVM-10.1.0-55f077d-Linux-x86_64-c-src.zip) = 06dbc388b8a4421c05adb3db53c53a940c22fc7f79a90773c0673c8e110b71565f5bb164ebe6c3ab7618b404e46026f8deebb4aaa24957feacfa8395fdddb945
-Size (PharoVM-10.1.0-55f077d-Linux-x86_64-c-src.zip) = 4129684 bytes
+BLAKE2s (PharoVM-10.3.0-51626b1-Linux-x86_64-c-src.zip) = 28c11be95e77161e363e0293e091eb67aeaf3340bfab5fdb8ae24c2a90da7821
+SHA512 (PharoVM-10.3.0-51626b1-Linux-x86_64-c-src.zip) = 4df8a7e94ee2fde5377bab0ae58e811272ef94b0d529f01aeb3811835d3534c87ebfd0ff3249b2fc14e730f099020574c7971083985ec7b254ab29f5da0eebd4
+Size (PharoVM-10.3.0-51626b1-Linux-x86_64-c-src.zip) = 4105768 bytes
SHA1 (patch-CMakeLists.txt) = 533049079f0d8db0584c8ba590150436cdc84a95
+SHA1 (patch-cmake_OpenBSD.cmake) = e34312fd124d2cfa5e35e0184c9e8c6a5e6dd2a1
SHA1 (patch-cmake_importCairo.cmake) = 0e90fbbcdebb4b0aa994be74737fa7d6462e253c
+SHA1 (patch-extracted_vm_src_unix_aio__select.c) = 6b9c83628c97744a4df614dc20d159539e167bec
SHA1 (patch-include_pharovm_debug.h) = a806f34f443b0d7907983d0d4f20fc121b7dfb65
SHA1 (patch-packaging_linux_bin_launch.sh.in) = 116b5151e0bd58558a1af3691d1f546437d94eae
SHA1 (patch-plugins.cmake) = b8eb5ad47d505c0b52a7601f86109cf8f6ccae40
SHA1 (patch-plugins_UUIDPlugin_common_UUIDPlugin.c) = ebed390cdfd0817c3d2e5fa5f1642d6a7226d10e
SHA1 (patch-src_debugUnix.c) = 68f2c801cda9ba010134d778f8b32060d2bc9d8a
+SHA1 (patch-tty_tty.c) = 6a2acb31f56de61879b044c0e13f5d4d41fd42ef
diff --git a/pharo-vm10/patches/patch-cmake_OpenBSD.cmake b/pharo-vm10/patches/patch-cmake_OpenBSD.cmake
new file mode 100644
index 0000000000..947ea235fe
--- /dev/null
+++ b/pharo-vm10/patches/patch-cmake_OpenBSD.cmake
@@ -0,0 +1,15 @@
+$NetBSD$
+
+Use aio using select(2).
+
+--- cmake/OpenBSD.cmake.orig 2024-08-10 01:15:33.961377106 +0000
++++ cmake/OpenBSD.cmake
+@@ -26,7 +26,7 @@ set(EXTRACTED_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/extracted/vm/src/common/sqTicker.c
+
+ #Platform sources
+- ${CMAKE_CURRENT_SOURCE_DIR}/extracted/vm/src/unix/aio.c
++ ${CMAKE_CURRENT_SOURCE_DIR}/extracted/vm/src/unix/aio_select.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/src/debugUnix.c
+
+ #Virtual Memory functions
diff --git a/pharo-vm10/patches/patch-extracted_vm_src_unix_aio__select.c b/pharo-vm10/patches/patch-extracted_vm_src_unix_aio__select.c
new file mode 100644
index 0000000000..0c0707ccc7
--- /dev/null
+++ b/pharo-vm10/patches/patch-extracted_vm_src_unix_aio__select.c
@@ -0,0 +1,478 @@
+$NetBSD$
+
+The last version using select(2).
+
+https://raw.githubusercontent.com/pharo-project/pharo-vm/c6623c0ba20eb009a92a4117108309df7a202bad/extracted/vm/src/unix/aio.c
+
+--- extracted/vm/src/unix/aio_select.c.orig 2024-08-10 01:15:25.495787585 +0000
++++ extracted/vm/src/unix/aio_select.c
+@@ -0,0 +1,469 @@
++/* aio.c -- asynchronous file i/o
++ *
++ * Copyright (C) 1996-2006 by Ian Piumarta and other authors/contributors
++ * listed elsewhere in this file.
++ * All rights reserved.
++ *
++ * This file is part of Unix Squeak.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in
++ * all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++/* Authors: Ian.Piumarta%squeakland.org@localhost, eliot.miranda%gmail.com@localhost
++ *
++ * Last edited: Tue Mar 29 13:06:00 PDT 2016
++ */
++
++#include "pharovm/debug.h"
++#include "pharovm/semaphores/platformSemaphore.h"
++#include "sqMemoryFence.h"
++#include "sqaio.h"
++
++#include <sys/types.h>
++#include <sys/socket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <unistd.h>
++#include <errno.h>
++#include <signal.h>
++#include <sys/types.h>
++#include <sys/time.h>
++#include <sys/select.h>
++#include <sys/ioctl.h>
++#include <fcntl.h>
++
++#define _DO_FLAG_TYPE() do { _DO(AIO_R, rd) _DO(AIO_W, wr) _DO(AIO_X, ex) } while (0)
++
++static aioHandler rdHandler[FD_SETSIZE];
++static aioHandler wrHandler[FD_SETSIZE];
++static aioHandler exHandler[FD_SETSIZE];
++
++static void *clientData[FD_SETSIZE];
++
++static int maxFd;
++static fd_set fdMask; /* handled by aio */
++static fd_set rdMask; /* handle read */
++static fd_set wrMask; /* handle write */
++static fd_set exMask; /* handle exception */
++static fd_set xdMask; /* external descriptor */
++
++/*
++ * This is important, the AIO poll should only do a long pause if there is no pending signals for semaphores.
++ * Check ExternalSemaphores to understand this function.
++ */
++int isPendingSemaphores();
++
++void heartbeat_poll_enter(long microSeconds);
++void heartbeat_poll_exit(long microSeconds);
++static int aio_handle_events(long microSeconds);
++
++Semaphore* interruptFIFOMutex;
++int pendingInterruption;
++int aio_in_sleep = 0;
++int aio_request_interrupt = 0;
++
++volatile int isPooling = 0;
++
++static void
++undefinedHandler(int fd, void *clientData, int flags)
++{
++ logError("Undefined handler called (fd %d, flags %x)\n", fd, flags);
++}
++
++/* initialise asynchronous i/o */
++
++int signal_pipe_fd[2];
++
++void
++aioInit(void)
++{
++ int arg;
++
++ interruptFIFOMutex = platform_semaphore_new(1);
++
++ FD_ZERO(&fdMask);
++ FD_ZERO(&rdMask);
++ FD_ZERO(&wrMask);
++ FD_ZERO(&exMask);
++ FD_ZERO(&xdMask);
++ maxFd = 0;
++
++ if (pipe(signal_pipe_fd) != 0) {
++ logErrorFromErrno("pipe");
++ exit(-1);
++ }
++
++ if ((arg = fcntl(signal_pipe_fd[0], F_GETFL, 0)) < 0)
++ logErrorFromErrno("fcntl(F_GETFL)");
++ if (fcntl(signal_pipe_fd[0], F_SETFL, arg | O_NONBLOCK | O_ASYNC ) < 0)
++ logErrorFromErrno("fcntl(F_SETFL, O_ASYNC)");
++
++ if ((arg = fcntl(signal_pipe_fd[1], F_GETFL, 0)) < 0)
++ logErrorFromErrno("fcntl(F_GETFL)");
++ if (fcntl(signal_pipe_fd[1], F_SETFL, arg | O_NONBLOCK | O_ASYNC | O_APPEND) < 0)
++ logErrorFromErrno("fcntl(F_SETFL, O_ASYNC)");
++
++
++ signal(SIGIO, forceInterruptCheck);
++}
++
++
++/* disable handlers and close all handled non-exteral descriptors */
++
++void
++aioFini(void)
++{
++ int fd;
++
++ for (fd = 0; fd < maxFd; fd++)
++ if (FD_ISSET(fd, &fdMask) && !(FD_ISSET(fd, &xdMask))) {
++ aioDisable(fd);
++ close(fd);
++ FD_CLR(fd, &fdMask);
++ FD_CLR(fd, &rdMask);
++ FD_CLR(fd, &wrMask);
++ FD_CLR(fd, &exMask);
++ }
++ while (maxFd && !FD_ISSET(maxFd - 1, &fdMask))
++ --maxFd;
++ signal(SIGPIPE, SIG_DFL);
++}
++
++
++/*
++ * answer whether i/o becomes possible within the given number of
++ * microSeconds
++ */
++#ifndef max
++# define max(a, b) (((a) > (b)) ? (a) : (b))
++#endif
++
++
++volatile int aio_requests = 0;
++volatile int aio_responses = 0;
++
++/*
++ * I Try to clear all the data available in the pipe, so it does not passes the limit of data.
++ * Do not call me outside the mutex area of interruptFIFOMutex.
++ */
++void
++aio_flush_pipe(int fd){
++
++ int bytesRead;
++ char buf[1024];
++
++ interruptFIFOMutex->wait(interruptFIFOMutex);
++ if(pendingInterruption){
++ pendingInterruption = false;
++ }
++
++ do {
++ bytesRead = read(fd, &buf, 1024);
++
++ if(bytesRead == -1){
++
++ if(errno == EAGAIN || errno == EWOULDBLOCK){
++ interruptFIFOMutex->signal(interruptFIFOMutex);
++ return;
++ }
++
++ logErrorFromErrno("pipe - read");
++
++ interruptFIFOMutex->signal(interruptFIFOMutex);
++ return;
++ }
++
++ } while(bytesRead > 0);
++
++ interruptFIFOMutex->signal(interruptFIFOMutex);
++}
++
++long
++aioPoll(long microSeconds){
++ long timeout;
++
++ interruptFIFOMutex->wait(interruptFIFOMutex);
++
++ if(pendingInterruption || isPendingSemaphores()){
++ timeout = 0;
++ }else{
++ timeout = microSeconds;
++ }
++
++ if(pendingInterruption){
++ pendingInterruption = false;
++ }
++
++ interruptFIFOMutex->signal(interruptFIFOMutex);
++
++ return aio_handle_events(timeout);
++}
++
++static int
++aio_handle_events(long microSeconds){
++ int fd;
++ fd_set rd, wr, ex;
++ unsigned long long us;
++ int maxFdToUse;
++ long remainingMicroSeconds;
++
++ /*
++ * Copy the Masks as they are used to know which
++ * FD wants which event
++ */
++ rd = rdMask;
++ wr = wrMask;
++ ex = exMask;
++ us = ioUTCMicroseconds();
++
++ remainingMicroSeconds = microSeconds;
++
++ FD_SET(signal_pipe_fd[0], &rd);
++
++ maxFdToUse = maxFd > (signal_pipe_fd[0] + 1) ? maxFd : signal_pipe_fd[0] + 1;
++
++ sqLowLevelMFence();
++ isPooling = 1;
++ heartbeat_poll_enter(microSeconds);
++
++ for (;;) {
++ struct timeval tv;
++ int n;
++ unsigned long long now;
++
++ tv.tv_sec = remainingMicroSeconds / 1000000;
++ tv.tv_usec = remainingMicroSeconds % 1000000;
++
++ n = select(maxFdToUse, &rd, &wr, &ex, &tv);
++
++ if (n > 0)
++ break;
++ if (n == 0) {
++ if (remainingMicroSeconds)
++ addIdleUsecs(remainingMicroSeconds);
++
++ sqLowLevelMFence();
++ isPooling = 0;
++ heartbeat_poll_exit(microSeconds);
++ return 0;
++ }
++ if (errno && (EINTR != errno)) {
++ logError("errno %d\n", errno);
++ logErrorFromErrno("select");
++
++ sqLowLevelMFence();
++ isPooling = 0;
++ heartbeat_poll_exit(microSeconds);
++ return 0;
++ }
++ now = ioUTCMicroseconds();
++ remainingMicroSeconds -= max(now - us, 1);
++
++ if (remainingMicroSeconds <= 0){
++ sqLowLevelMFence();
++ isPooling = 0;
++ heartbeat_poll_exit(microSeconds);
++ return 0;
++ }
++ us = now;
++ }
++
++ sqLowLevelMFence();
++ isPooling = 0;
++ heartbeat_poll_exit(microSeconds);
++ aio_flush_pipe(signal_pipe_fd[0]);
++
++ // We clear signal_pipe_fd because when it arrives here we do not care anymore
++ // about it, but it may cause a crash if it is set because we do not have
++ // a handler for it. Another solution could be to just add a handler to signal_pipe_fd
++ // but for now it does not seems needed.
++ FD_CLR(signal_pipe_fd[0], &rd);
++
++ for (fd = 0; fd < maxFd; ++fd) {
++ aioHandler handler;
++
++ //_DO_FLAG_TYPE();
++ //_DO(AIO_R, rd)
++ if (FD_ISSET(fd, &rd)) {
++ handler = rdHandler[fd];
++ FD_CLR(fd, &rdMask);
++ handler(fd, clientData[fd], AIO_R);
++ rdHandler[fd]= undefinedHandler;
++ }
++ //_DO(AIO_W, wr)
++ if (FD_ISSET(fd, &wr)) {
++ handler = wrHandler[fd];
++ FD_CLR(fd, &wrMask);
++ handler(fd, clientData[fd], AIO_W);
++ wrHandler[fd]= undefinedHandler;
++ }
++ //_DO(AIO_X, ex)
++ if (FD_ISSET(fd, &ex)) {
++ handler = exHandler[fd];
++ FD_CLR(fd, &exMask);
++ handler(fd, clientData[fd], AIO_X);
++ exHandler[fd]= undefinedHandler;
++ }
++ }
++
++ return 1;
++}
++
++/*
++ * This function is used to interrupt a aioPoll.
++ * Used when signalling a Pharo semaphore to re-wake the VM and execute code of the image.
++ */
++
++void
++aioInterruptPoll(){
++ int n;
++
++ sqLowLevelMFence();
++
++ if(isPooling){
++ n = write(signal_pipe_fd[1], "1", 1);
++ if(n != 1){
++ logErrorFromErrno("write to pipe");
++ }
++ fsync(signal_pipe_fd[1]);
++ }
++
++ interruptFIFOMutex->wait(interruptFIFOMutex);
++ pendingInterruption = true;
++ interruptFIFOMutex->signal(interruptFIFOMutex);
++}
++
++void
++aioEnable(int fd, void *data, int flags)
++{
++ if (fd < 0) {
++ logWarn("AioEnable(%d): IGNORED - Negative Number", fd);
++ return;
++ }
++ if (FD_ISSET(fd, &fdMask)) {
++ logWarn("AioEnable: descriptor %d already enabled", fd);
++ return;
++ }
++ clientData[fd] = data;
++ rdHandler[fd] = wrHandler[fd] = exHandler[fd] = undefinedHandler;
++ FD_SET(fd, &fdMask);
++ FD_CLR(fd, &rdMask);
++ FD_CLR(fd, &wrMask);
++ FD_CLR(fd, &exMask);
++ if (fd >= maxFd)
++ maxFd = fd + 1;
++ if (flags & AIO_EXT) {
++ FD_SET(fd, &xdMask);
++ /* we should not set NBIO ourselves on external descriptors! */
++ }
++ else {
++ /*
++ * enable non-blocking asynchronous i/o and delivery of SIGIO
++ * to the active process
++ */
++ int arg;
++
++ FD_CLR(fd, &xdMask);
++
++#if defined(O_ASYNC)
++ if (fcntl(fd, F_SETOWN, getpid()) < 0)
++ logErrorFromErrno("fcntl(F_SETOWN, getpid())");
++ if ((arg = fcntl(fd, F_GETFL, 0)) < 0)
++ logErrorFromErrno("fcntl(F_GETFL)");
++ if (fcntl(fd, F_SETFL, arg | O_NONBLOCK | O_ASYNC) < 0)
++ logErrorFromErrno("fcntl(F_SETFL, O_ASYNC)");
++
++#elif defined(FASYNC)
++ if (fcntl(fd, F_SETOWN, getpid()) < 0)
++ logErrorFromErrno("fcntl(F_SETOWN, getpid())");
++ if ((arg = fcntl(fd, F_GETFL, 0)) < 0)
++ logErrorFromErrno("fcntl(F_GETFL)");
++ if (fcntl(fd, F_SETFL, arg | O_NONBLOCK | FASYNC) < 0)
++ logErrorFromErrno("fcntl(F_SETFL, FASYNC)");
++
++#elif defined(FIOASYNC)
++ arg = getpid();
++ if (ioctl(fd, SIOCSPGRP, &arg) < 0)
++ logErrorFromErrno("ioctl(SIOCSPGRP, getpid())");
++ arg = 1;
++ if (ioctl(fd, FIOASYNC, &arg) < 0)
++ logErrorFromErrno("ioctl(FIOASYNC, 1)");
++#endif
++ }
++}
++
++
++/* install/change the handler for a descriptor */
++
++void
++aioHandle(int fd, aioHandler handlerFn, int mask)
++{
++ if (fd < 0) {
++ logWarn("aioHandle(%d): IGNORED - Negative FD", fd);
++ return;
++ }
++#undef _DO
++#define _DO(FLAG, TYPE) \
++ if (mask & FLAG) { \
++ FD_SET(fd, &TYPE##Mask); \
++ TYPE##Handler[fd]= handlerFn; \
++ }
++ _DO_FLAG_TYPE();
++}
++
++
++/* temporarily suspend asynchronous notification for a descriptor */
++
++void
++aioSuspend(int fd, int mask)
++{
++ if (fd < 0) {
++ logWarn("aioSuspend(%d): IGNORED - Negative FD\n", fd);
++ return;
++ }
++
++#undef _DO
++#define _DO(FLAG, TYPE) \
++ if (mask & FLAG) { \
++ FD_CLR(fd, &TYPE##Mask); \
++ TYPE##Handler[fd]= undefinedHandler; \
++ }
++ _DO_FLAG_TYPE();
++}
++
++
++/* definitively disable asynchronous notification for a descriptor */
++
++void
++aioDisable(int fd)
++{
++ if (fd < 0) {
++ logWarn( "aioDisable(%d): IGNORED - Negative FD\n", fd);
++ return;
++ }
++ aioSuspend(fd, AIO_RWX);
++ FD_CLR(fd, &xdMask);
++ FD_CLR(fd, &fdMask);
++ rdHandler[fd] = wrHandler[fd] = exHandler[fd] = 0;
++ clientData[fd] = 0;
++ /* keep maxFd accurate (drops to zero if no more sockets) */
++ while (maxFd && !FD_ISSET(maxFd - 1, &fdMask))
++ --maxFd;
++}
diff --git a/pharo-vm10/patches/patch-tty_tty.c b/pharo-vm10/patches/patch-tty_tty.c
new file mode 100644
index 0000000000..a0c5b51932
--- /dev/null
+++ b/pharo-vm10/patches/patch-tty_tty.c
@@ -0,0 +1,16 @@
+$NetBSD$
+
+Use dprintf(3) specified in POSIX.1-2008
+
+--- tty/tty.c.orig 2024-07-02 15:02:45.000000000 +0000
++++ tty/tty.c
+@@ -1,6 +1,9 @@
+ #ifndef _XOPEN_SOURCE
+ #define _XOPEN_SOURCE 700
+ #endif
++#ifndef _POSIX_C_SOURCE
++#define _POSIX_C_SOURCE 200809L
++#endif
+
+ #include <errno.h>
+ #include <string.h>
Home |
Main Index |
Thread Index |
Old Index