src/io/filehandle.c

   1 /*
   2 Copyright (C) 2001-2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/io/filehandle.c - FileHandle utility functions
   8
   9 =head1 DESCRIPTION
  10
  11 This file defines a set of utility functions for the FileHandle PMC used by all
  12 operating systems. For the primary public I/O API, see F<src/io/api.c>.
  13
  14 =cut
  15
  16 */
  17
  18 #include "parrot/parrot.h"
  19 #include "io_private.h"
  20 #include "pmc/pmc_filehandle.h"
  21
  22 /* HEADERIZER HFILE: include/parrot/io.h */
  23
  24 /*
  25
  26 =head2 Functions
  27
  28 =over 4
  29
  30 =item C<INTVAL Parrot_io_parse_open_flags(PARROT_INTERP, const STRING
  31 *mode_str)>
  32
  33 Parses a Parrot string for file open mode flags (C<r> for read, C<w> for write,
  34 C<a> for append, and C<p> for pipe) and returns the combined generic bit flags.
  35
  36 =cut
  37
  38 */
  39
  40 PARROT_EXPORT
  41 PARROT_WARN_UNUSED_RESULT
  42 INTVAL
  43 Parrot_io_parse_open_flags(PARROT_INTERP, ARGIN_NULLOK(const STRING *mode_str))
  44 {
  45     ASSERT_ARGS(Parrot_io_parse_open_flags)
  46     INTVAL i, mode_len;
  47     INTVAL flags = 0;
  48
  49     if (STRING_IS_NULL(mode_str))
  50         return PIO_F_READ;
  51
  52     mode_len = Parrot_str_byte_length(interp, mode_str);
  53
  54     for (i = 0; i < mode_len; ++i) {
  55         const INTVAL s = Parrot_str_indexed(interp, mode_str, i);
  56         switch (s) {
  57           case 'r':
  58             flags |= PIO_F_READ;
  59             break;
  60           case 'w':
  61             flags |= PIO_F_WRITE;
  62             if (!(flags & PIO_F_APPEND)) /* don't truncate if appending */
  63                 flags |= PIO_F_TRUNC;
  64             break;
  65           case 'a':
  66             flags |= PIO_F_APPEND;
  67             flags |= PIO_F_WRITE;
  68             if ((flags & PIO_F_TRUNC)) /* don't truncate if appending */
  69                 flags &= ~PIO_F_TRUNC;
  70             break;
  71           case 'p':
  72             flags |= PIO_F_PIPE;
  73             break;
  74           default:
  75             break;
  76         }
  77     }
  78
  79     return flags;
  80 }
  81
  82 /*
  83
  84 =item C<STRING * Parrot_io_make_string(PARROT_INTERP, STRING **buf, size_t len)>
  85
  86 Creates a STRING* suitable for returning results from IO read functions.
  87 The passed in C<buf> parameter can:
  88
  89 =over 4
  90
  91 =item 1
  92
  93 Point to a NULL STRING
  94
  95 =item 2
  96
  97 Point to a real STRING
  98
  99 =item 3
 100
 101 Point to a fake STRING with (strstart, bufused) holding the *buffer
 102 information.
 103
 104 =back
 105
 106 In the third case, the buffer or STRING must be able to hold the required
 107 amount of data. For cases 1 and 2, a NULL C<strstart> tells this function to
 108 allocate the STRING memory.
 109
 110 =cut
 111
 112 */
 113
 114 PARROT_WARN_UNUSED_RESULT
 115 PARROT_CANNOT_RETURN_NULL
 116 STRING *
 117 Parrot_io_make_string(PARROT_INTERP, ARGMOD(STRING **buf), size_t len)
 118 {
 119     ASSERT_ARGS(Parrot_io_make_string)
 120     /*
 121      * when we get a NULL string, we read a default len
 122      */
 123     if (*buf == NULL) {
 124         *buf = Parrot_str_new_noinit(interp, len);
 125         return *buf;
 126     }
 127     else {
 128         STRING * const s = *buf;
 129         if (s->bufused < len)
 130             Parrot_gc_reallocate_string_storage(interp, s, len);
 131         return s;
 132     }
 133 }
 134
 135
 136 /*
 137
 138 =item C<void Parrot_io_set_os_handle(PARROT_INTERP, PMC *filehandle, PIOHANDLE
 139 file_descriptor)>
 140
 141 Sets the C<os_handle> attribute of the FileHandle object, which stores the
 142 low-level filehandle for the OS.
 143
 144 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 145 needs to change to a general interface that can be used by all subclasses and
 146 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 147 it can be cleanly changed later.
 148
 149 Possibly, this function should reset some characteristics of the object (like
 150 buffer and file positions) to their default values.
 151
 152 =cut
 153
 154 */
 155
 156 PARROT_EXPORT
 157 void
 158 Parrot_io_set_os_handle(SHIM_INTERP, ARGMOD(PMC *filehandle), PIOHANDLE file_descriptor)
 159 {
 160     ASSERT_ARGS(Parrot_io_set_os_handle)
 161     PARROT_FILEHANDLE(filehandle)->os_handle = file_descriptor;
 162 }
 163
 164 /*
 165
 166 =item C<PIOHANDLE Parrot_io_get_os_handle(PARROT_INTERP, const PMC *filehandle)>
 167
 168 Retrieve the C<os_handle> attribute of the FileHandle object, which stores the
 169 low-level filehandle for the OS.
 170
 171 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 172 needs to change to a general interface that can be used by all subclasses and
 173 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 174 it can be cleanly changed later.
 175
 176 =cut
 177
 178 */
 179
 180 PARROT_EXPORT
 181 PARROT_WARN_UNUSED_RESULT
 182 PIOHANDLE
 183 Parrot_io_get_os_handle(SHIM_INTERP, ARGIN(const PMC *filehandle))
 184 {
 185     ASSERT_ARGS(Parrot_io_get_os_handle)
 186     return PARROT_FILEHANDLE(filehandle)->os_handle;
 187 }
 188
 189 /*
 190
 191 =item C<void Parrot_io_set_flags(PARROT_INTERP, PMC *filehandle, INTVAL flags)>
 192
 193 Set the C<flags> attribute of the FileHandle object, which stores bitwise flags
 194 marking filehandle characteristics.
 195
 196 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 197 needs to change to a general interface that can be used by all subclasses and
 198 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 199 it can be cleanly changed later.
 200
 201 =cut
 202
 203 */
 204
 205 PARROT_EXPORT
 206 void
 207 Parrot_io_set_flags(SHIM_INTERP, ARGIN(PMC *filehandle), INTVAL flags)
 208 {
 209     ASSERT_ARGS(Parrot_io_set_flags)
 210     Parrot_FileHandle_attributes * const handle_struct = PARROT_FILEHANDLE(filehandle);
 211     handle_struct->flags = flags;
 212 }
 213
 214 /*
 215
 216 =item C<INTVAL Parrot_io_get_flags(PARROT_INTERP, PMC *filehandle)>
 217
 218 Set the C<flags> attribute of the FileHandle object, which stores bitwise flags
 219 marking filehandle characteristics.
 220
 221 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 222 needs to change to a general interface that can be used by all subclasses and
 223 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 224 it can be cleanly changed later.
 225
 226 =cut
 227
 228 */
 229
 230 PARROT_EXPORT
 231 INTVAL
 232 Parrot_io_get_flags(SHIM_INTERP, ARGIN(PMC *filehandle))
 233 {
 234     ASSERT_ARGS(Parrot_io_get_flags)
 235     Parrot_FileHandle_attributes *handle_struct = PARROT_FILEHANDLE(filehandle);
 236     INTVAL flags = handle_struct->flags;
 237     return flags;
 238 }
 239
 240 /*
 241
 242 =item C<void Parrot_io_set_file_size(PARROT_INTERP, PMC *filehandle, PIOOFF_T
 243 file_size)>
 244
 245 Set the C<file_size> attribute of the FileHandle object, which stores the
 246 current file size.
 247
 248 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 249 needs to change to a general interface that can be used by all subclasses and
 250 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 251 it can be cleanly changed later.
 252
 253 =cut
 254
 255 */
 256
 257 PARROT_EXPORT
 258 void
 259 Parrot_io_set_file_size(SHIM_INTERP, ARGIN(PMC *filehandle), PIOOFF_T file_size)
 260 {
 261     ASSERT_ARGS(Parrot_io_set_file_size)
 262     PARROT_FILEHANDLE(filehandle)->file_size = file_size;
 263 }
 264
 265
 266 /*
 267
 268 =item C<PIOOFF_T Parrot_io_get_file_size(PARROT_INTERP, PMC *filehandle)>
 269
 270 Get the C<file_size> attribute of the FileHandle object, which stores the
 271 current file size.
 272
 273
 274 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 275 needs to change to a general interface that can be used by all subclasses and
 276 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 277 it can be cleanly changed later.
 278
 279 =cut
 280
 281 */
 282
 283 PARROT_EXPORT
 284 PIOOFF_T
 285 Parrot_io_get_file_size(SHIM_INTERP, ARGIN(PMC *filehandle))
 286 {
 287     ASSERT_ARGS(Parrot_io_get_file_size)
 288     return PARROT_FILEHANDLE(filehandle)->file_size;
 289 }
 290
 291 /*
 292
 293 =item C<void Parrot_io_set_buffer_start(PARROT_INTERP, PMC *filehandle, unsigned
 294 char *new_start)>
 295
 296 Set the C<buffer_start> attribute of the FileHandle object, which stores
 297 the position of the start of the buffer.
 298
 299 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 300 needs to change to a general interface that can be used by all subclasses and
 301 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 302 it can be cleanly changed later.
 303
 304 =cut
 305
 306 */
 307
 308 void
 309 Parrot_io_set_buffer_start(SHIM_INTERP, ARGMOD(PMC *filehandle),
 310         ARGIN_NULLOK(unsigned char *new_start))
 311 {
 312     ASSERT_ARGS(Parrot_io_set_buffer_start)
 313     PARROT_FILEHANDLE(filehandle)->buffer_start = new_start;
 314 }
 315
 316 /*
 317
 318 =item C<unsigned char * Parrot_io_get_buffer_start(PARROT_INTERP, PMC
 319 *filehandle)>
 320
 321 Get the C<buffer_start> attribute of the FileHandle object, which stores
 322 the position of the start of the buffer.
 323
 324 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 325 needs to change to a general interface that can be used by all subclasses and
 326 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 327 it can be cleanly changed later.
 328
 329 =cut
 330
 331 */
 332
 333 PARROT_EXPORT
 334 PARROT_WARN_UNUSED_RESULT
 335 PARROT_CAN_RETURN_NULL
 336 unsigned char *
 337 Parrot_io_get_buffer_start(SHIM_INTERP, ARGIN(PMC *filehandle))
 338 {
 339     ASSERT_ARGS(Parrot_io_get_buffer_start)
 340     return PARROT_FILEHANDLE(filehandle)->buffer_start;
 341 }
 342
 343 /*
 344
 345 =item C<unsigned char * Parrot_io_get_buffer_next(PARROT_INTERP, const PMC
 346 *filehandle)>
 347
 348 Get the C<buffer_next> attribute of the FileHandle object, which stores
 349 the current position within the buffer.
 350
 351 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 352 needs to change to a general interface that can be used by all subclasses and
 353 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 354 it can be cleanly changed later.
 355
 356 =cut
 357
 358 */
 359
 360 PARROT_EXPORT
 361 PARROT_CAN_RETURN_NULL
 362 unsigned char *
 363 Parrot_io_get_buffer_next(SHIM_INTERP, ARGIN(const PMC *filehandle))
 364 {
 365     ASSERT_ARGS(Parrot_io_get_buffer_next)
 366     return PARROT_FILEHANDLE(filehandle)->buffer_next;
 367 }
 368
 369 /*
 370
 371 =item C<void Parrot_io_set_buffer_next(PARROT_INTERP, PMC *filehandle, unsigned
 372 char *new_next)>
 373
 374 Set the C<buffer_next> attribute of the FileHandle object, which stores
 375 the current position within the buffer.
 376
 377 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 378 needs to change to a general interface that can be used by all subclasses and
 379 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 380 it can be cleanly changed later.
 381
 382 =cut
 383
 384 */
 385
 386 void
 387 Parrot_io_set_buffer_next(SHIM_INTERP, ARGMOD(PMC *filehandle),
 388         ARGIN_NULLOK(unsigned char *new_next))
 389 {
 390     ASSERT_ARGS(Parrot_io_set_buffer_next)
 391     PARROT_FILEHANDLE(filehandle)->buffer_next = new_next;
 392 }
 393
 394 /*
 395
 396 =item C<unsigned char * Parrot_io_get_buffer_end(PARROT_INTERP, const PMC
 397 *filehandle)>
 398
 399 Get the C<buffer_end> attribute of the FileHandle object, which stores
 400 the position of the end of the buffer.
 401
 402 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 403 needs to change to a general interface that can be used by all subclasses and
 404 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 405 it can be cleanly changed later.
 406
 407 =cut
 408
 409 */
 410
 411 PARROT_EXPORT
 412 PARROT_WARN_UNUSED_RESULT
 413 PARROT_CAN_RETURN_NULL
 414 unsigned char *
 415 Parrot_io_get_buffer_end(SHIM_INTERP, ARGIN(const PMC *filehandle))
 416 {
 417     ASSERT_ARGS(Parrot_io_get_buffer_end)
 418     return PARROT_FILEHANDLE(filehandle)->buffer_end;
 419 }
 420
 421 /*
 422
 423 =item C<void Parrot_io_set_buffer_end(PARROT_INTERP, PMC *filehandle, unsigned
 424 char *new_end)>
 425
 426 Set the C<buffer_end> attribute of the FileHandle object, which stores
 427 the position of the end of the buffer.
 428
 429 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 430 needs to change to a general interface that can be used by all subclasses and
 431 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 432 it can be cleanly changed later.
 433
 434 =cut
 435
 436 */
 437
 438 void
 439 Parrot_io_set_buffer_end(SHIM_INTERP, ARGMOD(PMC *filehandle),
 440         ARGIN_NULLOK(unsigned char *new_end))
 441 {
 442     ASSERT_ARGS(Parrot_io_set_buffer_end)
 443     PARROT_FILEHANDLE(filehandle)->buffer_end = new_end;
 444 }
 445
 446 /*
 447
 448 =item C<INTVAL Parrot_io_get_buffer_flags(PARROT_INTERP, const PMC *filehandle)>
 449
 450 Get the C<buffer_flags> attribute of the FileHandle object, which stores
 451 a collection of flags specific to the buffer.
 452
 453 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 454 needs to change to a general interface that can be used by all subclasses and
 455 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 456 it can be cleanly changed later.
 457
 458 =cut
 459
 460 */
 461
 462 PARROT_CAN_RETURN_NULL
 463 INTVAL
 464 Parrot_io_get_buffer_flags(SHIM_INTERP, ARGIN(const PMC *filehandle))
 465 {
 466     ASSERT_ARGS(Parrot_io_get_buffer_flags)
 467     return PARROT_FILEHANDLE(filehandle)->buffer_flags;
 468 }
 469
 470 /*
 471
 472 =item C<void Parrot_io_set_buffer_flags(PARROT_INTERP, PMC *filehandle, INTVAL
 473 new_flags)>
 474
 475 Set the C<buffer_flags> attribute of the FileHandle object, which stores
 476 a collection of flags specific to the buffer.
 477
 478 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 479 needs to change to a general interface that can be used by all subclasses and
 480 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 481 it can be cleanly changed later.
 482
 483 =cut
 484
 485 */
 486
 487 void
 488 Parrot_io_set_buffer_flags(SHIM_INTERP, ARGMOD(PMC *filehandle), INTVAL new_flags)
 489 {
 490     ASSERT_ARGS(Parrot_io_set_buffer_flags)
 491     PARROT_FILEHANDLE(filehandle)->buffer_flags = new_flags;
 492 }
 493
 494 /*
 495
 496 =item C<size_t Parrot_io_get_buffer_size(PARROT_INTERP, const PMC *filehandle)>
 497
 498 Get the C<buffer_size> attribute of the FileHandle object, which stores
 499 the size of the buffer (in bytes).
 500
 501 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 502 needs to change to a general interface that can be used by all subclasses and
 503 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 504 it can be cleanly changed later.
 505
 506 =cut
 507
 508 */
 509
 510 PARROT_CAN_RETURN_NULL
 511 PARROT_WARN_UNUSED_RESULT
 512 size_t
 513 Parrot_io_get_buffer_size(SHIM_INTERP, ARGIN(const PMC *filehandle))
 514 {
 515     ASSERT_ARGS(Parrot_io_get_buffer_size)
 516     return PARROT_FILEHANDLE(filehandle)->buffer_size;
 517 }
 518
 519 /*
 520
 521 =item C<void Parrot_io_set_buffer_size(PARROT_INTERP, PMC *filehandle, size_t
 522 new_size)>
 523
 524 Set the C<buffer_size> attribute of the FileHandle object, which stores
 525 the size of the buffer (in bytes).
 526
 527 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 528 needs to change to a general interface that can be used by all subclasses and
 529 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 530 it can be cleanly changed later.
 531
 532 =cut
 533
 534 */
 535
 536 void
 537 Parrot_io_set_buffer_size(SHIM_INTERP, ARGMOD(PMC *filehandle), size_t new_size)
 538 {
 539     ASSERT_ARGS(Parrot_io_set_buffer_size)
 540     PARROT_FILEHANDLE(filehandle)->buffer_size = new_size;
 541 }
 542
 543 /*
 544
 545 =item C<void Parrot_io_clear_buffer(PARROT_INTERP, PMC *filehandle)>
 546
 547 Clear the filehandle buffer and free the associated memory.
 548
 549 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 550 needs to change to a general interface that can be used by all subclasses and
 551 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 552 it can be cleanly changed later.
 553
 554 =cut
 555
 556 */
 557
 558 PARROT_CAN_RETURN_NULL
 559 void
 560 Parrot_io_clear_buffer(PARROT_INTERP, ARGMOD(PMC *filehandle))
 561 {
 562     ASSERT_ARGS(Parrot_io_clear_buffer)
 563     Parrot_FileHandle_attributes * const io = PARROT_FILEHANDLE(filehandle);
 564     if (io->buffer_start && (io->flags & PIO_BF_MALLOC)) {
 565         mem_gc_free(interp, io->buffer_start);
 566         io->buffer_start = NULL;
 567     }
 568 }
 569
 570 /*
 571
 572 =item C<PIOOFF_T Parrot_io_get_file_position(PARROT_INTERP, const PMC
 573 *filehandle)>
 574
 575 Get the C<file_pos> attribute of the FileHandle object, which stores
 576 the current file position of the filehandle.
 577
 578 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 579 needs to change to a general interface that can be used by all subclasses and
 580 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 581 it can be cleanly changed later.
 582
 583 =cut
 584
 585 */
 586
 587 PARROT_EXPORT
 588 PARROT_WARN_UNUSED_RESULT
 589 PIOOFF_T
 590 Parrot_io_get_file_position(SHIM_INTERP, ARGIN(const PMC *filehandle))
 591 {
 592     ASSERT_ARGS(Parrot_io_get_file_position)
 593     return PARROT_FILEHANDLE(filehandle)->file_pos;
 594 }
 595
 596 /*
 597
 598 =item C<PIOOFF_T Parrot_io_get_last_file_position(PARROT_INTERP, const PMC
 599 *filehandle)>
 600
 601 Get the C<file_pos> attribute of the FileHandle object, which stores
 602 the current file position of the filehandle.
 603
 604 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 605 needs to change to a general interface that can be used by all subclasses and
 606 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 607 it can be cleanly changed later.
 608
 609 =cut
 610
 611 */
 612
 613 PARROT_EXPORT
 614 PARROT_WARN_UNUSED_RESULT
 615 PIOOFF_T
 616 Parrot_io_get_last_file_position(SHIM_INTERP, ARGIN(const PMC *filehandle))
 617 {
 618     ASSERT_ARGS(Parrot_io_get_last_file_position)
 619     return PARROT_FILEHANDLE(filehandle)->last_pos;
 620 }
 621
 622 /*
 623
 624 =item C<void Parrot_io_set_file_position(PARROT_INTERP, PMC *filehandle,
 625 PIOOFF_T file_pos)>
 626
 627 Get the C<file_pos> attribute of the FileHandle object, which stores the
 628 current file position of the filehandle. Also set the C<last_pos> attribute to
 629 the previous value of C<file_pos>.
 630
 631 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 632 needs to change to a general interface that can be used by all subclasses and
 633 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 634 it can be cleanly changed later.
 635
 636 =cut
 637
 638 */
 639
 640 PARROT_EXPORT
 641 void
 642 Parrot_io_set_file_position(SHIM_INTERP, ARGMOD(PMC *filehandle), PIOOFF_T file_pos)
 643 {
 644     ASSERT_ARGS(Parrot_io_set_file_position)
 645     Parrot_FileHandle_attributes * const handle_struct = PARROT_FILEHANDLE(filehandle);
 646     handle_struct->last_pos = handle_struct->file_pos;
 647     handle_struct->file_pos = file_pos;
 648 }
 649
 650 /*
 651
 652 =item C<INTVAL Parrot_io_is_encoding(PARROT_INTERP, const PMC *filehandle,
 653 STRING *value)>
 654
 655 Check whether the encoding attribute of the filehandle matches a passed in
 656 string.
 657
 658 Currently, this pokes directly into the C struct of the FileHandle PMC. This
 659 needs to change to a general interface that can be used by all subclasses and
 660 polymorphic equivalents of FileHandle. For now, hiding it behind a function, so
 661 it can be cleanly changed later.
 662
 663 =cut
 664
 665 */
 666
 667 PARROT_EXPORT
 668 PARROT_WARN_UNUSED_RESULT
 669 INTVAL
 670 Parrot_io_is_encoding(PARROT_INTERP, ARGIN(const PMC *filehandle), ARGIN(STRING *value))
 671 {
 672     ASSERT_ARGS(Parrot_io_is_encoding)
 673     Parrot_FileHandle_attributes * const handle_struct = PARROT_FILEHANDLE(filehandle);
 674     if (STRING_IS_NULL(handle_struct->encoding))
 675         return 0;
 676
 677     if (Parrot_str_equal(interp, value, handle_struct->encoding))
 678         return 1;
 679
 680     return 0;
 681 }
 682
 683 /*
 684
 685 =item C<INTVAL Parrot_io_close_filehandle(PARROT_INTERP, PMC *pmc)>
 686
 687 Flushes and closes the C<FileHandle> PMC C<*pmc>, but leaves the object intact
 688 to be reused or collected.
 689
 690 =cut
 691
 692 */
 693
 694 PARROT_EXPORT
 695 INTVAL
 696 Parrot_io_close_filehandle(PARROT_INTERP, ARGMOD(PMC *pmc))
 697 {
 698     ASSERT_ARGS(Parrot_io_close_filehandle)
 699     INTVAL result;
 700
 701     if (Parrot_io_is_closed_filehandle(interp, pmc))
 702         return -1;
 703
 704     Parrot_io_flush_buffer(interp, pmc);
 705     PIO_FLUSH(interp, pmc);
 706
 707     result = PIO_CLOSE(interp, pmc);
 708     Parrot_io_clear_buffer(interp, pmc);
 709
 710     return result;
 711 }
 712
 713 /*
 714
 715 =item C<INTVAL Parrot_io_is_closed_filehandle(PARROT_INTERP, const PMC *pmc)>
 716
 717 Test whether a filehandle is closed.
 718
 719 =cut
 720
 721 */
 722
 723 PARROT_EXPORT
 724 PARROT_WARN_UNUSED_RESULT
 725 INTVAL
 726 Parrot_io_is_closed_filehandle(PARROT_INTERP, ARGIN(const PMC *pmc))
 727 {
 728     ASSERT_ARGS(Parrot_io_is_closed_filehandle)
 729     return PIO_IS_CLOSED(interp, pmc);
 730 }
 731
 732 /*
 733
 734 =item C<void Parrot_io_flush_filehandle(PARROT_INTERP, PMC *pmc)>
 735
 736 Flushes the C<FileHandle> PMC C<*pmc>.
 737
 738 =cut
 739
 740 */
 741
 742 PARROT_EXPORT
 743 void
 744 Parrot_io_flush_filehandle(PARROT_INTERP, ARGMOD(PMC *pmc))
 745 {
 746     ASSERT_ARGS(Parrot_io_flush_filehandle)
 747     if (Parrot_io_is_closed(interp, pmc))
 748         return;
 749
 750     Parrot_io_flush_buffer(interp, pmc);
 751     PIO_FLUSH(interp, pmc);
 752 }
 753
 754 /*
 755
 756 =back
 757
 758 =head1 SEE ALSO
 759
 760 F<src/io/unix.c>,
 761 F<src/io/win32.c>,
 762 F<src/io/stdio.c>,
 763 F<src/io/io_private.h>.
 764
 765 =cut
 766
 767 */
 768
 769
 770 /*
 771  * Local variables:
 772  *   c-file-style: "parrot"
 773  * End:
 774  * vim: expandtab shiftwidth=4:
 775  */