Annotation of embedaddon/php/ext/dom/php_dom.c, revision 1.1.1.2

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:    | Authors: Christian Stocker <chregu@php.net>                          |
                     16:    |          Rob Richards <rrichards@php.net>                            |
                     17:    |          Marcus Borger <helly@php.net>                               |
                     18:    +----------------------------------------------------------------------+
                     19: */
                     20: 
1.1.1.2 ! misho      21: /* $Id$ */
1.1       misho      22: 
                     23: #ifdef HAVE_CONFIG_H
                     24: #include "config.h"
                     25: #endif
                     26: 
                     27: #include "php.h"
                     28: #if HAVE_LIBXML && HAVE_DOM
                     29: #include "ext/standard/php_rand.h"
                     30: #include "php_dom.h"
                     31: #include "dom_properties.h"
                     32: #include "zend_interfaces.h"
                     33: 
                     34: #include "ext/standard/info.h"
                     35: #define PHP_XPATH 1
                     36: #define PHP_XPTR 2
                     37: 
                     38: /* {{{ class entries */
                     39: zend_class_entry *dom_node_class_entry;
                     40: zend_class_entry *dom_domexception_class_entry;
                     41: zend_class_entry *dom_domstringlist_class_entry;
                     42: zend_class_entry *dom_namelist_class_entry;
                     43: zend_class_entry *dom_domimplementationlist_class_entry;
                     44: zend_class_entry *dom_domimplementationsource_class_entry;
                     45: zend_class_entry *dom_domimplementation_class_entry;
                     46: zend_class_entry *dom_documentfragment_class_entry;
                     47: zend_class_entry *dom_document_class_entry;
                     48: zend_class_entry *dom_nodelist_class_entry;
                     49: zend_class_entry *dom_namednodemap_class_entry;
                     50: zend_class_entry *dom_characterdata_class_entry;
                     51: zend_class_entry *dom_attr_class_entry;
                     52: zend_class_entry *dom_element_class_entry;
                     53: zend_class_entry *dom_text_class_entry;
                     54: zend_class_entry *dom_comment_class_entry;
                     55: zend_class_entry *dom_typeinfo_class_entry;
                     56: zend_class_entry *dom_userdatahandler_class_entry;
                     57: zend_class_entry *dom_domerror_class_entry;
                     58: zend_class_entry *dom_domerrorhandler_class_entry;
                     59: zend_class_entry *dom_domlocator_class_entry;
                     60: zend_class_entry *dom_domconfiguration_class_entry;
                     61: zend_class_entry *dom_cdatasection_class_entry;
                     62: zend_class_entry *dom_documenttype_class_entry;
                     63: zend_class_entry *dom_notation_class_entry;
                     64: zend_class_entry *dom_entity_class_entry;
                     65: zend_class_entry *dom_entityreference_class_entry;
                     66: zend_class_entry *dom_processinginstruction_class_entry;
                     67: zend_class_entry *dom_string_extend_class_entry;
                     68: #if defined(LIBXML_XPATH_ENABLED)
                     69: zend_class_entry *dom_xpath_class_entry;
                     70: #endif
                     71: zend_class_entry *dom_namespace_node_class_entry;
                     72: /* }}} */
                     73: 
                     74: zend_object_handlers dom_object_handlers;
                     75: 
                     76: static HashTable classes;
                     77: /* {{{ prop handler tables */
                     78: static HashTable dom_domstringlist_prop_handlers;
                     79: static HashTable dom_namelist_prop_handlers;
                     80: static HashTable dom_domimplementationlist_prop_handlers;
                     81: static HashTable dom_document_prop_handlers;
                     82: static HashTable dom_node_prop_handlers;
                     83: static HashTable dom_nodelist_prop_handlers;
                     84: static HashTable dom_namednodemap_prop_handlers;
                     85: static HashTable dom_characterdata_prop_handlers;
                     86: static HashTable dom_attr_prop_handlers;
                     87: static HashTable dom_element_prop_handlers;
                     88: static HashTable dom_text_prop_handlers;
                     89: static HashTable dom_typeinfo_prop_handlers;
                     90: static HashTable dom_domerror_prop_handlers;
                     91: static HashTable dom_domlocator_prop_handlers;
                     92: static HashTable dom_documenttype_prop_handlers;
                     93: static HashTable dom_notation_prop_handlers;
                     94: static HashTable dom_entity_prop_handlers;
                     95: static HashTable dom_processinginstruction_prop_handlers;
                     96: static HashTable dom_namespace_node_prop_handlers;
                     97: #if defined(LIBXML_XPATH_ENABLED)
                     98: static HashTable dom_xpath_prop_handlers;
                     99: #endif
                    100: /* }}} */
                    101: 
                    102: typedef int (*dom_read_t)(dom_object *obj, zval **retval TSRMLS_DC);
                    103: typedef int (*dom_write_t)(dom_object *obj, zval *newval TSRMLS_DC);
                    104: 
                    105: typedef struct _dom_prop_handler {
                    106:        dom_read_t read_func;
                    107:        dom_write_t write_func;
                    108: } dom_prop_handler;
                    109: 
                    110: /* {{{ int dom_node_is_read_only(xmlNodePtr node) */
                    111: int dom_node_is_read_only(xmlNodePtr node) {
                    112:        switch (node->type) {
                    113:                case XML_ENTITY_REF_NODE:
                    114:                case XML_ENTITY_NODE:
                    115:                case XML_DOCUMENT_TYPE_NODE:
                    116:                case XML_NOTATION_NODE:
                    117:                case XML_DTD_NODE:
                    118:                case XML_ELEMENT_DECL:
                    119:                case XML_ATTRIBUTE_DECL:
                    120:                case XML_ENTITY_DECL:
                    121:                case XML_NAMESPACE_DECL:
                    122:                        return SUCCESS;
                    123:                        break;
                    124:                default:
                    125:                        if (node->doc == NULL) {
                    126:                                return SUCCESS;
                    127:                        } else {
                    128:                                return FAILURE;
                    129:                        }
                    130:        }
                    131: }
                    132: /* }}} end dom_node_is_read_only */
                    133: 
                    134: /* {{{ int dom_node_children_valid(xmlNodePtr node) */
                    135: int dom_node_children_valid(xmlNodePtr node) {
                    136:        switch (node->type) {
                    137:                case XML_DOCUMENT_TYPE_NODE:
                    138:                case XML_DTD_NODE:
                    139:                case XML_PI_NODE:
                    140:                case XML_COMMENT_NODE:
                    141:                case XML_TEXT_NODE:
                    142:                case XML_CDATA_SECTION_NODE:
                    143:                case XML_NOTATION_NODE:
                    144:                        return FAILURE;
                    145:                        break;
                    146:                default:
                    147:                        return SUCCESS;
                    148:        }
                    149: }
                    150: /* }}} end dom_node_children_valid */
                    151: 
                    152: /* {{{ dom_get_doc_props() */
                    153: dom_doc_propsptr dom_get_doc_props(php_libxml_ref_obj *document)
                    154: {
                    155:        dom_doc_propsptr doc_props;
                    156: 
                    157:        if (document && document->doc_props) {
                    158:                return document->doc_props;
                    159:        } else {
                    160:                doc_props = emalloc(sizeof(libxml_doc_props));
                    161:                doc_props->formatoutput = 0;
                    162:                doc_props->validateonparse = 0;
                    163:                doc_props->resolveexternals = 0;
                    164:                doc_props->preservewhitespace = 1;
                    165:                doc_props->substituteentities = 0;
                    166:                doc_props->stricterror = 1;
                    167:                doc_props->recover = 0;
                    168:                doc_props->classmap = NULL;
                    169:                if (document) {
                    170:                        document->doc_props = doc_props;
                    171:                }
                    172:                return doc_props;
                    173:        }
                    174: }
                    175: 
                    176: static void dom_copy_doc_props(php_libxml_ref_obj *source_doc, php_libxml_ref_obj *dest_doc)
                    177: {
                    178:        dom_doc_propsptr source, dest;
                    179:        
                    180:        if (source_doc && dest_doc) {
                    181:                
                    182:                source = dom_get_doc_props(source_doc);
                    183:                dest = dom_get_doc_props(dest_doc);
                    184: 
                    185:                dest->formatoutput = source->formatoutput;
                    186:                dest->validateonparse = source->validateonparse;
                    187:                dest->resolveexternals = source->resolveexternals;
                    188:                dest->preservewhitespace = source->preservewhitespace;
                    189:                dest->substituteentities = source->substituteentities;
                    190:                dest->stricterror = source->stricterror;
                    191:                dest->recover = source->recover;
                    192:                if (source->classmap) {
                    193:                        ALLOC_HASHTABLE(dest->classmap);
                    194:                        zend_hash_init(dest->classmap, 0, NULL, NULL, 0);
                    195:                        zend_hash_copy(dest->classmap, source->classmap, NULL, NULL, sizeof(zend_class_entry *));
                    196:                }
                    197: 
                    198:        }
                    199: }
                    200: 
                    201: int dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece, zend_class_entry *ce TSRMLS_DC)
                    202: {
                    203:        dom_doc_propsptr doc_props;
                    204: 
                    205:        if (document) {
                    206:                doc_props = dom_get_doc_props(document);
                    207:                if (doc_props->classmap == NULL) {
                    208:                        if (ce == NULL) {
                    209:                                return SUCCESS;
                    210:                        }
                    211:                        ALLOC_HASHTABLE(doc_props->classmap);
                    212:                        zend_hash_init(doc_props->classmap, 0, NULL, NULL, 0);
                    213:                }
                    214:                if (ce) {
                    215:                        return zend_hash_update(doc_props->classmap, basece->name, basece->name_length + 1, &ce, sizeof(zend_class_entry *), NULL);
                    216:                } else {
                    217:                        zend_hash_del(doc_props->classmap, basece->name, basece->name_length + 1);
                    218:                }
                    219:        }
                    220:        return SUCCESS;
                    221: }
                    222: 
                    223: zend_class_entry *dom_get_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece TSRMLS_DC)
                    224: {
                    225:        dom_doc_propsptr doc_props;
                    226:        zend_class_entry **ce = NULL;
                    227:        
                    228:        if (document) {
                    229:                doc_props = dom_get_doc_props(document);
                    230:                if (doc_props->classmap) {
                    231:                        if (zend_hash_find(doc_props->classmap, basece->name, basece->name_length + 1,  (void**) &ce) == SUCCESS) {
                    232:                                return *ce;
                    233:                        }
                    234:                }
                    235:        }
                    236: 
                    237:        return basece;
                    238: }
                    239: /* }}} */
                    240: 
                    241: /* {{{ dom_get_strict_error() */
                    242: int dom_get_strict_error(php_libxml_ref_obj *document) {
                    243:        int stricterror;
                    244:        dom_doc_propsptr doc_props;
                    245: 
                    246:        doc_props = dom_get_doc_props(document);
                    247:        stricterror = doc_props->stricterror;
                    248:        if (document == NULL) {
                    249:                efree(doc_props);
                    250:        }
                    251: 
                    252:        return stricterror;
                    253: }
                    254: /* }}} */
                    255: 
                    256: /* {{{ xmlNodePtr dom_object_get_node(dom_object *obj) */
                    257: PHP_DOM_EXPORT xmlNodePtr dom_object_get_node(dom_object *obj)
                    258: {
                    259:        if (obj && obj->ptr != NULL) {
                    260:                return ((php_libxml_node_ptr *)obj->ptr)->node;
                    261:        } else {
                    262:                return NULL;
                    263:        }
                    264: }
                    265: /* }}} end dom_object_get_node */
                    266: 
                    267: /* {{{ dom_object *php_dom_object_get_data(xmlNodePtr obj) */
                    268: PHP_DOM_EXPORT dom_object *php_dom_object_get_data(xmlNodePtr obj)
                    269: {
                    270:        if (obj && obj->_private != NULL) {
                    271:                return (dom_object *) ((php_libxml_node_ptr *) obj->_private)->_private;
                    272:        } else {
                    273:                return NULL;
                    274:        }
                    275: }
                    276: /* }}} end php_dom_object_get_data */
                    277: 
                    278: /* {{{ dom_read_na */
                    279: static int dom_read_na(dom_object *obj, zval **retval TSRMLS_DC)
                    280: {
                    281:        *retval = NULL;
                    282:        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot read property");
                    283:        return FAILURE;
                    284: }
                    285: /* }}} */
                    286: 
                    287: /* {{{ dom_write_na */
                    288: static int dom_write_na(dom_object *obj, zval *newval TSRMLS_DC)
                    289: {
                    290:        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot write property");
                    291:        return FAILURE;
                    292: }
                    293: /* }}} */
                    294: 
                    295: /* {{{ dom_register_prop_handler */
                    296: static void dom_register_prop_handler(HashTable *prop_handler, char *name, dom_read_t read_func, dom_write_t write_func TSRMLS_DC)
                    297: {
                    298:        dom_prop_handler hnd;
                    299:        
                    300:        hnd.read_func = read_func ? read_func : dom_read_na;
                    301:        hnd.write_func = write_func ? write_func : dom_write_na;
                    302:        zend_hash_add(prop_handler, name, strlen(name)+1, &hnd, sizeof(dom_prop_handler), NULL);
                    303: }
                    304: /* }}} */
                    305: 
1.1.1.2 ! misho     306: static zval **dom_get_property_ptr_ptr(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
1.1       misho     307: {
                    308:        dom_object *obj;
                    309:        zval tmp_member;
                    310:        zval **retval = NULL;
                    311:        dom_prop_handler *hnd;
                    312:        zend_object_handlers *std_hnd;
                    313:        int ret = FAILURE;
                    314: 
                    315:        if (member->type != IS_STRING) {
                    316:                tmp_member = *member;
                    317:                zval_copy_ctor(&tmp_member);
                    318:                convert_to_string(&tmp_member);
                    319:                member = &tmp_member;
                    320:        }
                    321: 
                    322:        obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
                    323: 
                    324:        if (obj->prop_handler != NULL) {
                    325:                ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
                    326:        }
                    327:        if (ret == FAILURE) {
                    328:                std_hnd = zend_get_std_object_handlers();
1.1.1.2 ! misho     329:                retval = std_hnd->get_property_ptr_ptr(object, member, key TSRMLS_CC);
1.1       misho     330:        }
                    331: 
                    332:        if (member == &tmp_member) {
                    333:                zval_dtor(member);
                    334:        }
                    335:        return retval;
                    336: }
                    337: /* }}} */
                    338: 
                    339: /* {{{ dom_read_property */
1.1.1.2 ! misho     340: zval *dom_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
1.1       misho     341: {
                    342:        dom_object *obj;
                    343:        zval tmp_member;
                    344:        zval *retval;
                    345:        dom_prop_handler *hnd;
                    346:        zend_object_handlers *std_hnd;
                    347:        int ret;
                    348: 
                    349:        if (member->type != IS_STRING) {
                    350:                tmp_member = *member;
                    351:                zval_copy_ctor(&tmp_member);
                    352:                convert_to_string(&tmp_member);
                    353:                member = &tmp_member;
                    354:        }
                    355: 
                    356:        ret = FAILURE;
                    357:        obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
                    358: 
                    359:        if (obj->prop_handler != NULL) {
                    360:                ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
                    361:        } else if (instanceof_function(obj->std.ce, dom_node_class_entry TSRMLS_CC)) {
                    362:                php_error(E_WARNING, "Couldn't fetch %s. Node no longer exists", obj->std.ce->name);
                    363:        }
                    364:        if (ret == SUCCESS) {
                    365:                ret = hnd->read_func(obj, &retval TSRMLS_CC);
                    366:                if (ret == SUCCESS) {
                    367:                        /* ensure we're creating a temporary variable */
                    368:                        Z_SET_REFCOUNT_P(retval, 0);
                    369:                        Z_UNSET_ISREF_P(retval);
                    370:                } else {
                    371:                        retval = EG(uninitialized_zval_ptr);
                    372:                }
                    373:        } else {
                    374:                std_hnd = zend_get_std_object_handlers();
1.1.1.2 ! misho     375:                retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
1.1       misho     376:        }
                    377: 
                    378:        if (member == &tmp_member) {
                    379:                zval_dtor(member);
                    380:        }
                    381:        return retval;
                    382: }
                    383: /* }}} */
                    384: 
                    385: /* {{{ dom_write_property */
1.1.1.2 ! misho     386: void dom_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
1.1       misho     387: {
                    388:        dom_object *obj;
                    389:        zval tmp_member;
                    390:        dom_prop_handler *hnd;
                    391:        zend_object_handlers *std_hnd;
                    392:        int ret;
                    393: 
                    394:        if (member->type != IS_STRING) {
                    395:                tmp_member = *member;
                    396:                zval_copy_ctor(&tmp_member);
                    397:                convert_to_string(&tmp_member);
                    398:                member = &tmp_member;
                    399:        }
                    400: 
                    401:        ret = FAILURE;
                    402:        obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
                    403: 
                    404:        if (obj->prop_handler != NULL) {
                    405:                ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
                    406:        }
                    407:        if (ret == SUCCESS) {
                    408:                hnd->write_func(obj, value TSRMLS_CC);
                    409:        } else {
                    410:                std_hnd = zend_get_std_object_handlers();
1.1.1.2 ! misho     411:                std_hnd->write_property(object, member, value, key TSRMLS_CC);
1.1       misho     412:        }
                    413: 
                    414:        if (member == &tmp_member) {
                    415:                zval_dtor(member);
                    416:        }
                    417: }
                    418: /* }}} */
                    419: 
                    420: /* {{{ dom_property_exists */
1.1.1.2 ! misho     421: static int dom_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
1.1       misho     422: {
                    423:        dom_object *obj;
                    424:        zval tmp_member;
                    425:        dom_prop_handler *hnd;
                    426:        zend_object_handlers *std_hnd;
                    427:        int ret, retval=0;
                    428: 
                    429:        if (member->type != IS_STRING) {
                    430:                tmp_member = *member;
                    431:                zval_copy_ctor(&tmp_member);
                    432:                convert_to_string(&tmp_member);
                    433:                member = &tmp_member;
                    434:        }
                    435: 
                    436:        ret = FAILURE;
                    437:        obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
                    438: 
                    439:        if (obj->prop_handler != NULL) {
                    440:                ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
                    441:        }
                    442:        if (ret == SUCCESS) {
                    443:                zval *tmp;
                    444: 
                    445:                if (check_empty == 2) {
                    446:                        retval = 1;
                    447:                } else if (hnd->read_func(obj, &tmp TSRMLS_CC) == SUCCESS) {
                    448:                        Z_SET_REFCOUNT_P(tmp, 1);
                    449:                        Z_UNSET_ISREF_P(tmp);
                    450:                        if (check_empty == 1) {
                    451:                                retval = zend_is_true(tmp);
                    452:                        } else if (check_empty == 0) {
                    453:                                retval = (Z_TYPE_P(tmp) != IS_NULL);
                    454:                        }
                    455:                        zval_ptr_dtor(&tmp);
                    456:                }
                    457:        } else {
                    458:                std_hnd = zend_get_std_object_handlers();
1.1.1.2 ! misho     459:                retval = std_hnd->has_property(object, member, check_empty, key TSRMLS_CC);
1.1       misho     460:        }
                    461: 
                    462:        if (member == &tmp_member) {
                    463:                zval_dtor(member);
                    464:        }
                    465:        return retval;
                    466: }
                    467: /* }}} */
                    468: 
1.1.1.2 ! misho     469: static HashTable* dom_get_debug_info_helper(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
        !           470: {
        !           471:        dom_object                      *obj = zend_object_store_get_object(object TSRMLS_CC);
        !           472:        HashTable                       *debug_info,
        !           473:                                                *prop_handlers = obj->prop_handler,
        !           474:                                                *std_props;
        !           475:        HashPosition            pos;
        !           476:        dom_prop_handler        *entry;
        !           477:        zval                            *object_value,
        !           478:                                                *null_value;
        !           479: 
        !           480:        *is_temp = 1;
        !           481: 
        !           482:        ALLOC_HASHTABLE(debug_info);
        !           483:        ZEND_INIT_SYMTABLE_EX(debug_info, 32, 0);
        !           484: 
        !           485:        std_props = zend_std_get_properties(object TSRMLS_CC);
        !           486:        zend_hash_copy(debug_info, std_props, (copy_ctor_func_t)zval_add_ref,
        !           487:                        NULL, sizeof(zval*));
        !           488: 
        !           489:        if (!prop_handlers) {
        !           490:                return debug_info;
        !           491:        }
        !           492: 
        !           493:        ALLOC_INIT_ZVAL(object_value);
        !           494:        ZVAL_STRING(object_value, "(object value omitted)", 1);
        !           495: 
        !           496:        ALLOC_INIT_ZVAL(null_value);
        !           497:        ZVAL_NULL(null_value);
        !           498: 
        !           499:        for (zend_hash_internal_pointer_reset_ex(prop_handlers, &pos);
        !           500:                        zend_hash_get_current_data_ex(prop_handlers, (void **)&entry, &pos)
        !           501:                                        == SUCCESS;
        !           502:                        zend_hash_move_forward_ex(prop_handlers, &pos)) {
        !           503:                zval    *value;
        !           504:                char    *string_key             = NULL;
        !           505:                uint    string_length   = 0;
        !           506:                ulong   num_key;
        !           507: 
        !           508:                if (entry->read_func(obj, &value TSRMLS_CC) == FAILURE) {
        !           509:                        continue;
        !           510:                }
        !           511: 
        !           512:                if (zend_hash_get_current_key_ex(prop_handlers, &string_key,
        !           513:                        &string_length, &num_key, 0, &pos) != HASH_KEY_IS_STRING) {
        !           514:                        continue;
        !           515:                }
        !           516: 
        !           517:                if (value == EG(uninitialized_zval_ptr)) {
        !           518:                        value = null_value;
        !           519:                } else if (Z_TYPE_P(value) == IS_OBJECT) {
        !           520:                        /* these are zvalues create on demand, with refcount and is_ref
        !           521:                         * status left in an uninitalized stated */
        !           522:                        zval_dtor(value);
        !           523:                        efree(value);
        !           524: 
        !           525:                        value = object_value;
        !           526:                } else {
        !           527:                        /* see comment above */
        !           528:                        Z_SET_REFCOUNT_P(value, 0);
        !           529:                        Z_UNSET_ISREF_P(value);
        !           530:                }
        !           531: 
        !           532:                zval_add_ref(&value);
        !           533:                zend_hash_add(debug_info, string_key, string_length,
        !           534:                                &value, sizeof(zval *), NULL);
        !           535:        }
        !           536: 
        !           537:        zval_ptr_dtor(&null_value);
        !           538:        zval_ptr_dtor(&object_value);
        !           539: 
        !           540:        return debug_info;
        !           541: }
        !           542: /* }}} */
        !           543: 
        !           544: static HashTable* dom_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
        !           545: {
        !           546:        return dom_get_debug_info_helper(object, is_temp TSRMLS_CC);
        !           547: }
        !           548: /* }}} */
        !           549: 
1.1       misho     550: void *php_dom_export_node(zval *object TSRMLS_DC) /* {{{ */
                    551: {
                    552:        php_libxml_node_object *intern;
                    553:        xmlNodePtr nodep = NULL;
                    554: 
                    555:        intern = (php_libxml_node_object *)zend_object_store_get_object(object TSRMLS_CC);
                    556:        if (intern && intern->node) {
                    557:                nodep = intern->node->node;
                    558:        }
                    559: 
                    560:        return nodep;   
                    561: }
                    562: /* }}} */
                    563: 
                    564: /* {{{ proto somNode dom_import_simplexml(sxeobject node)
                    565:    Get a simplexml_element object from dom to allow for processing */
                    566: PHP_FUNCTION(dom_import_simplexml)
                    567: {
                    568:        zval *node;
                    569:        xmlNodePtr nodep = NULL;
                    570:        php_libxml_node_object *nodeobj;
                    571:        int ret;
                    572: 
                    573:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &node) == FAILURE) {
                    574:                return;
                    575:        }
                    576: 
                    577:        nodeobj = (php_libxml_node_object *)zend_object_store_get_object(node TSRMLS_CC);
                    578:        nodep = php_libxml_import_node(node TSRMLS_CC);
                    579: 
                    580:        if (nodep && nodeobj && (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE)) {
1.1.1.2 ! misho     581:                DOM_RET_OBJ((xmlNodePtr) nodep, &ret, (dom_object *)nodeobj);
1.1       misho     582:        } else {
                    583:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Nodetype to import");
                    584:                RETURN_NULL();
                    585:        }
                    586: }
                    587: /* }}} */
                    588: 
                    589: zend_object_value dom_objects_store_clone_obj(zval *zobject TSRMLS_DC) /* {{{ */
                    590: {
                    591:        zend_object_value retval;
                    592:        void *new_object;
                    593:        dom_object *intern;
                    594:        dom_object *old_object;
                    595:        struct _store_object *obj;
                    596:        zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
                    597: 
                    598:        obj = &EG(objects_store).object_buckets[handle].bucket.obj;
                    599:        
                    600:        if (obj->clone == NULL) {
                    601:                php_error(E_ERROR, "Trying to clone an uncloneable object of class %s", Z_OBJCE_P(zobject)->name);
                    602:        }               
                    603: 
                    604:        obj->clone(obj->object, &new_object TSRMLS_CC);
                    605: 
                    606:        retval.handle = zend_objects_store_put(new_object, obj->dtor, obj->free_storage, obj->clone TSRMLS_CC);
                    607:        intern = (dom_object *) new_object;
                    608:        intern->handle = retval.handle;
                    609:        retval.handlers = Z_OBJ_HT_P(zobject);
                    610:        
                    611:        old_object = (dom_object *) obj->object;
                    612:        zend_objects_clone_members(&intern->std, retval, &old_object->std, intern->handle TSRMLS_CC);
                    613: 
                    614:        return retval;
                    615: }
                    616: /* }}} */
                    617: 
                    618: /* {{{ arginfo */
                    619: ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_import_simplexml, 0, 0, 1)
                    620:        ZEND_ARG_INFO(0, node)
                    621: ZEND_END_ARG_INFO()
                    622: /* }}} */
                    623: 
                    624: static const zend_function_entry dom_functions[] = {
                    625:        PHP_FE(dom_import_simplexml, arginfo_dom_import_simplexml)
                    626:        PHP_FE_END
                    627: };
                    628: 
                    629: static zend_object_handlers* dom_get_obj_handlers(TSRMLS_D) {
                    630:        return &dom_object_handlers;
                    631: }
                    632: 
                    633: static const zend_module_dep dom_deps[] = {
                    634:        ZEND_MOD_REQUIRED("libxml")
                    635:        ZEND_MOD_CONFLICTS("domxml")
                    636:        ZEND_MOD_END
                    637: };
                    638: 
                    639: zend_module_entry dom_module_entry = { /* {{{ */
                    640:        STANDARD_MODULE_HEADER_EX, NULL,
                    641:        dom_deps,
                    642:        "dom",
                    643:        dom_functions,
                    644:        PHP_MINIT(dom),
                    645:        PHP_MSHUTDOWN(dom),
                    646:        NULL,
                    647:        NULL,
                    648:        PHP_MINFO(dom),
                    649:        DOM_API_VERSION, /* Extension versionnumber */
                    650:        STANDARD_MODULE_PROPERTIES
                    651: };
                    652: /* }}} */
                    653: 
                    654: #ifdef COMPILE_DL_DOM
                    655: ZEND_GET_MODULE(dom)
                    656: #endif
                    657: 
                    658: /* {{{ PHP_MINIT_FUNCTION(dom) */
                    659: PHP_MINIT_FUNCTION(dom)
                    660: {
                    661:        zend_class_entry ce;
                    662: 
                    663:        memcpy(&dom_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
                    664:        dom_object_handlers.read_property = dom_read_property;
                    665:        dom_object_handlers.write_property = dom_write_property;
                    666:        dom_object_handlers.get_property_ptr_ptr = dom_get_property_ptr_ptr;
                    667:        dom_object_handlers.clone_obj = dom_objects_store_clone_obj;
                    668:        dom_object_handlers.has_property = dom_property_exists;
1.1.1.2 ! misho     669:        dom_object_handlers.get_debug_info = dom_get_debug_info;
1.1       misho     670: 
                    671:        zend_hash_init(&classes, 0, NULL, NULL, 1);
                    672: 
                    673:        INIT_CLASS_ENTRY(ce, "DOMException", php_dom_domexception_class_functions);
                    674:        dom_domexception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
                    675:        dom_domexception_class_entry->ce_flags |= ZEND_ACC_FINAL;
                    676:        zend_declare_property_long(dom_domexception_class_entry, "code", sizeof("code")-1, 0, ZEND_ACC_PUBLIC TSRMLS_CC);
                    677: 
                    678:        REGISTER_DOM_CLASS(ce, "DOMStringList", NULL, php_dom_domstringlist_class_functions, dom_domstringlist_class_entry);
                    679:        
                    680:        zend_hash_init(&dom_domstringlist_prop_handlers, 0, NULL, NULL, 1);
                    681:        dom_register_prop_handler(&dom_domstringlist_prop_handlers, "length", dom_domstringlist_length_read, NULL TSRMLS_CC);
                    682:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domstringlist_prop_handlers, sizeof(dom_domstringlist_prop_handlers), NULL);
                    683: 
                    684:        REGISTER_DOM_CLASS(ce, "DOMNameList", NULL, php_dom_namelist_class_functions, dom_namelist_class_entry);
                    685:        
                    686:        zend_hash_init(&dom_namelist_prop_handlers, 0, NULL, NULL, 1);
                    687:        dom_register_prop_handler(&dom_namelist_prop_handlers, "length", dom_namelist_length_read, NULL TSRMLS_CC);
                    688:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namelist_prop_handlers, sizeof(dom_namelist_prop_handlers), NULL);
                    689: 
                    690:        REGISTER_DOM_CLASS(ce, "DOMImplementationList", NULL, php_dom_domimplementationlist_class_functions, dom_domimplementationlist_class_entry);
                    691:        
                    692:        zend_hash_init(&dom_domimplementationlist_prop_handlers, 0, NULL, NULL, 1);
                    693:        dom_register_prop_handler(&dom_domimplementationlist_prop_handlers, "length", dom_domimplementationlist_length_read, NULL TSRMLS_CC);
                    694:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domimplementationlist_prop_handlers, sizeof(dom_domimplementationlist_prop_handlers), NULL);
                    695: 
                    696:        REGISTER_DOM_CLASS(ce, "DOMImplementationSource", NULL, php_dom_domimplementationsource_class_functions, dom_domimplementationsource_class_entry);
                    697:        REGISTER_DOM_CLASS(ce, "DOMImplementation", NULL, php_dom_domimplementation_class_functions, dom_domimplementation_class_entry);
                    698: 
                    699:        REGISTER_DOM_CLASS(ce, "DOMNode", NULL, php_dom_node_class_functions, dom_node_class_entry);
                    700:        
                    701:        zend_hash_init(&dom_node_prop_handlers, 0, NULL, NULL, 1);
                    702:        dom_register_prop_handler(&dom_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
                    703:        dom_register_prop_handler(&dom_node_prop_handlers, "nodeValue", dom_node_node_value_read, dom_node_node_value_write TSRMLS_CC);
                    704:        dom_register_prop_handler(&dom_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL TSRMLS_CC);
                    705:        dom_register_prop_handler(&dom_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL TSRMLS_CC);
                    706:        dom_register_prop_handler(&dom_node_prop_handlers, "childNodes", dom_node_child_nodes_read, NULL TSRMLS_CC);
                    707:        dom_register_prop_handler(&dom_node_prop_handlers, "firstChild", dom_node_first_child_read, NULL TSRMLS_CC);
                    708:        dom_register_prop_handler(&dom_node_prop_handlers, "lastChild", dom_node_last_child_read, NULL TSRMLS_CC);
                    709:        dom_register_prop_handler(&dom_node_prop_handlers, "previousSibling", dom_node_previous_sibling_read, NULL TSRMLS_CC);
                    710:        dom_register_prop_handler(&dom_node_prop_handlers, "nextSibling", dom_node_next_sibling_read, NULL TSRMLS_CC);
                    711:        dom_register_prop_handler(&dom_node_prop_handlers, "attributes", dom_node_attributes_read, NULL TSRMLS_CC);
                    712:        dom_register_prop_handler(&dom_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL TSRMLS_CC);
                    713:        dom_register_prop_handler(&dom_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL TSRMLS_CC);
                    714:        dom_register_prop_handler(&dom_node_prop_handlers, "prefix", dom_node_prefix_read, dom_node_prefix_write TSRMLS_CC);
                    715:        dom_register_prop_handler(&dom_node_prop_handlers, "localName", dom_node_local_name_read, NULL TSRMLS_CC);
                    716:        dom_register_prop_handler(&dom_node_prop_handlers, "baseURI", dom_node_base_uri_read, NULL TSRMLS_CC);
                    717:        dom_register_prop_handler(&dom_node_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write TSRMLS_CC);
                    718:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
                    719: 
                    720:        REGISTER_DOM_CLASS(ce, "DOMNameSpaceNode", NULL, NULL, dom_namespace_node_class_entry);
                    721: 
                    722:        zend_hash_init(&dom_namespace_node_prop_handlers, 0, NULL, NULL, 1);
                    723:        dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
                    724:        dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeValue", dom_node_node_value_read, NULL TSRMLS_CC);
                    725:        dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL TSRMLS_CC);
                    726:        dom_register_prop_handler(&dom_namespace_node_prop_handlers, "prefix", dom_node_prefix_read, NULL TSRMLS_CC);
                    727:        dom_register_prop_handler(&dom_namespace_node_prop_handlers, "localName", dom_node_local_name_read, NULL TSRMLS_CC);
                    728:        dom_register_prop_handler(&dom_namespace_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL TSRMLS_CC);
                    729:        dom_register_prop_handler(&dom_namespace_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL TSRMLS_CC);
                    730:        dom_register_prop_handler(&dom_namespace_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL TSRMLS_CC);
                    731:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namespace_node_prop_handlers, sizeof(dom_namespace_node_prop_handlers), NULL);
                    732: 
                    733:        REGISTER_DOM_CLASS(ce, "DOMDocumentFragment", dom_node_class_entry, php_dom_documentfragment_class_functions, dom_documentfragment_class_entry);
                    734:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
                    735:        
                    736:        REGISTER_DOM_CLASS(ce, "DOMDocument", dom_node_class_entry, php_dom_document_class_functions, dom_document_class_entry);
                    737:        zend_hash_init(&dom_document_prop_handlers, 0, NULL, NULL, 1);
                    738:        dom_register_prop_handler(&dom_document_prop_handlers, "doctype", dom_document_doctype_read, NULL TSRMLS_CC);
                    739:        dom_register_prop_handler(&dom_document_prop_handlers, "implementation", dom_document_implementation_read, NULL TSRMLS_CC);
                    740:        dom_register_prop_handler(&dom_document_prop_handlers, "documentElement", dom_document_document_element_read, NULL TSRMLS_CC);
                    741:        dom_register_prop_handler(&dom_document_prop_handlers, "actualEncoding", dom_document_encoding_read, NULL TSRMLS_CC);
                    742:        dom_register_prop_handler(&dom_document_prop_handlers, "encoding", dom_document_encoding_read, dom_document_encoding_write TSRMLS_CC);
                    743:        dom_register_prop_handler(&dom_document_prop_handlers, "xmlEncoding", dom_document_encoding_read, NULL TSRMLS_CC);
                    744:        dom_register_prop_handler(&dom_document_prop_handlers, "standalone", dom_document_standalone_read, dom_document_standalone_write TSRMLS_CC);
                    745:        dom_register_prop_handler(&dom_document_prop_handlers, "xmlStandalone", dom_document_standalone_read, dom_document_standalone_write TSRMLS_CC);
                    746:        dom_register_prop_handler(&dom_document_prop_handlers, "version", dom_document_version_read, dom_document_version_write TSRMLS_CC);
                    747:        dom_register_prop_handler(&dom_document_prop_handlers, "xmlVersion", dom_document_version_read, dom_document_version_write TSRMLS_CC);
                    748:        dom_register_prop_handler(&dom_document_prop_handlers, "strictErrorChecking", dom_document_strict_error_checking_read, dom_document_strict_error_checking_write TSRMLS_CC);
                    749:        dom_register_prop_handler(&dom_document_prop_handlers, "documentURI", dom_document_document_uri_read, dom_document_document_uri_write TSRMLS_CC);
                    750:        dom_register_prop_handler(&dom_document_prop_handlers, "config", dom_document_config_read, NULL TSRMLS_CC);
                    751:        dom_register_prop_handler(&dom_document_prop_handlers, "formatOutput", dom_document_format_output_read, dom_document_format_output_write TSRMLS_CC);
                    752:        dom_register_prop_handler(&dom_document_prop_handlers, "validateOnParse", dom_document_validate_on_parse_read, dom_document_validate_on_parse_write TSRMLS_CC);
                    753:        dom_register_prop_handler(&dom_document_prop_handlers, "resolveExternals", dom_document_resolve_externals_read, dom_document_resolve_externals_write TSRMLS_CC);
                    754:        dom_register_prop_handler(&dom_document_prop_handlers, "preserveWhiteSpace", dom_document_preserve_whitespace_read, dom_document_preserve_whitespace_write TSRMLS_CC);
                    755:        dom_register_prop_handler(&dom_document_prop_handlers, "recover", dom_document_recover_read, dom_document_recover_write TSRMLS_CC);
                    756:        dom_register_prop_handler(&dom_document_prop_handlers, "substituteEntities", dom_document_substitue_entities_read, dom_document_substitue_entities_write TSRMLS_CC);
                    757: 
                    758:        zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
                    759:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_document_prop_handlers, sizeof(dom_document_prop_handlers), NULL);
                    760: 
                    761:        INIT_CLASS_ENTRY(ce, "DOMNodeList", php_dom_nodelist_class_functions);
                    762:        ce.create_object = dom_nnodemap_objects_new;
                    763:        dom_nodelist_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
                    764:        dom_nodelist_class_entry->get_iterator = php_dom_get_iterator;
                    765:        zend_class_implements(dom_nodelist_class_entry TSRMLS_CC, 1, zend_ce_traversable);
                    766: 
                    767:        zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, NULL, 1);
                    768:        dom_register_prop_handler(&dom_nodelist_prop_handlers, "length", dom_nodelist_length_read, NULL TSRMLS_CC);
                    769:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_nodelist_prop_handlers, sizeof(dom_nodelist_prop_handlers), NULL);
                    770: 
                    771:        INIT_CLASS_ENTRY(ce, "DOMNamedNodeMap", php_dom_namednodemap_class_functions);
                    772:        ce.create_object = dom_nnodemap_objects_new;
                    773:        dom_namednodemap_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
                    774:        dom_namednodemap_class_entry->get_iterator = php_dom_get_iterator;
                    775:        zend_class_implements(dom_namednodemap_class_entry TSRMLS_CC, 1, zend_ce_traversable);
                    776: 
                    777:        zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, NULL, 1);
                    778:        dom_register_prop_handler(&dom_namednodemap_prop_handlers, "length", dom_namednodemap_length_read, NULL TSRMLS_CC);
                    779:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namednodemap_prop_handlers, sizeof(dom_namednodemap_prop_handlers), NULL);
                    780: 
                    781:        REGISTER_DOM_CLASS(ce, "DOMCharacterData", dom_node_class_entry, php_dom_characterdata_class_functions, dom_characterdata_class_entry);
                    782:        
                    783:        zend_hash_init(&dom_characterdata_prop_handlers, 0, NULL, NULL, 1);
                    784:        dom_register_prop_handler(&dom_characterdata_prop_handlers, "data", dom_characterdata_data_read, dom_characterdata_data_write TSRMLS_CC);
                    785:        dom_register_prop_handler(&dom_characterdata_prop_handlers, "length", dom_characterdata_length_read, NULL TSRMLS_CC);
                    786:        zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
                    787:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_characterdata_prop_handlers), NULL);
                    788: 
                    789:        REGISTER_DOM_CLASS(ce, "DOMAttr", dom_node_class_entry, php_dom_attr_class_functions, dom_attr_class_entry);
                    790:        
                    791:        zend_hash_init(&dom_attr_prop_handlers, 0, NULL, NULL, 1);
                    792:        dom_register_prop_handler(&dom_attr_prop_handlers, "name", dom_attr_name_read, NULL TSRMLS_CC);
                    793:        dom_register_prop_handler(&dom_attr_prop_handlers, "specified", dom_attr_specified_read, NULL TSRMLS_CC);
                    794:        dom_register_prop_handler(&dom_attr_prop_handlers, "value", dom_attr_value_read, dom_attr_value_write TSRMLS_CC);
                    795:        dom_register_prop_handler(&dom_attr_prop_handlers, "ownerElement", dom_attr_owner_element_read, NULL TSRMLS_CC);
                    796:        dom_register_prop_handler(&dom_attr_prop_handlers, "schemaTypeInfo", dom_attr_schema_type_info_read, NULL TSRMLS_CC);
                    797:        zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
                    798:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_attr_prop_handlers, sizeof(dom_attr_prop_handlers), NULL);
                    799: 
                    800:        REGISTER_DOM_CLASS(ce, "DOMElement", dom_node_class_entry, php_dom_element_class_functions, dom_element_class_entry);
                    801:        
                    802:        zend_hash_init(&dom_element_prop_handlers, 0, NULL, NULL, 1);
                    803:        dom_register_prop_handler(&dom_element_prop_handlers, "tagName", dom_element_tag_name_read, NULL TSRMLS_CC);
                    804:        dom_register_prop_handler(&dom_element_prop_handlers, "schemaTypeInfo", dom_element_schema_type_info_read, NULL TSRMLS_CC);
                    805:        zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
                    806:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_element_prop_handlers, sizeof(dom_element_prop_handlers), NULL);
                    807: 
                    808:        REGISTER_DOM_CLASS(ce, "DOMText", dom_characterdata_class_entry, php_dom_text_class_functions, dom_text_class_entry);
                    809:        
                    810:        zend_hash_init(&dom_text_prop_handlers, 0, NULL, NULL, 1);
                    811:        dom_register_prop_handler(&dom_text_prop_handlers, "wholeText", dom_text_whole_text_read, NULL TSRMLS_CC);
                    812:        zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
                    813:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_text_prop_handlers), NULL);
                    814: 
                    815:        REGISTER_DOM_CLASS(ce, "DOMComment", dom_characterdata_class_entry, php_dom_comment_class_functions, dom_comment_class_entry);
                    816:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
                    817: 
                    818:        REGISTER_DOM_CLASS(ce, "DOMTypeinfo", NULL, php_dom_typeinfo_class_functions, dom_typeinfo_class_entry);
                    819:        
                    820:        zend_hash_init(&dom_typeinfo_prop_handlers, 0, NULL, NULL, 1);
                    821:        dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeName", dom_typeinfo_type_name_read, NULL TSRMLS_CC);
                    822:        dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeNamespace", dom_typeinfo_type_namespace_read, NULL TSRMLS_CC);
                    823:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_typeinfo_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
                    824: 
                    825:        REGISTER_DOM_CLASS(ce, "DOMUserDataHandler", NULL, php_dom_userdatahandler_class_functions, dom_userdatahandler_class_entry);
                    826:        REGISTER_DOM_CLASS(ce, "DOMDomError", NULL, php_dom_domerror_class_functions, dom_domerror_class_entry);
                    827:        
                    828:        zend_hash_init(&dom_domerror_prop_handlers, 0, NULL, NULL, 1);
                    829:        dom_register_prop_handler(&dom_domerror_prop_handlers, "severity", dom_domerror_severity_read, NULL TSRMLS_CC);
                    830:        dom_register_prop_handler(&dom_domerror_prop_handlers, "message", dom_domerror_message_read, NULL TSRMLS_CC);
                    831:        dom_register_prop_handler(&dom_domerror_prop_handlers, "type", dom_domerror_type_read, NULL TSRMLS_CC);
                    832:        dom_register_prop_handler(&dom_domerror_prop_handlers, "relatedException", dom_domerror_related_exception_read, NULL TSRMLS_CC);
                    833:        dom_register_prop_handler(&dom_domerror_prop_handlers, "related_data", dom_domerror_related_data_read, NULL TSRMLS_CC);
                    834:        dom_register_prop_handler(&dom_domerror_prop_handlers, "location", dom_domerror_location_read, NULL TSRMLS_CC);
                    835:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domerror_prop_handlers, sizeof(dom_domerror_prop_handlers), NULL);
                    836: 
                    837:        REGISTER_DOM_CLASS(ce, "DOMErrorHandler", NULL, php_dom_domerrorhandler_class_functions, dom_domerrorhandler_class_entry);
                    838:        REGISTER_DOM_CLASS(ce, "DOMLocator", NULL, php_dom_domlocator_class_functions, dom_domlocator_class_entry);
                    839:        
                    840:        zend_hash_init(&dom_domlocator_prop_handlers, 0, NULL, NULL, 1);
                    841:        dom_register_prop_handler(&dom_domlocator_prop_handlers, "lineNumber", dom_domlocator_line_number_read, NULL TSRMLS_CC);
                    842:        dom_register_prop_handler(&dom_domlocator_prop_handlers, "columnNumber", dom_domlocator_column_number_read, NULL TSRMLS_CC);
                    843:        dom_register_prop_handler(&dom_domlocator_prop_handlers, "offset", dom_domlocator_offset_read, NULL TSRMLS_CC);
                    844:        dom_register_prop_handler(&dom_domlocator_prop_handlers, "relatedNode", dom_domlocator_related_node_read, NULL TSRMLS_CC);
                    845:        dom_register_prop_handler(&dom_domlocator_prop_handlers, "uri", dom_domlocator_uri_read, NULL TSRMLS_CC);
                    846:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domlocator_prop_handlers, sizeof(dom_domlocator_prop_handlers), NULL);
                    847: 
                    848:        REGISTER_DOM_CLASS(ce, "DOMConfiguration", NULL, php_dom_domconfiguration_class_functions, dom_domconfiguration_class_entry);
                    849:        REGISTER_DOM_CLASS(ce, "DOMCdataSection", dom_text_class_entry, php_dom_cdatasection_class_functions, dom_cdatasection_class_entry);
                    850:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
                    851: 
                    852:        REGISTER_DOM_CLASS(ce, "DOMDocumentType", dom_node_class_entry, php_dom_documenttype_class_functions, dom_documenttype_class_entry);
                    853:        
                    854:        zend_hash_init(&dom_documenttype_prop_handlers, 0, NULL, NULL, 1);
                    855:        dom_register_prop_handler(&dom_documenttype_prop_handlers, "name", dom_documenttype_name_read, NULL TSRMLS_CC);
                    856:        dom_register_prop_handler(&dom_documenttype_prop_handlers, "entities", dom_documenttype_entities_read, NULL TSRMLS_CC);
                    857:        dom_register_prop_handler(&dom_documenttype_prop_handlers, "notations", dom_documenttype_notations_read, NULL TSRMLS_CC);
                    858:        dom_register_prop_handler(&dom_documenttype_prop_handlers, "publicId", dom_documenttype_public_id_read, NULL TSRMLS_CC);
                    859:        dom_register_prop_handler(&dom_documenttype_prop_handlers, "systemId", dom_documenttype_system_id_read, NULL TSRMLS_CC);
                    860:        dom_register_prop_handler(&dom_documenttype_prop_handlers, "internalSubset", dom_documenttype_internal_subset_read, NULL TSRMLS_CC);
                    861:        zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
                    862:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_documenttype_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
                    863: 
                    864:        REGISTER_DOM_CLASS(ce, "DOMNotation", dom_node_class_entry, php_dom_notation_class_functions, dom_notation_class_entry);
                    865:        
                    866:        zend_hash_init(&dom_notation_prop_handlers, 0, NULL, NULL, 1);
                    867:        dom_register_prop_handler(&dom_notation_prop_handlers, "publicId", dom_notation_public_id_read, NULL TSRMLS_CC);
                    868:        dom_register_prop_handler(&dom_notation_prop_handlers, "systemId", dom_notation_system_id_read, NULL TSRMLS_CC);
                    869:        zend_hash_merge(&dom_notation_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
                    870:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_notation_prop_handlers, sizeof(dom_notation_prop_handlers), NULL);
                    871: 
                    872:        REGISTER_DOM_CLASS(ce, "DOMEntity", dom_node_class_entry, php_dom_entity_class_functions, dom_entity_class_entry);
                    873:        
                    874:        zend_hash_init(&dom_entity_prop_handlers, 0, NULL, NULL, 1);
                    875:        dom_register_prop_handler(&dom_entity_prop_handlers, "publicId", dom_entity_public_id_read, NULL TSRMLS_CC);
                    876:        dom_register_prop_handler(&dom_entity_prop_handlers, "systemId", dom_entity_system_id_read, NULL TSRMLS_CC);
                    877:        dom_register_prop_handler(&dom_entity_prop_handlers, "notationName", dom_entity_notation_name_read, NULL TSRMLS_CC);
                    878:        dom_register_prop_handler(&dom_entity_prop_handlers, "actualEncoding", dom_entity_actual_encoding_read, dom_entity_actual_encoding_write TSRMLS_CC);
                    879:        dom_register_prop_handler(&dom_entity_prop_handlers, "encoding", dom_entity_encoding_read, dom_entity_encoding_write TSRMLS_CC);
                    880:        dom_register_prop_handler(&dom_entity_prop_handlers, "version", dom_entity_version_read, dom_entity_version_write TSRMLS_CC);
                    881:        zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
                    882: 
                    883:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_entity_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
                    884: 
                    885:        REGISTER_DOM_CLASS(ce, "DOMEntityReference", dom_node_class_entry, php_dom_entityreference_class_functions, dom_entityreference_class_entry);
                    886:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
                    887: 
                    888:        REGISTER_DOM_CLASS(ce, "DOMProcessingInstruction", dom_node_class_entry, php_dom_processinginstruction_class_functions, dom_processinginstruction_class_entry);
                    889:        
                    890:        zend_hash_init(&dom_processinginstruction_prop_handlers, 0, NULL, NULL, 1);
                    891:        dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "target", dom_processinginstruction_target_read, NULL TSRMLS_CC);
                    892:        dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "data", dom_processinginstruction_data_read, dom_processinginstruction_data_write TSRMLS_CC);
                    893:        zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
                    894:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_processinginstruction_prop_handlers, sizeof(dom_processinginstruction_prop_handlers), NULL);
                    895: 
                    896:        REGISTER_DOM_CLASS(ce, "DOMStringExtend", NULL, php_dom_string_extend_class_functions, dom_string_extend_class_entry);
                    897: 
                    898: #if defined(LIBXML_XPATH_ENABLED)
                    899:        INIT_CLASS_ENTRY(ce, "DOMXPath", php_dom_xpath_class_functions);
                    900:        ce.create_object = dom_xpath_objects_new;
                    901:        dom_xpath_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
                    902: 
                    903:        zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, NULL, 1);
                    904:        dom_register_prop_handler(&dom_xpath_prop_handlers, "document", dom_xpath_document_read, NULL TSRMLS_CC);
                    905:        zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_xpath_prop_handlers, sizeof(dom_xpath_prop_handlers), NULL);
                    906: #endif
                    907: 
                    908:        REGISTER_LONG_CONSTANT("XML_ELEMENT_NODE",                      XML_ELEMENT_NODE,                       CONST_CS | CONST_PERSISTENT);
                    909:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NODE",            XML_ATTRIBUTE_NODE,                     CONST_CS | CONST_PERSISTENT);
                    910:        REGISTER_LONG_CONSTANT("XML_TEXT_NODE",                         XML_TEXT_NODE,                          CONST_CS | CONST_PERSISTENT);
                    911:        REGISTER_LONG_CONSTANT("XML_CDATA_SECTION_NODE",        XML_CDATA_SECTION_NODE,         CONST_CS | CONST_PERSISTENT);
                    912:        REGISTER_LONG_CONSTANT("XML_ENTITY_REF_NODE",           XML_ENTITY_REF_NODE,            CONST_CS | CONST_PERSISTENT);
                    913:        REGISTER_LONG_CONSTANT("XML_ENTITY_NODE",                       XML_ENTITY_NODE,                        CONST_CS | CONST_PERSISTENT);
                    914:        REGISTER_LONG_CONSTANT("XML_PI_NODE",                           XML_PI_NODE,                            CONST_CS | CONST_PERSISTENT);
                    915:        REGISTER_LONG_CONSTANT("XML_COMMENT_NODE",                      XML_COMMENT_NODE,                       CONST_CS | CONST_PERSISTENT);
                    916:        REGISTER_LONG_CONSTANT("XML_DOCUMENT_NODE",                     XML_DOCUMENT_NODE,                      CONST_CS | CONST_PERSISTENT);
                    917:        REGISTER_LONG_CONSTANT("XML_DOCUMENT_TYPE_NODE",        XML_DOCUMENT_TYPE_NODE,         CONST_CS | CONST_PERSISTENT);
                    918:        REGISTER_LONG_CONSTANT("XML_DOCUMENT_FRAG_NODE",        XML_DOCUMENT_FRAG_NODE,         CONST_CS | CONST_PERSISTENT);
                    919:        REGISTER_LONG_CONSTANT("XML_NOTATION_NODE",                     XML_NOTATION_NODE,                      CONST_CS | CONST_PERSISTENT);
                    920:        REGISTER_LONG_CONSTANT("XML_HTML_DOCUMENT_NODE",        XML_HTML_DOCUMENT_NODE,         CONST_CS | CONST_PERSISTENT);
                    921:        REGISTER_LONG_CONSTANT("XML_DTD_NODE",                          XML_DTD_NODE,                           CONST_CS | CONST_PERSISTENT);
                    922:        REGISTER_LONG_CONSTANT("XML_ELEMENT_DECL_NODE",         XML_ELEMENT_DECL,                       CONST_CS | CONST_PERSISTENT);
                    923:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_DECL_NODE",       XML_ATTRIBUTE_DECL,                     CONST_CS | CONST_PERSISTENT);
                    924:        REGISTER_LONG_CONSTANT("XML_ENTITY_DECL_NODE",          XML_ENTITY_DECL,                        CONST_CS | CONST_PERSISTENT);
                    925:        REGISTER_LONG_CONSTANT("XML_NAMESPACE_DECL_NODE",       XML_NAMESPACE_DECL,                     CONST_CS | CONST_PERSISTENT);
                    926: #ifdef XML_GLOBAL_NAMESPACE
                    927:        REGISTER_LONG_CONSTANT("XML_GLOBAL_NAMESPACE",          XML_GLOBAL_NAMESPACE,           CONST_CS | CONST_PERSISTENT);
                    928: #endif
                    929:        REGISTER_LONG_CONSTANT("XML_LOCAL_NAMESPACE",           XML_LOCAL_NAMESPACE,            CONST_CS | CONST_PERSISTENT);
                    930:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_CDATA",           XML_ATTRIBUTE_CDATA,            CONST_CS | CONST_PERSISTENT);
                    931:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ID",                      XML_ATTRIBUTE_ID,                       CONST_CS | CONST_PERSISTENT);
                    932:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREF",           XML_ATTRIBUTE_IDREF,            CONST_CS | CONST_PERSISTENT);
                    933:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_IDREFS",          XML_ATTRIBUTE_IDREFS,           CONST_CS | CONST_PERSISTENT);
                    934:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENTITY",          XML_ATTRIBUTE_ENTITIES,         CONST_CS | CONST_PERSISTENT);
                    935:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKEN",         XML_ATTRIBUTE_NMTOKEN,          CONST_CS | CONST_PERSISTENT);
                    936:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NMTOKENS",        XML_ATTRIBUTE_NMTOKENS,         CONST_CS | CONST_PERSISTENT);
                    937:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_ENUMERATION",     XML_ATTRIBUTE_ENUMERATION,      CONST_CS | CONST_PERSISTENT);
                    938:        REGISTER_LONG_CONSTANT("XML_ATTRIBUTE_NOTATION",        XML_ATTRIBUTE_NOTATION,         CONST_CS | CONST_PERSISTENT);
                    939: 
                    940:        /* DOMException Codes */
                    941:        REGISTER_LONG_CONSTANT("DOM_PHP_ERR",                           PHP_ERR,                                CONST_CS | CONST_PERSISTENT);
                    942:        REGISTER_LONG_CONSTANT("DOM_INDEX_SIZE_ERR",            INDEX_SIZE_ERR,                 CONST_CS | CONST_PERSISTENT);
                    943:        REGISTER_LONG_CONSTANT("DOMSTRING_SIZE_ERR",            DOMSTRING_SIZE_ERR,             CONST_CS | CONST_PERSISTENT);
                    944:        REGISTER_LONG_CONSTANT("DOM_HIERARCHY_REQUEST_ERR",     HIERARCHY_REQUEST_ERR,  CONST_CS | CONST_PERSISTENT);
                    945:        REGISTER_LONG_CONSTANT("DOM_WRONG_DOCUMENT_ERR",        WRONG_DOCUMENT_ERR,             CONST_CS | CONST_PERSISTENT);
                    946:        REGISTER_LONG_CONSTANT("DOM_INVALID_CHARACTER_ERR",     INVALID_CHARACTER_ERR,  CONST_CS | CONST_PERSISTENT);
                    947:        REGISTER_LONG_CONSTANT("DOM_NO_DATA_ALLOWED_ERR",       NO_DATA_ALLOWED_ERR,    CONST_CS | CONST_PERSISTENT);
                    948:        REGISTER_LONG_CONSTANT("DOM_NO_MODIFICATION_ALLOWED_ERR", NO_MODIFICATION_ALLOWED_ERR, CONST_CS | CONST_PERSISTENT);
                    949:        REGISTER_LONG_CONSTANT("DOM_NOT_FOUND_ERR",                     NOT_FOUND_ERR,                  CONST_CS | CONST_PERSISTENT);
                    950:        REGISTER_LONG_CONSTANT("DOM_NOT_SUPPORTED_ERR",         NOT_SUPPORTED_ERR,              CONST_CS | CONST_PERSISTENT);
                    951:        REGISTER_LONG_CONSTANT("DOM_INUSE_ATTRIBUTE_ERR",       INUSE_ATTRIBUTE_ERR,    CONST_CS | CONST_PERSISTENT);
                    952:        REGISTER_LONG_CONSTANT("DOM_INVALID_STATE_ERR",         INVALID_STATE_ERR,              CONST_CS | CONST_PERSISTENT);
                    953:        REGISTER_LONG_CONSTANT("DOM_SYNTAX_ERR",                        SYNTAX_ERR,                             CONST_CS | CONST_PERSISTENT);
                    954:        REGISTER_LONG_CONSTANT("DOM_INVALID_MODIFICATION_ERR",  INVALID_MODIFICATION_ERR, CONST_CS | CONST_PERSISTENT);
                    955:        REGISTER_LONG_CONSTANT("DOM_NAMESPACE_ERR",                     NAMESPACE_ERR,                  CONST_CS | CONST_PERSISTENT);
                    956:        REGISTER_LONG_CONSTANT("DOM_INVALID_ACCESS_ERR",        INVALID_ACCESS_ERR,             CONST_CS | CONST_PERSISTENT);
                    957:        REGISTER_LONG_CONSTANT("DOM_VALIDATION_ERR",            VALIDATION_ERR,                 CONST_CS | CONST_PERSISTENT);
                    958: 
                    959:        php_libxml_register_export(dom_node_class_entry, php_dom_export_node);
                    960: 
                    961:        return SUCCESS;
                    962: }
                    963: /* }}} */
                    964: 
                    965: /* {{{ */
                    966: PHP_MINFO_FUNCTION(dom)
                    967: {
                    968:        php_info_print_table_start();
                    969:        php_info_print_table_row(2, "DOM/XML", "enabled");
                    970:        php_info_print_table_row(2, "DOM/XML API Version", DOM_API_VERSION);
                    971:        php_info_print_table_row(2, "libxml Version", LIBXML_DOTTED_VERSION);
                    972: #if defined(LIBXML_HTML_ENABLED)
                    973:        php_info_print_table_row(2, "HTML Support", "enabled");
                    974: #endif
                    975: #if defined(LIBXML_XPATH_ENABLED)
                    976:        php_info_print_table_row(2, "XPath Support", "enabled");
                    977: #endif
                    978: #if defined(LIBXML_XPTR_ENABLED)
                    979:        php_info_print_table_row(2, "XPointer Support", "enabled");
                    980: #endif
                    981: #ifdef LIBXML_SCHEMAS_ENABLED
                    982:        php_info_print_table_row(2, "Schema Support", "enabled");
                    983:        php_info_print_table_row(2, "RelaxNG Support", "enabled");
                    984: #endif
                    985:        php_info_print_table_end();
                    986: }
                    987: /* }}} */
                    988: 
                    989: PHP_MSHUTDOWN_FUNCTION(dom) /* {{{ */
                    990: {
                    991:        zend_hash_destroy(&dom_domstringlist_prop_handlers);
                    992:        zend_hash_destroy(&dom_namelist_prop_handlers);
                    993:        zend_hash_destroy(&dom_domimplementationlist_prop_handlers);
                    994:        zend_hash_destroy(&dom_document_prop_handlers);
                    995:        zend_hash_destroy(&dom_node_prop_handlers);
                    996:        zend_hash_destroy(&dom_namespace_node_prop_handlers);
                    997:        zend_hash_destroy(&dom_nodelist_prop_handlers);
                    998:        zend_hash_destroy(&dom_namednodemap_prop_handlers);
                    999:        zend_hash_destroy(&dom_characterdata_prop_handlers);
                   1000:        zend_hash_destroy(&dom_attr_prop_handlers);
                   1001:        zend_hash_destroy(&dom_element_prop_handlers);
                   1002:        zend_hash_destroy(&dom_text_prop_handlers);
                   1003:        zend_hash_destroy(&dom_typeinfo_prop_handlers);
                   1004:        zend_hash_destroy(&dom_domerror_prop_handlers);
                   1005:        zend_hash_destroy(&dom_domlocator_prop_handlers);
                   1006:        zend_hash_destroy(&dom_documenttype_prop_handlers);
                   1007:        zend_hash_destroy(&dom_notation_prop_handlers);
                   1008:        zend_hash_destroy(&dom_entity_prop_handlers);
                   1009:        zend_hash_destroy(&dom_processinginstruction_prop_handlers);
                   1010: #if defined(LIBXML_XPATH_ENABLED)
                   1011:        zend_hash_destroy(&dom_xpath_prop_handlers);
                   1012: #endif
                   1013:        zend_hash_destroy(&classes);
                   1014:        
                   1015: /*     If you want do find memleaks in this module, compile libxml2 with --with-mem-debug and
                   1016:        uncomment the following line, this will tell you the amount of not freed memory
                   1017:        and the total used memory into apaches error_log  */
                   1018: /*  xmlMemoryDump();*/
                   1019: 
                   1020:        return SUCCESS;
                   1021: }
                   1022: /* }}} */
                   1023: 
                   1024: /* {{{ node_list_unlink */
                   1025: void node_list_unlink(xmlNodePtr node TSRMLS_DC)
                   1026: {
                   1027:        dom_object *wrapper;
                   1028: 
                   1029:        while (node != NULL) {
                   1030: 
                   1031:                wrapper = php_dom_object_get_data(node);
                   1032: 
                   1033:                if (wrapper != NULL ) {
                   1034:                        xmlUnlinkNode(node);
                   1035:                } else {
                   1036:                        if (node->type == XML_ENTITY_REF_NODE)
                   1037:                                break;
                   1038:                        node_list_unlink(node->children TSRMLS_CC);
                   1039: 
                   1040:                        switch (node->type) {
                   1041:                                case XML_ATTRIBUTE_DECL:
                   1042:                                case XML_DTD_NODE:
                   1043:                                case XML_DOCUMENT_TYPE_NODE:
                   1044:                                case XML_ENTITY_DECL:
                   1045:                                case XML_ATTRIBUTE_NODE:
                   1046:                                case XML_TEXT_NODE:
                   1047:                                        break;
                   1048:                                default:
                   1049:                                        node_list_unlink((xmlNodePtr) node->properties TSRMLS_CC);
                   1050:                        }
                   1051: 
                   1052:                }
                   1053: 
                   1054:                node = node->next;
                   1055:        }
                   1056: }
                   1057: /* }}} end node_list_unlink */
                   1058: 
                   1059: #if defined(LIBXML_XPATH_ENABLED)
                   1060: /* {{{ dom_xpath_objects_free_storage */
                   1061: void dom_xpath_objects_free_storage(void *object TSRMLS_DC)
                   1062: {
                   1063:        dom_xpath_object *intern = (dom_xpath_object *)object;
                   1064: 
                   1065:        zend_object_std_dtor(&intern->std TSRMLS_CC);
                   1066: 
                   1067:        if (intern->ptr != NULL) {
                   1068:                xmlXPathFreeContext((xmlXPathContextPtr) intern->ptr);
                   1069:                php_libxml_decrement_doc_ref((php_libxml_node_object *) intern TSRMLS_CC);
                   1070:                intern->ptr = NULL;
                   1071:        }
                   1072: 
                   1073:        if (intern->registered_phpfunctions) {
                   1074:                zend_hash_destroy(intern->registered_phpfunctions);
                   1075:                FREE_HASHTABLE(intern->registered_phpfunctions);
                   1076:        }
                   1077:        
                   1078:        if (intern->node_list) {
                   1079:                zend_hash_destroy(intern->node_list);
                   1080:                FREE_HASHTABLE(intern->node_list);
                   1081:        }
                   1082: 
                   1083:        efree(object);
                   1084: }
                   1085: /* }}} */
                   1086: #endif
                   1087: 
                   1088: /* {{{ dom_objects_free_storage */
                   1089: void dom_objects_free_storage(void *object TSRMLS_DC)
                   1090: {
                   1091:        dom_object *intern = (dom_object *)object;
                   1092:        int retcount;
                   1093: 
                   1094:        zend_object_std_dtor(&intern->std TSRMLS_CC);
                   1095: 
                   1096:        if (intern->ptr != NULL && ((php_libxml_node_ptr *)intern->ptr)->node != NULL) {
                   1097:                if (((xmlNodePtr) ((php_libxml_node_ptr *)intern->ptr)->node)->type != XML_DOCUMENT_NODE && ((xmlNodePtr) ((php_libxml_node_ptr *)intern->ptr)->node)->type != XML_HTML_DOCUMENT_NODE) {
                   1098:                        php_libxml_node_decrement_resource((php_libxml_node_object *) intern TSRMLS_CC);
                   1099:                } else {
                   1100:                        php_libxml_decrement_node_ptr((php_libxml_node_object *) intern TSRMLS_CC);
                   1101:                        retcount = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
                   1102:                }
                   1103:                intern->ptr = NULL;
                   1104:        }
                   1105: 
                   1106:        efree(object);
                   1107: }
                   1108: /* }}} */
                   1109: 
                   1110: void dom_namednode_iter(dom_object *basenode, int ntype, dom_object *intern, xmlHashTablePtr ht, xmlChar *local, xmlChar *ns TSRMLS_DC) /* {{{ */
                   1111: {
                   1112:        dom_nnodemap_object *mapptr;
                   1113:        zval *baseobj = NULL;
                   1114: 
                   1115:        mapptr = (dom_nnodemap_object *)intern->ptr;
                   1116:        if (basenode) {
                   1117:                MAKE_STD_ZVAL(baseobj);
                   1118:                baseobj->type = IS_OBJECT;
                   1119:                Z_SET_ISREF_P(baseobj);
                   1120:                baseobj->value.obj.handle = basenode->handle;
                   1121:                baseobj->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
                   1122:                zval_copy_ctor(baseobj);
                   1123:        }
                   1124:        mapptr->baseobjptr = baseobj;
                   1125:        mapptr->baseobj = basenode;
                   1126:        mapptr->nodetype = ntype;
                   1127:        mapptr->ht = ht;
                   1128:        mapptr->local = local;
                   1129:        mapptr->ns = ns;
                   1130: 
                   1131: }
                   1132: /* }}} */
                   1133: 
                   1134: static dom_object* dom_objects_set_class(zend_class_entry *class_type, zend_bool hash_copy TSRMLS_DC) /* {{{ */
                   1135: {
                   1136:        zend_class_entry *base_class;
                   1137:        dom_object *intern;
                   1138: 
                   1139:        if (instanceof_function(class_type, dom_xpath_class_entry TSRMLS_CC)) {
                   1140:                intern = emalloc(sizeof(dom_xpath_object));
                   1141:                memset(intern, 0, sizeof(dom_xpath_object));
                   1142:        } else {
                   1143:                intern = emalloc(sizeof(dom_object));
                   1144:        }
                   1145:        intern->ptr = NULL;
                   1146:        intern->prop_handler = NULL;
                   1147:        intern->document = NULL;
                   1148: 
                   1149:        base_class = class_type;
                   1150:        while(base_class->type != ZEND_INTERNAL_CLASS && base_class->parent != NULL) {
                   1151:                base_class = base_class->parent;
                   1152:        }
                   1153: 
                   1154:        zend_hash_find(&classes, base_class->name, base_class->name_length + 1, (void **) &intern->prop_handler);
                   1155: 
                   1156:        zend_object_std_init(&intern->std, class_type TSRMLS_CC);
                   1157:        if (hash_copy) {
1.1.1.2 ! misho    1158:                object_properties_init(&intern->std, class_type);
1.1       misho    1159:        }
                   1160: 
                   1161:        return intern;
                   1162: }
                   1163: /* }}} */
                   1164: 
                   1165: /* {{{ dom_objects_clone */
                   1166: void dom_objects_clone(void *object, void **object_clone TSRMLS_DC)
                   1167: {
                   1168:        dom_object *intern = (dom_object *) object;
                   1169:        dom_object *clone;
                   1170:        xmlNodePtr node;
                   1171:        xmlNodePtr cloned_node;
                   1172: 
                   1173:        clone = dom_objects_set_class(intern->std.ce, 0 TSRMLS_CC);
                   1174: 
                   1175:        if (instanceof_function(intern->std.ce, dom_node_class_entry TSRMLS_CC)) {
                   1176:                node = (xmlNodePtr)dom_object_get_node((dom_object *) object);
                   1177:                if (node != NULL) {
                   1178:                        cloned_node = xmlDocCopyNode(node, node->doc, 1);
                   1179:                        if (cloned_node != NULL) {
                   1180:                                /* If we cloned a document then we must create new doc proxy */
                   1181:                                if (cloned_node->doc == node->doc) {
                   1182:                                        clone->document = intern->document;
                   1183:                                }
                   1184:                                php_libxml_increment_doc_ref((php_libxml_node_object *)clone, cloned_node->doc TSRMLS_CC);
                   1185:                                php_libxml_increment_node_ptr((php_libxml_node_object *)clone, cloned_node, (void *)clone TSRMLS_CC);
                   1186:                                if (intern->document != clone->document) {
                   1187:                                        dom_copy_doc_props(intern->document, clone->document);
                   1188:                                }
                   1189:                        }
                   1190: 
                   1191:                }
                   1192:        }
                   1193: 
                   1194:        *object_clone = (void *) clone;
                   1195: }
                   1196: /* }}} */
                   1197: 
                   1198: /* {{{ dom_objects_new */
                   1199: zend_object_value dom_objects_new(zend_class_entry *class_type TSRMLS_DC)
                   1200: {
                   1201:        zend_object_value retval;
                   1202:        dom_object *intern;
                   1203:        
                   1204:        intern = dom_objects_set_class(class_type, 1 TSRMLS_CC);
                   1205: 
                   1206:        retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)dom_objects_free_storage, dom_objects_clone TSRMLS_CC);
                   1207:        intern->handle = retval.handle;
                   1208:        retval.handlers = dom_get_obj_handlers(TSRMLS_C);
                   1209: 
                   1210:        return retval;
                   1211: }
                   1212: /* }}} */
                   1213: 
                   1214: #if defined(LIBXML_XPATH_ENABLED)
                   1215: /* {{{ zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC) */
                   1216: zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC)
                   1217: {
                   1218:        zend_object_value retval;
                   1219:        dom_xpath_object *intern;
                   1220: 
                   1221:        intern = (dom_xpath_object *)dom_objects_set_class(class_type, 1 TSRMLS_CC);
                   1222:        intern->registerPhpFunctions = 0;
                   1223:        intern->registered_phpfunctions = NULL;
                   1224:        intern->node_list = NULL;
                   1225: 
                   1226:        ALLOC_HASHTABLE(intern->registered_phpfunctions);
                   1227:        zend_hash_init(intern->registered_phpfunctions, 0, NULL, ZVAL_PTR_DTOR, 0);
                   1228: 
                   1229:        retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)dom_xpath_objects_free_storage, dom_objects_clone TSRMLS_CC);
                   1230:        intern->handle = retval.handle;
                   1231:        retval.handlers = dom_get_obj_handlers(TSRMLS_C);
                   1232: 
                   1233:        return retval;
                   1234: }
                   1235: /* }}} */
                   1236: #endif
                   1237: 
                   1238: static void dom_nnodemap_object_dtor(void *object, zend_object_handle handle TSRMLS_DC) /* {{{ */
                   1239: {
                   1240:        zval *baseobj;
                   1241:        dom_object *intern;
                   1242:        dom_nnodemap_object *objmap;
                   1243: 
                   1244:        intern = (dom_object *)object;
                   1245:        objmap = (dom_nnodemap_object *)intern->ptr;
                   1246: 
                   1247:        if (objmap) {
                   1248:                if (objmap->local) {
                   1249:                        xmlFree(objmap->local);
                   1250:                }
                   1251:                if (objmap->ns) {
                   1252:                        xmlFree(objmap->ns);
                   1253:                }
                   1254:                if (objmap->baseobjptr) {
                   1255:                        baseobj = objmap->baseobjptr;
                   1256:                        zval_ptr_dtor((zval **)&baseobj);
                   1257:                }
                   1258:                efree(objmap);
                   1259:                intern->ptr = NULL;
                   1260:        }
                   1261: 
                   1262: 
                   1263: }
                   1264: /* }}} */
                   1265: 
                   1266: void dom_nnodemap_objects_free_storage(void *object TSRMLS_DC) /* {{{ */
                   1267: {
                   1268:        dom_object *intern = (dom_object *)object;
                   1269: 
                   1270:        php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
                   1271: 
                   1272:        zend_object_std_dtor(&intern->std TSRMLS_CC);
                   1273: 
                   1274:        efree(object);
                   1275: }
                   1276: /* }}} */
                   1277: 
                   1278: zend_object_value dom_nnodemap_objects_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
                   1279: {
                   1280:        zend_object_value retval;
                   1281:        dom_object *intern;
                   1282:        dom_nnodemap_object *objmap;
                   1283:        
                   1284:        intern = dom_objects_set_class(class_type, 1 TSRMLS_CC);
                   1285:        intern->ptr = emalloc(sizeof(dom_nnodemap_object));
                   1286:        objmap = (dom_nnodemap_object *)intern->ptr;
                   1287:        objmap->baseobj = NULL;
                   1288:        objmap->baseobjptr = NULL;
                   1289:        objmap->nodetype = 0;
                   1290:        objmap->ht = NULL;
                   1291:        objmap->local = NULL;
                   1292:        objmap->ns = NULL;
                   1293: 
                   1294:        retval.handle = zend_objects_store_put(intern, dom_nnodemap_object_dtor, (zend_objects_free_object_storage_t)dom_nnodemap_objects_free_storage, dom_objects_clone TSRMLS_CC);
                   1295:        intern->handle = retval.handle;
                   1296:        retval.handlers = dom_get_obj_handlers(TSRMLS_C);
                   1297: 
                   1298:        return retval;
                   1299: }
                   1300: /* }}} */
                   1301: 
                   1302: void php_dom_create_interator(zval *return_value, int ce_type TSRMLS_DC) /* {{{ */
                   1303: {
                   1304:        zend_class_entry *ce;
                   1305: 
                   1306:        if (ce_type == DOM_NAMEDNODEMAP) {
                   1307:                ce = dom_namednodemap_class_entry;
                   1308:        } else {
                   1309:                ce = dom_nodelist_class_entry;
                   1310:        }
                   1311: 
                   1312:        object_init_ex(return_value, ce);
                   1313: }
                   1314: /* }}} */
                   1315: 
                   1316: /* {{{ php_dom_create_object */
1.1.1.2 ! misho    1317: PHP_DOM_EXPORT zval *php_dom_create_object(xmlNodePtr obj, int *found, zval *return_value, dom_object *domobj TSRMLS_DC)
1.1       misho    1318: {
                   1319:        zval *wrapper;
                   1320:        zend_class_entry *ce;
                   1321:        dom_object *intern;
                   1322: 
                   1323:        *found = 0;
                   1324: 
                   1325:        if (!obj) {
                   1326:                ALLOC_ZVAL(wrapper);
                   1327:                ZVAL_NULL(wrapper);
                   1328:                return wrapper;
                   1329:        }
                   1330: 
                   1331:        if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) {
                   1332:                return_value->type = IS_OBJECT;
                   1333:                Z_SET_ISREF_P(return_value);
                   1334:                return_value->value.obj.handle = intern->handle;
                   1335:                return_value->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
                   1336:                zval_copy_ctor(return_value);
                   1337:                *found = 1;
                   1338:                return return_value;
                   1339:        }
                   1340: 
                   1341:        wrapper = return_value;
                   1342: 
                   1343:        switch (obj->type) {
                   1344:                case XML_DOCUMENT_NODE:
                   1345:                case XML_HTML_DOCUMENT_NODE:
                   1346:                {
                   1347:                        ce = dom_document_class_entry;
                   1348:                        break;
                   1349:                }
                   1350:                case XML_DTD_NODE:
                   1351:                case XML_DOCUMENT_TYPE_NODE:
                   1352:                {
                   1353:                        ce = dom_documenttype_class_entry;
                   1354:                        break;
                   1355:                }
                   1356:                case XML_ELEMENT_NODE:
                   1357:                {
                   1358:                        ce = dom_element_class_entry;
                   1359:                        break;
                   1360:                }
                   1361:                case XML_ATTRIBUTE_NODE:
                   1362:                {
                   1363:                        ce = dom_attr_class_entry;
                   1364:                        break;
                   1365:                }
                   1366:                case XML_TEXT_NODE:
                   1367:                {
                   1368:                        ce = dom_text_class_entry;
                   1369:                        break;
                   1370:                }
                   1371:                case XML_COMMENT_NODE:
                   1372:                {
                   1373:                        ce = dom_comment_class_entry;
                   1374:                        break;
                   1375:                }
                   1376:                case XML_PI_NODE:
                   1377:                {
                   1378:                        ce = dom_processinginstruction_class_entry;
                   1379:                        break;
                   1380:                }
                   1381:                case XML_ENTITY_REF_NODE:
                   1382:                {
                   1383:                        ce = dom_entityreference_class_entry;
                   1384:                        break;
                   1385:                }
                   1386:                case XML_ENTITY_DECL:
                   1387:                case XML_ELEMENT_DECL:
                   1388:                {
                   1389:                        ce = dom_entity_class_entry;
                   1390:                        break;
                   1391:                }
                   1392:                case XML_CDATA_SECTION_NODE:
                   1393:                {
                   1394:                        ce = dom_cdatasection_class_entry;
                   1395:                        break;
                   1396:                }
                   1397:                case XML_DOCUMENT_FRAG_NODE:
                   1398:                {
                   1399:                        ce = dom_documentfragment_class_entry;
                   1400:                        break;
                   1401:                }
                   1402:                case XML_NOTATION_NODE:
                   1403:                {
                   1404:                        ce = dom_notation_class_entry;
                   1405:                        break;
                   1406:                }
                   1407:                case XML_NAMESPACE_DECL:
                   1408:                {
                   1409:                        ce = dom_namespace_node_class_entry;
                   1410:                        break;
                   1411:                }
                   1412:                default:
                   1413:                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported node type: %d", Z_TYPE_P(obj));
                   1414:                        ZVAL_NULL(wrapper);
                   1415:                        return wrapper;
                   1416:        }
                   1417: 
                   1418:        if (domobj && domobj->document) {
                   1419:                ce = dom_get_doc_classmap(domobj->document, ce TSRMLS_CC);
                   1420:        }
                   1421:        object_init_ex(wrapper, ce);
                   1422: 
                   1423:        intern = (dom_object *)zend_objects_get_address(wrapper TSRMLS_CC);
                   1424:        if (obj->doc != NULL) {
                   1425:                if (domobj != NULL) {
                   1426:                        intern->document = domobj->document;
                   1427:                }
                   1428:                php_libxml_increment_doc_ref((php_libxml_node_object *)intern, obj->doc TSRMLS_CC);
                   1429:        }
                   1430: 
                   1431:        php_libxml_increment_node_ptr((php_libxml_node_object *)intern, obj, (void *)intern TSRMLS_CC);
                   1432:        return (wrapper);
                   1433: }
                   1434: /* }}} end php_domobject_new */
                   1435: 
                   1436: void php_dom_create_implementation(zval **retval  TSRMLS_DC) {
                   1437:        object_init_ex(*retval, dom_domimplementation_class_entry);
                   1438: }
                   1439: 
                   1440: /* {{{ int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) */
                   1441: int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) 
                   1442: {
                   1443:        xmlNodePtr nodep;
                   1444: 
                   1445:     if (parent == NULL || child == NULL || child->doc != parent->doc) {
                   1446:         return SUCCESS;
                   1447:     }
                   1448: 
                   1449:        nodep = parent;
                   1450: 
                   1451:        while (nodep) {
                   1452:                if (nodep == child) {
                   1453:                        return FAILURE;
                   1454:                }
                   1455:                nodep = nodep->parent;
                   1456:        }
                   1457: 
                   1458:     return SUCCESS;
                   1459: }
                   1460: /* }}} end dom_hierarchy */
                   1461: 
                   1462: /* {{{ dom_has_feature(char *feature, char *version) */
                   1463: int dom_has_feature(char *feature, char *version)
                   1464: {
                   1465:        int retval = 0;
                   1466: 
                   1467:        if (!(strcmp (version, "1.0") && strcmp (version,"2.0") && strcmp(version, ""))) {
                   1468:                if ((!strcasecmp(feature, "Core") && !strcmp (version, "1.0")) || !strcasecmp(feature, "XML"))
                   1469:                        retval = 1;
                   1470:        }
                   1471: 
                   1472:        return retval;
                   1473: }
                   1474: /* }}} end dom_has_feature */
                   1475: 
                   1476: xmlNode *dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep, char *ns, char *local, int *cur, int index) /* {{{ */
                   1477: {
                   1478:        xmlNodePtr ret = NULL;
                   1479: 
                   1480:        while (nodep != NULL && (*cur <= index || index == -1)) {
                   1481:                if (nodep->type == XML_ELEMENT_NODE) {
                   1482:                        if (xmlStrEqual(nodep->name, (xmlChar *)local) || xmlStrEqual((xmlChar *)"*", (xmlChar *)local)) {
                   1483:                                if (ns == NULL || (nodep->ns != NULL && (xmlStrEqual(nodep->ns->href, (xmlChar *)ns) || xmlStrEqual((xmlChar *)"*", (xmlChar *)ns)))) {
                   1484:                                        if (*cur == index) {
                   1485:                                                ret = nodep;
                   1486:                                                break;
                   1487:                                        }
                   1488:                                        (*cur)++;
                   1489:                                }
                   1490:                        }
                   1491:                        ret = dom_get_elements_by_tag_name_ns_raw(nodep->children, ns, local, cur, index);
                   1492:                        if (ret != NULL) {
                   1493:                                break;
                   1494:                        }
                   1495:                }
                   1496:                nodep = nodep->next;
                   1497:        }
                   1498:        return ret;
                   1499: }
                   1500: /* }}} */
                   1501: /* }}} end dom_element_get_elements_by_tag_name_ns_raw */
                   1502: 
                   1503: /* {{{ void dom_normalize (xmlNodePtr nodep TSRMLS_DC) */
                   1504: void dom_normalize (xmlNodePtr nodep TSRMLS_DC)
                   1505: {
                   1506:        xmlNodePtr child, nextp, newnextp;
                   1507:        xmlAttrPtr attr;
                   1508:        xmlChar *strContent; 
                   1509: 
                   1510:        child = nodep->children;
                   1511:        while(child != NULL) {
                   1512:                switch (child->type) {
                   1513:                        case XML_TEXT_NODE:
                   1514:                                nextp = child->next;
                   1515:                                while (nextp != NULL) {
                   1516:                                        if (nextp->type == XML_TEXT_NODE) {
                   1517:                                                newnextp = nextp->next;
                   1518:                                                strContent = xmlNodeGetContent(nextp);
                   1519:                                                xmlNodeAddContent(child, strContent);
                   1520:                                                xmlFree(strContent);
                   1521:                                                xmlUnlinkNode(nextp);
                   1522:                                                php_libxml_node_free_resource(nextp TSRMLS_CC);
                   1523:                                                nextp = newnextp;
                   1524:                                        } else {
                   1525:                                                break;
                   1526:                                        }
                   1527:                                }
                   1528:                                break;
                   1529:                        case XML_ELEMENT_NODE:
                   1530:                                dom_normalize (child TSRMLS_CC);
                   1531:                                attr = child->properties;
                   1532:                                while (attr != NULL) {
                   1533:                                        dom_normalize((xmlNodePtr) attr TSRMLS_CC);
                   1534:                                        attr = attr->next;
                   1535:                                }
                   1536:                                break;
                   1537:                        case XML_ATTRIBUTE_NODE:
                   1538:                                dom_normalize (child TSRMLS_CC);
                   1539:                                break;
                   1540:                        default:
                   1541:                                break;
                   1542:                }
                   1543:                child = child->next;
                   1544:        }
                   1545: }
                   1546: /* }}} end dom_normalize */
                   1547: 
                   1548: 
                   1549: /* {{{ void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) */
                   1550: void dom_set_old_ns(xmlDoc *doc, xmlNs *ns) {
                   1551:        xmlNs *cur;
                   1552: 
                   1553:        if (doc == NULL)
                   1554:                return;
                   1555: 
                   1556:        if (doc->oldNs == NULL) {
                   1557:                doc->oldNs = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
                   1558:                if (doc->oldNs == NULL) {
                   1559:                        return;
                   1560:                }
                   1561:                memset(doc->oldNs, 0, sizeof(xmlNs));
                   1562:                doc->oldNs->type = XML_LOCAL_NAMESPACE;
                   1563:                doc->oldNs->href = xmlStrdup(XML_XML_NAMESPACE); 
                   1564:                doc->oldNs->prefix = xmlStrdup((const xmlChar *)"xml"); 
                   1565:        }
                   1566: 
                   1567:        cur = doc->oldNs;
                   1568:        while (cur->next != NULL) {
                   1569:                cur = cur->next;
                   1570:        }
                   1571:        cur->next = ns;
                   1572: }
                   1573: /* }}} end dom_set_old_ns */
                   1574: 
                   1575: /*
                   1576: http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
                   1577: 
                   1578: NAMESPACE_ERR: Raised if
                   1579: 
                   1580: 1. the qualifiedName is a malformed qualified name
                   1581: 2. the qualifiedName has a prefix and the  namespaceURI is null
                   1582: */
                   1583: 
                   1584: /* {{{ int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) */
                   1585: int dom_check_qname(char *qname, char **localname, char **prefix, int uri_len, int name_len) {
                   1586:        if (name_len == 0) {
                   1587:                return NAMESPACE_ERR;
                   1588:        }
                   1589:        
                   1590:        *localname = (char *)xmlSplitQName2((xmlChar *)qname, (xmlChar **) prefix);
                   1591:        if (*localname == NULL) {
                   1592:                *localname = (char *)xmlStrdup((xmlChar *)qname);
                   1593:                if (*prefix == NULL && uri_len == 0) {
                   1594:                        return 0;
                   1595:                }
                   1596:        }
                   1597: 
                   1598:        /* 1 */
                   1599:        if (xmlValidateQName((xmlChar *) qname, 0) != 0) {
                   1600:                return NAMESPACE_ERR;
                   1601:        }
                   1602: 
                   1603:        /* 2 */
                   1604:        if (*prefix != NULL && uri_len == 0) {
                   1605:                return NAMESPACE_ERR;
                   1606:        }
                   1607: 
                   1608:        return 0;
                   1609: }
                   1610: /* }}} */
                   1611: 
                   1612: /*
                   1613: http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
                   1614: 
                   1615: NAMESPACE_ERR: Raised if
                   1616: 
                   1617: 3. the qualifiedName has a prefix that is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace" [XML Namespaces]
                   1618: 4. the qualifiedName or its prefix is "xmlns" and the namespaceURI is different from  "http://www.w3.org/2000/xmlns/"
                   1619: 5. the namespaceURI is "http://www.w3.org/2000/xmlns/" and neither the qualifiedName nor its prefix is "xmlns".
                   1620: */
                   1621: 
                   1622: /* {{{ xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) */
                   1623: xmlNsPtr dom_get_ns(xmlNodePtr nodep, char *uri, int *errorcode, char *prefix) {
                   1624:        xmlNsPtr nsptr = NULL;
                   1625: 
                   1626:        *errorcode = 0;
                   1627: 
                   1628:        if (! ((prefix && !strcmp (prefix, "xml") && strcmp(uri, (char *)XML_XML_NAMESPACE)) ||
                   1629:                   (prefix && !strcmp (prefix, "xmlns") && strcmp(uri, (char *)DOM_XMLNS_NAMESPACE)) ||
                   1630:                   (prefix && !strcmp(uri, (char *)DOM_XMLNS_NAMESPACE) && strcmp (prefix, "xmlns")))) {
                   1631:                nsptr = xmlNewNs(nodep, (xmlChar *)uri, (xmlChar *)prefix);
                   1632:        }
                   1633: 
                   1634:        if (nsptr == NULL) {
                   1635:                *errorcode = NAMESPACE_ERR;
                   1636:        }
                   1637: 
                   1638:        return nsptr;
                   1639: 
                   1640: }
                   1641: /* }}} end dom_get_ns */
                   1642: 
                   1643: /* {{{ xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) */
                   1644: xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName) {
                   1645:        xmlNsPtr cur;
                   1646:        xmlNs *ret = NULL;
                   1647:        if (node == NULL)
                   1648:                return NULL;
                   1649: 
                   1650:        if (localName == NULL || xmlStrEqual(localName, (xmlChar *)"")) {
                   1651:                cur = node->nsDef;
                   1652:                while (cur != NULL) {
                   1653:                        if (cur->prefix == NULL  && cur->href != NULL) {
                   1654:                                ret = cur;
                   1655:                                break;
                   1656:                        }
                   1657:                        cur = cur->next;
                   1658:                }
                   1659:        } else {
                   1660:                cur = node->nsDef;
                   1661:                while (cur != NULL) {
                   1662:                        if (cur->prefix != NULL && xmlStrEqual(localName, cur->prefix)) {
                   1663:                                ret = cur;
                   1664:                                break;
                   1665:                        }
                   1666:                        cur = cur->next;
                   1667:                }
                   1668:        }
                   1669:        return ret;
                   1670: }
                   1671: /* }}} end dom_get_nsdecl */
                   1672: 
                   1673: #endif /* HAVE_DOM */
                   1674: 
                   1675: /*
                   1676:  * Local variables:
                   1677:  * tab-width: 4
                   1678:  * c-basic-offset: 4
                   1679:  * End:
                   1680:  * vim600: noet sw=4 ts=4 fdm=marker
                   1681:  * vim<600: noet sw=4 ts=4
                   1682:  */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>