/*
	 A C++ interface to POSIX functions.
	
	 Copyright (c) 2012 - 2016, Victor Zverovich
	 All rights reserved.
	
	 For the license information refer to format.h.
	 */
	
	#ifndef FMT_POSIX_H_
	#define FMT_POSIX_H_
	
	#if defined(__MINGW32__) || defined(__CYGWIN__)
	// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
	# undef __STRICT_ANSI__
	#endif
	
	#include <errno.h>
	#include <fcntl.h>   // for O_RDONLY
	#include <locale.h>  // for locale_t
	#include <stdio.h>
	#include <stdlib.h>  // for strtod_l
	
	#include <cstddef>
	
	#if defined __APPLE__ || defined(__FreeBSD__)
	# include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
	#endif
	
	#include "format.h"
	
	#ifndef FMT_POSIX
	# if defined(_WIN32) && !defined(__MINGW32__)
	// Fix warnings about deprecated symbols.
	#  define FMT_POSIX(call) _##call
	# else
	#  define FMT_POSIX(call) call
	# endif
	#endif
	
	// Calls to system functions are wrapped in FMT_SYSTEM for testability.
	#ifdef FMT_SYSTEM
	# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
	#else
	# define FMT_SYSTEM(call) call
	# ifdef _WIN32
	// Fix warnings about deprecated symbols.
	#  define FMT_POSIX_CALL(call) ::_##call
	# else
	#  define FMT_POSIX_CALL(call) ::call
	# endif
	#endif
	
	#if FMT_GCC_VERSION >= 407
	# define FMT_UNUSED __attribute__((unused))
	#else
	# define FMT_UNUSED
	#endif
	
	#ifndef FMT_USE_STATIC_ASSERT
	# define FMT_USE_STATIC_ASSERT 0
	#endif
	
	#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \
	  (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600
	# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message)
	#else
	# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b)
	# define FMT_STATIC_ASSERT(cond, message) \
	  typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
	#endif
	
	// Retries the expression while it evaluates to error_result and errno
	// equals to EINTR.
	#ifndef _WIN32
	# define FMT_RETRY_VAL(result, expression, error_result) \
	  do { \
	    result = (expression); \
	  } while (result == error_result && errno == EINTR)
	#else
	# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
	#endif
	
	#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
	
	namespace fmt {
	
	// An error code.
	class ErrorCode {
	 private:
	  int value_;
	
	 public:
	  explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {}
	
	  int get() const FMT_NOEXCEPT { return value_; }
	};
	
	// A buffered file.
	class BufferedFile {
	 private:
	  FILE *file_;
	
	  friend class File;
	
	  explicit BufferedFile(FILE *f) : file_(f) {}
	
	 public:
	  // Constructs a BufferedFile object which doesn't represent any file.
	  BufferedFile() FMT_NOEXCEPT : file_(0) {}
	
	  // Destroys the object closing the file it represents if any.
	  ~BufferedFile() FMT_NOEXCEPT;
	
	#if !FMT_USE_RVALUE_REFERENCES
	  // Emulate a move constructor and a move assignment operator if rvalue
	  // references are not supported.
	
	 private:
	  // A proxy object to emulate a move constructor.
	  // It is private to make it impossible call operator Proxy directly.
	  struct Proxy {
	    FILE *file;
	  };
	
	public:
	  // A "move constructor" for moving from a temporary.
	  BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
	
	  // A "move constructor" for moving from an lvalue.
	  BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) {
	    f.file_ = 0;
	  }
	
	  // A "move assignment operator" for moving from a temporary.
	  BufferedFile &operator=(Proxy p) {
	    close();
	    file_ = p.file;
	    return *this;
	  }
	
	  // A "move assignment operator" for moving from an lvalue.
	  BufferedFile &operator=(BufferedFile &other) {
	    close();
	    file_ = other.file_;
	    other.file_ = 0;
	    return *this;
	  }
	
	  // Returns a proxy object for moving from a temporary:
	  //   BufferedFile file = BufferedFile(...);
	  operator Proxy() FMT_NOEXCEPT {
	    Proxy p = {file_};
	    file_ = 0;
	    return p;
	  }
	
	#else
	 private:
	  FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);
	
	 public:
	  BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) {
	    other.file_ = 0;
	  }
	
	  BufferedFile& operator=(BufferedFile &&other) {
	    close();
	    file_ = other.file_;
	    other.file_ = 0;
	    return *this;
	  }
	#endif
	
	  // Opens a file.
	  BufferedFile(CStringRef filename, CStringRef mode);
	
	  // Closes the file.
	  void close();
	
	  // Returns the pointer to a FILE object representing this file.
	  FILE *get() const FMT_NOEXCEPT { return file_; }
	
	  // We place parentheses around fileno to workaround a bug in some versions
	  // of MinGW that define fileno as a macro.
	  int (fileno)() const;
	
	  void print(CStringRef format_str, const ArgList &args) {
	    fmt::print(file_, format_str, args);
	  }
	  FMT_VARIADIC(void, print, CStringRef)
	};
	
	// A file. Closed file is represented by a File object with descriptor -1.
	// Methods that are not declared with FMT_NOEXCEPT may throw
	// fmt::SystemError in case of failure. Note that some errors such as
	// closing the file multiple times will cause a crash on Windows rather
	// than an exception. You can get standard behavior by overriding the
	// invalid parameter handler with _set_invalid_parameter_handler.
	class File {
	 private:
	  int fd_;  // File descriptor.
	
	  // Constructs a File object with a given descriptor.
	  explicit File(int fd) : fd_(fd) {}
	
	 public:
	  // Possible values for the oflag argument to the constructor.
	  enum {
	    RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
	    WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
	    RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
	  };
	
	  // Constructs a File object which doesn't represent any file.
	  File() FMT_NOEXCEPT : fd_(-1) {}
	
	  // Opens a file and constructs a File object representing this file.
	  File(CStringRef path, int oflag);
	
	#if !FMT_USE_RVALUE_REFERENCES
	  // Emulate a move constructor and a move assignment operator if rvalue
	  // references are not supported.
	
	 private:
	  // A proxy object to emulate a move constructor.
	  // It is private to make it impossible call operator Proxy directly.
	  struct Proxy {
	    int fd;
	  };
	
	 public:
	  // A "move constructor" for moving from a temporary.
	  File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}
	
	  // A "move constructor" for moving from an lvalue.
	  File(File &other) FMT_NOEXCEPT : fd_(other.fd_) {
	    other.fd_ = -1;
	  }
	
	  // A "move assignment operator" for moving from a temporary.
	  File &operator=(Proxy p) {
	    close();
	    fd_ = p.fd;
	    return *this;
	  }
	
	  // A "move assignment operator" for moving from an lvalue.
	  File &operator=(File &other) {
	    close();
	    fd_ = other.fd_;
	    other.fd_ = -1;
	    return *this;
	  }
	
	  // Returns a proxy object for moving from a temporary:
	  //   File file = File(...);
	  operator Proxy() FMT_NOEXCEPT {
	    Proxy p = {fd_};
	    fd_ = -1;
	    return p;
	  }
	
	#else
	 private:
	  FMT_DISALLOW_COPY_AND_ASSIGN(File);
	
	 public:
	  File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) {
	    other.fd_ = -1;
	  }
	
	  File& operator=(File &&other) {
	    close();

	    fd_ = other.fd_;
	    other.fd_ = -1;
	    return *this;
	  }
	#endif
	
	  // Destroys the object closing the file it represents if any.
	  ~File() FMT_NOEXCEPT;
	
	  // Returns the file descriptor.
	  int descriptor() const FMT_NOEXCEPT { return fd_; }
	
	  // Closes the file.
	  void close();
	
	  // Returns the file size. The size has signed type for consistency with
	  // stat::st_size.
	  LongLong size() const;
	
	  // Attempts to read count bytes from the file into the specified buffer.
	  std::size_t read(void *buffer, std::size_t count);
	
	  // Attempts to write count bytes from the specified buffer to the file.
	  std::size_t write(const void *buffer, std::size_t count);
	
	  // Duplicates a file descriptor with the dup function and returns
	  // the duplicate as a file object.
	  static File dup(int fd);
	
	  // Makes fd be the copy of this file descriptor, closing fd first if
	  // necessary.
	  void dup2(int fd);
	
	  // Makes fd be the copy of this file descriptor, closing fd first if
	  // necessary.
	  void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT;
	
	  // Creates a pipe setting up read_end and write_end file objects for reading
	  // and writing respectively.
	  static void pipe(File &read_end, File &write_end);
	
	  // Creates a BufferedFile object associated with this file and detaches
	  // this File object from the file.
	  BufferedFile fdopen(const char *mode);
	};
	
	// Returns the memory page size.
	long getpagesize();
	
	#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
	    !defined(__ANDROID__) && !defined(__CYGWIN__)
	# define FMT_LOCALE
	#endif
	
	#ifdef FMT_LOCALE
	// A "C" numeric locale.
	class Locale {
	 private:
	# ifdef _MSC_VER
	  typedef _locale_t locale_t;
	
	  enum { LC_NUMERIC_MASK = LC_NUMERIC };
	
	  static locale_t newlocale(int category_mask, const char *locale, locale_t) {
	    return _create_locale(category_mask, locale);
	  }
	
	  static void freelocale(locale_t locale) {
	    _free_locale(locale);
	  }
	
	  static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
	    return _strtod_l(nptr, endptr, locale);
	  }
	# endif
	
	  locale_t locale_;
	
	  FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
	
	 public:
	  typedef locale_t Type;
	
	  Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", NULL)) {
	    if (!locale_)
	      FMT_THROW(fmt::SystemError(errno, "cannot create locale"));
	  }
	  ~Locale() { freelocale(locale_); }
	
	  Type get() const { return locale_; }
	
	  // Converts string to floating-point number and advances str past the end
	  // of the parsed input.
	  double strtod(const char *&str) const {
	    char *end = 0;
	    double result = strtod_l(str, &end, locale_);
	    str = end;
	    return result;
	  }
	};
	#endif  // FMT_LOCALE
	}  // namespace fmt
	
	#if !FMT_USE_RVALUE_REFERENCES
	namespace std {
	// For compatibility with C++98.
	inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; }
	inline fmt::File &move(fmt::File &f) { return f; }
	}
	#endif
	
	#endif  // FMT_POSIX_H_