src/strio.c

   1 #include "charset.h"
   2 #include "magic.h"
   3 #include "stream.h"
   4 #include <errno.h>
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <glib.h>
   8 #include <glib/gstdio.h>
   9
  10 /*
  11  *
  12  **************** WRITING FUNCTIONS ********************************************
  13  *
  14  */
  15
  16 /* Internal function: write a UTF-8 string to a text grid window's text buffer. */
  17 static void
  18 write_utf8_to_grid(winid_t win, gchar *s)
  19 {
  20         if(win->input_request_type == INPUT_REQUEST_LINE || win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
  21         {
  22                 ILLEGAL("Tried to print to a text grid window with line input pending.");
  23                 return;
  24         }
  25
  26     /* Number of characters to insert */
  27     glong length = g_utf8_strlen(s, -1);
  28     glong chars_left = length;
  29
  30     gdk_threads_enter();
  31
  32     GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
  33     GtkTextMark *cursor = gtk_text_buffer_get_mark(buffer, "cursor_position");
  34
  35     /* Get cursor position */
  36     GtkTextIter start;
  37     gtk_text_buffer_get_iter_at_mark(buffer, &start, cursor);
  38     /* Spaces available on this line */
  39     gint available_space = win->width - gtk_text_iter_get_line_offset(&start);
  40
  41     while(chars_left > available_space && !gtk_text_iter_is_end(&start))
  42     {
  43         GtkTextIter end = start;
  44         gtk_text_iter_forward_to_line_end(&end);
  45         gtk_text_buffer_delete(buffer, &start, &end);
  46         gtk_text_buffer_insert(buffer, &start, s + (length - chars_left), available_space);
  47         chars_left -= available_space;
  48         gtk_text_iter_forward_line(&start);
  49         available_space = win->width;
  50     }
  51     if(!gtk_text_iter_is_end(&start))
  52     {
  53         GtkTextIter end = start;
  54         gtk_text_iter_forward_chars(&end, chars_left);
  55         gtk_text_buffer_delete(buffer, &start, &end);
  56         gtk_text_buffer_insert(buffer, &start, s + (length - chars_left), -1);
  57     }
  58
  59     gtk_text_buffer_move_mark(buffer, cursor, &start);
  60
  61     gdk_threads_leave();
  62 }
  63
  64 /* Internal function: write a UTF-8 string to a text buffer window's text buffer. */
  65 static void
  66 write_utf8_to_window(winid_t win, gchar *s)
  67 {
  68         if(win->input_request_type == INPUT_REQUEST_LINE || win->input_request_type == INPUT_REQUEST_LINE_UNICODE)
  69         {
  70                 ILLEGAL("Tried to print to a text buffer window with line input pending.");
  71                 return;
  72         }
  73
  74         gdk_threads_enter();
  75
  76         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
  77
  78         GtkTextIter iter;
  79         gtk_text_buffer_get_end_iter(buffer, &iter);
  80         gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, s, -1, win->window_stream->style, NULL);
  81
  82         gdk_threads_leave();
  83 }
  84
  85 /* Internal function: write a Latin-1 buffer with length to a stream. */
  86 static void
  87 write_buffer_to_stream(strid_t str, gchar *buf, glui32 len)
  88 {
  89         switch(str->type)
  90         {
  91                 case STREAM_TYPE_WINDOW:
  92                         /* Each window type has a different way of printing to it */
  93                         switch(str->window->type)
  94                         {
  95                                 /* Printing to these windows' streams does nothing */
  96                                 case wintype_Blank:
  97                                 case wintype_Pair:
  98                                 case wintype_Graphics:
  99                                         str->write_count += len;
 100                                         break;
 101
 102                             /* Text grid window */
 103                             case wintype_TextGrid:
 104                             {
 105                                 gchar *utf8 = convert_latin1_to_utf8(buf, len);
 106                                 if(utf8 != NULL)
 107                                 {
 108                                     /* FIXME: What to do if string contains \n? Split the input string at newlines and write each string separately? */
 109                                     write_utf8_to_grid(str->window, utf8);
 110                                     g_free(utf8);
 111                                 }
 112                             }
 113                                 str->write_count += len;
 114                                 break;
 115
 116                                 /* Text buffer window */
 117                                 case wintype_TextBuffer:
 118                                 {
 119                                         gchar *utf8 = convert_latin1_to_utf8(buf, len);
 120                                         if(utf8 != NULL)
 121                                         {
 122                                                 write_utf8_to_window(str->window, utf8);
 123                                                 g_free(utf8);
 124                                         }
 125                                 }
 126                                         str->write_count += len;
 127                                         break;
 128                                 default:
 129                                         ILLEGAL_PARAM("Unknown window type: %u", str->window->type);
 130                         }
 131
 132                         /* Now write the same buffer to the window's echo stream */
 133                         if(str->window->echo_stream != NULL)
 134                                 write_buffer_to_stream(str->window->echo_stream, buf, len);
 135
 136                         break;
 137
 138                 case STREAM_TYPE_MEMORY:
 139                         if(str->unicode && str->ubuffer)
 140                         {
 141                                 int foo = 0;
 142                                 while(str->mark < str->buflen && foo < len)
 143                                         str->ubuffer[str->mark++] = (unsigned char)buf[foo++];
 144                         }
 145                         if(!str->unicode && str->buffer)
 146                         {
 147                                 int copycount = MIN(len, str->buflen - str->mark);
 148                                 memmove(str->buffer + str->mark, buf, copycount);
 149                                 str->mark += copycount;
 150                         }
 151
 152                         str->write_count += len;
 153                         break;
 154
 155                 case STREAM_TYPE_FILE:
 156                         if(str->binary)
 157                         {
 158                                 if(str->unicode)
 159                                 {
 160                                         gchar *writebuffer = convert_latin1_to_ucs4be_string(buf, len);
 161                                         fwrite(writebuffer, sizeof(gchar), len * 4, str->file_pointer);
 162                                         g_free(writebuffer);
 163                                 }
 164                                 else /* Regular file */
 165                                 {
 166                                         fwrite(buf, sizeof(gchar), len, str->file_pointer);
 167                                 }
 168                         }
 169                         else /* Text mode is the same for Unicode and regular files */
 170                         {
 171                                 gchar *utf8 = convert_latin1_to_utf8(buf, len);
 172                                 if(utf8 != NULL)
 173                                 {
 174                                         g_fprintf(str->file_pointer, "%s", utf8);
 175                                         g_free(utf8);
 176                                 }
 177                         }
 178
 179                         str->write_count += len;
 180                         break;
 181                 default:
 182                         ILLEGAL_PARAM("Unknown stream type: %u", str->type);
 183         }
 184 }
 185
 186 /* Internal function: write a Unicode buffer with length to a stream. */
 187 static void
 188 write_buffer_to_stream_uni(strid_t str, glui32 *buf, glui32 len)
 189 {
 190         switch(str->type)
 191         {
 192                 case STREAM_TYPE_WINDOW:
 193                         /* Each window type has a different way of printing to it */
 194                         switch(str->window->type)
 195                         {
 196                                 /* Printing to these windows' streams does nothing */
 197                                 case wintype_Blank:
 198                                 case wintype_Pair:
 199                                 case wintype_Graphics:
 200                                         str->write_count += len;
 201                                         break;
 202
 203                             /* Text grid window */
 204                             case wintype_TextGrid:
 205                             {
 206                                 gchar *utf8 = convert_ucs4_to_utf8(buf, len);
 207                                 if(utf8 != NULL)
 208                                 {
 209                                     /* FIXME: What to do if string contains \n? Split the input string at newlines and write each string separately? */
 210                                     write_utf8_to_grid(str->window, utf8);
 211                                     g_free(utf8);
 212                                 }
 213                             }
 214                                 str->write_count += len;
 215                                 break;
 216
 217                                 /* Text buffer window */
 218                                 case wintype_TextBuffer:
 219                                 {
 220                                         gchar *utf8 = convert_ucs4_to_utf8(buf, len);
 221                                         if(utf8 != NULL)
 222                                         {
 223                                                 write_utf8_to_window(str->window, utf8);
 224                                                 g_free(utf8);
 225                                         }
 226                                 }
 227                                         str->write_count += len;
 228                                         break;
 229                                 default:
 230                                         ILLEGAL_PARAM("Unknown window type: %u", str->window->type);
 231                         }
 232
 233                         /* Now write the same buffer to the window's echo stream */
 234                         if(str->window->echo_stream != NULL)
 235                                 write_buffer_to_stream_uni(str->window->echo_stream, buf, len);
 236
 237                         break;
 238
 239                 case STREAM_TYPE_MEMORY:
 240                         if(str->unicode && str->ubuffer)
 241                         {
 242                                 int copycount = MIN(len, str->buflen - str->mark);
 243                                 memmove(str->ubuffer + str->mark, buf, copycount * sizeof(glui32));
 244                                 str->mark += copycount;
 245                         }
 246                         if(!str->unicode && str->buffer)
 247                         {
 248                                 gchar *latin1 = convert_ucs4_to_latin1_binary(buf, len);
 249                                 int copycount = MIN(len, str->buflen - str->mark);
 250                                 memmove(str->buffer + str->mark, latin1, copycount);
 251                                 g_free(latin1);
 252                                 str->mark += copycount;
 253                         }
 254
 255                         str->write_count += len;
 256                         break;
 257
 258                 case STREAM_TYPE_FILE:
 259                         if(str->binary)
 260                         {
 261                                 if(str->unicode)
 262                                 {
 263                                         gchar *writebuffer = convert_ucs4_to_ucs4be_string(buf, len);
 264                                         fwrite(writebuffer, sizeof(gchar), len * 4, str->file_pointer);
 265                                         g_free(writebuffer);
 266                                 }
 267                                 else /* Regular file */
 268                                 {
 269                                         gchar *latin1 = convert_ucs4_to_latin1_binary(buf, len);
 270                                         fwrite(latin1, sizeof(gchar), len, str->file_pointer);
 271                                         g_free(latin1);
 272                                 }
 273                         }
 274                         else /* Text mode is the same for Unicode and regular files */
 275                         {
 276                                 gchar *utf8 = convert_ucs4_to_utf8(buf, len);
 277                                 if(utf8 != NULL)
 278                                 {
 279                                         g_fprintf(str->file_pointer, "%s", utf8);
 280                                         g_free(utf8);
 281                                 }
 282                         }
 283
 284                         str->write_count += len;
 285                         break;
 286                 default:
 287                         ILLEGAL_PARAM("Unknown stream type: %u", str->type);
 288         }
 289 }
 290
 291 /**
 292  * glk_put_char_stream:
 293  * @str: An output stream.
 294  * @ch: A character in Latin-1 encoding.
 295  *
 296  * The same as glk_put_char(), except that you specify a stream @str to print
 297  * to, instead of using the current stream. It is illegal for @str to be %NULL,
 298  * or an input-only stream.
 299  */
 300 void
 301 glk_put_char_stream(strid_t str, unsigned char ch)
 302 {
 303         VALID_STREAM(str, return);
 304         g_return_if_fail(str->file_mode != filemode_Read);
 305
 306         write_buffer_to_stream(str, (gchar *)&ch, 1);
 307 }
 308
 309 /**
 310  * glk_put_char_stream_uni:
 311  * @str: An output stream.
 312  * @ch: A Unicode code point.
 313  *
 314  * The same as glk_put_char_uni(), except that you specify a stream @str to
 315  * print to, instead of using the current stream. It is illegal for @str to be
 316  * %NULL, or an input-only stream.
 317  */
 318 void
 319 glk_put_char_stream_uni(strid_t str, glui32 ch)
 320 {
 321         VALID_STREAM(str, return);
 322         g_return_if_fail(str->file_mode != filemode_Read);
 323
 324         write_buffer_to_stream_uni(str, &ch, 1);
 325 }
 326
 327 /**
 328  * glk_put_string_stream:
 329  * @str: An output stream.
 330  * @s: A null-terminated string in Latin-1 encoding.
 331  *
 332  * The same as glk_put_string(), except that you specify a stream @str to print
 333  * to, instead of using the current stream. It is illegal for @str to be %NULL,
 334  * or an input-only stream.
 335  */
 336 void
 337 glk_put_string_stream(strid_t str, char *s)
 338 {
 339         VALID_STREAM(str, return);
 340         g_return_if_fail(str->file_mode != filemode_Read);
 341
 342         write_buffer_to_stream(str, s, strlen(s));
 343 }
 344
 345 /**
 346  * glk_put_string_stream_uni:
 347  * @str: An output stream.
 348  * @s: A null-terminated array of Unicode code points.
 349  *
 350  * The same as glk_put_string_uni(), except that you specify a stream @str to
 351  * print to, instead of using the current stream. It is illegal for @str to be
 352  * %NULL, or an input-only stream.
 353  */
 354 void
 355 glk_put_string_stream_uni(strid_t str, glui32 *s)
 356 {
 357         VALID_STREAM(str, return);
 358         g_return_if_fail(str->file_mode != filemode_Read);
 359
 360         /* An impromptu strlen() for glui32 arrays */
 361         glong len = 0;
 362         glui32 *ptr = s;
 363         while(*ptr++)
 364                 len++;
 365         write_buffer_to_stream_uni(str, s, len);
 366 }
 367
 368 /**
 369  * glk_put_buffer_stream:
 370  * @str: An output stream.
 371  * @buf: An array of characters in Latin-1 encoding.
 372  * @len: Length of @buf.
 373  *
 374  * The same as glk_put_buffer(), except that you specify a stream @str to print
 375  * to, instead of using the current stream. It is illegal for @str to be %NULL,
 376  * or an input-only stream.
 377  */
 378 void
 379 glk_put_buffer_stream(strid_t str, char *buf, glui32 len)
 380 {
 381         VALID_STREAM(str, return);
 382         g_return_if_fail(str->file_mode != filemode_Read);
 383
 384         write_buffer_to_stream(str, buf, len);
 385 }
 386
 387 /**
 388  * glk_put_buffer_stream_uni:
 389  * @str: An output stream.
 390  * @buf: An array of Unicode code points.
 391  * @len: Length of @buf.
 392  *
 393  * The same as glk_put_buffer_uni(), except that you specify a stream @str to
 394  * print to, instead of using the current stream. It is illegal for @str to be
 395  * %NULL, or an input-only stream.
 396  */
 397 void
 398 glk_put_buffer_stream_uni(strid_t str, glui32 *buf, glui32 len)
 399 {
 400         VALID_STREAM(str, return);
 401         g_return_if_fail(str->file_mode != filemode_Read);
 402
 403         write_buffer_to_stream_uni(str, buf, len);
 404 }
 405
 406 /*
 407  *
 408  **************** READING FUNCTIONS ********************************************
 409  *
 410  */
 411
 412 /* Internal function: Read one big-endian four-byte character from file fp and
 413 return it as a Unicode code point, or -1 on EOF */
 414 static glsi32
 415 read_ucs4be_char_from_file(FILE *fp)
 416 {
 417         unsigned char readbuffer[4];
 418         if(fread(readbuffer, sizeof(unsigned char), 4, fp) < 4)
 419                 return -1; /* EOF */
 420         return
 421                 readbuffer[0] << 24 |
 422                 readbuffer[1] << 16 |
 423                 readbuffer[2] << 8  |
 424                 readbuffer[3];
 425 }
 426
 427 /* Internal function: Read one UTF-8 character, which may be more than one byte,
 428 from file fp and return it as a Unicode code point, or -1 on EOF */
 429 static glsi32
 430 read_utf8_char_from_file(FILE *fp)
 431 {
 432         gchar readbuffer[4] = {0, 0, 0, 0}; /* Max UTF-8 width */
 433         int foo;
 434         gunichar charresult = (gunichar)-2;
 435         for(foo = 0; foo < 4 && charresult == (gunichar)-2; foo++)
 436         {
 437                 int ch = fgetc(fp);
 438                 if(ch == EOF)
 439                         return -1;
 440                 readbuffer[foo] = (gchar)ch;
 441                 charresult = g_utf8_get_char_validated(readbuffer, foo + 1);
 442                 /* charresult is -1 if invalid, -2 if incomplete, and the unicode code
 443                 point otherwise */
 444         }
 445         /* Silently return unknown characters as 0xFFFD, Replacement Character */
 446         if(charresult == (gunichar)-1 || charresult == (gunichar)-2)
 447                 return 0xFFFD;
 448         return charresult;
 449 }
 450
 451 /* Internal function: Tell whether this code point is a Unicode newline. The
 452 file pointer and eight-bit flag are included in case the newline is a CR
 453 (U+000D). If the next character is LF (U+000A) then it also belongs to the
 454 newline. */
 455 static gboolean
 456 is_unicode_newline(glsi32 ch, FILE *fp, gboolean utf8)
 457 {
 458         if(ch == 0x0A || ch == 0x85 || ch == 0x0C || ch == 0x2028 || ch == 0x2029)
 459                 return TRUE;
 460         if(ch == 0x0D) {
 461                 glsi32 ch2 = utf8? read_utf8_char_from_file(fp) :
 462                         read_ucs4be_char_from_file(fp);
 463                 if(ch2 != 0x0A)
 464                         if(fseek(fp, utf8? -1 : -4, SEEK_CUR) == -1);
 465                                 WARNING_S("Seek failed on stream", g_strerror(errno) );
 466                 return TRUE;
 467         }
 468         return FALSE;
 469 }
 470
 471 /* Internal function: Read one character from a stream. Returns a value which
 472  can be returned unchanged by glk_get_char_stream_uni(), but
 473  glk_get_char_stream() must replace high values by the placeholder character. */
 474 static glsi32
 475 get_char_stream_common(strid_t str)
 476 {
 477         switch(str->type)
 478         {
 479                 case STREAM_TYPE_MEMORY:
 480                         if(str->unicode)
 481                         {
 482                                 if(!str->ubuffer || str->mark >= str->buflen)
 483                                         return -1;
 484                                 glui32 ch = str->ubuffer[str->mark++];
 485                                 str->read_count++;
 486                                 return ch;
 487                         }
 488                         else
 489                         {
 490                                 if(!str->buffer || str->mark >= str->buflen)
 491                                         return -1;
 492                                 unsigned char ch = str->buffer[str->mark++];
 493                                 str->read_count++;
 494                                 return ch;
 495                         }
 496                         break;
 497
 498                 case STREAM_TYPE_FILE:
 499                         if(str->binary)
 500                         {
 501                                 if(str->unicode)
 502                                 {
 503                                         glsi32 ch = read_ucs4be_char_from_file(str->file_pointer);
 504                                         if(ch == -1)
 505                                                 return -1;
 506                                         str->read_count++;
 507                                         return ch;
 508                                 }
 509                                 else /* Regular file */
 510                                 {
 511                                         int ch = fgetc(str->file_pointer);
 512                                         if(ch == EOF)
 513                                                 return -1;
 514
 515                                         str->read_count++;
 516                                         return ch;
 517                                 }
 518                         }
 519                         else /* Text mode is the same for Unicode and regular files */
 520                         {
 521                                 glsi32 ch = read_utf8_char_from_file(str->file_pointer);
 522                                 if(ch == -1)
 523                                         return -1;
 524
 525                                 str->read_count++;
 526                                 return ch;
 527                         }
 528                 default:
 529                         ILLEGAL_PARAM("Reading illegal on stream type: %u", str->type);
 530                         return -1;
 531         }
 532 }
 533
 534 /**
 535  * glk_get_char_stream:
 536  * @str: An input stream.
 537  *
 538  * Reads one character from the stream @str. (There is no notion of a
 539  * <quote>current input stream.</quote>) It is illegal for @str to be %NULL, or
 540  * an output-only stream.
 541  *
 542  * The result will be between 0 and 255. As with all basic text functions, Glk
 543  * assumes the Latin-1 encoding. See <link
 544  * linkend="chimara-Character-Encoding">Character Encoding</link>. If the end
 545  * of the stream has been reached, the result will be -1.
 546  *
 547  * <note><para>
 548  *   Note that high-bit characters (128..255) are <emphasis>not</emphasis>
 549  *   returned as negative numbers.
 550  * </para></note>
 551  *
 552  * If the stream contains Unicode data &mdash; for example, if it was created
 553  * with glk_stream_open_file_uni() or glk_stream_open_memory_uni() &mdash; then
 554  * characters beyond 255 will be returned as 0x3F (<code>"?"</code>).
 555  *
 556  * It is usually more efficient to read several characters at once with
 557  * glk_get_buffer_stream() or glk_get_line_stream(), as opposed to calling
 558  * glk_get_char_stream() several times.
 559  *
 560  * Returns: A character value between 0 and 255, or -1 on end of stream.
 561  */
 562 glsi32
 563 glk_get_char_stream(strid_t str)
 564 {
 565         VALID_STREAM(str, return -1);
 566         g_return_val_if_fail(str->file_mode == filemode_Read || str->file_mode == filemode_ReadWrite, -1);
 567
 568         glsi32 ch = get_char_stream_common(str);
 569         return (ch > 0xFF)? PLACEHOLDER : ch;
 570 }
 571
 572 /**
 573  * glk_get_char_stream_uni:
 574  * @str: An input stream.
 575  *
 576  * Reads one character from the stream @str. The result will be between 0 and
 577  * 0x7FFFFFFF. If the end of the stream has been reached, the result will be -1.
 578  *
 579  * Returns: A value between 0 and 0x7FFFFFFF, or -1 on end of stream.
 580  */
 581 glsi32
 582 glk_get_char_stream_uni(strid_t str)
 583 {
 584         VALID_STREAM(str, return -1);
 585         g_return_val_if_fail(str->file_mode == filemode_Read || str->file_mode == filemode_ReadWrite, -1);
 586
 587         return get_char_stream_common(str);
 588 }
 589
 590 /**
 591  * glk_get_buffer_stream:
 592  * @str: An input stream.
 593  * @buf: A buffer with space for at least @len characters.
 594  * @len: The number of characters to read.
 595  *
 596  * Reads @len characters from @str, unless the end of stream is reached first.
 597  * No terminal null is placed in the buffer.
 598  *
 599  * Returns: The number of characters actually read.
 600  */
 601 glui32
 602 glk_get_buffer_stream(strid_t str, char *buf, glui32 len)
 603 {
 604         VALID_STREAM(str, return 0);
 605         g_return_val_if_fail(str->file_mode == filemode_Read || str->file_mode == filemode_ReadWrite, 0);
 606         g_return_val_if_fail(buf != NULL, 0);
 607
 608         switch(str->type)
 609         {
 610                 case STREAM_TYPE_MEMORY:
 611                 {
 612                         int copycount = 0;
 613                         if(str->unicode)
 614                         {
 615                                 while(copycount < len && str->ubuffer && str->mark < str->buflen)
 616                                 {
 617                                         glui32 ch = str->ubuffer[str->mark++];
 618                                         buf[copycount++] = (ch > 0xFF)? '?' : (char)ch;
 619                                 }
 620                         }
 621                         else
 622                         {
 623                                 if(str->buffer) /* if not, copycount stays 0 */
 624                                         copycount = MIN(len, str->buflen - str->mark);
 625                                 memmove(buf, str->buffer + str->mark, copycount);
 626                                 str->mark += copycount;
 627                         }
 628
 629                         str->read_count += copycount;
 630                         return copycount;
 631                 }
 632                 case STREAM_TYPE_FILE:
 633                         if(str->binary)
 634                         {
 635                                 if(str->unicode) /* Binary file with 4-byte characters */
 636                                 {
 637                                         /* Read len characters of 4 bytes each */
 638                                         unsigned char *readbuffer = g_new0(unsigned char, 4 * len);
 639                                         size_t count = fread(readbuffer, sizeof(unsigned char), 4 * len, str->file_pointer);
 640                                         /* If there was an incomplete character */
 641                                         if(count % 4 != 0)
 642                                         {
 643                                                 count -= count % 4;
 644                                                 WARNING("Incomplete character in binary Unicode file");
 645                                         }
 646
 647                                         int foo;
 648                                         for(foo = 0; foo < count; foo += 4)
 649                                         {
 650                                                 glsi32 ch = readbuffer[foo] << 24
 651                                                         | readbuffer[foo + 1] << 16
 652                                                         | readbuffer[foo + 2] << 8
 653                                                         | readbuffer[foo + 3];
 654                                                 buf[foo / 4] = (ch > 255)? 0x3F : (char)ch;
 655                                         }
 656                                         g_free(readbuffer);
 657                                         str->read_count += count / 4;
 658                                         return count / 4;
 659                                 }
 660                                 else /* Regular binary file */
 661                                 {
 662                                         size_t count = fread(buf, sizeof(char), len, str->file_pointer);
 663                                         str->read_count += count;
 664                                         return count;
 665                                 }
 666                         }
 667                         else /* Text mode is the same for Unicode and regular files */
 668                         {
 669                                 /* Do it character-by-character */
 670                                 int foo;
 671                                 for(foo = 0; foo < len; foo++)
 672                                 {
 673                                         glsi32 ch = read_utf8_char_from_file(str->file_pointer);
 674                                         if(ch == -1)
 675                                                 break;
 676                                         str->read_count++;
 677                                         buf[foo] = (ch > 0xFF)? 0x3F : (gchar)ch;
 678                                 }
 679                                 return foo;
 680                         }
 681                 default:
 682                         ILLEGAL_PARAM("Reading illegal on stream type: %u", str->type);
 683                         return 0;
 684         }
 685 }
 686
 687 /**
 688  * glk_get_buffer_stream_uni:
 689  * @str: An input stream.
 690  * @buf: A buffer with space for at least @len Unicode code points.
 691  * @len: The number of characters to read.
 692  *
 693  * Reads @len Unicode characters from @str, unless the end of stream is reached
 694  * first. No terminal null is placed in the buffer.
 695  *
 696  * Returns: The number of Unicode characters actually read.
 697  */
 698 glui32
 699 glk_get_buffer_stream_uni(strid_t str, glui32 *buf, glui32 len)
 700 {
 701         VALID_STREAM(str, return 0);
 702         g_return_val_if_fail(str->file_mode == filemode_Read || str->file_mode == filemode_ReadWrite, 0);
 703         g_return_val_if_fail(buf != NULL, 0);
 704
 705         switch(str->type)
 706         {
 707                 case STREAM_TYPE_MEMORY:
 708                 {
 709                         int copycount = 0;
 710                         if(str->unicode)
 711                         {
 712                                 if(str->ubuffer) /* if not, copycount stays 0 */
 713                                         copycount = MIN(len, str->buflen - str->mark);
 714                                 memmove(buf, str->ubuffer + str->mark, copycount * 4);
 715                                 str->mark += copycount;
 716                         }
 717                         else
 718                         {
 719                                 while(copycount < len && str->buffer && str->mark < str->buflen)
 720                                 {
 721                                         unsigned char ch = str->buffer[str->mark++];
 722                                         buf[copycount++] = ch;
 723                                 }
 724                         }
 725
 726                         str->read_count += copycount;
 727                         return copycount;
 728                 }
 729                 case STREAM_TYPE_FILE:
 730                         if(str->binary)
 731                         {
 732                                 if(str->unicode) /* Binary file with 4-byte characters */
 733                                 {
 734                                         /* Read len characters of 4 bytes each */
 735                                         unsigned char *readbuffer = g_new0(unsigned char, 4 * len);
 736                                         size_t count = fread(readbuffer, sizeof(unsigned char), 4 * len, str->file_pointer);
 737                                         /* If there was an incomplete character */
 738                                         if(count % 4 != 0)
 739                                         {
 740                                                 count -= count % 4;
 741                                                 WARNING("Incomplete character in binary Unicode file");
 742                                         }
 743
 744                                         int foo;
 745                                         for(foo = 0; foo < count; foo += 4)
 746                                                 buf[foo / 4] = readbuffer[foo] << 24
 747                                                         | readbuffer[foo + 1] << 16
 748                                                         | readbuffer[foo + 2] << 8
 749                                                         | readbuffer[foo + 3];
 750                                         g_free(readbuffer);
 751                                         str->read_count += count / 4;
 752                                         return count / 4;
 753                                 }
 754                                 else /* Regular binary file */
 755                                 {
 756                                         unsigned char *readbuffer = g_new0(unsigned char, len);
 757                                         size_t count = fread(readbuffer, sizeof(unsigned char), len, str->file_pointer);
 758                                         int foo;
 759                                         for(foo = 0; foo < count; foo++)
 760                                                 buf[foo] = readbuffer[foo];
 761                                         g_free(readbuffer);
 762                                         str->read_count += count;
 763                                         return count;
 764                                 }
 765                         }
 766                         else /* Text mode is the same for Unicode and regular files */
 767                         {
 768                                 /* Do it character-by-character */
 769                                 int foo;
 770                                 for(foo = 0; foo < len; foo++)
 771                                 {
 772                                         glsi32 ch = read_utf8_char_from_file(str->file_pointer);
 773                                         if(ch == -1)
 774                                                 break;
 775                                         str->read_count++;
 776                                         buf[foo] = ch;
 777                                 }
 778                                 return foo;
 779                         }
 780                 default:
 781                         ILLEGAL_PARAM("Reading illegal on stream type: %u", str->type);
 782                         return 0;
 783         }
 784 }
 785
 786 /**
 787  * glk_get_line_stream:
 788  * @str: An input stream.
 789  * @buf: A buffer with space for at least @len characters.
 790  * @len: The number of characters to read, plus one.
 791  *
 792  * Reads characters from @str, until either
 793  * <inlineequation>
 794  *   <alt>@len - 1</alt>
 795  *   <mathphrase>@len - 1</mathphrase>
 796  * </inlineequation>
 797  * characters have been read or a newline has been read. It then puts a
 798  * terminal null (<code>'\0'</code>) aracter on
 799  * the end. It returns the number of characters actually read, including the
 800  * newline (if there is one) but not including the terminal null.
 801  *
 802  * Returns: The number of characters actually read.
 803  */
 804 glui32
 805 glk_get_line_stream(strid_t str, char *buf, glui32 len)
 806 {
 807         VALID_STREAM(str, return 0);
 808         g_return_val_if_fail(str->file_mode == filemode_Read || str->file_mode == filemode_ReadWrite, 0);
 809         g_return_val_if_fail(buf != NULL, 0);
 810
 811         switch(str->type)
 812         {
 813                 case STREAM_TYPE_MEMORY:
 814                 {
 815                         int copycount = 0;
 816                         if(str->unicode)
 817                         {
 818                                 /* Do it character-by-character */
 819                                 while(copycount < len - 1 && str->ubuffer && str->mark < str->buflen)
 820                                 {
 821                                         glui32 ch = str->ubuffer[str->mark++];
 822                                         /* Check for Unicode newline; slightly different than
 823                                         in file streams */
 824                                         if(ch == 0x0A || ch == 0x85 || ch == 0x0C || ch == 0x2028 || ch == 0x2029)
 825                                         {
 826                                                 buf[copycount++] = '\n';
 827                                                 break;
 828                                         }
 829                                         if(ch == 0x0D)
 830                                         {
 831                                                 if(str->ubuffer[str->mark] == 0x0A)
 832                                                         str->mark++; /* skip past next newline */
 833                                                 buf[copycount++] = '\n';
 834                                                 break;
 835                                         }
 836                                         buf[copycount++] = (ch > 0xFF)? '?' : (char)ch;
 837                                 }
 838                                 buf[copycount] = '\0';
 839                         }
 840                         else
 841                         {
 842                                 if(str->buffer) /* if not, copycount stays 0 */
 843                                         copycount = MIN(len - 1, str->buflen - str->mark);
 844                                 char *endptr = memccpy(buf, str->buffer + str->mark, '\n', copycount);
 845                                 if(endptr) /* newline was found */
 846                                         copycount = endptr - buf; /* Real copy count */
 847                                 buf[copycount] = '\0';
 848                                 str->mark += copycount;
 849                         }
 850
 851                         str->read_count += copycount;
 852                         return copycount;
 853                 }
 854                 case STREAM_TYPE_FILE:
 855                         if(str->binary)
 856                         {
 857                                 if(str->unicode) /* Binary file with 4-byte characters */
 858                                 {
 859                                         /* Do it character-by-character */
 860                                         int foo;
 861                                         for(foo = 0; foo < len - 1; foo++)
 862                                         {
 863                                                 glsi32 ch = read_ucs4be_char_from_file(str->file_pointer);
 864                                                 if(ch == -1)
 865                                                 {
 866                                                         buf[foo] = '\0';
 867                                                         return foo - 1;
 868                                                 }
 869                                                 str->read_count++;
 870                                                 if(is_unicode_newline(ch, str->file_pointer, FALSE))
 871                                                 {
 872                                                         buf[foo] = '\n';
 873                                                         buf[foo + 1] = '\0';
 874                                                         return foo;
 875                                                 }
 876                                                 buf[foo] = (ch > 0xFF)? '?' : (char)ch;
 877                                         }
 878                                         buf[len] = '\0';
 879                                         return foo;
 880                                 }
 881                                 else /* Regular binary file */
 882                                 {
 883                                         fgets(buf, len, str->file_pointer);
 884                                         str->read_count += strlen(buf);
 885                                         return strlen(buf);
 886                                 }
 887                         }
 888                         else /* Text mode is the same for Unicode and regular files */
 889                         {
 890                                 /* Do it character-by-character */
 891                                 int foo;
 892                                 for(foo = 0; foo < len - 1; foo++)
 893                                 {
 894                                         glsi32 ch = read_utf8_char_from_file(str->file_pointer);
 895                                         if(ch == -1)
 896                                         {
 897                                                 buf[foo] = '\0';
 898                                                 return foo - 1;
 899                                         }
 900                                         str->read_count++;
 901                                         if(is_unicode_newline(ch, str->file_pointer, TRUE))
 902                                         {
 903                                                 buf[foo] = '\n';
 904                                                 buf[foo + 1] = '\0';
 905                                                 return foo;
 906                                         }
 907                                         buf[foo] = (ch > 0xFF)? 0x3F : (char)ch;
 908                                 }
 909                                 buf[len] = '\0';
 910                                 return foo;
 911                         }
 912                 default:
 913                         ILLEGAL_PARAM("Reading illegal on stream type: %u", str->type);
 914                         return 0;
 915         }
 916 }
 917
 918 /**
 919  * glk_get_line_stream_uni:
 920  * @str: An input stream.
 921  * @buf: A buffer with space for at least @len Unicode code points.
 922  * @len: The number of characters to read, plus one.
 923  *
 924  * Reads Unicode characters from @str, until either
 925  * <inlineequation>
 926  *   <alt>@len - 1</alt>
 927  *   <mathphrase>@len - 1</mathphrase>
 928  * </inlineequation>
 929  * Unicode characters have been read or a newline has been read. It then puts a
 930  * terminal null (a zero value) on the end.
 931  *
 932  * Returns: The number of characters actually read, including the newline (if
 933  * there is one) but not including the terminal null.
 934  */
 935 glui32
 936 glk_get_line_stream_uni(strid_t str, glui32 *buf, glui32 len)
 937 {
 938         VALID_STREAM(str, return 0);
 939         g_return_val_if_fail(str->file_mode == filemode_Read || str->file_mode == filemode_ReadWrite, 0);
 940         g_return_val_if_fail(buf != NULL, 0);
 941
 942         switch(str->type)
 943         {
 944                 case STREAM_TYPE_MEMORY:
 945                 {
 946                         int copycount = 0;
 947                         if(str->unicode)
 948                         {
 949                                 /* Do it character-by-character */
 950                                 while(copycount < len - 1 && str->ubuffer && str->mark < str->buflen)
 951                                 {
 952                                         glui32 ch = str->ubuffer[str->mark++];
 953                                         /* Check for Unicode newline; slightly different than
 954                                         in file streams */
 955                                         if(ch == 0x0A || ch == 0x85 || ch == 0x0C || ch == 0x2028 || ch == 0x2029)
 956                                         {
 957                                                 buf[copycount++] = '\n';
 958                                                 break;
 959                                         }
 960                                         if(ch == 0x0D)
 961                                         {
 962                                                 if(str->ubuffer[str->mark] == 0x0A)
 963                                                         str->mark++; /* skip past next newline */
 964                                                 buf[copycount++] = '\n';
 965                                                 break;
 966                                         }
 967                                         buf[copycount++] = ch;
 968                                 }
 969                                 buf[copycount] = '\0';
 970                         }
 971                         else
 972                         {
 973                                 /* No recourse to memccpy(), so do it character-by-character */
 974                                 while(copycount < len - 1 && str->buffer && str->mark < str->buflen)
 975                                 {
 976                                         gchar ch = str->buffer[str->mark++];
 977                                         /* Check for newline */
 978                                         if(ch == '\n') /* Also check for \r and \r\n? */
 979                                         {
 980                                                 buf[copycount++] = '\n';
 981                                                 break;
 982                                         }
 983                                         buf[copycount++] = (unsigned char)ch;
 984                                 }
 985                                 buf[copycount] = 0;
 986                         }
 987
 988                         str->read_count += copycount;
 989                         return copycount;
 990                 }
 991                 case STREAM_TYPE_FILE:
 992                         if(str->binary)
 993                         {
 994                                 if(str->unicode) /* Binary file with 4-byte characters */
 995                                 {
 996                                         /* Do it character-by-character */
 997                                         int foo;
 998                                         for(foo = 0; foo < len - 1; foo++)
 999                                         {
1000                                                 glsi32 ch = read_ucs4be_char_from_file(str->file_pointer);
1001                                                 if(ch == -1)
1002                                                 {
1003                                                         buf[foo] = 0;
1004                                                         return foo - 1;
1005                                                 }
1006                                                 str->read_count++;
1007                                                 if(is_unicode_newline(ch, str->file_pointer, FALSE))
1008                                                 {
1009                                                         buf[foo] = ch; /* Preserve newline types??? */
1010                                                         buf[foo + 1] = 0;
1011                                                         return foo;
1012                                                 }
1013                                                 buf[foo] = ch;
1014                                         }
1015                                         buf[len] = 0;
1016                                         return foo;
1017                                 }
1018                                 else /* Regular binary file */
1019                                 {
1020                                         gchar *readbuffer = g_new0(gchar, len);
1021                                         fgets(readbuffer, len, str->file_pointer);
1022                                         glui32 count = strlen(readbuffer) + 1; /* Copy terminator */
1023                                         int foo;
1024                                         for(foo = 0; foo < count; foo++)
1025                                                 buf[foo] = (unsigned char)(readbuffer[foo]);
1026                                         str->read_count += count;
1027                                         return count;
1028                                 }
1029                         }
1030                         else /* Text mode is the same for Unicode and regular files */
1031                         {
1032                                 /* Do it character-by-character */
1033                                 int foo;
1034                                 for(foo = 0; foo < len - 1; foo++)
1035                                 {
1036                                         glsi32 ch = read_utf8_char_from_file(str->file_pointer);
1037                                         if(ch == -1)
1038                                         {
1039                                                 buf[foo] = 0;
1040                                                 return foo - 1;
1041                                         }
1042                                         str->read_count++;
1043                                         if(is_unicode_newline(ch, str->file_pointer, TRUE))
1044                                         {
1045                                                 buf[foo] = ch; /* Preserve newline types??? */
1046                                                 buf[foo + 1] = 0;
1047                                                 return foo;
1048                                         }
1049                                         buf[foo] = ch;
1050                                 }
1051                                 buf[len] = 0;
1052                                 return foo;
1053                         }
1054                 default:
1055                         ILLEGAL_PARAM("Reading illegal on stream type: %u", str->type);
1056                         return 0;
1057         }
1058 }
1059
1060 /*
1061  *
1062  **************** SEEKING FUNCTIONS ********************************************
1063  *
1064  */
1065
1066 /**
1067  * glk_stream_get_position:
1068  * @str: A file or memory stream.
1069  *
1070  * Returns the position of the read/write mark in @str. For memory streams and
1071  * binary file streams, this is exactly the number of characters read or written
1072  * from the beginning of the stream (unless you have moved the mark with
1073  * glk_stream_set_position().) For text file streams, matters are more
1074  * ambiguous, since (for example) writing one byte to a text file may store more
1075  * than one character in the platform's native encoding. You can only be sure
1076  * that the position increases as you read or write to the file.
1077  *
1078  * Additional complication: for Latin-1 memory and file streams, a character is
1079  * a byte. For Unicode memory and file streams (those created by
1080  * glk_stream_open_file_uni() and glk_stream_open_memory_uni()), a character is
1081  * a 32-bit word. So in a binary Unicode file, positions are multiples of four
1082  * bytes.
1083  *
1084  * <note><para>
1085  *   If this bothers you, don't use binary Unicode files. I don't think they're
1086  *   good for much anyhow.
1087  * </para></note>
1088  *
1089  * Returns: position of the read/write mark in @str.
1090  */
1091 glui32
1092 glk_stream_get_position(strid_t str)
1093 {
1094         VALID_STREAM(str, return 0);
1095
1096         switch(str->type)
1097         {
1098                 case STREAM_TYPE_MEMORY:
1099                         return str->mark;
1100                 case STREAM_TYPE_FILE:
1101                         return ftell(str->file_pointer);
1102                 default:
1103                         ILLEGAL_PARAM("Seeking illegal on stream type: %u", str->type);
1104                         return 0;
1105         }
1106 }
1107
1108 /**
1109  * glk_stream_set_position:
1110  * @str: A file or memory stream.
1111  * @pos: The position to set the mark to, relative to @seekmode.
1112  * @seekmode: One of #seekmode_Start, #seekmode_Current, or #seekmode_End.
1113  *
1114  * Sets the position of the read/write mark in @str. The position is controlled
1115  * by @pos, and the meaning of @pos is controlled by @seekmode. See the
1116  * <code>seekmode_</code> constants below.
1117  *
1118  * It is illegal to specify a position before the beginning or after the end of
1119  * the file.
1120  *
1121  * In binary files, the mark position is exact &mdash; it corresponds with the
1122  * number of characters you have read or written. In text files, this mapping
1123  * can vary, because of linefeed conventions or other character-set
1124  * approximations. See <link linkend="chimara-Streams">Streams</link>.
1125  * glk_stream_set_position() and glk_stream_get_position() measure positions in
1126  * the platform's native encoding &mdash; after character cookery. Therefore,
1127  * in a text stream, it is safest to use glk_stream_set_position() only to move
1128  * to the beginning or end of a file, or to a position determined by
1129  * glk_stream_get_position().
1130  *
1131  * Again, in Latin-1 streams, characters are bytes. In Unicode streams,
1132  * characters are 32-bit words, or four bytes each.
1133  */
1134 void
1135 glk_stream_set_position(strid_t str, glsi32 pos, glui32 seekmode)
1136 {
1137         VALID_STREAM(str, return);
1138         g_return_if_fail(!(seekmode == seekmode_Start && pos < 0));
1139         g_return_if_fail(!(seekmode == seekmode_End || pos > 0));
1140
1141         switch(str->type)
1142         {
1143                 case STREAM_TYPE_MEMORY:
1144                         switch(seekmode)
1145                         {
1146                                 case seekmode_Start:   str->mark = pos;  break;
1147                                 case seekmode_Current: str->mark += pos; break;
1148                                 case seekmode_End:     str->mark = str->buflen + pos; break;
1149                                 default:
1150                                         g_return_if_reached();
1151                                         return;
1152                         }
1153                         break;
1154                 case STREAM_TYPE_FILE:
1155                 {
1156                         int whence;
1157                         switch(seekmode)
1158                         {
1159                                 case seekmode_Start:   whence = SEEK_SET; break;
1160                                 case seekmode_Current: whence = SEEK_CUR; break;
1161                                 case seekmode_End:     whence = SEEK_END; break;
1162                                 default:
1163                                         g_return_if_reached();
1164                                         return;
1165                         }
1166                         if(fseek(str->file_pointer, pos, whence) == -1)
1167                                 WARNING("Seek failed on file stream");
1168                         break;
1169                 }
1170                 default:
1171                         ILLEGAL_PARAM("Seeking illegal on stream type: %u", str->type);
1172                         return;
1173         }
1174 }
1175