+  :utf-8

+	;; unix-namestring converts "." to "".  Convert it back to

+	;; "." so we can stat the current directory.  (Perhaps

+	;; that's a bug in unix-namestring?)

+	(when (zerop (length name))

+	  (setf name "."))

+	(let (author)

+	  (unwind-protect

+	       (progn

+		 (setf author (alien:alien-funcall

+			       (alien:extern-alien "os_file_author"

+						   (function (alien:* c-call:c-string) c-call:c-string))

+			       (unix::%name->file name)))

+		 (unless (alien:null-alien author)

+		   (alien:cast author c-call:c-string)))

+	    (alien:free-alien author))))))

+    * The default external format is `:utf-8` instead of `:iso8859-1`

+    * #139 `*default-external-format*` defaults to `:utf-8`

+#include <assert.h>

+#include <pwd.h>

+#include <stdlib.h>

+#include <unistd.h>

+

+/*

+ * Interface for file-author.  Given a pathname, returns a new string

+ * holding the author of the file or NULL if some error occurred.  The

+ * caller is responsible for freeing the memory used by the string.

+ */

+char *

+os_file_author(const char *path)

+{

+    struct stat sb;

+    char initial[1024];

+    char *buffer, *obuffer;

+    size_t size;

+    struct passwd pwd;

+    struct passwd *ppwd;

+    char *result;

+

+    if (stat(path, &sb) != 0) {

+        return NULL;

+    }

+

+    result = NULL;

+    buffer = initial;

+    obuffer = NULL;

+    size = sizeof(initial) / sizeof(initial[0]);

+

+    /*

+     * Keep trying with larger buffers until a maximum is reached.  We

+     * assume (1 << 20) is large enough for any OS.

+     */

+    while (size <= (1 << 20)) {

+        switch (getpwuid_r(sb.st_uid, &pwd, buffer, size, &ppwd)) {

+          case 0:

+              /* Success, though we might not have a matching entry */

+              result = (ppwd == NULL) ? NULL : strdup(pwd.pw_name);

+              goto exit;

+          case ERANGE:

+              /* Buffer is too small, double its size and try again */

+              size *= 2;

+              obuffer = (buffer == initial) ? NULL : buffer;

+              if ((buffer = realloc(obuffer, size)) == NULL) {

+                  goto exit;

+              }

+              continue;

+          default:

+              /* All other errors */

+              goto exit;

+        }

+    }

+exit:

+    free(obuffer);

+    

+    return result;

+}

+(defmethod stream-line-column ((stream fundamental-character-output-stream))

+  nil)

+

+/out-utf8.txt

+(defparameter *test-path*

+  (merge-pathnames (make-pathname :name :unspecific :type :unspecific

+                                  :version :unspecific)

+                   *load-truename*)

+  "Path to where this file is.")

+

+(define-test issue.130

+    (:tag :issues)

+  ;; Just verify that file-author works.  In particular "." should

+  ;; work and not return NIL.

+  (assert-true (file-author "."))

+  (assert-true (file-author "bin/build.sh"))

+  (let ((unix::*filename-encoding* :utf-8))

+    ;; Set filename encoding to utf-8 so that we can encode the

+    ;; filename properly.

+    (assert-true

+   (file-author

+    (merge-pathnames 

+     (concatenate 'string

+		  ;; Write the test file name this way so

+		  ;; that it's independent of the encoding

+		  ;; used to load this file.  The name is

+		  ;; "안녕하십니까".

+		  '(#\Hangul_Syllable_An #\Hangul_Syllable_Nyeong #\Hangul_Syllable_Ha

+		    #\Hangul_Syllable_Sib #\Hangul_Syllable_Ni #\Hangul_Syllable_Gga)

+		  ".txt")

+     *test-path*)))))

+

+(define-test issue.139-default-external-format

+    (:tag :issues)

+  (assert-eq :utf-8 stream:*default-external-format*))

+

+(define-test issue.139-default-external-format-read-file

+    (:tag :issues)

+  (let ((string (concatenate 'string

+			     ;; This is "hello" in Korean

+			     '(#\Hangul_syllable_an

+			       #\Hangul_Syllable_Nyeong

+			       #\Hangul_Syllable_Ha

+			       #\Hangul_Syllable_Se

+			       #\Hangul_Syllable_Yo))))

+    ;; Test that opening a file for reading uses the the default :utf8

+    ;; encoding.

+    (with-open-file (s (merge-pathnames "utf8.txt"

+					*test-path*)

+		       :direction :input)

+      ;; The first line should be "hello" in Hangul.

+      (assert-equal (map 'list #'char-name string)

+		    (map 'list #'char-name (read-line s))))))

+

+(define-test issue.139-default-external-format-write-file

+    (:tag :issues)

+  ;; Test that opening a file for writing uses the default :utf8.

+  ;; First write something out to the file.  Then read it back in

+  ;; using an explicit format of utf8 and verifying that we got the

+  ;; right contents.

+  (let ((string (concatenate 'string

+			     ;; This is "hello" in Korean

+			     '(#\Hangul_syllable_an

+			       #\Hangul_Syllable_Nyeong

+			       #\Hangul_Syllable_Ha

+			       #\Hangul_Syllable_Se

+			       #\Hangul_Syllable_Yo))))

+    (with-open-file (s (merge-pathnames "out-utf8.txt"

+					*test-path*)

+		       :direction :output

+		       :if-exists :supersede)

+      (write-line string s))

+    (with-open-file (s (merge-pathnames "out-utf8.txt"

+					*test-path*)

+		       :direction :input

+		       :external-format :utf-8)

+      (assert-equal (map 'list #'char-name string)

+		    (map 'list #'char-name (read-line s))))))

+  

+안녕하세요

+UTF8 test.  The above line is "Hello" in Hangul.

+The file name of this file is "안녕하십니까.txt" ("Hello" in Korean.)

+

+