Annotation of embedaddon/php/ext/spl/spl_directory.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Author: Marcus Boerger <helly@php.net> |
! 16: +----------------------------------------------------------------------+
! 17: */
! 18:
! 19: /* $Id: spl_directory.c 321634 2012-01-01 13:15:04Z felipe $ */
! 20:
! 21: #ifdef HAVE_CONFIG_H
! 22: # include "config.h"
! 23: #endif
! 24:
! 25: #include "php.h"
! 26: #include "php_ini.h"
! 27: #include "ext/standard/info.h"
! 28: #include "ext/standard/file.h"
! 29: #include "ext/standard/php_string.h"
! 30: #include "zend_compile.h"
! 31: #include "zend_exceptions.h"
! 32: #include "zend_interfaces.h"
! 33:
! 34: #include "php_spl.h"
! 35: #include "spl_functions.h"
! 36: #include "spl_engine.h"
! 37: #include "spl_iterators.h"
! 38: #include "spl_directory.h"
! 39: #include "spl_exceptions.h"
! 40:
! 41: #include "php.h"
! 42: #include "fopen_wrappers.h"
! 43:
! 44: #include "ext/standard/basic_functions.h"
! 45: #include "ext/standard/php_filestat.h"
! 46:
! 47: #define SPL_HAS_FLAG(flags, test_flag) ((flags & test_flag) ? 1 : 0)
! 48:
! 49: /* declare the class handlers */
! 50: static zend_object_handlers spl_filesystem_object_handlers;
! 51: /* includes handler to validate object state when retrieving methods */
! 52: static zend_object_handlers spl_filesystem_object_check_handlers;
! 53:
! 54: /* decalre the class entry */
! 55: PHPAPI zend_class_entry *spl_ce_SplFileInfo;
! 56: PHPAPI zend_class_entry *spl_ce_DirectoryIterator;
! 57: PHPAPI zend_class_entry *spl_ce_FilesystemIterator;
! 58: PHPAPI zend_class_entry *spl_ce_RecursiveDirectoryIterator;
! 59: PHPAPI zend_class_entry *spl_ce_GlobIterator;
! 60: PHPAPI zend_class_entry *spl_ce_SplFileObject;
! 61: PHPAPI zend_class_entry *spl_ce_SplTempFileObject;
! 62:
! 63: static void spl_filesystem_file_free_line(spl_filesystem_object *intern TSRMLS_DC) /* {{{ */
! 64: {
! 65: if (intern->u.file.current_line) {
! 66: efree(intern->u.file.current_line);
! 67: intern->u.file.current_line = NULL;
! 68: }
! 69: if (intern->u.file.current_zval) {
! 70: zval_ptr_dtor(&intern->u.file.current_zval);
! 71: intern->u.file.current_zval = NULL;
! 72: }
! 73: } /* }}} */
! 74:
! 75: static void spl_filesystem_object_free_storage(void *object TSRMLS_DC) /* {{{ */
! 76: {
! 77: spl_filesystem_object *intern = (spl_filesystem_object*)object;
! 78:
! 79: if (intern->oth_handler && intern->oth_handler->dtor) {
! 80: intern->oth_handler->dtor(intern TSRMLS_CC);
! 81: }
! 82:
! 83: zend_object_std_dtor(&intern->std TSRMLS_CC);
! 84:
! 85: if (intern->_path) {
! 86: efree(intern->_path);
! 87: }
! 88: if (intern->file_name) {
! 89: efree(intern->file_name);
! 90: }
! 91: switch(intern->type) {
! 92: case SPL_FS_INFO:
! 93: break;
! 94: case SPL_FS_DIR:
! 95: if (intern->u.dir.dirp) {
! 96: php_stream_close(intern->u.dir.dirp);
! 97: intern->u.dir.dirp = NULL;
! 98: }
! 99: if (intern->u.dir.sub_path) {
! 100: efree(intern->u.dir.sub_path);
! 101: }
! 102: break;
! 103: case SPL_FS_FILE:
! 104: if (intern->u.file.stream) {
! 105: if (intern->u.file.zcontext) {
! 106: /* zend_list_delref(Z_RESVAL_P(intern->zcontext));*/
! 107: }
! 108: if (!intern->u.file.stream->is_persistent) {
! 109: php_stream_free(intern->u.file.stream, PHP_STREAM_FREE_CLOSE);
! 110: } else {
! 111: php_stream_free(intern->u.file.stream, PHP_STREAM_FREE_CLOSE_PERSISTENT);
! 112: }
! 113: if (intern->u.file.open_mode) {
! 114: efree(intern->u.file.open_mode);
! 115: }
! 116: if (intern->orig_path) {
! 117: efree(intern->orig_path);
! 118: }
! 119: }
! 120: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 121: break;
! 122: }
! 123: efree(object);
! 124: } /* }}} */
! 125:
! 126: /* {{{ spl_ce_dir_object_new */
! 127: /* creates the object by
! 128: - allocating memory
! 129: - initializing the object members
! 130: - storing the object
! 131: - setting it's handlers
! 132:
! 133: called from
! 134: - clone
! 135: - new
! 136: */
! 137: static zend_object_value spl_filesystem_object_new_ex(zend_class_entry *class_type, spl_filesystem_object **obj TSRMLS_DC)
! 138: {
! 139: zend_object_value retval;
! 140: spl_filesystem_object *intern;
! 141: zval *tmp;
! 142:
! 143: intern = emalloc(sizeof(spl_filesystem_object));
! 144: memset(intern, 0, sizeof(spl_filesystem_object));
! 145: /* intern->type = SPL_FS_INFO; done by set 0 */
! 146: intern->file_class = spl_ce_SplFileObject;
! 147: intern->info_class = spl_ce_SplFileInfo;
! 148: if (obj) *obj = intern;
! 149:
! 150: zend_object_std_init(&intern->std, class_type TSRMLS_CC);
! 151: zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
! 152:
! 153: retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, (zend_objects_free_object_storage_t) spl_filesystem_object_free_storage, NULL TSRMLS_CC);
! 154: retval.handlers = &spl_filesystem_object_handlers;
! 155: return retval;
! 156: }
! 157: /* }}} */
! 158:
! 159: /* {{{ spl_filesystem_object_new */
! 160: /* See spl_filesystem_object_new_ex */
! 161: static zend_object_value spl_filesystem_object_new(zend_class_entry *class_type TSRMLS_DC)
! 162: {
! 163: return spl_filesystem_object_new_ex(class_type, NULL TSRMLS_CC);
! 164: }
! 165: /* }}} */
! 166:
! 167: /* {{{ spl_filesystem_object_new_ex */
! 168: static zend_object_value spl_filesystem_object_new_check(zend_class_entry *class_type TSRMLS_DC)
! 169: {
! 170: zend_object_value ret = spl_filesystem_object_new_ex(class_type, NULL TSRMLS_CC);
! 171: ret.handlers = &spl_filesystem_object_check_handlers;
! 172: return ret;
! 173: }
! 174: /* }}} */
! 175:
! 176:
! 177: PHPAPI char* spl_filesystem_object_get_path(spl_filesystem_object *intern, int *len TSRMLS_DC) /* {{{ */
! 178: {
! 179: #ifdef HAVE_GLOB
! 180: if (intern->type == SPL_FS_DIR) {
! 181: if (php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) {
! 182: return php_glob_stream_get_path(intern->u.dir.dirp, 0, len);
! 183: }
! 184: }
! 185: #endif
! 186: if (len) {
! 187: *len = intern->_path_len;
! 188: }
! 189: return intern->_path;
! 190: } /* }}} */
! 191:
! 192: static inline void spl_filesystem_object_get_file_name(spl_filesystem_object *intern TSRMLS_DC) /* {{{ */
! 193: {
! 194: char slash = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_UNIXPATHS) ? '/' : DEFAULT_SLASH;
! 195:
! 196: if (!intern->file_name) {
! 197: switch (intern->type) {
! 198: case SPL_FS_INFO:
! 199: case SPL_FS_FILE:
! 200: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Object not initialized");
! 201: break;
! 202: case SPL_FS_DIR:
! 203: intern->file_name_len = spprintf(&intern->file_name, 0, "%s%c%s",
! 204: spl_filesystem_object_get_path(intern, NULL TSRMLS_CC),
! 205: slash, intern->u.dir.entry.d_name);
! 206: break;
! 207: }
! 208: }
! 209: } /* }}} */
! 210:
! 211: static int spl_filesystem_dir_read(spl_filesystem_object *intern TSRMLS_DC) /* {{{ */
! 212: {
! 213: if (!intern->u.dir.dirp || !php_stream_readdir(intern->u.dir.dirp, &intern->u.dir.entry)) {
! 214: intern->u.dir.entry.d_name[0] = '\0';
! 215: return 0;
! 216: } else {
! 217: return 1;
! 218: }
! 219: }
! 220: /* }}} */
! 221:
! 222: #define IS_SLASH_AT(zs, pos) (IS_SLASH(zs[pos]))
! 223:
! 224: static inline int spl_filesystem_is_dot(const char * d_name) /* {{{ */
! 225: {
! 226: return !strcmp(d_name, ".") || !strcmp(d_name, "..");
! 227: }
! 228: /* }}} */
! 229:
! 230: /* {{{ spl_filesystem_dir_open */
! 231: /* open a directory resource */
! 232: static void spl_filesystem_dir_open(spl_filesystem_object* intern, char *path TSRMLS_DC)
! 233: {
! 234: int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);
! 235:
! 236: intern->type = SPL_FS_DIR;
! 237: intern->_path_len = strlen(path);
! 238: intern->u.dir.dirp = php_stream_opendir(path, ENFORCE_SAFE_MODE|REPORT_ERRORS, NULL);
! 239:
! 240: if (intern->_path_len > 1 && IS_SLASH_AT(path, intern->_path_len-1)) {
! 241: intern->_path = estrndup(path, --intern->_path_len);
! 242: } else {
! 243: intern->_path = estrndup(path, intern->_path_len);
! 244: }
! 245: intern->u.dir.index = 0;
! 246:
! 247: if (EG(exception) || intern->u.dir.dirp == NULL) {
! 248: intern->u.dir.entry.d_name[0] = '\0';
! 249: if (!EG(exception)) {
! 250: /* open failed w/out notice (turned to exception due to EH_THROW) */
! 251: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0
! 252: TSRMLS_CC, "Failed to open directory \"%s\"", path);
! 253: }
! 254: } else {
! 255: do {
! 256: spl_filesystem_dir_read(intern TSRMLS_CC);
! 257: } while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));
! 258: }
! 259: }
! 260: /* }}} */
! 261:
! 262: static int spl_filesystem_file_open(spl_filesystem_object *intern, int use_include_path, int silent TSRMLS_DC) /* {{{ */
! 263: {
! 264: intern->type = SPL_FS_FILE;
! 265: intern->u.file.context = php_stream_context_from_zval(intern->u.file.zcontext, 0);
! 266: intern->u.file.stream = php_stream_open_wrapper_ex(intern->file_name, intern->u.file.open_mode, (use_include_path ? USE_PATH : 0) | ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, intern->u.file.context);
! 267:
! 268: if (!intern->file_name_len || !intern->u.file.stream) {
! 269: if (!EG(exception)) {
! 270: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Cannot open file '%s'", intern->file_name_len ? intern->file_name : "");
! 271: }
! 272: intern->file_name = NULL; /* until here it is not a copy */
! 273: intern->u.file.open_mode = NULL;
! 274: return FAILURE;
! 275: }
! 276:
! 277: if (intern->u.file.zcontext) {
! 278: zend_list_addref(Z_RESVAL_P(intern->u.file.zcontext));
! 279: }
! 280:
! 281: if (intern->file_name_len > 1 && IS_SLASH_AT(intern->file_name, intern->file_name_len-1)) {
! 282: intern->file_name_len--;
! 283: }
! 284:
! 285: intern->orig_path = estrndup(intern->u.file.stream->orig_path, strlen(intern->u.file.stream->orig_path));
! 286:
! 287: intern->file_name = estrndup(intern->file_name, intern->file_name_len);
! 288: intern->u.file.open_mode = estrndup(intern->u.file.open_mode, intern->u.file.open_mode_len);
! 289:
! 290: /* avoid reference counting in debug mode, thus do it manually */
! 291: ZVAL_RESOURCE(&intern->u.file.zresource, php_stream_get_resource_id(intern->u.file.stream));
! 292: Z_SET_REFCOUNT(intern->u.file.zresource, 1);
! 293:
! 294: intern->u.file.delimiter = ',';
! 295: intern->u.file.enclosure = '"';
! 296: intern->u.file.escape = '\\';
! 297:
! 298: zend_hash_find(&intern->std.ce->function_table, "getcurrentline", sizeof("getcurrentline"), (void **) &intern->u.file.func_getCurr);
! 299:
! 300: return SUCCESS;
! 301: } /* }}} */
! 302:
! 303: /* {{{ spl_filesystem_object_clone */
! 304: /* Local zend_object_value creation (on stack)
! 305: Load the 'other' object
! 306: Create a new empty object (See spl_filesystem_object_new_ex)
! 307: Open the directory
! 308: Clone other members (properties)
! 309: */
! 310: static zend_object_value spl_filesystem_object_clone(zval *zobject TSRMLS_DC)
! 311: {
! 312: zend_object_value new_obj_val;
! 313: zend_object *old_object;
! 314: zend_object *new_object;
! 315: zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
! 316: spl_filesystem_object *intern;
! 317: spl_filesystem_object *source;
! 318: int index, skip_dots;
! 319:
! 320: old_object = zend_objects_get_address(zobject TSRMLS_CC);
! 321: source = (spl_filesystem_object*)old_object;
! 322:
! 323: new_obj_val = spl_filesystem_object_new_ex(old_object->ce, &intern TSRMLS_CC);
! 324: new_object = &intern->std;
! 325:
! 326: intern->flags = source->flags;
! 327:
! 328: switch (source->type) {
! 329: case SPL_FS_INFO:
! 330: intern->_path_len = source->_path_len;
! 331: intern->_path = estrndup(source->_path, source->_path_len);
! 332: intern->file_name_len = source->file_name_len;
! 333: intern->file_name = estrndup(source->file_name, intern->file_name_len);
! 334: break;
! 335: case SPL_FS_DIR:
! 336: spl_filesystem_dir_open(intern, source->_path TSRMLS_CC);
! 337: /* read until we hit the position in which we were before */
! 338: skip_dots = SPL_HAS_FLAG(source->flags, SPL_FILE_DIR_SKIPDOTS);
! 339: for(index = 0; index < source->u.dir.index; ++index) {
! 340: do {
! 341: spl_filesystem_dir_read(intern TSRMLS_CC);
! 342: } while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));
! 343: }
! 344: intern->u.dir.index = index;
! 345: break;
! 346: case SPL_FS_FILE:
! 347: php_error_docref(NULL TSRMLS_CC, E_ERROR, "An object of class %s cannot be cloned", old_object->ce->name);
! 348: break;
! 349: }
! 350:
! 351: intern->file_class = source->file_class;
! 352: intern->info_class = source->info_class;
! 353: intern->oth = source->oth;
! 354: intern->oth_handler = source->oth_handler;
! 355:
! 356: zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
! 357:
! 358: if (intern->oth_handler && intern->oth_handler->clone) {
! 359: intern->oth_handler->clone(source, intern TSRMLS_CC);
! 360: }
! 361:
! 362: return new_obj_val;
! 363: }
! 364: /* }}} */
! 365:
! 366: void spl_filesystem_info_set_filename(spl_filesystem_object *intern, char *path, int len, int use_copy TSRMLS_DC) /* {{{ */
! 367: {
! 368: char *p1, *p2;
! 369:
! 370: intern->file_name = use_copy ? estrndup(path, len) : path;
! 371: intern->file_name_len = len;
! 372:
! 373: while(IS_SLASH_AT(intern->file_name, intern->file_name_len-1) && intern->file_name_len > 1) {
! 374: intern->file_name[intern->file_name_len-1] = 0;
! 375: intern->file_name_len--;
! 376: }
! 377:
! 378: p1 = strrchr(intern->file_name, '/');
! 379: #if defined(PHP_WIN32) || defined(NETWARE)
! 380: p2 = strrchr(intern->file_name, '\\');
! 381: #else
! 382: p2 = 0;
! 383: #endif
! 384: if (p1 || p2) {
! 385: intern->_path_len = (p1 > p2 ? p1 : p2) - intern->file_name;
! 386: } else {
! 387: intern->_path_len = 0;
! 388: }
! 389:
! 390: intern->_path = estrndup(path, intern->_path_len);
! 391: } /* }}} */
! 392:
! 393: static spl_filesystem_object * spl_filesystem_object_create_info(spl_filesystem_object *source, char *file_path, int file_path_len, int use_copy, zend_class_entry *ce, zval *return_value TSRMLS_DC) /* {{{ */
! 394: {
! 395: spl_filesystem_object *intern;
! 396: zval *arg1;
! 397: zend_error_handling error_handling;
! 398:
! 399: if (!file_path || !file_path_len) {
! 400: #if defined(PHP_WIN32)
! 401: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Cannot create SplFileInfo for empty path");
! 402: if (file_path && !use_copy) {
! 403: efree(file_path);
! 404: }
! 405: #else
! 406: if (file_path && !use_copy) {
! 407: efree(file_path);
! 408: }
! 409: use_copy = 1;
! 410: file_path_len = 1;
! 411: file_path = "/";
! 412: #endif
! 413: return NULL;
! 414: }
! 415:
! 416: zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);
! 417:
! 418: ce = ce ? ce : source->info_class;
! 419:
! 420: zend_update_class_constants(ce TSRMLS_CC);
! 421:
! 422: return_value->value.obj = spl_filesystem_object_new_ex(ce, &intern TSRMLS_CC);
! 423: Z_TYPE_P(return_value) = IS_OBJECT;
! 424:
! 425: if (ce->constructor->common.scope != spl_ce_SplFileInfo) {
! 426: MAKE_STD_ZVAL(arg1);
! 427: ZVAL_STRINGL(arg1, file_path, file_path_len, use_copy);
! 428: zend_call_method_with_1_params(&return_value, ce, &ce->constructor, "__construct", NULL, arg1);
! 429: zval_ptr_dtor(&arg1);
! 430: } else {
! 431: spl_filesystem_info_set_filename(intern, file_path, file_path_len, use_copy TSRMLS_CC);
! 432: }
! 433:
! 434: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 435: return intern;
! 436: } /* }}} */
! 437:
! 438: static spl_filesystem_object * spl_filesystem_object_create_type(int ht, spl_filesystem_object *source, int type, zend_class_entry *ce, zval *return_value TSRMLS_DC) /* {{{ */
! 439: {
! 440: spl_filesystem_object *intern;
! 441: zend_bool use_include_path = 0;
! 442: zval *arg1, *arg2;
! 443: zend_error_handling error_handling;
! 444:
! 445: zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);
! 446:
! 447: switch (source->type) {
! 448: case SPL_FS_INFO:
! 449: case SPL_FS_FILE:
! 450: break;
! 451: case SPL_FS_DIR:
! 452: if (!source->u.dir.entry.d_name[0]) {
! 453: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Could not open file");
! 454: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 455: return NULL;
! 456: }
! 457: }
! 458:
! 459: switch (type) {
! 460: case SPL_FS_INFO:
! 461: ce = ce ? ce : source->info_class;
! 462:
! 463: zend_update_class_constants(ce TSRMLS_CC);
! 464:
! 465: return_value->value.obj = spl_filesystem_object_new_ex(ce, &intern TSRMLS_CC);
! 466: Z_TYPE_P(return_value) = IS_OBJECT;
! 467:
! 468: spl_filesystem_object_get_file_name(source TSRMLS_CC);
! 469: if (ce->constructor->common.scope != spl_ce_SplFileInfo) {
! 470: MAKE_STD_ZVAL(arg1);
! 471: ZVAL_STRINGL(arg1, source->file_name, source->file_name_len, 1);
! 472: zend_call_method_with_1_params(&return_value, ce, &ce->constructor, "__construct", NULL, arg1);
! 473: zval_ptr_dtor(&arg1);
! 474: } else {
! 475: intern->file_name = estrndup(source->file_name, source->file_name_len);
! 476: intern->file_name_len = source->file_name_len;
! 477: intern->_path = spl_filesystem_object_get_path(source, &intern->_path_len TSRMLS_CC);
! 478: intern->_path = estrndup(intern->_path, intern->_path_len);
! 479: }
! 480: break;
! 481: case SPL_FS_FILE:
! 482: ce = ce ? ce : source->file_class;
! 483:
! 484: zend_update_class_constants(ce TSRMLS_CC);
! 485:
! 486: return_value->value.obj = spl_filesystem_object_new_ex(ce, &intern TSRMLS_CC);
! 487: Z_TYPE_P(return_value) = IS_OBJECT;
! 488:
! 489: spl_filesystem_object_get_file_name(source TSRMLS_CC);
! 490:
! 491: if (ce->constructor->common.scope != spl_ce_SplFileObject) {
! 492: MAKE_STD_ZVAL(arg1);
! 493: MAKE_STD_ZVAL(arg2);
! 494: ZVAL_STRINGL(arg1, source->file_name, source->file_name_len, 1);
! 495: ZVAL_STRINGL(arg2, "r", 1, 1);
! 496: zend_call_method_with_2_params(&return_value, ce, &ce->constructor, "__construct", NULL, arg1, arg2);
! 497: zval_ptr_dtor(&arg1);
! 498: zval_ptr_dtor(&arg2);
! 499: } else {
! 500: intern->file_name = source->file_name;
! 501: intern->file_name_len = source->file_name_len;
! 502: intern->_path = spl_filesystem_object_get_path(source, &intern->_path_len TSRMLS_CC);
! 503: intern->_path = estrndup(intern->_path, intern->_path_len);
! 504:
! 505: intern->u.file.open_mode = "r";
! 506: intern->u.file.open_mode_len = 1;
! 507:
! 508: if (ht && zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sbr",
! 509: &intern->u.file.open_mode, &intern->u.file.open_mode_len,
! 510: &use_include_path, &intern->u.file.zcontext) == FAILURE) {
! 511: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 512: intern->u.file.open_mode = NULL;
! 513: intern->file_name = NULL;
! 514: zval_dtor(return_value);
! 515: Z_TYPE_P(return_value) = IS_NULL;
! 516: return NULL;
! 517: }
! 518:
! 519: if (spl_filesystem_file_open(intern, use_include_path, 0 TSRMLS_CC) == FAILURE) {
! 520: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 521: zval_dtor(return_value);
! 522: Z_TYPE_P(return_value) = IS_NULL;
! 523: return NULL;
! 524: }
! 525: }
! 526: break;
! 527: case SPL_FS_DIR:
! 528: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 529: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Operation not supported");
! 530: return NULL;
! 531: }
! 532: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 533: return NULL;
! 534: } /* }}} */
! 535:
! 536: static int spl_filesystem_is_invalid_or_dot(const char * d_name) /* {{{ */
! 537: {
! 538: return d_name[0] == '\0' || spl_filesystem_is_dot(d_name);
! 539: }
! 540: /* }}} */
! 541:
! 542: static char *spl_filesystem_object_get_pathname(spl_filesystem_object *intern, int *len TSRMLS_DC) { /* {{{ */
! 543: switch (intern->type) {
! 544: case SPL_FS_INFO:
! 545: case SPL_FS_FILE:
! 546: *len = intern->file_name_len;
! 547: return intern->file_name;
! 548: case SPL_FS_DIR:
! 549: if (intern->u.dir.entry.d_name[0]) {
! 550: spl_filesystem_object_get_file_name(intern TSRMLS_CC);
! 551: *len = intern->file_name_len;
! 552: return intern->file_name;
! 553: }
! 554: }
! 555: *len = 0;
! 556: return NULL;
! 557: }
! 558: /* }}} */
! 559:
! 560: static HashTable* spl_filesystem_object_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{ */
! 561: {
! 562: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(obj TSRMLS_CC);
! 563: HashTable *rv;
! 564: zval *tmp, zrv;
! 565: char *pnstr, *path;
! 566: int pnlen, path_len;
! 567: char stmp[2];
! 568:
! 569: *is_temp = 1;
! 570:
! 571: ALLOC_HASHTABLE(rv);
! 572: ZEND_INIT_SYMTABLE_EX(rv, zend_hash_num_elements(intern->std.properties) + 3, 0);
! 573:
! 574: INIT_PZVAL(&zrv);
! 575: Z_ARRVAL(zrv) = rv;
! 576:
! 577: zend_hash_copy(rv, intern->std.properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
! 578:
! 579: pnstr = spl_gen_private_prop_name(spl_ce_SplFileInfo, "pathName", sizeof("pathName")-1, &pnlen TSRMLS_CC);
! 580: path = spl_filesystem_object_get_pathname(intern, &path_len TSRMLS_CC);
! 581: add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, path, path_len, 1);
! 582: efree(pnstr);
! 583:
! 584: if (intern->file_name) {
! 585: pnstr = spl_gen_private_prop_name(spl_ce_SplFileInfo, "fileName", sizeof("fileName")-1, &pnlen TSRMLS_CC);
! 586: spl_filesystem_object_get_path(intern, &path_len TSRMLS_CC);
! 587:
! 588: if (path_len && path_len < intern->file_name_len) {
! 589: add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->file_name + path_len + 1, intern->file_name_len - (path_len + 1), 1);
! 590: } else {
! 591: add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->file_name, intern->file_name_len, 1);
! 592: }
! 593: efree(pnstr);
! 594: }
! 595: if (intern->type == SPL_FS_DIR) {
! 596: #ifdef HAVE_GLOB
! 597: pnstr = spl_gen_private_prop_name(spl_ce_DirectoryIterator, "glob", sizeof("glob")-1, &pnlen TSRMLS_CC);
! 598: if (php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) {
! 599: add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->_path, intern->_path_len, 1);
! 600: } else {
! 601: add_assoc_bool_ex(&zrv, pnstr, pnlen+1, 0);
! 602: }
! 603: efree(pnstr);
! 604: #endif
! 605: pnstr = spl_gen_private_prop_name(spl_ce_RecursiveDirectoryIterator, "subPathName", sizeof("subPathName")-1, &pnlen TSRMLS_CC);
! 606: if (intern->u.dir.sub_path) {
! 607: add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->u.dir.sub_path, intern->u.dir.sub_path_len, 1);
! 608: } else {
! 609: add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, "", 0, 1);
! 610: }
! 611: efree(pnstr);
! 612: }
! 613: if (intern->type == SPL_FS_FILE) {
! 614: pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "openMode", sizeof("openMode")-1, &pnlen TSRMLS_CC);
! 615: add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->u.file.open_mode, intern->u.file.open_mode_len, 1);
! 616: efree(pnstr);
! 617: stmp[1] = '\0';
! 618: stmp[0] = intern->u.file.delimiter;
! 619: pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "delimiter", sizeof("delimiter")-1, &pnlen TSRMLS_CC);
! 620: add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, stmp, 1, 1);
! 621: efree(pnstr);
! 622: stmp[0] = intern->u.file.enclosure;
! 623: pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "enclosure", sizeof("enclosure")-1, &pnlen TSRMLS_CC);
! 624: add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, stmp, 1, 1);
! 625: efree(pnstr);
! 626: }
! 627:
! 628: return rv;
! 629: }
! 630: /* }}} */
! 631:
! 632: zend_function *spl_filesystem_object_get_method_check(zval **object_ptr, char *method, int method_len TSRMLS_DC) /* {{{ */
! 633: {
! 634: spl_filesystem_object *fsobj = zend_object_store_get_object(*object_ptr TSRMLS_CC);
! 635:
! 636: if (fsobj->u.dir.entry.d_name[0] == '\0' && fsobj->orig_path == NULL) {
! 637: method = "_bad_state_ex";
! 638: method_len = sizeof("_bad_state_ex") - 1;
! 639: }
! 640:
! 641: return zend_get_std_object_handlers()->get_method(object_ptr, method, method_len TSRMLS_CC);
! 642: }
! 643: /* }}} */
! 644:
! 645: #define DIT_CTOR_FLAGS 0x00000001
! 646: #define DIT_CTOR_GLOB 0x00000002
! 647:
! 648: void spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAMETERS, long ctor_flags) /* {{{ */
! 649: {
! 650: spl_filesystem_object *intern;
! 651: char *path;
! 652: int parsed, len;
! 653: long flags;
! 654: zend_error_handling error_handling;
! 655:
! 656: zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling TSRMLS_CC);
! 657:
! 658: if (SPL_HAS_FLAG(ctor_flags, DIT_CTOR_FLAGS)) {
! 659: flags = SPL_FILE_DIR_KEY_AS_PATHNAME|SPL_FILE_DIR_CURRENT_AS_FILEINFO;
! 660: parsed = zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &path, &len, &flags);
! 661: } else {
! 662: flags = SPL_FILE_DIR_KEY_AS_PATHNAME|SPL_FILE_DIR_CURRENT_AS_SELF;
! 663: parsed = zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &len);
! 664: }
! 665: if (SPL_HAS_FLAG(ctor_flags, SPL_FILE_DIR_SKIPDOTS)) {
! 666: flags |= SPL_FILE_DIR_SKIPDOTS;
! 667: }
! 668: if (SPL_HAS_FLAG(ctor_flags, SPL_FILE_DIR_UNIXPATHS)) {
! 669: flags |= SPL_FILE_DIR_UNIXPATHS;
! 670: }
! 671: if (parsed == FAILURE) {
! 672: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 673: return;
! 674: }
! 675: if (!len) {
! 676: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Directory name must not be empty.");
! 677: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 678: return;
! 679: }
! 680:
! 681: intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 682: intern->flags = flags;
! 683: #ifdef HAVE_GLOB
! 684: if (SPL_HAS_FLAG(ctor_flags, DIT_CTOR_GLOB) && strstr(path, "glob://") != path) {
! 685: spprintf(&path, 0, "glob://%s", path);
! 686: spl_filesystem_dir_open(intern, path TSRMLS_CC);
! 687: efree(path);
! 688: } else
! 689: #endif
! 690: {
! 691: spl_filesystem_dir_open(intern, path TSRMLS_CC);
! 692:
! 693: }
! 694:
! 695: intern->u.dir.is_recursive = instanceof_function(intern->std.ce, spl_ce_RecursiveDirectoryIterator TSRMLS_CC) ? 1 : 0;
! 696:
! 697: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 698: }
! 699: /* }}} */
! 700:
! 701: /* {{{ proto void DirectoryIterator::__construct(string path)
! 702: Cronstructs a new dir iterator from a path. */
! 703: SPL_METHOD(DirectoryIterator, __construct)
! 704: {
! 705: spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
! 706: }
! 707: /* }}} */
! 708:
! 709: /* {{{ proto void DirectoryIterator::rewind()
! 710: Rewind dir back to the start */
! 711: SPL_METHOD(DirectoryIterator, rewind)
! 712: {
! 713: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 714:
! 715: if (zend_parse_parameters_none() == FAILURE) {
! 716: return;
! 717: }
! 718:
! 719: intern->u.dir.index = 0;
! 720: if (intern->u.dir.dirp) {
! 721: php_stream_rewinddir(intern->u.dir.dirp);
! 722: }
! 723: spl_filesystem_dir_read(intern TSRMLS_CC);
! 724: }
! 725: /* }}} */
! 726:
! 727: /* {{{ proto string DirectoryIterator::key()
! 728: Return current dir entry */
! 729: SPL_METHOD(DirectoryIterator, key)
! 730: {
! 731: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 732:
! 733: if (zend_parse_parameters_none() == FAILURE) {
! 734: return;
! 735: }
! 736:
! 737: if (intern->u.dir.dirp) {
! 738: RETURN_LONG(intern->u.dir.index);
! 739: } else {
! 740: RETURN_FALSE;
! 741: }
! 742: }
! 743: /* }}} */
! 744:
! 745: /* {{{ proto DirectoryIterator DirectoryIterator::current()
! 746: Return this (needed for Iterator interface) */
! 747: SPL_METHOD(DirectoryIterator, current)
! 748: {
! 749: if (zend_parse_parameters_none() == FAILURE) {
! 750: return;
! 751: }
! 752: RETURN_ZVAL(getThis(), 1, 0);
! 753: }
! 754: /* }}} */
! 755:
! 756: /* {{{ proto void DirectoryIterator::next()
! 757: Move to next entry */
! 758: SPL_METHOD(DirectoryIterator, next)
! 759: {
! 760: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 761: int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);
! 762:
! 763: if (zend_parse_parameters_none() == FAILURE) {
! 764: return;
! 765: }
! 766:
! 767: intern->u.dir.index++;
! 768: do {
! 769: spl_filesystem_dir_read(intern TSRMLS_CC);
! 770: } while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));
! 771: if (intern->file_name) {
! 772: efree(intern->file_name);
! 773: intern->file_name = NULL;
! 774: }
! 775: }
! 776: /* }}} */
! 777:
! 778: /* {{{ proto void DirectoryIterator::seek(int position)
! 779: Seek to the given position */
! 780: SPL_METHOD(DirectoryIterator, seek)
! 781: {
! 782: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 783: zval *retval = NULL;
! 784: long pos;
! 785:
! 786: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &pos) == FAILURE) {
! 787: return;
! 788: }
! 789:
! 790: if (intern->u.dir.index > pos) {
! 791: /* we first rewind */
! 792: zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_rewind, "rewind", &retval);
! 793: if (retval) {
! 794: zval_ptr_dtor(&retval);
! 795: }
! 796: }
! 797:
! 798: while (intern->u.dir.index < pos) {
! 799: int valid = 0;
! 800: zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_valid, "valid", &retval);
! 801: if (retval) {
! 802: valid = zend_is_true(retval);
! 803: zval_ptr_dtor(&retval);
! 804: }
! 805: if (!valid) {
! 806: break;
! 807: }
! 808: zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_next, "next", &retval);
! 809: if (retval) {
! 810: zval_ptr_dtor(&retval);
! 811: }
! 812: }
! 813: } /* }}} */
! 814:
! 815: /* {{{ proto string DirectoryIterator::valid()
! 816: Check whether dir contains more entries */
! 817: SPL_METHOD(DirectoryIterator, valid)
! 818: {
! 819: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 820:
! 821: if (zend_parse_parameters_none() == FAILURE) {
! 822: return;
! 823: }
! 824:
! 825: RETURN_BOOL(intern->u.dir.entry.d_name[0] != '\0');
! 826: }
! 827: /* }}} */
! 828:
! 829: /* {{{ proto string SplFileInfo::getPath()
! 830: Return the path */
! 831: SPL_METHOD(SplFileInfo, getPath)
! 832: {
! 833: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 834: char *path;
! 835: int path_len;
! 836:
! 837: if (zend_parse_parameters_none() == FAILURE) {
! 838: return;
! 839: }
! 840:
! 841: path = spl_filesystem_object_get_path(intern, &path_len TSRMLS_CC);
! 842: RETURN_STRINGL(path, path_len, 1);
! 843: }
! 844: /* }}} */
! 845:
! 846: /* {{{ proto string SplFileInfo::getFilename()
! 847: Return filename only */
! 848: SPL_METHOD(SplFileInfo, getFilename)
! 849: {
! 850: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 851: int path_len;
! 852:
! 853: if (zend_parse_parameters_none() == FAILURE) {
! 854: return;
! 855: }
! 856:
! 857: spl_filesystem_object_get_path(intern, &path_len TSRMLS_CC);
! 858:
! 859: if (path_len && path_len < intern->file_name_len) {
! 860: RETURN_STRINGL(intern->file_name + path_len + 1, intern->file_name_len - (path_len + 1), 1);
! 861: } else {
! 862: RETURN_STRINGL(intern->file_name, intern->file_name_len, 1);
! 863: }
! 864: }
! 865: /* }}} */
! 866:
! 867: /* {{{ proto string DirectoryIterator::getFilename()
! 868: Return filename of current dir entry */
! 869: SPL_METHOD(DirectoryIterator, getFilename)
! 870: {
! 871: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 872:
! 873: if (zend_parse_parameters_none() == FAILURE) {
! 874: return;
! 875: }
! 876:
! 877: RETURN_STRING(intern->u.dir.entry.d_name, 1);
! 878: }
! 879: /* }}} */
! 880:
! 881: /* {{{ proto string SplFileInfo::getExtension()
! 882: Returns file extension component of path */
! 883: SPL_METHOD(SplFileInfo, getExtension)
! 884: {
! 885: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 886: char *fname = NULL;
! 887: const char *p;
! 888: size_t flen;
! 889: int path_len, idx;
! 890:
! 891: if (zend_parse_parameters_none() == FAILURE) {
! 892: return;
! 893: }
! 894:
! 895: spl_filesystem_object_get_path(intern, &path_len TSRMLS_CC);
! 896:
! 897: if (path_len && path_len < intern->file_name_len) {
! 898: fname = intern->file_name + path_len + 1;
! 899: flen = intern->file_name_len - (path_len + 1);
! 900: } else {
! 901: fname = intern->file_name;
! 902: flen = intern->file_name_len;
! 903: }
! 904:
! 905: php_basename(fname, flen, NULL, 0, &fname, &flen TSRMLS_CC);
! 906:
! 907: p = zend_memrchr(fname, '.', flen);
! 908: if (p) {
! 909: idx = p - fname;
! 910: RETVAL_STRINGL(fname + idx + 1, flen - idx - 1, 1);
! 911: efree(fname);
! 912: return;
! 913: } else {
! 914: if (fname) {
! 915: efree(fname);
! 916: }
! 917: RETURN_EMPTY_STRING();
! 918: }
! 919: }
! 920: /* }}}*/
! 921:
! 922: /* {{{ proto string DirectoryIterator::getExtension()
! 923: Returns the file extension component of path */
! 924: SPL_METHOD(DirectoryIterator, getExtension)
! 925: {
! 926: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 927: char *fname = NULL;
! 928: const char *p;
! 929: size_t flen;
! 930: int idx;
! 931:
! 932: if (zend_parse_parameters_none() == FAILURE) {
! 933: return;
! 934: }
! 935:
! 936: php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), NULL, 0, &fname, &flen TSRMLS_CC);
! 937:
! 938: p = zend_memrchr(fname, '.', flen);
! 939: if (p) {
! 940: idx = p - fname;
! 941: RETVAL_STRINGL(fname + idx + 1, flen - idx - 1, 1);
! 942: efree(fname);
! 943: return;
! 944: } else {
! 945: if (fname) {
! 946: efree(fname);
! 947: }
! 948: RETURN_EMPTY_STRING();
! 949: }
! 950: }
! 951: /* }}} */
! 952:
! 953: /* {{{ proto string SplFileInfo::getBasename([string $suffix]) U
! 954: Returns filename component of path */
! 955: SPL_METHOD(SplFileInfo, getBasename)
! 956: {
! 957: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 958: char *fname, *suffix = 0;
! 959: size_t flen;
! 960: int slen = 0, path_len;
! 961:
! 962: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &suffix, &slen) == FAILURE) {
! 963: return;
! 964: }
! 965:
! 966: spl_filesystem_object_get_path(intern, &path_len TSRMLS_CC);
! 967:
! 968: if (path_len && path_len < intern->file_name_len) {
! 969: fname = intern->file_name + path_len + 1;
! 970: flen = intern->file_name_len - (path_len + 1);
! 971: } else {
! 972: fname = intern->file_name;
! 973: flen = intern->file_name_len;
! 974: }
! 975:
! 976: php_basename(fname, flen, suffix, slen, &fname, &flen TSRMLS_CC);
! 977:
! 978: RETURN_STRINGL(fname, flen, 0);
! 979: }
! 980: /* }}}*/
! 981:
! 982: /* {{{ proto string DirectoryIterator::getBasename([string $suffix]) U
! 983: Returns filename component of current dir entry */
! 984: SPL_METHOD(DirectoryIterator, getBasename)
! 985: {
! 986: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 987: char *suffix = 0, *fname;
! 988: int slen = 0;
! 989: size_t flen;
! 990:
! 991: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &suffix, &slen) == FAILURE) {
! 992: return;
! 993: }
! 994:
! 995: php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), suffix, slen, &fname, &flen TSRMLS_CC);
! 996:
! 997: RETURN_STRINGL(fname, flen, 0);
! 998: }
! 999: /* }}} */
! 1000:
! 1001: /* {{{ proto string SplFileInfo::getPathname()
! 1002: Return path and filename */
! 1003: SPL_METHOD(SplFileInfo, getPathname)
! 1004: {
! 1005: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1006: char *path;
! 1007: int path_len;
! 1008:
! 1009: if (zend_parse_parameters_none() == FAILURE) {
! 1010: return;
! 1011: }
! 1012: path = spl_filesystem_object_get_pathname(intern, &path_len TSRMLS_CC);
! 1013: if (path != NULL) {
! 1014: RETURN_STRINGL(path, path_len, 1);
! 1015: } else {
! 1016: RETURN_FALSE;
! 1017: }
! 1018: }
! 1019: /* }}} */
! 1020:
! 1021: /* {{{ proto string FilesystemIterator::key()
! 1022: Return getPathname() or getFilename() depending on flags */
! 1023: SPL_METHOD(FilesystemIterator, key)
! 1024: {
! 1025: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1026:
! 1027: if (zend_parse_parameters_none() == FAILURE) {
! 1028: return;
! 1029: }
! 1030:
! 1031: if (SPL_FILE_DIR_KEY(intern, SPL_FILE_DIR_KEY_AS_FILENAME)) {
! 1032: RETURN_STRING(intern->u.dir.entry.d_name, 1);
! 1033: } else {
! 1034: spl_filesystem_object_get_file_name(intern TSRMLS_CC);
! 1035: RETURN_STRINGL(intern->file_name, intern->file_name_len, 1);
! 1036: }
! 1037: }
! 1038: /* }}} */
! 1039:
! 1040: /* {{{ proto string FilesystemIterator::current()
! 1041: Return getFilename(), getFileInfo() or $this depending on flags */
! 1042: SPL_METHOD(FilesystemIterator, current)
! 1043: {
! 1044: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1045:
! 1046: if (zend_parse_parameters_none() == FAILURE) {
! 1047: return;
! 1048: }
! 1049:
! 1050: if (SPL_FILE_DIR_CURRENT(intern, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) {
! 1051: spl_filesystem_object_get_file_name(intern TSRMLS_CC);
! 1052: RETURN_STRINGL(intern->file_name, intern->file_name_len, 1);
! 1053: } else if (SPL_FILE_DIR_CURRENT(intern, SPL_FILE_DIR_CURRENT_AS_FILEINFO)) {
! 1054: spl_filesystem_object_get_file_name(intern TSRMLS_CC);
! 1055: spl_filesystem_object_create_type(0, intern, SPL_FS_INFO, NULL, return_value TSRMLS_CC);
! 1056: } else {
! 1057: RETURN_ZVAL(getThis(), 1, 0);
! 1058: /*RETURN_STRING(intern->u.dir.entry.d_name, 1);*/
! 1059: }
! 1060: }
! 1061: /* }}} */
! 1062:
! 1063: /* {{{ proto bool DirectoryIterator::isDot()
! 1064: Returns true if current entry is '.' or '..' */
! 1065: SPL_METHOD(DirectoryIterator, isDot)
! 1066: {
! 1067: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1068:
! 1069: if (zend_parse_parameters_none() == FAILURE) {
! 1070: return;
! 1071: }
! 1072:
! 1073: RETURN_BOOL(spl_filesystem_is_dot(intern->u.dir.entry.d_name));
! 1074: }
! 1075: /* }}} */
! 1076:
! 1077: /* {{{ proto void SplFileInfo::__construct(string file_name)
! 1078: Cronstructs a new SplFileInfo from a path. */
! 1079: /* zend_replace_error_handling() is used to throw exceptions in case
! 1080: the constructor fails. Here we use this to ensure the object
! 1081: has a valid directory resource.
! 1082:
! 1083: When the constructor gets called the object is already created
! 1084: by the engine, so we must only call 'additional' initializations.
! 1085: */
! 1086: SPL_METHOD(SplFileInfo, __construct)
! 1087: {
! 1088: spl_filesystem_object *intern;
! 1089: char *path;
! 1090: int len;
! 1091: zend_error_handling error_handling;
! 1092:
! 1093: zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);
! 1094:
! 1095: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &len) == FAILURE) {
! 1096: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1097: return;
! 1098: }
! 1099:
! 1100: intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1101:
! 1102: spl_filesystem_info_set_filename(intern, path, len, 1 TSRMLS_CC);
! 1103:
! 1104: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1105:
! 1106: /* intern->type = SPL_FS_INFO; already set */
! 1107: }
! 1108: /* }}} */
! 1109:
! 1110: /* {{{ FileInfoFunction */
! 1111: #define FileInfoFunction(func_name, func_num) \
! 1112: SPL_METHOD(SplFileInfo, func_name) \
! 1113: { \
! 1114: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \
! 1115: zend_error_handling error_handling; \
! 1116: if (zend_parse_parameters_none() == FAILURE) { \
! 1117: return; \
! 1118: } \
! 1119: \
! 1120: zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);\
! 1121: spl_filesystem_object_get_file_name(intern TSRMLS_CC); \
! 1122: php_stat(intern->file_name, intern->file_name_len, func_num, return_value TSRMLS_CC); \
! 1123: zend_restore_error_handling(&error_handling TSRMLS_CC); \
! 1124: }
! 1125: /* }}} */
! 1126:
! 1127: /* {{{ proto int SplFileInfo::getPerms()
! 1128: Get file permissions */
! 1129: FileInfoFunction(getPerms, FS_PERMS)
! 1130: /* }}} */
! 1131:
! 1132: /* {{{ proto int SplFileInfo::getInode()
! 1133: Get file inode */
! 1134: FileInfoFunction(getInode, FS_INODE)
! 1135: /* }}} */
! 1136:
! 1137: /* {{{ proto int SplFileInfo::getSize()
! 1138: Get file size */
! 1139: FileInfoFunction(getSize, FS_SIZE)
! 1140: /* }}} */
! 1141:
! 1142: /* {{{ proto int SplFileInfo::getOwner()
! 1143: Get file owner */
! 1144: FileInfoFunction(getOwner, FS_OWNER)
! 1145: /* }}} */
! 1146:
! 1147: /* {{{ proto int SplFileInfo::getGroup()
! 1148: Get file group */
! 1149: FileInfoFunction(getGroup, FS_GROUP)
! 1150: /* }}} */
! 1151:
! 1152: /* {{{ proto int SplFileInfo::getATime()
! 1153: Get last access time of file */
! 1154: FileInfoFunction(getATime, FS_ATIME)
! 1155: /* }}} */
! 1156:
! 1157: /* {{{ proto int SplFileInfo::getMTime()
! 1158: Get last modification time of file */
! 1159: FileInfoFunction(getMTime, FS_MTIME)
! 1160: /* }}} */
! 1161:
! 1162: /* {{{ proto int SplFileInfo::getCTime()
! 1163: Get inode modification time of file */
! 1164: FileInfoFunction(getCTime, FS_CTIME)
! 1165: /* }}} */
! 1166:
! 1167: /* {{{ proto string SplFileInfo::getType()
! 1168: Get file type */
! 1169: FileInfoFunction(getType, FS_TYPE)
! 1170: /* }}} */
! 1171:
! 1172: /* {{{ proto bool SplFileInfo::isWritable()
! 1173: Returns true if file can be written */
! 1174: FileInfoFunction(isWritable, FS_IS_W)
! 1175: /* }}} */
! 1176:
! 1177: /* {{{ proto bool SplFileInfo::isReadable()
! 1178: Returns true if file can be read */
! 1179: FileInfoFunction(isReadable, FS_IS_R)
! 1180: /* }}} */
! 1181:
! 1182: /* {{{ proto bool SplFileInfo::isExecutable()
! 1183: Returns true if file is executable */
! 1184: FileInfoFunction(isExecutable, FS_IS_X)
! 1185: /* }}} */
! 1186:
! 1187: /* {{{ proto bool SplFileInfo::isFile()
! 1188: Returns true if file is a regular file */
! 1189: FileInfoFunction(isFile, FS_IS_FILE)
! 1190: /* }}} */
! 1191:
! 1192: /* {{{ proto bool SplFileInfo::isDir()
! 1193: Returns true if file is directory */
! 1194: FileInfoFunction(isDir, FS_IS_DIR)
! 1195: /* }}} */
! 1196:
! 1197: /* {{{ proto bool SplFileInfo::isLink()
! 1198: Returns true if file is symbolic link */
! 1199: FileInfoFunction(isLink, FS_IS_LINK)
! 1200: /* }}} */
! 1201:
! 1202: /* {{{ proto string SplFileInfo::getLinkTarget() U
! 1203: Return the target of a symbolic link */
! 1204: SPL_METHOD(SplFileInfo, getLinkTarget)
! 1205: {
! 1206: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1207: int ret;
! 1208: char buff[MAXPATHLEN];
! 1209: zend_error_handling error_handling;
! 1210:
! 1211: if (zend_parse_parameters_none() == FAILURE) {
! 1212: return;
! 1213: }
! 1214:
! 1215: zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);
! 1216:
! 1217: #if defined(PHP_WIN32) || HAVE_SYMLINK
! 1218: if (intern->file_name == NULL) {
! 1219: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty filename");
! 1220: RETURN_FALSE;
! 1221: } else if (!IS_ABSOLUTE_PATH(intern->file_name, intern->file_name_len)) {
! 1222: char expanded_path[MAXPATHLEN];
! 1223:
! 1224: /* TODO: Fix expand_filepath to do not resolve links but only expand the path
! 1225: avoiding double two resolution attempts
! 1226: (Pierre) */
! 1227: if (!expand_filepath(intern->file_name, expanded_path TSRMLS_CC)) {
! 1228: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No such file or directory");
! 1229: RETURN_FALSE;
! 1230: }
! 1231: ret = php_sys_readlink(expanded_path, buff, MAXPATHLEN - 1);
! 1232: } else {
! 1233: ret = php_sys_readlink(intern->file_name, buff, MAXPATHLEN-1);
! 1234: }
! 1235: #else
! 1236: ret = -1; /* always fail if not implemented */
! 1237: #endif
! 1238:
! 1239: if (ret == -1) {
! 1240: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Unable to read link %s, error: %s", intern->file_name, strerror(errno));
! 1241: RETVAL_FALSE;
! 1242: } else {
! 1243: /* Append NULL to the end of the string */
! 1244: buff[ret] = '\0';
! 1245:
! 1246: RETVAL_STRINGL(buff, ret, 1);
! 1247: }
! 1248:
! 1249: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1250: }
! 1251: /* }}} */
! 1252:
! 1253: #if (!defined(__BEOS__) && !defined(NETWARE) && HAVE_REALPATH) || defined(ZTS)
! 1254: /* {{{ proto string SplFileInfo::getRealPath()
! 1255: Return the resolved path */
! 1256: SPL_METHOD(SplFileInfo, getRealPath)
! 1257: {
! 1258: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1259: char buff[MAXPATHLEN];
! 1260: char *filename;
! 1261: zend_error_handling error_handling;
! 1262:
! 1263: if (zend_parse_parameters_none() == FAILURE) {
! 1264: return;
! 1265: }
! 1266:
! 1267: zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);
! 1268:
! 1269: if (intern->type == SPL_FS_DIR && !intern->file_name && intern->u.dir.entry.d_name[0]) {
! 1270: spl_filesystem_object_get_file_name(intern TSRMLS_CC);
! 1271: }
! 1272:
! 1273: if (intern->orig_path) {
! 1274: filename = intern->orig_path;
! 1275: } else {
! 1276: filename = intern->file_name;
! 1277: }
! 1278:
! 1279:
! 1280: if (filename && VCWD_REALPATH(filename, buff)) {
! 1281: #ifdef ZTS
! 1282: if (VCWD_ACCESS(buff, F_OK)) {
! 1283: RETVAL_FALSE;
! 1284: } else
! 1285: #endif
! 1286: RETVAL_STRING(buff, 1);
! 1287: } else {
! 1288: RETVAL_FALSE;
! 1289: }
! 1290:
! 1291: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1292: }
! 1293: /* }}} */
! 1294: #endif
! 1295:
! 1296: /* {{{ proto SplFileObject SplFileInfo::openFile([string mode = 'r' [, bool use_include_path [, resource context]]])
! 1297: Open the current file */
! 1298: SPL_METHOD(SplFileInfo, openFile)
! 1299: {
! 1300: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1301:
! 1302: spl_filesystem_object_create_type(ht, intern, SPL_FS_FILE, NULL, return_value TSRMLS_CC);
! 1303: }
! 1304: /* }}} */
! 1305:
! 1306: /* {{{ proto void SplFileInfo::setFileClass([string class_name])
! 1307: Class to use in openFile() */
! 1308: SPL_METHOD(SplFileInfo, setFileClass)
! 1309: {
! 1310: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1311: zend_class_entry *ce = spl_ce_SplFileObject;
! 1312: zend_error_handling error_handling;
! 1313:
! 1314: zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling TSRMLS_CC);
! 1315:
! 1316: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|C", &ce) == SUCCESS) {
! 1317: intern->file_class = ce;
! 1318: }
! 1319:
! 1320: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1321: }
! 1322: /* }}} */
! 1323:
! 1324: /* {{{ proto void SplFileInfo::setInfoClass([string class_name])
! 1325: Class to use in getFileInfo(), getPathInfo() */
! 1326: SPL_METHOD(SplFileInfo, setInfoClass)
! 1327: {
! 1328: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1329: zend_class_entry *ce = spl_ce_SplFileInfo;
! 1330: zend_error_handling error_handling;
! 1331:
! 1332: zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling TSRMLS_CC);
! 1333:
! 1334: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|C", &ce) == SUCCESS) {
! 1335: intern->info_class = ce;
! 1336: }
! 1337:
! 1338: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1339: }
! 1340: /* }}} */
! 1341:
! 1342: /* {{{ proto SplFileInfo SplFileInfo::getFileInfo([string $class_name])
! 1343: Get/copy file info */
! 1344: SPL_METHOD(SplFileInfo, getFileInfo)
! 1345: {
! 1346: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1347: zend_class_entry *ce = intern->info_class;
! 1348: zend_error_handling error_handling;
! 1349:
! 1350: zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling TSRMLS_CC);
! 1351:
! 1352: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|C", &ce) == SUCCESS) {
! 1353: spl_filesystem_object_create_type(ht, intern, SPL_FS_INFO, ce, return_value TSRMLS_CC);
! 1354: }
! 1355:
! 1356: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1357: }
! 1358: /* }}} */
! 1359:
! 1360: /* {{{ proto SplFileInfo SplFileInfo::getPathInfo([string $class_name])
! 1361: Get/copy file info */
! 1362: SPL_METHOD(SplFileInfo, getPathInfo)
! 1363: {
! 1364: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1365: zend_class_entry *ce = intern->info_class;
! 1366: zend_error_handling error_handling;
! 1367:
! 1368: zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling TSRMLS_CC);
! 1369:
! 1370: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|C", &ce) == SUCCESS) {
! 1371: int path_len;
! 1372: char *path = spl_filesystem_object_get_pathname(intern, &path_len TSRMLS_CC);
! 1373: if (path) {
! 1374: char *dpath = estrndup(path, path_len);
! 1375: path_len = php_dirname(dpath, path_len);
! 1376: spl_filesystem_object_create_info(intern, dpath, path_len, 1, ce, return_value TSRMLS_CC);
! 1377: efree(dpath);
! 1378: }
! 1379: }
! 1380:
! 1381: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1382: }
! 1383: /* }}} */
! 1384:
! 1385: /* {{{ */
! 1386: SPL_METHOD(SplFileInfo, _bad_state_ex)
! 1387: {
! 1388: zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC,
! 1389: "The parent constructor was not called: the object is in an "
! 1390: "invalid state ");
! 1391: }
! 1392: /* }}} */
! 1393:
! 1394: /* {{{ proto void FilesystemIterator::__construct(string path [, int flags])
! 1395: Cronstructs a new dir iterator from a path. */
! 1396: SPL_METHOD(FilesystemIterator, __construct)
! 1397: {
! 1398: spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, DIT_CTOR_FLAGS | SPL_FILE_DIR_SKIPDOTS);
! 1399: }
! 1400: /* }}} */
! 1401:
! 1402: /* {{{ proto void FilesystemIterator::rewind()
! 1403: Rewind dir back to the start */
! 1404: SPL_METHOD(FilesystemIterator, rewind)
! 1405: {
! 1406: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1407:
! 1408: if (zend_parse_parameters_none() == FAILURE) {
! 1409: return;
! 1410: }
! 1411:
! 1412: intern->u.dir.index = 0;
! 1413: if (intern->u.dir.dirp) {
! 1414: php_stream_rewinddir(intern->u.dir.dirp);
! 1415: }
! 1416: do {
! 1417: spl_filesystem_dir_read(intern TSRMLS_CC);
! 1418: } while (spl_filesystem_is_dot(intern->u.dir.entry.d_name));
! 1419: }
! 1420: /* }}} */
! 1421:
! 1422: /* {{{ proto int FilesystemIterator::getFlags()
! 1423: Get handling flags */
! 1424: SPL_METHOD(FilesystemIterator, getFlags)
! 1425: {
! 1426: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1427:
! 1428: if (zend_parse_parameters_none() == FAILURE) {
! 1429: return;
! 1430: }
! 1431:
! 1432: RETURN_LONG(intern->flags & (SPL_FILE_DIR_KEY_MODE_MASK | SPL_FILE_DIR_CURRENT_MODE_MASK | SPL_FILE_DIR_OTHERS_MASK));
! 1433: } /* }}} */
! 1434:
! 1435: /* {{{ proto void FilesystemIterator::setFlags(long $flags)
! 1436: Set handling flags */
! 1437: SPL_METHOD(FilesystemIterator, setFlags)
! 1438: {
! 1439: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1440: long flags;
! 1441:
! 1442: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flags) == FAILURE) {
! 1443: return;
! 1444: }
! 1445:
! 1446: intern->flags &= ~(SPL_FILE_DIR_KEY_MODE_MASK|SPL_FILE_DIR_CURRENT_MODE_MASK|SPL_FILE_DIR_OTHERS_MASK);
! 1447: intern->flags |= ((SPL_FILE_DIR_KEY_MODE_MASK|SPL_FILE_DIR_CURRENT_MODE_MASK|SPL_FILE_DIR_OTHERS_MASK) & flags);
! 1448: } /* }}} */
! 1449:
! 1450: /* {{{ proto bool RecursiveDirectoryIterator::hasChildren([bool $allow_links = false])
! 1451: Returns whether current entry is a directory and not '.' or '..' */
! 1452: SPL_METHOD(RecursiveDirectoryIterator, hasChildren)
! 1453: {
! 1454: zend_bool allow_links = 0;
! 1455: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1456:
! 1457: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &allow_links) == FAILURE) {
! 1458: return;
! 1459: }
! 1460: if (spl_filesystem_is_invalid_or_dot(intern->u.dir.entry.d_name)) {
! 1461: RETURN_FALSE;
! 1462: } else {
! 1463: spl_filesystem_object_get_file_name(intern TSRMLS_CC);
! 1464: if (!allow_links && !(intern->flags & SPL_FILE_DIR_FOLLOW_SYMLINKS)) {
! 1465: php_stat(intern->file_name, intern->file_name_len, FS_IS_LINK, return_value TSRMLS_CC);
! 1466: if (zend_is_true(return_value)) {
! 1467: RETURN_FALSE;
! 1468: }
! 1469: }
! 1470: php_stat(intern->file_name, intern->file_name_len, FS_IS_DIR, return_value TSRMLS_CC);
! 1471: }
! 1472: }
! 1473: /* }}} */
! 1474:
! 1475: /* {{{ proto RecursiveDirectoryIterator DirectoryIterator::getChildren()
! 1476: Returns an iterator for the current entry if it is a directory */
! 1477: SPL_METHOD(RecursiveDirectoryIterator, getChildren)
! 1478: {
! 1479: zval zpath, zflags;
! 1480: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1481: spl_filesystem_object *subdir;
! 1482: char slash = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_UNIXPATHS) ? '/' : DEFAULT_SLASH;
! 1483:
! 1484: if (zend_parse_parameters_none() == FAILURE) {
! 1485: return;
! 1486: }
! 1487:
! 1488: spl_filesystem_object_get_file_name(intern TSRMLS_CC);
! 1489:
! 1490: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) {
! 1491: RETURN_STRINGL(intern->file_name, intern->file_name_len, 1);
! 1492: } else {
! 1493: INIT_PZVAL(&zflags);
! 1494: INIT_PZVAL(&zpath);
! 1495: ZVAL_LONG(&zflags, intern->flags);
! 1496: ZVAL_STRINGL(&zpath, intern->file_name, intern->file_name_len, 0);
! 1497: spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, &zpath, &zflags TSRMLS_CC);
! 1498:
! 1499: subdir = (spl_filesystem_object*)zend_object_store_get_object(return_value TSRMLS_CC);
! 1500: if (subdir) {
! 1501: if (intern->u.dir.sub_path && intern->u.dir.sub_path[0]) {
! 1502: subdir->u.dir.sub_path_len = spprintf(&subdir->u.dir.sub_path, 0, "%s%c%s", intern->u.dir.sub_path, slash, intern->u.dir.entry.d_name);
! 1503: } else {
! 1504: subdir->u.dir.sub_path_len = strlen(intern->u.dir.entry.d_name);
! 1505: subdir->u.dir.sub_path = estrndup(intern->u.dir.entry.d_name, subdir->u.dir.sub_path_len);
! 1506: }
! 1507: subdir->info_class = intern->info_class;
! 1508: subdir->file_class = intern->file_class;
! 1509: subdir->oth = intern->oth;
! 1510: }
! 1511: }
! 1512: }
! 1513: /* }}} */
! 1514:
! 1515: /* {{{ proto void RecursiveDirectoryIterator::getSubPath()
! 1516: Get sub path */
! 1517: SPL_METHOD(RecursiveDirectoryIterator, getSubPath)
! 1518: {
! 1519: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1520:
! 1521: if (zend_parse_parameters_none() == FAILURE) {
! 1522: return;
! 1523: }
! 1524:
! 1525: if (intern->u.dir.sub_path) {
! 1526: RETURN_STRINGL(intern->u.dir.sub_path, intern->u.dir.sub_path_len, 1);
! 1527: } else {
! 1528: RETURN_STRINGL("", 0, 1);
! 1529: }
! 1530: }
! 1531: /* }}} */
! 1532:
! 1533: /* {{{ proto void RecursiveDirectoryIterator::getSubPathname()
! 1534: Get sub path and file name */
! 1535: SPL_METHOD(RecursiveDirectoryIterator, getSubPathname)
! 1536: {
! 1537: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1538: char *sub_name;
! 1539: int len;
! 1540: char slash = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_UNIXPATHS) ? '/' : DEFAULT_SLASH;
! 1541:
! 1542: if (zend_parse_parameters_none() == FAILURE) {
! 1543: return;
! 1544: }
! 1545:
! 1546: if (intern->u.dir.sub_path) {
! 1547: len = spprintf(&sub_name, 0, "%s%c%s", intern->u.dir.sub_path, slash, intern->u.dir.entry.d_name);
! 1548: RETURN_STRINGL(sub_name, len, 0);
! 1549: } else {
! 1550: RETURN_STRING(intern->u.dir.entry.d_name, 1);
! 1551: }
! 1552: }
! 1553: /* }}} */
! 1554:
! 1555: /* {{{ proto int RecursiveDirectoryIterator::__construct(string path [, int flags])
! 1556: Cronstructs a new dir iterator from a path. */
! 1557: SPL_METHOD(RecursiveDirectoryIterator, __construct)
! 1558: {
! 1559: spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, DIT_CTOR_FLAGS);
! 1560: }
! 1561: /* }}} */
! 1562:
! 1563: #ifdef HAVE_GLOB
! 1564: /* {{{ proto int GlobIterator::__construct(string path [, int flags])
! 1565: Cronstructs a new dir iterator from a glob expression (no glob:// needed). */
! 1566: SPL_METHOD(GlobIterator, __construct)
! 1567: {
! 1568: spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, DIT_CTOR_FLAGS|DIT_CTOR_GLOB);
! 1569: }
! 1570: /* }}} */
! 1571:
! 1572: /* {{{ proto int GlobIterator::cont()
! 1573: Return the number of directories and files found by globbing */
! 1574: SPL_METHOD(GlobIterator, count)
! 1575: {
! 1576: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1577:
! 1578: if (zend_parse_parameters_none() == FAILURE) {
! 1579: return;
! 1580: }
! 1581:
! 1582: if (php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) {
! 1583: RETURN_LONG(php_glob_stream_get_count(intern->u.dir.dirp, NULL));
! 1584: } else {
! 1585: /* should not happen */
! 1586: php_error_docref(NULL TSRMLS_CC, E_ERROR, "GlobIterator lost glob state");
! 1587: }
! 1588: }
! 1589: /* }}} */
! 1590: #endif /* HAVE_GLOB */
! 1591:
! 1592: /* {{{ forward declarations to the iterator handlers */
! 1593: static void spl_filesystem_dir_it_dtor(zend_object_iterator *iter TSRMLS_DC);
! 1594: static int spl_filesystem_dir_it_valid(zend_object_iterator *iter TSRMLS_DC);
! 1595: static void spl_filesystem_dir_it_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC);
! 1596: static int spl_filesystem_dir_it_current_key(zend_object_iterator *iter, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC);
! 1597: static void spl_filesystem_dir_it_move_forward(zend_object_iterator *iter TSRMLS_DC);
! 1598: static void spl_filesystem_dir_it_rewind(zend_object_iterator *iter TSRMLS_DC);
! 1599:
! 1600: /* iterator handler table */
! 1601: zend_object_iterator_funcs spl_filesystem_dir_it_funcs = {
! 1602: spl_filesystem_dir_it_dtor,
! 1603: spl_filesystem_dir_it_valid,
! 1604: spl_filesystem_dir_it_current_data,
! 1605: spl_filesystem_dir_it_current_key,
! 1606: spl_filesystem_dir_it_move_forward,
! 1607: spl_filesystem_dir_it_rewind
! 1608: };
! 1609: /* }}} */
! 1610:
! 1611: /* {{{ spl_ce_dir_get_iterator */
! 1612: zend_object_iterator *spl_filesystem_dir_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
! 1613: {
! 1614: spl_filesystem_iterator *iterator;
! 1615: spl_filesystem_object *dir_object;
! 1616:
! 1617: if (by_ref) {
! 1618: zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
! 1619: }
! 1620: dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC);
! 1621: iterator = spl_filesystem_object_to_iterator(dir_object);
! 1622:
! 1623: Z_SET_REFCOUNT_P(object, Z_REFCOUNT_P(object) + 2);
! 1624: iterator->intern.data = (void*)object;
! 1625: iterator->intern.funcs = &spl_filesystem_dir_it_funcs;
! 1626: iterator->current = object;
! 1627:
! 1628: return (zend_object_iterator*)iterator;
! 1629: }
! 1630: /* }}} */
! 1631:
! 1632: /* {{{ spl_filesystem_dir_it_dtor */
! 1633: static void spl_filesystem_dir_it_dtor(zend_object_iterator *iter TSRMLS_DC)
! 1634: {
! 1635: spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
! 1636: zval *zfree = (zval*)iterator->intern.data;
! 1637:
! 1638: iterator->intern.data = NULL; /* mark as unused */
! 1639: zval_ptr_dtor(&iterator->current);
! 1640: if (zfree) {
! 1641: zval_ptr_dtor(&zfree);
! 1642: }
! 1643: }
! 1644: /* }}} */
! 1645:
! 1646: /* {{{ spl_filesystem_dir_it_valid */
! 1647: static int spl_filesystem_dir_it_valid(zend_object_iterator *iter TSRMLS_DC)
! 1648: {
! 1649: spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
! 1650:
! 1651: return object->u.dir.entry.d_name[0] != '\0' ? SUCCESS : FAILURE;
! 1652: }
! 1653: /* }}} */
! 1654:
! 1655: /* {{{ spl_filesystem_dir_it_current_data */
! 1656: static void spl_filesystem_dir_it_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
! 1657: {
! 1658: spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
! 1659:
! 1660: *data = &iterator->current;
! 1661: }
! 1662: /* }}} */
! 1663:
! 1664: /* {{{ spl_filesystem_dir_it_current_key */
! 1665: static int spl_filesystem_dir_it_current_key(zend_object_iterator *iter, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC)
! 1666: {
! 1667: spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
! 1668:
! 1669: *int_key = object->u.dir.index;
! 1670: return HASH_KEY_IS_LONG;
! 1671: }
! 1672: /* }}} */
! 1673:
! 1674: /* {{{ spl_filesystem_dir_it_move_forward */
! 1675: static void spl_filesystem_dir_it_move_forward(zend_object_iterator *iter TSRMLS_DC)
! 1676: {
! 1677: spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
! 1678:
! 1679: object->u.dir.index++;
! 1680: spl_filesystem_dir_read(object TSRMLS_CC);
! 1681: if (object->file_name) {
! 1682: efree(object->file_name);
! 1683: object->file_name = NULL;
! 1684: }
! 1685: }
! 1686: /* }}} */
! 1687:
! 1688: /* {{{ spl_filesystem_dir_it_rewind */
! 1689: static void spl_filesystem_dir_it_rewind(zend_object_iterator *iter TSRMLS_DC)
! 1690: {
! 1691: spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
! 1692:
! 1693: object->u.dir.index = 0;
! 1694: if (object->u.dir.dirp) {
! 1695: php_stream_rewinddir(object->u.dir.dirp);
! 1696: }
! 1697: spl_filesystem_dir_read(object TSRMLS_CC);
! 1698: }
! 1699: /* }}} */
! 1700:
! 1701: /* {{{ spl_filesystem_tree_it_dtor */
! 1702: static void spl_filesystem_tree_it_dtor(zend_object_iterator *iter TSRMLS_DC)
! 1703: {
! 1704: spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
! 1705: zval *zfree = (zval*)iterator->intern.data;
! 1706:
! 1707: if (iterator->current) {
! 1708: zval_ptr_dtor(&iterator->current);
! 1709: }
! 1710: iterator->intern.data = NULL; /* mark as unused */
! 1711: /* free twice as we add ref twice */
! 1712: zval_ptr_dtor(&zfree);
! 1713: zval_ptr_dtor(&zfree);
! 1714: }
! 1715: /* }}} */
! 1716:
! 1717: /* {{{ spl_filesystem_tree_it_current_data */
! 1718: static void spl_filesystem_tree_it_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
! 1719: {
! 1720: spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
! 1721: spl_filesystem_object *object = spl_filesystem_iterator_to_object(iterator);
! 1722:
! 1723: if (SPL_FILE_DIR_CURRENT(object, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) {
! 1724: if (!iterator->current) {
! 1725: ALLOC_INIT_ZVAL(iterator->current);
! 1726: spl_filesystem_object_get_file_name(object TSRMLS_CC);
! 1727: ZVAL_STRINGL(iterator->current, object->file_name, object->file_name_len, 1);
! 1728: }
! 1729: *data = &iterator->current;
! 1730: } else if (SPL_FILE_DIR_CURRENT(object, SPL_FILE_DIR_CURRENT_AS_FILEINFO)) {
! 1731: if (!iterator->current) {
! 1732: ALLOC_INIT_ZVAL(iterator->current);
! 1733: spl_filesystem_object_get_file_name(object TSRMLS_CC);
! 1734: spl_filesystem_object_create_type(0, object, SPL_FS_INFO, NULL, iterator->current TSRMLS_CC);
! 1735: }
! 1736: *data = &iterator->current;
! 1737: } else {
! 1738: *data = (zval**)&iterator->intern.data;
! 1739: }
! 1740: }
! 1741: /* }}} */
! 1742:
! 1743: /* {{{ spl_filesystem_tree_it_current_key */
! 1744: static int spl_filesystem_tree_it_current_key(zend_object_iterator *iter, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC)
! 1745: {
! 1746: spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
! 1747:
! 1748: if (SPL_FILE_DIR_KEY(object, SPL_FILE_DIR_KEY_AS_FILENAME)) {
! 1749: *str_key_len = strlen(object->u.dir.entry.d_name) + 1;
! 1750: *str_key = estrndup(object->u.dir.entry.d_name, *str_key_len - 1);
! 1751: } else {
! 1752: spl_filesystem_object_get_file_name(object TSRMLS_CC);
! 1753: *str_key_len = object->file_name_len + 1;
! 1754: *str_key = estrndup(object->file_name, object->file_name_len);
! 1755: }
! 1756: return HASH_KEY_IS_STRING;
! 1757: }
! 1758: /* }}} */
! 1759:
! 1760: /* {{{ spl_filesystem_tree_it_move_forward */
! 1761: static void spl_filesystem_tree_it_move_forward(zend_object_iterator *iter TSRMLS_DC)
! 1762: {
! 1763: spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
! 1764: spl_filesystem_object *object = spl_filesystem_iterator_to_object(iterator);
! 1765:
! 1766: object->u.dir.index++;
! 1767: do {
! 1768: spl_filesystem_dir_read(object TSRMLS_CC);
! 1769: } while (spl_filesystem_is_dot(object->u.dir.entry.d_name));
! 1770: if (object->file_name) {
! 1771: efree(object->file_name);
! 1772: object->file_name = NULL;
! 1773: }
! 1774: if (iterator->current) {
! 1775: zval_ptr_dtor(&iterator->current);
! 1776: iterator->current = NULL;
! 1777: }
! 1778: }
! 1779: /* }}} */
! 1780:
! 1781: /* {{{ spl_filesystem_tree_it_rewind */
! 1782: static void spl_filesystem_tree_it_rewind(zend_object_iterator *iter TSRMLS_DC)
! 1783: {
! 1784: spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
! 1785: spl_filesystem_object *object = spl_filesystem_iterator_to_object(iterator);
! 1786:
! 1787: object->u.dir.index = 0;
! 1788: if (object->u.dir.dirp) {
! 1789: php_stream_rewinddir(object->u.dir.dirp);
! 1790: }
! 1791: do {
! 1792: spl_filesystem_dir_read(object TSRMLS_CC);
! 1793: } while (spl_filesystem_is_dot(object->u.dir.entry.d_name));
! 1794: if (iterator->current) {
! 1795: zval_ptr_dtor(&iterator->current);
! 1796: iterator->current = NULL;
! 1797: }
! 1798: }
! 1799: /* }}} */
! 1800:
! 1801: /* {{{ iterator handler table */
! 1802: zend_object_iterator_funcs spl_filesystem_tree_it_funcs = {
! 1803: spl_filesystem_tree_it_dtor,
! 1804: spl_filesystem_dir_it_valid,
! 1805: spl_filesystem_tree_it_current_data,
! 1806: spl_filesystem_tree_it_current_key,
! 1807: spl_filesystem_tree_it_move_forward,
! 1808: spl_filesystem_tree_it_rewind
! 1809: };
! 1810: /* }}} */
! 1811:
! 1812: /* {{{ spl_ce_dir_get_iterator */
! 1813: zend_object_iterator *spl_filesystem_tree_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
! 1814: {
! 1815: spl_filesystem_iterator *iterator;
! 1816: spl_filesystem_object *dir_object;
! 1817:
! 1818: if (by_ref) {
! 1819: zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
! 1820: }
! 1821: dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC);
! 1822: iterator = spl_filesystem_object_to_iterator(dir_object);
! 1823:
! 1824: Z_SET_REFCOUNT_P(object, Z_REFCOUNT_P(object) + 2);
! 1825: iterator->intern.data = (void*)object;
! 1826: iterator->intern.funcs = &spl_filesystem_tree_it_funcs;
! 1827: iterator->current = NULL;
! 1828:
! 1829: return (zend_object_iterator*)iterator;
! 1830: }
! 1831: /* }}} */
! 1832:
! 1833: /* {{{ spl_filesystem_object_cast */
! 1834: static int spl_filesystem_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
! 1835: {
! 1836: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(readobj TSRMLS_CC);
! 1837:
! 1838: if (type == IS_STRING) {
! 1839: switch (intern->type) {
! 1840: case SPL_FS_INFO:
! 1841: case SPL_FS_FILE:
! 1842: if (readobj == writeobj) {
! 1843: zval retval;
! 1844: zval *retval_ptr = &retval;
! 1845:
! 1846: ZVAL_STRINGL(retval_ptr, intern->file_name, intern->file_name_len, 1);
! 1847: zval_dtor(readobj);
! 1848: ZVAL_ZVAL(writeobj, retval_ptr, 0, 0);
! 1849: } else {
! 1850: ZVAL_STRINGL(writeobj, intern->file_name, intern->file_name_len, 1);
! 1851: }
! 1852: return SUCCESS;
! 1853: case SPL_FS_DIR:
! 1854: if (readobj == writeobj) {
! 1855: zval retval;
! 1856: zval *retval_ptr = &retval;
! 1857:
! 1858: ZVAL_STRING(retval_ptr, intern->u.dir.entry.d_name, 1);
! 1859: zval_dtor(readobj);
! 1860: ZVAL_ZVAL(writeobj, retval_ptr, 0, 0);
! 1861: } else {
! 1862: ZVAL_STRING(writeobj, intern->u.dir.entry.d_name, 1);
! 1863: }
! 1864: return SUCCESS;
! 1865: }
! 1866: }
! 1867: if (readobj == writeobj) {
! 1868: zval_dtor(readobj);
! 1869: }
! 1870: ZVAL_NULL(writeobj);
! 1871: return FAILURE;
! 1872: }
! 1873: /* }}} */
! 1874:
! 1875: /* {{{ declare method parameters */
! 1876: /* supply a name and default to call by parameter */
! 1877: ZEND_BEGIN_ARG_INFO(arginfo_info___construct, 0)
! 1878: ZEND_ARG_INFO(0, file_name)
! 1879: ZEND_END_ARG_INFO()
! 1880:
! 1881: ZEND_BEGIN_ARG_INFO_EX(arginfo_info_openFile, 0, 0, 0)
! 1882: ZEND_ARG_INFO(0, open_mode)
! 1883: ZEND_ARG_INFO(0, use_include_path)
! 1884: ZEND_ARG_INFO(0, context)
! 1885: ZEND_END_ARG_INFO()
! 1886:
! 1887: ZEND_BEGIN_ARG_INFO_EX(arginfo_info_optinalFileClass, 0, 0, 0)
! 1888: ZEND_ARG_INFO(0, class_name)
! 1889: ZEND_END_ARG_INFO()
! 1890:
! 1891: ZEND_BEGIN_ARG_INFO_EX(arginfo_optinalSuffix, 0, 0, 0)
! 1892: ZEND_ARG_INFO(0, suffix)
! 1893: ZEND_END_ARG_INFO()
! 1894:
! 1895: ZEND_BEGIN_ARG_INFO(arginfo_splfileinfo_void, 0)
! 1896: ZEND_END_ARG_INFO()
! 1897:
! 1898: /* the method table */
! 1899: /* each method can have its own parameters and visibility */
! 1900: static const zend_function_entry spl_SplFileInfo_functions[] = {
! 1901: SPL_ME(SplFileInfo, __construct, arginfo_info___construct, ZEND_ACC_PUBLIC)
! 1902: SPL_ME(SplFileInfo, getPath, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1903: SPL_ME(SplFileInfo, getFilename, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1904: SPL_ME(SplFileInfo, getExtension, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1905: SPL_ME(SplFileInfo, getBasename, arginfo_optinalSuffix, ZEND_ACC_PUBLIC)
! 1906: SPL_ME(SplFileInfo, getPathname, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1907: SPL_ME(SplFileInfo, getPerms, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1908: SPL_ME(SplFileInfo, getInode, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1909: SPL_ME(SplFileInfo, getSize, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1910: SPL_ME(SplFileInfo, getOwner, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1911: SPL_ME(SplFileInfo, getGroup, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1912: SPL_ME(SplFileInfo, getATime, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1913: SPL_ME(SplFileInfo, getMTime, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1914: SPL_ME(SplFileInfo, getCTime, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1915: SPL_ME(SplFileInfo, getType, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1916: SPL_ME(SplFileInfo, isWritable, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1917: SPL_ME(SplFileInfo, isReadable, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1918: SPL_ME(SplFileInfo, isExecutable, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1919: SPL_ME(SplFileInfo, isFile, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1920: SPL_ME(SplFileInfo, isDir, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1921: SPL_ME(SplFileInfo, isLink, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1922: SPL_ME(SplFileInfo, getLinkTarget, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1923: #if (!defined(__BEOS__) && !defined(NETWARE) && HAVE_REALPATH) || defined(ZTS)
! 1924: SPL_ME(SplFileInfo, getRealPath, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1925: #endif
! 1926: SPL_ME(SplFileInfo, getFileInfo, arginfo_info_optinalFileClass, ZEND_ACC_PUBLIC)
! 1927: SPL_ME(SplFileInfo, getPathInfo, arginfo_info_optinalFileClass, ZEND_ACC_PUBLIC)
! 1928: SPL_ME(SplFileInfo, openFile, arginfo_info_openFile, ZEND_ACC_PUBLIC)
! 1929: SPL_ME(SplFileInfo, setFileClass, arginfo_info_optinalFileClass, ZEND_ACC_PUBLIC)
! 1930: SPL_ME(SplFileInfo, setInfoClass, arginfo_info_optinalFileClass, ZEND_ACC_PUBLIC)
! 1931: SPL_ME(SplFileInfo, _bad_state_ex, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
! 1932: SPL_MA(SplFileInfo, __toString, SplFileInfo, getPathname, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1933: PHP_FE_END
! 1934: };
! 1935:
! 1936: ZEND_BEGIN_ARG_INFO(arginfo_dir___construct, 0)
! 1937: ZEND_ARG_INFO(0, path)
! 1938: ZEND_END_ARG_INFO()
! 1939:
! 1940: ZEND_BEGIN_ARG_INFO(arginfo_dir_it_seek, 0)
! 1941: ZEND_ARG_INFO(0, position)
! 1942: ZEND_END_ARG_INFO();
! 1943:
! 1944: /* the method table */
! 1945: /* each method can have its own parameters and visibility */
! 1946: static const zend_function_entry spl_DirectoryIterator_functions[] = {
! 1947: SPL_ME(DirectoryIterator, __construct, arginfo_dir___construct, ZEND_ACC_PUBLIC)
! 1948: SPL_ME(DirectoryIterator, getFilename, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1949: SPL_ME(DirectoryIterator, getExtension, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1950: SPL_ME(DirectoryIterator, getBasename, arginfo_optinalSuffix, ZEND_ACC_PUBLIC)
! 1951: SPL_ME(DirectoryIterator, isDot, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1952: SPL_ME(DirectoryIterator, rewind, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1953: SPL_ME(DirectoryIterator, valid, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1954: SPL_ME(DirectoryIterator, key, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1955: SPL_ME(DirectoryIterator, current, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1956: SPL_ME(DirectoryIterator, next, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1957: SPL_ME(DirectoryIterator, seek, arginfo_dir_it_seek, ZEND_ACC_PUBLIC)
! 1958: SPL_MA(DirectoryIterator, __toString, DirectoryIterator, getFilename, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1959: PHP_FE_END
! 1960: };
! 1961:
! 1962: ZEND_BEGIN_ARG_INFO_EX(arginfo_r_dir___construct, 0, 0, 1)
! 1963: ZEND_ARG_INFO(0, path)
! 1964: ZEND_ARG_INFO(0, flags)
! 1965: ZEND_END_ARG_INFO()
! 1966:
! 1967: ZEND_BEGIN_ARG_INFO_EX(arginfo_r_dir_hasChildren, 0, 0, 0)
! 1968: ZEND_ARG_INFO(0, allow_links)
! 1969: ZEND_END_ARG_INFO()
! 1970:
! 1971: ZEND_BEGIN_ARG_INFO_EX(arginfo_r_dir_setFlags, 0, 0, 0)
! 1972: ZEND_ARG_INFO(0, flags)
! 1973: ZEND_END_ARG_INFO()
! 1974:
! 1975: static const zend_function_entry spl_FilesystemIterator_functions[] = {
! 1976: SPL_ME(FilesystemIterator, __construct, arginfo_r_dir___construct, ZEND_ACC_PUBLIC)
! 1977: SPL_ME(FilesystemIterator, rewind, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1978: SPL_ME(DirectoryIterator, next, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1979: SPL_ME(FilesystemIterator, key, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1980: SPL_ME(FilesystemIterator, current, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1981: SPL_ME(FilesystemIterator, getFlags, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1982: SPL_ME(FilesystemIterator, setFlags, arginfo_r_dir_setFlags, ZEND_ACC_PUBLIC)
! 1983: PHP_FE_END
! 1984: };
! 1985:
! 1986: static const zend_function_entry spl_RecursiveDirectoryIterator_functions[] = {
! 1987: SPL_ME(RecursiveDirectoryIterator, __construct, arginfo_r_dir___construct, ZEND_ACC_PUBLIC)
! 1988: SPL_ME(RecursiveDirectoryIterator, hasChildren, arginfo_r_dir_hasChildren, ZEND_ACC_PUBLIC)
! 1989: SPL_ME(RecursiveDirectoryIterator, getChildren, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1990: SPL_ME(RecursiveDirectoryIterator, getSubPath, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1991: SPL_ME(RecursiveDirectoryIterator, getSubPathname,arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1992: PHP_FE_END
! 1993: };
! 1994:
! 1995: #ifdef HAVE_GLOB
! 1996: static const zend_function_entry spl_GlobIterator_functions[] = {
! 1997: SPL_ME(GlobIterator, __construct, arginfo_r_dir___construct, ZEND_ACC_PUBLIC)
! 1998: SPL_ME(GlobIterator, count, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 1999: PHP_FE_END
! 2000: };
! 2001: #endif
! 2002: /* }}} */
! 2003:
! 2004: static int spl_filesystem_file_read(spl_filesystem_object *intern, int silent TSRMLS_DC) /* {{{ */
! 2005: {
! 2006: char *buf;
! 2007: size_t line_len = 0;
! 2008: int len;
! 2009: long line_add = (intern->u.file.current_line || intern->u.file.current_zval) ? 1 : 0;
! 2010:
! 2011: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 2012:
! 2013: if (php_stream_eof(intern->u.file.stream)) {
! 2014: if (!silent) {
! 2015: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Cannot read from file %s", intern->file_name);
! 2016: }
! 2017: return FAILURE;
! 2018: }
! 2019:
! 2020: if (intern->u.file.max_line_len > 0) {
! 2021: buf = safe_emalloc((intern->u.file.max_line_len + 1), sizeof(char), 0);
! 2022: if (php_stream_get_line(intern->u.file.stream, buf, intern->u.file.max_line_len, &line_len) == NULL) {
! 2023: efree(buf);
! 2024: buf = NULL;
! 2025: } else {
! 2026: buf[line_len] = '\0';
! 2027: }
! 2028: } else {
! 2029: buf = php_stream_get_line(intern->u.file.stream, NULL, 0, &line_len);
! 2030: }
! 2031:
! 2032: if (!buf) {
! 2033: intern->u.file.current_line = estrdup("");
! 2034: intern->u.file.current_line_len = 0;
! 2035: } else {
! 2036: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_DROP_NEW_LINE)) {
! 2037: line_len = strcspn(buf, "\r\n");
! 2038: buf[line_len] = '\0';
! 2039: }
! 2040:
! 2041: if (PG(magic_quotes_runtime)) {
! 2042: buf = php_addslashes(buf, line_len, &len, 1 TSRMLS_CC);
! 2043: line_len = len;
! 2044: }
! 2045:
! 2046: intern->u.file.current_line = buf;
! 2047: intern->u.file.current_line_len = line_len;
! 2048: }
! 2049: intern->u.file.current_line_num += line_add;
! 2050:
! 2051: return SUCCESS;
! 2052: } /* }}} */
! 2053:
! 2054: static int spl_filesystem_file_call(spl_filesystem_object *intern, zend_function *func_ptr, int pass_num_args, zval *return_value, zval *arg2 TSRMLS_DC) /* {{{ */
! 2055: {
! 2056: zend_fcall_info fci;
! 2057: zend_fcall_info_cache fcic;
! 2058: zval z_fname;
! 2059: zval * zresource_ptr = &intern->u.file.zresource, *retval;
! 2060: int result;
! 2061: int num_args = pass_num_args + (arg2 ? 2 : 1);
! 2062:
! 2063: zval ***params = (zval***)safe_emalloc(num_args, sizeof(zval**), 0);
! 2064:
! 2065: params[0] = &zresource_ptr;
! 2066:
! 2067: if (arg2) {
! 2068: params[1] = &arg2;
! 2069: }
! 2070:
! 2071: zend_get_parameters_array_ex(pass_num_args, params+(arg2 ? 2 : 1));
! 2072:
! 2073: ZVAL_STRING(&z_fname, func_ptr->common.function_name, 0);
! 2074:
! 2075: fci.size = sizeof(fci);
! 2076: fci.function_table = EG(function_table);
! 2077: fci.object_ptr = NULL;
! 2078: fci.function_name = &z_fname;
! 2079: fci.retval_ptr_ptr = &retval;
! 2080: fci.param_count = num_args;
! 2081: fci.params = params;
! 2082: fci.no_separation = 1;
! 2083: fci.symbol_table = NULL;
! 2084:
! 2085: fcic.initialized = 1;
! 2086: fcic.function_handler = func_ptr;
! 2087: fcic.calling_scope = NULL;
! 2088: fcic.called_scope = NULL;
! 2089: fcic.object_ptr = NULL;
! 2090:
! 2091: result = zend_call_function(&fci, &fcic TSRMLS_CC);
! 2092:
! 2093: if (result == FAILURE) {
! 2094: RETVAL_FALSE;
! 2095: } else {
! 2096: ZVAL_ZVAL(return_value, retval, 1, 1);
! 2097: }
! 2098:
! 2099: efree(params);
! 2100: return result;
! 2101: } /* }}} */
! 2102:
! 2103: #define FileFunctionCall(func_name, pass_num_args, arg2) /* {{{ */ \
! 2104: { \
! 2105: zend_function *func_ptr; \
! 2106: int ret; \
! 2107: ret = zend_hash_find(EG(function_table), #func_name, sizeof(#func_name), (void **) &func_ptr); \
! 2108: if (ret != SUCCESS) { \
! 2109: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Internal error, function '%s' not found. Please report", #func_name); \
! 2110: return; \
! 2111: } \
! 2112: spl_filesystem_file_call(intern, func_ptr, pass_num_args, return_value, arg2 TSRMLS_CC); \
! 2113: } /* }}} */
! 2114:
! 2115: static int spl_filesystem_file_read_csv(spl_filesystem_object *intern, char delimiter, char enclosure, char escape, zval *return_value TSRMLS_DC) /* {{{ */
! 2116: {
! 2117: int ret = SUCCESS;
! 2118:
! 2119: do {
! 2120: ret = spl_filesystem_file_read(intern, 1 TSRMLS_CC);
! 2121: } while (ret == SUCCESS && !intern->u.file.current_line_len && SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_SKIP_EMPTY));
! 2122:
! 2123: if (ret == SUCCESS) {
! 2124: size_t buf_len = intern->u.file.current_line_len;
! 2125: char *buf = estrndup(intern->u.file.current_line, buf_len);
! 2126:
! 2127: if (intern->u.file.current_zval) {
! 2128: zval_ptr_dtor(&intern->u.file.current_zval);
! 2129: }
! 2130: ALLOC_INIT_ZVAL(intern->u.file.current_zval);
! 2131:
! 2132: php_fgetcsv(intern->u.file.stream, delimiter, enclosure, escape, buf_len, buf, intern->u.file.current_zval TSRMLS_CC);
! 2133: if (return_value) {
! 2134: if (Z_TYPE_P(return_value) != IS_NULL) {
! 2135: zval_dtor(return_value);
! 2136: ZVAL_NULL(return_value);
! 2137: }
! 2138: ZVAL_ZVAL(return_value, intern->u.file.current_zval, 1, 0);
! 2139: }
! 2140: }
! 2141: return ret;
! 2142: }
! 2143: /* }}} */
! 2144:
! 2145: static int spl_filesystem_file_read_line_ex(zval * this_ptr, spl_filesystem_object *intern, int silent TSRMLS_DC) /* {{{ */
! 2146: {
! 2147: zval *retval = NULL;
! 2148:
! 2149: /* 1) use fgetcsv? 2) overloaded call the function, 3) do it directly */
! 2150: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) || intern->u.file.func_getCurr->common.scope != spl_ce_SplFileObject) {
! 2151: if (php_stream_eof(intern->u.file.stream)) {
! 2152: if (!silent) {
! 2153: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Cannot read from file %s", intern->file_name);
! 2154: }
! 2155: return FAILURE;
! 2156: }
! 2157: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV)) {
! 2158: return spl_filesystem_file_read_csv(intern, intern->u.file.delimiter, intern->u.file.enclosure, intern->u.file.escape, NULL TSRMLS_CC);
! 2159: } else {
! 2160: zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.file.func_getCurr, "getCurrentLine", &retval);
! 2161: }
! 2162: if (retval) {
! 2163: if (intern->u.file.current_line || intern->u.file.current_zval) {
! 2164: intern->u.file.current_line_num++;
! 2165: }
! 2166: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 2167: if (Z_TYPE_P(retval) == IS_STRING) {
! 2168: intern->u.file.current_line = estrndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval));
! 2169: intern->u.file.current_line_len = Z_STRLEN_P(retval);
! 2170: } else {
! 2171: MAKE_STD_ZVAL(intern->u.file.current_zval);
! 2172: ZVAL_ZVAL(intern->u.file.current_zval, retval, 1, 0);
! 2173: }
! 2174: zval_ptr_dtor(&retval);
! 2175: return SUCCESS;
! 2176: } else {
! 2177: return FAILURE;
! 2178: }
! 2179: } else {
! 2180: return spl_filesystem_file_read(intern, silent TSRMLS_CC);
! 2181: }
! 2182: } /* }}} */
! 2183:
! 2184: static int spl_filesystem_file_is_empty_line(spl_filesystem_object *intern TSRMLS_DC) /* {{{ */
! 2185: {
! 2186: if (intern->u.file.current_line) {
! 2187: return intern->u.file.current_line_len == 0;
! 2188: } else if (intern->u.file.current_zval) {
! 2189: switch(Z_TYPE_P(intern->u.file.current_zval)) {
! 2190: case IS_STRING:
! 2191: return Z_STRLEN_P(intern->u.file.current_zval) == 0;
! 2192: case IS_ARRAY:
! 2193: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV)
! 2194: && zend_hash_num_elements(Z_ARRVAL_P(intern->u.file.current_zval)) == 1) {
! 2195: zval ** first = Z_ARRVAL_P(intern->u.file.current_zval)->pListHead->pData;
! 2196:
! 2197: return Z_TYPE_PP(first) == IS_STRING && Z_STRLEN_PP(first) == 0;
! 2198: }
! 2199: return zend_hash_num_elements(Z_ARRVAL_P(intern->u.file.current_zval)) == 0;
! 2200: case IS_NULL:
! 2201: return 1;
! 2202: default:
! 2203: return 0;
! 2204: }
! 2205: } else {
! 2206: return 1;
! 2207: }
! 2208: }
! 2209: /* }}} */
! 2210:
! 2211: static int spl_filesystem_file_read_line(zval * this_ptr, spl_filesystem_object *intern, int silent TSRMLS_DC) /* {{{ */
! 2212: {
! 2213: int ret = spl_filesystem_file_read_line_ex(this_ptr, intern, silent TSRMLS_CC);
! 2214:
! 2215: while (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_SKIP_EMPTY) && ret == SUCCESS && spl_filesystem_file_is_empty_line(intern TSRMLS_CC)) {
! 2216: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 2217: ret = spl_filesystem_file_read_line_ex(this_ptr, intern, silent TSRMLS_CC);
! 2218: }
! 2219:
! 2220: return ret;
! 2221: }
! 2222: /* }}} */
! 2223:
! 2224: static void spl_filesystem_file_rewind(zval * this_ptr, spl_filesystem_object *intern TSRMLS_DC) /* {{{ */
! 2225: {
! 2226: if (-1 == php_stream_rewind(intern->u.file.stream)) {
! 2227: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Cannot rewind file %s", intern->file_name);
! 2228: } else {
! 2229: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 2230: intern->u.file.current_line_num = 0;
! 2231: }
! 2232: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_AHEAD)) {
! 2233: spl_filesystem_file_read_line(this_ptr, intern, 1 TSRMLS_CC);
! 2234: }
! 2235: } /* }}} */
! 2236:
! 2237: /* {{{ proto void SplFileObject::__construct(string filename [, string mode = 'r' [, bool use_include_path [, resource context]]]])
! 2238: Construct a new file object */
! 2239: SPL_METHOD(SplFileObject, __construct)
! 2240: {
! 2241: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2242: zend_bool use_include_path = 0;
! 2243: char *p1, *p2;
! 2244: char *tmp_path;
! 2245: int tmp_path_len;
! 2246: zend_error_handling error_handling;
! 2247:
! 2248: zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);
! 2249:
! 2250: intern->u.file.open_mode = NULL;
! 2251: intern->u.file.open_mode_len = 0;
! 2252:
! 2253: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sbr",
! 2254: &intern->file_name, &intern->file_name_len,
! 2255: &intern->u.file.open_mode, &intern->u.file.open_mode_len,
! 2256: &use_include_path, &intern->u.file.zcontext) == FAILURE) {
! 2257: intern->u.file.open_mode = NULL;
! 2258: intern->file_name = NULL;
! 2259: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 2260: return;
! 2261: }
! 2262:
! 2263: if (intern->u.file.open_mode == NULL) {
! 2264: intern->u.file.open_mode = "r";
! 2265: intern->u.file.open_mode_len = 1;
! 2266: }
! 2267:
! 2268: if (spl_filesystem_file_open(intern, use_include_path, 0 TSRMLS_CC) == SUCCESS) {
! 2269: tmp_path_len = strlen(intern->u.file.stream->orig_path);
! 2270:
! 2271: if (tmp_path_len > 1 && IS_SLASH_AT(intern->u.file.stream->orig_path, tmp_path_len-1)) {
! 2272: tmp_path_len--;
! 2273: }
! 2274:
! 2275: tmp_path = estrndup(intern->u.file.stream->orig_path, tmp_path_len);
! 2276:
! 2277: p1 = strrchr(tmp_path, '/');
! 2278: #if defined(PHP_WIN32) || defined(NETWARE)
! 2279: p2 = strrchr(tmp_path, '\\');
! 2280: #else
! 2281: p2 = 0;
! 2282: #endif
! 2283: if (p1 || p2) {
! 2284: intern->_path_len = (p1 > p2 ? p1 : p2) - tmp_path;
! 2285: } else {
! 2286: intern->_path_len = 0;
! 2287: }
! 2288:
! 2289: efree(tmp_path);
! 2290:
! 2291: intern->_path = estrndup(intern->u.file.stream->orig_path, intern->_path_len);
! 2292: }
! 2293:
! 2294: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 2295:
! 2296: } /* }}} */
! 2297:
! 2298: /* {{{ proto void SplTempFileObject::__construct([int max_memory])
! 2299: Construct a new temp file object */
! 2300: SPL_METHOD(SplTempFileObject, __construct)
! 2301: {
! 2302: long max_memory = PHP_STREAM_MAX_MEM;
! 2303: char tmp_fname[48];
! 2304: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2305: zend_error_handling error_handling;
! 2306:
! 2307: zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);
! 2308:
! 2309: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &max_memory) == FAILURE) {
! 2310: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 2311: return;
! 2312: }
! 2313:
! 2314: if (max_memory < 0) {
! 2315: intern->file_name = "php://memory";
! 2316: intern->file_name_len = 12;
! 2317: } else if (ZEND_NUM_ARGS()) {
! 2318: intern->file_name_len = slprintf(tmp_fname, sizeof(tmp_fname), "php://temp/maxmemory:%ld", max_memory);
! 2319: intern->file_name = tmp_fname;
! 2320: } else {
! 2321: intern->file_name = "php://temp";
! 2322: intern->file_name_len = 10;
! 2323: }
! 2324: intern->u.file.open_mode = "wb";
! 2325: intern->u.file.open_mode_len = 1;
! 2326: intern->u.file.zcontext = NULL;
! 2327:
! 2328: if (spl_filesystem_file_open(intern, 0, 0 TSRMLS_CC) == SUCCESS) {
! 2329: intern->_path_len = 0;
! 2330: intern->_path = estrndup("", 0);
! 2331: }
! 2332: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 2333: } /* }}} */
! 2334:
! 2335: /* {{{ proto void SplFileObject::rewind()
! 2336: Rewind the file and read the first line */
! 2337: SPL_METHOD(SplFileObject, rewind)
! 2338: {
! 2339: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2340:
! 2341: if (zend_parse_parameters_none() == FAILURE) {
! 2342: return;
! 2343: }
! 2344:
! 2345: spl_filesystem_file_rewind(getThis(), intern TSRMLS_CC);
! 2346: } /* }}} */
! 2347:
! 2348: /* {{{ proto void SplFileObject::eof()
! 2349: Return whether end of file is reached */
! 2350: SPL_METHOD(SplFileObject, eof)
! 2351: {
! 2352: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2353:
! 2354: if (zend_parse_parameters_none() == FAILURE) {
! 2355: return;
! 2356: }
! 2357:
! 2358: RETURN_BOOL(php_stream_eof(intern->u.file.stream));
! 2359: } /* }}} */
! 2360:
! 2361: /* {{{ proto void SplFileObject::valid()
! 2362: Return !eof() */
! 2363: SPL_METHOD(SplFileObject, valid)
! 2364: {
! 2365: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2366:
! 2367: if (zend_parse_parameters_none() == FAILURE) {
! 2368: return;
! 2369: }
! 2370:
! 2371: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_AHEAD)) {
! 2372: RETURN_BOOL(intern->u.file.current_line || intern->u.file.current_zval);
! 2373: } else {
! 2374: RETVAL_BOOL(!php_stream_eof(intern->u.file.stream));
! 2375: }
! 2376: } /* }}} */
! 2377:
! 2378: /* {{{ proto string SplFileObject::fgets()
! 2379: Rturn next line from file */
! 2380: SPL_METHOD(SplFileObject, fgets)
! 2381: {
! 2382: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2383:
! 2384: if (zend_parse_parameters_none() == FAILURE) {
! 2385: return;
! 2386: }
! 2387:
! 2388: if (spl_filesystem_file_read(intern, 0 TSRMLS_CC) == FAILURE) {
! 2389: RETURN_FALSE;
! 2390: }
! 2391: RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len, 1);
! 2392: } /* }}} */
! 2393:
! 2394: /* {{{ proto string SplFileObject::current()
! 2395: Return current line from file */
! 2396: SPL_METHOD(SplFileObject, current)
! 2397: {
! 2398: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2399:
! 2400: if (zend_parse_parameters_none() == FAILURE) {
! 2401: return;
! 2402: }
! 2403:
! 2404: if (!intern->u.file.current_line && !intern->u.file.current_zval) {
! 2405: spl_filesystem_file_read_line(getThis(), intern, 1 TSRMLS_CC);
! 2406: }
! 2407: if (intern->u.file.current_line && (!SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) || !intern->u.file.current_zval)) {
! 2408: RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len, 1);
! 2409: } else if (intern->u.file.current_zval) {
! 2410: RETURN_ZVAL(intern->u.file.current_zval, 1, 0);
! 2411: }
! 2412: RETURN_FALSE;
! 2413: } /* }}} */
! 2414:
! 2415: /* {{{ proto int SplFileObject::key()
! 2416: Return line number */
! 2417: SPL_METHOD(SplFileObject, key)
! 2418: {
! 2419: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2420:
! 2421: if (zend_parse_parameters_none() == FAILURE) {
! 2422: return;
! 2423: }
! 2424:
! 2425: /* Do not read the next line to support correct counting with fgetc()
! 2426: if (!intern->current_line) {
! 2427: spl_filesystem_file_read_line(getThis(), intern, 1 TSRMLS_CC);
! 2428: } */
! 2429: RETURN_LONG(intern->u.file.current_line_num);
! 2430: } /* }}} */
! 2431:
! 2432: /* {{{ proto void SplFileObject::next()
! 2433: Read next line */
! 2434: SPL_METHOD(SplFileObject, next)
! 2435: {
! 2436: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2437:
! 2438: if (zend_parse_parameters_none() == FAILURE) {
! 2439: return;
! 2440: }
! 2441:
! 2442: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 2443: if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_AHEAD)) {
! 2444: spl_filesystem_file_read_line(getThis(), intern, 1 TSRMLS_CC);
! 2445: }
! 2446: intern->u.file.current_line_num++;
! 2447: } /* }}} */
! 2448:
! 2449: /* {{{ proto void SplFileObject::setFlags(int flags)
! 2450: Set file handling flags */
! 2451: SPL_METHOD(SplFileObject, setFlags)
! 2452: {
! 2453: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2454:
! 2455: zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &intern->flags);
! 2456: } /* }}} */
! 2457:
! 2458: /* {{{ proto int SplFileObject::getFlags()
! 2459: Get file handling flags */
! 2460: SPL_METHOD(SplFileObject, getFlags)
! 2461: {
! 2462: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2463:
! 2464: if (zend_parse_parameters_none() == FAILURE) {
! 2465: return;
! 2466: }
! 2467:
! 2468: RETURN_LONG(intern->flags & SPL_FILE_OBJECT_MASK);
! 2469: } /* }}} */
! 2470:
! 2471: /* {{{ proto void SplFileObject::setMaxLineLen(int max_len)
! 2472: Set maximum line length */
! 2473: SPL_METHOD(SplFileObject, setMaxLineLen)
! 2474: {
! 2475: long max_len;
! 2476:
! 2477: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2478:
! 2479: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &max_len) == FAILURE) {
! 2480: return;
! 2481: }
! 2482:
! 2483: if (max_len < 0) {
! 2484: zend_throw_exception_ex(spl_ce_DomainException, 0 TSRMLS_CC, "Maximum line length must be greater than or equal zero");
! 2485: return;
! 2486: }
! 2487:
! 2488: intern->u.file.max_line_len = max_len;
! 2489: } /* }}} */
! 2490:
! 2491: /* {{{ proto int SplFileObject::getMaxLineLen()
! 2492: Get maximum line length */
! 2493: SPL_METHOD(SplFileObject, getMaxLineLen)
! 2494: {
! 2495: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2496:
! 2497: if (zend_parse_parameters_none() == FAILURE) {
! 2498: return;
! 2499: }
! 2500:
! 2501: RETURN_LONG((long)intern->u.file.max_line_len);
! 2502: } /* }}} */
! 2503:
! 2504: /* {{{ proto bool SplFileObject::hasChildren()
! 2505: Return false */
! 2506: SPL_METHOD(SplFileObject, hasChildren)
! 2507: {
! 2508: if (zend_parse_parameters_none() == FAILURE) {
! 2509: return;
! 2510: }
! 2511:
! 2512: RETURN_FALSE;
! 2513: } /* }}} */
! 2514:
! 2515: /* {{{ proto bool SplFileObject::getChildren()
! 2516: Read NULL */
! 2517: SPL_METHOD(SplFileObject, getChildren)
! 2518: {
! 2519: if (zend_parse_parameters_none() == FAILURE) {
! 2520: return;
! 2521: }
! 2522: /* return NULL */
! 2523: } /* }}} */
! 2524:
! 2525: /* {{{ FileFunction */
! 2526: #define FileFunction(func_name) \
! 2527: SPL_METHOD(SplFileObject, func_name) \
! 2528: { \
! 2529: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \
! 2530: FileFunctionCall(func_name, ZEND_NUM_ARGS(), NULL); \
! 2531: }
! 2532: /* }}} */
! 2533:
! 2534: /* {{{ proto array SplFileObject::fgetcsv([string delimiter [, string enclosure [, escape = '\\']]])
! 2535: Return current line as csv */
! 2536: SPL_METHOD(SplFileObject, fgetcsv)
! 2537: {
! 2538: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2539: char delimiter = intern->u.file.delimiter, enclosure = intern->u.file.enclosure, escape = intern->u.file.escape;
! 2540: char *delim = NULL, *enclo = NULL, *esc = NULL;
! 2541: int d_len = 0, e_len = 0, esc_len = 0;
! 2542:
! 2543: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sss", &delim, &d_len, &enclo, &e_len, &esc, &esc_len) == SUCCESS) {
! 2544: switch(ZEND_NUM_ARGS())
! 2545: {
! 2546: case 3:
! 2547: if (esc_len != 1) {
! 2548: php_error_docref(NULL TSRMLS_CC, E_WARNING, "escape must be a character");
! 2549: RETURN_FALSE;
! 2550: }
! 2551: escape = esc[0];
! 2552: /* no break */
! 2553: case 2:
! 2554: if (e_len != 1) {
! 2555: php_error_docref(NULL TSRMLS_CC, E_WARNING, "enclosure must be a character");
! 2556: RETURN_FALSE;
! 2557: }
! 2558: enclosure = enclo[0];
! 2559: /* no break */
! 2560: case 1:
! 2561: if (d_len != 1) {
! 2562: php_error_docref(NULL TSRMLS_CC, E_WARNING, "delimiter must be a character");
! 2563: RETURN_FALSE;
! 2564: }
! 2565: delimiter = delim[0];
! 2566: /* no break */
! 2567: case 0:
! 2568: break;
! 2569: }
! 2570: spl_filesystem_file_read_csv(intern, delimiter, enclosure, escape, return_value TSRMLS_CC);
! 2571: }
! 2572: }
! 2573: /* }}} */
! 2574:
! 2575: /* {{{ proto void SplFileObject::setCsvControl([string delimiter = ',' [, string enclosure = '"' [, string escape = '\\']]])
! 2576: Set the delimiter and enclosure character used in fgetcsv */
! 2577: SPL_METHOD(SplFileObject, setCsvControl)
! 2578: {
! 2579: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2580: char delimiter = ',', enclosure = '"', escape='\\';
! 2581: char *delim = NULL, *enclo = NULL, *esc = NULL;
! 2582: int d_len = 0, e_len = 0, esc_len = 0;
! 2583:
! 2584: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sss", &delim, &d_len, &enclo, &e_len, &esc, &esc_len) == SUCCESS) {
! 2585: switch(ZEND_NUM_ARGS())
! 2586: {
! 2587: case 3:
! 2588: if (esc_len != 1) {
! 2589: php_error_docref(NULL TSRMLS_CC, E_WARNING, "escape must be a character");
! 2590: RETURN_FALSE;
! 2591: }
! 2592: escape = esc[0];
! 2593: /* no break */
! 2594: case 2:
! 2595: if (e_len != 1) {
! 2596: php_error_docref(NULL TSRMLS_CC, E_WARNING, "enclosure must be a character");
! 2597: RETURN_FALSE;
! 2598: }
! 2599: enclosure = enclo[0];
! 2600: /* no break */
! 2601: case 1:
! 2602: if (d_len != 1) {
! 2603: php_error_docref(NULL TSRMLS_CC, E_WARNING, "delimiter must be a character");
! 2604: RETURN_FALSE;
! 2605: }
! 2606: delimiter = delim[0];
! 2607: /* no break */
! 2608: case 0:
! 2609: break;
! 2610: }
! 2611: intern->u.file.delimiter = delimiter;
! 2612: intern->u.file.enclosure = enclosure;
! 2613: intern->u.file.escape = escape;
! 2614: }
! 2615: }
! 2616: /* }}} */
! 2617:
! 2618: /* {{{ proto array SplFileObject::getCsvControl()
! 2619: Get the delimiter and enclosure character used in fgetcsv */
! 2620: SPL_METHOD(SplFileObject, getCsvControl)
! 2621: {
! 2622: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2623: char delimiter[2], enclosure[2];
! 2624:
! 2625: array_init(return_value);
! 2626:
! 2627: delimiter[0] = intern->u.file.delimiter;
! 2628: delimiter[1] = '\0';
! 2629: enclosure[0] = intern->u.file.enclosure;
! 2630: enclosure[1] = '\0';
! 2631:
! 2632: add_next_index_string(return_value, delimiter, 1);
! 2633: add_next_index_string(return_value, enclosure, 1);
! 2634: }
! 2635: /* }}} */
! 2636:
! 2637: /* {{{ proto bool SplFileObject::flock(int operation [, int &wouldblock])
! 2638: Portable file locking */
! 2639: FileFunction(flock)
! 2640: /* }}} */
! 2641:
! 2642: /* {{{ proto bool SplFileObject::fflush()
! 2643: Flush the file */
! 2644: SPL_METHOD(SplFileObject, fflush)
! 2645: {
! 2646: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2647:
! 2648: RETURN_BOOL(!php_stream_flush(intern->u.file.stream));
! 2649: } /* }}} */
! 2650:
! 2651: /* {{{ proto int SplFileObject::ftell()
! 2652: Return current file position */
! 2653: SPL_METHOD(SplFileObject, ftell)
! 2654: {
! 2655: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2656: long ret = php_stream_tell(intern->u.file.stream);
! 2657:
! 2658: if (ret == -1) {
! 2659: RETURN_FALSE;
! 2660: } else {
! 2661: RETURN_LONG(ret);
! 2662: }
! 2663: } /* }}} */
! 2664:
! 2665: /* {{{ proto int SplFileObject::fseek(int pos [, int whence = SEEK_SET])
! 2666: Return current file position */
! 2667: SPL_METHOD(SplFileObject, fseek)
! 2668: {
! 2669: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2670: long pos, whence = SEEK_SET;
! 2671:
! 2672: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &pos, &whence) == FAILURE) {
! 2673: return;
! 2674: }
! 2675:
! 2676: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 2677: RETURN_LONG(php_stream_seek(intern->u.file.stream, pos, whence));
! 2678: } /* }}} */
! 2679:
! 2680: /* {{{ proto int SplFileObject::fgetc()
! 2681: Get a character form the file */
! 2682: SPL_METHOD(SplFileObject, fgetc)
! 2683: {
! 2684: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2685: char buf[2];
! 2686: int result;
! 2687:
! 2688: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 2689:
! 2690: result = php_stream_getc(intern->u.file.stream);
! 2691:
! 2692: if (result == EOF) {
! 2693: RETVAL_FALSE;
! 2694: } else {
! 2695: if (result == '\n') {
! 2696: intern->u.file.current_line_num++;
! 2697: }
! 2698: buf[0] = result;
! 2699: buf[1] = '\0';
! 2700:
! 2701: RETURN_STRINGL(buf, 1, 1);
! 2702: }
! 2703: } /* }}} */
! 2704:
! 2705: /* {{{ proto string SplFileObject::fgetss([string allowable_tags])
! 2706: Get a line from file pointer and strip HTML tags */
! 2707: SPL_METHOD(SplFileObject, fgetss)
! 2708: {
! 2709: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2710: zval *arg2 = NULL;
! 2711: MAKE_STD_ZVAL(arg2);
! 2712:
! 2713: if (intern->u.file.max_line_len > 0) {
! 2714: ZVAL_LONG(arg2, intern->u.file.max_line_len);
! 2715: } else {
! 2716: ZVAL_LONG(arg2, 1024);
! 2717: }
! 2718:
! 2719: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 2720: intern->u.file.current_line_num++;
! 2721:
! 2722: FileFunctionCall(fgetss, ZEND_NUM_ARGS(), arg2);
! 2723:
! 2724: zval_ptr_dtor(&arg2);
! 2725: } /* }}} */
! 2726:
! 2727: /* {{{ proto int SplFileObject::fpassthru()
! 2728: Output all remaining data from a file pointer */
! 2729: SPL_METHOD(SplFileObject, fpassthru)
! 2730: {
! 2731: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2732:
! 2733: RETURN_LONG(php_stream_passthru(intern->u.file.stream));
! 2734: } /* }}} */
! 2735:
! 2736: /* {{{ proto bool SplFileObject::fscanf(string format [, string ...])
! 2737: Implements a mostly ANSI compatible fscanf() */
! 2738: SPL_METHOD(SplFileObject, fscanf)
! 2739: {
! 2740: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2741:
! 2742: spl_filesystem_file_free_line(intern TSRMLS_CC);
! 2743: intern->u.file.current_line_num++;
! 2744:
! 2745: FileFunctionCall(fscanf, ZEND_NUM_ARGS(), NULL);
! 2746: }
! 2747: /* }}} */
! 2748:
! 2749: /* {{{ proto mixed SplFileObject::fwrite(string str [, int length])
! 2750: Binary-safe file write */
! 2751: SPL_METHOD(SplFileObject, fwrite)
! 2752: {
! 2753: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2754: char *str;
! 2755: int str_len;
! 2756: int ret;
! 2757: long length = 0;
! 2758:
! 2759: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &length) == FAILURE) {
! 2760: return;
! 2761: }
! 2762:
! 2763: if (ZEND_NUM_ARGS() > 1) {
! 2764: str_len = MAX(0, MIN(length, str_len));
! 2765: }
! 2766: if (!str_len) {
! 2767: RETURN_LONG(0);
! 2768: }
! 2769:
! 2770: if (PG(magic_quotes_runtime)) {
! 2771: str = estrndup(str, str_len);
! 2772: php_stripslashes(str, &str_len TSRMLS_CC);
! 2773: ret = php_stream_write(intern->u.file.stream, str, str_len);
! 2774: efree(str);
! 2775: RETURN_LONG(ret);
! 2776: }
! 2777:
! 2778: RETURN_LONG(php_stream_write(intern->u.file.stream, str, str_len));
! 2779: } /* }}} */
! 2780:
! 2781: /* {{{ proto bool SplFileObject::fstat()
! 2782: Stat() on a filehandle */
! 2783: FileFunction(fstat)
! 2784: /* }}} */
! 2785:
! 2786: /* {{{ proto bool SplFileObject::ftruncate(int size)
! 2787: Truncate file to 'size' length */
! 2788: SPL_METHOD(SplFileObject, ftruncate)
! 2789: {
! 2790: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2791: long size;
! 2792:
! 2793: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &size) == FAILURE) {
! 2794: return;
! 2795: }
! 2796:
! 2797: if (!php_stream_truncate_supported(intern->u.file.stream)) {
! 2798: zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Can't truncate file %s", intern->file_name);
! 2799: RETURN_FALSE;
! 2800: }
! 2801:
! 2802: RETURN_BOOL(0 == php_stream_truncate_set_size(intern->u.file.stream, size));
! 2803: } /* }}} */
! 2804:
! 2805: /* {{{ proto void SplFileObject::seek(int line_pos)
! 2806: Seek to specified line */
! 2807: SPL_METHOD(SplFileObject, seek)
! 2808: {
! 2809: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 2810: long line_pos;
! 2811:
! 2812: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &line_pos) == FAILURE) {
! 2813: return;
! 2814: }
! 2815: if (line_pos < 0) {
! 2816: zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Can't seek file %s to negative line %ld", intern->file_name, line_pos);
! 2817: RETURN_FALSE;
! 2818: }
! 2819:
! 2820: spl_filesystem_file_rewind(getThis(), intern TSRMLS_CC);
! 2821:
! 2822: while(intern->u.file.current_line_num < line_pos) {
! 2823: if (spl_filesystem_file_read_line(getThis(), intern, 1 TSRMLS_CC) == FAILURE) {
! 2824: break;
! 2825: }
! 2826: }
! 2827: } /* }}} */
! 2828:
! 2829: /* {{{ Function/Class/Method definitions */
! 2830: ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object___construct, 0, 0, 1)
! 2831: ZEND_ARG_INFO(0, file_name)
! 2832: ZEND_ARG_INFO(0, open_mode)
! 2833: ZEND_ARG_INFO(0, use_include_path)
! 2834: ZEND_ARG_INFO(0, context)
! 2835: ZEND_END_ARG_INFO()
! 2836:
! 2837: ZEND_BEGIN_ARG_INFO(arginfo_file_object_setFlags, 0)
! 2838: ZEND_ARG_INFO(0, flags)
! 2839: ZEND_END_ARG_INFO()
! 2840:
! 2841: ZEND_BEGIN_ARG_INFO(arginfo_file_object_setMaxLineLen, 0)
! 2842: ZEND_ARG_INFO(0, max_len)
! 2843: ZEND_END_ARG_INFO()
! 2844:
! 2845: ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object_fgetcsv, 0, 0, 0)
! 2846: ZEND_ARG_INFO(0, delimiter)
! 2847: ZEND_ARG_INFO(0, enclosure)
! 2848: ZEND_END_ARG_INFO()
! 2849:
! 2850: ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object_flock, 0, 0, 1)
! 2851: ZEND_ARG_INFO(0, operation)
! 2852: ZEND_ARG_INFO(1, wouldblock)
! 2853: ZEND_END_ARG_INFO()
! 2854:
! 2855: ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object_fseek, 0, 0, 1)
! 2856: ZEND_ARG_INFO(0, pos)
! 2857: ZEND_ARG_INFO(0, whence)
! 2858: ZEND_END_ARG_INFO()
! 2859:
! 2860: ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object_fgetss, 0, 0, 0)
! 2861: ZEND_ARG_INFO(0, allowable_tags)
! 2862: ZEND_END_ARG_INFO()
! 2863:
! 2864: ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object_fscanf, 1, 0, 1)
! 2865: ZEND_ARG_INFO(0, format)
! 2866: ZEND_END_ARG_INFO()
! 2867:
! 2868: ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object_fwrite, 0, 0, 1)
! 2869: ZEND_ARG_INFO(0, str)
! 2870: ZEND_ARG_INFO(0, length)
! 2871: ZEND_END_ARG_INFO()
! 2872:
! 2873: ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object_ftruncate, 0, 0, 1)
! 2874: ZEND_ARG_INFO(0, size)
! 2875: ZEND_END_ARG_INFO()
! 2876:
! 2877: ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object_seek, 0, 0, 1)
! 2878: ZEND_ARG_INFO(0, line_pos)
! 2879: ZEND_END_ARG_INFO()
! 2880:
! 2881: static const zend_function_entry spl_SplFileObject_functions[] = {
! 2882: SPL_ME(SplFileObject, __construct, arginfo_file_object___construct, ZEND_ACC_PUBLIC)
! 2883: SPL_ME(SplFileObject, rewind, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2884: SPL_ME(SplFileObject, eof, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2885: SPL_ME(SplFileObject, valid, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2886: SPL_ME(SplFileObject, fgets, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2887: SPL_ME(SplFileObject, fgetcsv, arginfo_file_object_fgetcsv, ZEND_ACC_PUBLIC)
! 2888: SPL_ME(SplFileObject, setCsvControl, arginfo_file_object_fgetcsv, ZEND_ACC_PUBLIC)
! 2889: SPL_ME(SplFileObject, getCsvControl, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2890: SPL_ME(SplFileObject, flock, arginfo_file_object_flock, ZEND_ACC_PUBLIC)
! 2891: SPL_ME(SplFileObject, fflush, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2892: SPL_ME(SplFileObject, ftell, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2893: SPL_ME(SplFileObject, fseek, arginfo_file_object_fseek, ZEND_ACC_PUBLIC)
! 2894: SPL_ME(SplFileObject, fgetc, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2895: SPL_ME(SplFileObject, fpassthru, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2896: SPL_ME(SplFileObject, fgetss, arginfo_file_object_fgetss, ZEND_ACC_PUBLIC)
! 2897: SPL_ME(SplFileObject, fscanf, arginfo_file_object_fscanf, ZEND_ACC_PUBLIC)
! 2898: SPL_ME(SplFileObject, fwrite, arginfo_file_object_fwrite, ZEND_ACC_PUBLIC)
! 2899: SPL_ME(SplFileObject, fstat, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2900: SPL_ME(SplFileObject, ftruncate, arginfo_file_object_ftruncate, ZEND_ACC_PUBLIC)
! 2901: SPL_ME(SplFileObject, current, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2902: SPL_ME(SplFileObject, key, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2903: SPL_ME(SplFileObject, next, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2904: SPL_ME(SplFileObject, setFlags, arginfo_file_object_setFlags, ZEND_ACC_PUBLIC)
! 2905: SPL_ME(SplFileObject, getFlags, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2906: SPL_ME(SplFileObject, setMaxLineLen, arginfo_file_object_setMaxLineLen, ZEND_ACC_PUBLIC)
! 2907: SPL_ME(SplFileObject, getMaxLineLen, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2908: SPL_ME(SplFileObject, hasChildren, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2909: SPL_ME(SplFileObject, getChildren, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2910: SPL_ME(SplFileObject, seek, arginfo_file_object_seek, ZEND_ACC_PUBLIC)
! 2911: /* mappings */
! 2912: SPL_MA(SplFileObject, getCurrentLine, SplFileObject, fgets, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2913: SPL_MA(SplFileObject, __toString, SplFileObject, current, arginfo_splfileinfo_void, ZEND_ACC_PUBLIC)
! 2914: PHP_FE_END
! 2915: };
! 2916:
! 2917: ZEND_BEGIN_ARG_INFO_EX(arginfo_temp_file_object___construct, 0, 0, 0)
! 2918: ZEND_ARG_INFO(0, max_memory)
! 2919: ZEND_END_ARG_INFO()
! 2920:
! 2921: static const zend_function_entry spl_SplTempFileObject_functions[] = {
! 2922: SPL_ME(SplTempFileObject, __construct, arginfo_temp_file_object___construct, ZEND_ACC_PUBLIC)
! 2923: PHP_FE_END
! 2924: };
! 2925: /* }}} */
! 2926:
! 2927: /* {{{ PHP_MINIT_FUNCTION(spl_directory)
! 2928: */
! 2929: PHP_MINIT_FUNCTION(spl_directory)
! 2930: {
! 2931: REGISTER_SPL_STD_CLASS_EX(SplFileInfo, spl_filesystem_object_new, spl_SplFileInfo_functions);
! 2932: memcpy(&spl_filesystem_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
! 2933: spl_filesystem_object_handlers.clone_obj = spl_filesystem_object_clone;
! 2934: spl_filesystem_object_handlers.cast_object = spl_filesystem_object_cast;
! 2935: spl_filesystem_object_handlers.get_debug_info = spl_filesystem_object_get_debug_info;
! 2936: spl_ce_SplFileInfo->serialize = zend_class_serialize_deny;
! 2937: spl_ce_SplFileInfo->unserialize = zend_class_unserialize_deny;
! 2938:
! 2939: REGISTER_SPL_SUB_CLASS_EX(DirectoryIterator, SplFileInfo, spl_filesystem_object_new, spl_DirectoryIterator_functions);
! 2940: zend_class_implements(spl_ce_DirectoryIterator TSRMLS_CC, 1, zend_ce_iterator);
! 2941: REGISTER_SPL_IMPLEMENTS(DirectoryIterator, SeekableIterator);
! 2942:
! 2943: spl_ce_DirectoryIterator->get_iterator = spl_filesystem_dir_get_iterator;
! 2944:
! 2945: REGISTER_SPL_SUB_CLASS_EX(FilesystemIterator, DirectoryIterator, spl_filesystem_object_new, spl_FilesystemIterator_functions);
! 2946:
! 2947: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_MODE_MASK", SPL_FILE_DIR_CURRENT_MODE_MASK);
! 2948: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_PATHNAME", SPL_FILE_DIR_CURRENT_AS_PATHNAME);
! 2949: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_FILEINFO", SPL_FILE_DIR_CURRENT_AS_FILEINFO);
! 2950: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_SELF", SPL_FILE_DIR_CURRENT_AS_SELF);
! 2951: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "KEY_MODE_MASK", SPL_FILE_DIR_KEY_MODE_MASK);
! 2952: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "KEY_AS_PATHNAME", SPL_FILE_DIR_KEY_AS_PATHNAME);
! 2953: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "FOLLOW_SYMLINKS", SPL_FILE_DIR_FOLLOW_SYMLINKS);
! 2954: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "KEY_AS_FILENAME", SPL_FILE_DIR_KEY_AS_FILENAME);
! 2955: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "NEW_CURRENT_AND_KEY", SPL_FILE_DIR_KEY_AS_FILENAME|SPL_FILE_DIR_CURRENT_AS_FILEINFO);
! 2956: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "SKIP_DOTS", SPL_FILE_DIR_SKIPDOTS);
! 2957: REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "UNIX_PATHS", SPL_FILE_DIR_UNIXPATHS);
! 2958:
! 2959: spl_ce_FilesystemIterator->get_iterator = spl_filesystem_tree_get_iterator;
! 2960:
! 2961: REGISTER_SPL_SUB_CLASS_EX(RecursiveDirectoryIterator, FilesystemIterator, spl_filesystem_object_new, spl_RecursiveDirectoryIterator_functions);
! 2962: REGISTER_SPL_IMPLEMENTS(RecursiveDirectoryIterator, RecursiveIterator);
! 2963:
! 2964: memcpy(&spl_filesystem_object_check_handlers, &spl_filesystem_object_handlers, sizeof(zend_object_handlers));
! 2965: spl_filesystem_object_check_handlers.get_method = spl_filesystem_object_get_method_check;
! 2966:
! 2967: #ifdef HAVE_GLOB
! 2968: REGISTER_SPL_SUB_CLASS_EX(GlobIterator, FilesystemIterator, spl_filesystem_object_new_check, spl_GlobIterator_functions);
! 2969: REGISTER_SPL_IMPLEMENTS(GlobIterator, Countable);
! 2970: #endif
! 2971:
! 2972: REGISTER_SPL_SUB_CLASS_EX(SplFileObject, SplFileInfo, spl_filesystem_object_new_check, spl_SplFileObject_functions);
! 2973: REGISTER_SPL_IMPLEMENTS(SplFileObject, RecursiveIterator);
! 2974: REGISTER_SPL_IMPLEMENTS(SplFileObject, SeekableIterator);
! 2975:
! 2976: REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "DROP_NEW_LINE", SPL_FILE_OBJECT_DROP_NEW_LINE);
! 2977: REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "READ_AHEAD", SPL_FILE_OBJECT_READ_AHEAD);
! 2978: REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "SKIP_EMPTY", SPL_FILE_OBJECT_SKIP_EMPTY);
! 2979: REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "READ_CSV", SPL_FILE_OBJECT_READ_CSV);
! 2980:
! 2981: REGISTER_SPL_SUB_CLASS_EX(SplTempFileObject, SplFileObject, spl_filesystem_object_new_check, spl_SplTempFileObject_functions);
! 2982: return SUCCESS;
! 2983: }
! 2984: /* }}} */
! 2985:
! 2986: /*
! 2987: * Local variables:
! 2988: * tab-width: 4
! 2989: * c-basic-offset: 4
! 2990: * End:
! 2991: * vim600: noet sw=4 ts=4 fdm=marker
! 2992: * vim<600: noet sw=4 ts=4
! 2993: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to spl_directory.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / spl