/** * Parses a raw doc block returning the annotations found * * @param string $docBlock * @param string $file * @param int $line * @return array */ PHP_METHOD(Phalcon_Annotations_Reader, parseDocBlock){ zval *doc_block, *file = NULL, *line = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 2, &doc_block, &file, &line); if (!file) { PHALCON_INIT_VAR(file); } else { PHALCON_SEPARATE_PARAM(file); } if (!line) { PHALCON_INIT_VAR(line); } if (Z_TYPE_P(file) != IS_STRING) { PHALCON_INIT_NVAR(file); ZVAL_STRING(file, "eval code", 1); } if (phannot_parse_annotations(return_value, doc_block, file, line TSRMLS_CC) == FAILURE) { return; } RETURN_MM(); }
/** * Parses a raw doc block returning the annotations found */ PHP_METHOD(Phalcon_Annotations_Reader, parseDocBlock) { int ZEPHIR_LAST_CALL_STATUS; zval *docBlock_param = NULL, *file = NULL, *line = NULL; zval *docBlock = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &docBlock_param, &file, &line); zephir_get_strval(docBlock, docBlock_param); if (!file) { ZEPHIR_CPY_WRT(file, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(file); } if (!line) { line = ZEPHIR_GLOBAL(global_null); } if (Z_TYPE_P(file) != IS_STRING) { ZEPHIR_INIT_NVAR(file); ZVAL_STRING(file, "eval code", 1); } ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(return_value, docBlock, file, line TSRMLS_CC); zephir_check_call_status(); RETURN_MM(); }
/** * Parses a raw doc block returning the annotations found * * @param string $docBlock * @param string $file * @param int $line * @return array */ PHP_METHOD(Phalcon_Annotations_Reader, parseDocBlock) { zval **doc_block, **file = NULL, **line = NULL; phalcon_fetch_params_ex(3, 0, &doc_block, &file, &line); PHALCON_ENSURE_IS_STRING(doc_block); PHALCON_ENSURE_IS_STRING(file); PHALCON_ENSURE_IS_LONG(line); RETURN_ON_FAILURE(phannot_parse_annotations(return_value, Z_STRVAL_PP(doc_block), Z_STRLEN_PP(doc_block), Z_STRVAL_PP(file), Z_LVAL_PP(line) TSRMLS_CC)); }
PHP_METHOD(Owl_Annotations_Reader, parse) { zval *comment_param = NULL, _0, _1; zval *comment = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &comment_param); zephir_get_strval(comment, comment_param); ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 1); ZEPHIR_SINIT_VAR(_1); ZVAL_LONG(&_1, 2); phannot_parse_annotations(return_value, comment, &_0, &_1 TSRMLS_CC); RETURN_MM(); }
/** * Reads annotations from the class dockblocks, its methods and/or properties * * @param string $className * @return array */ PHP_METHOD(Phalcon_Annotations_Reader, parse){ zval *class_name, *annotations; zval *class_annotations, *annotations_properties, *annotations_methods; zend_class_entry *class_ce; const char *file; uint32_t line; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &class_name); if (unlikely(Z_TYPE_P(class_name) != IS_STRING)) { PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "The class name must be a string"); return; } class_ce = zend_fetch_class(Z_STR_P(class_name), ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_SILENT); if (!class_ce) { PHALCON_THROW_EXCEPTION_FORMAT(phalcon_annotations_exception_ce, "Class %s does not exist", Z_STRVAL_P(class_name)); return; } if (class_ce->type != ZEND_USER_CLASS) { array_init(return_value); RETURN_MM(); } PHALCON_INIT_VAR(annotations); array_init(annotations); file = ZSTR_VAL(phalcon_get_class_filename(class_ce)); if (!file) { file = "(unknown)"; } /* Class info */ { zend_string *cmt; if ((cmt = phalcon_get_class_doc_comment(class_ce)) != NULL) { line = phalcon_get_class_startline(class_ce); PHALCON_INIT_VAR(class_annotations); RETURN_MM_ON_FAILURE(phannot_parse_annotations(class_annotations, cmt, file, line)); if (Z_TYPE_P(class_annotations) == IS_ARRAY) { phalcon_array_update_str(annotations, SL("class"), class_annotations, PH_COPY); } } } /* Get class properties */ { HashTable *props = &class_ce->properties_info; if (zend_hash_num_elements(props) > 0) { zend_property_info *property; PHALCON_INIT_VAR(annotations_properties); array_init_size(annotations_properties, zend_hash_num_elements(props)); ZEND_HASH_FOREACH_PTR(props, property) { zend_string *cmt; if ((cmt = phalcon_get_property_doc_comment(property)) != NULL) { zval *property_annotations; PHALCON_ALLOC_INIT_ZVAL(property_annotations); if (FAILURE == phannot_parse_annotations(property_annotations, cmt, file, 0)) { zval_ptr_dtor(property_annotations); RETURN_MM(); } if (Z_TYPE_P(property_annotations) == IS_ARRAY) { const char *prop_name, *class_name; if (zend_unmangle_property_name(property->name, &class_name, &prop_name) == SUCCESS) { add_assoc_zval_ex(annotations_properties, prop_name, strlen(prop_name), property_annotations); } } else { zval_ptr_dtor(property_annotations); } } } ZEND_HASH_FOREACH_END(); if (zend_hash_num_elements(Z_ARRVAL_P(annotations_properties))) { phalcon_array_update_str(annotations, SL("properties"), annotations_properties, PH_COPY); } }
/** * Reads annotations from the class dockblocks, its methods and/or properties * * @param string $className * @return array */ PHP_METHOD(Phalcon_Annotations_Reader, parse){ zval *class_name, *annotations, *reflection; zval *comment = NULL, *file = NULL, *line = NULL, *class_annotations; zval *properties, *annotations_properties; zval *property = NULL, *property_annotations = NULL, *name = NULL; zval *methods, *annotations_methods, *method = NULL; zval *method_annotations = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; zend_class_entry *ce0; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &class_name); if (unlikely(Z_TYPE_P(class_name) != IS_STRING)) { PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "The class name must be an object"); return; } PHALCON_INIT_VAR(annotations); array_init(annotations); /** * A ReflectionClass is used to obtain the class dockblock */ ce0 = zend_fetch_class(SL("ReflectionClass"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); PHALCON_INIT_VAR(reflection); object_init_ex(reflection, ce0); if (phalcon_has_constructor(reflection TSRMLS_CC)) { phalcon_call_method_p1_noret(reflection, "__construct", class_name); } PHALCON_INIT_VAR(comment); phalcon_call_method(comment, reflection, "getdoccomment"); if (Z_TYPE_P(comment) == IS_STRING) { /** * Get the file where the class was declared */ PHALCON_INIT_VAR(file); phalcon_call_method(file, reflection, "getfilename"); /** * Get the line where the class was declared */ PHALCON_INIT_VAR(line); phalcon_call_method(line, reflection, "getstartline"); /** * Read annotations from class */ PHALCON_INIT_VAR(class_annotations); if (phannot_parse_annotations(class_annotations, comment, file, line TSRMLS_CC) == FAILURE) { return; } /** * Append the class annotations to the annotations var */ if (Z_TYPE_P(class_annotations) == IS_ARRAY) { phalcon_array_update_string(&annotations, SL("class"), &class_annotations, PH_COPY | PH_SEPARATE); } } /** * Get the class properties */ PHALCON_INIT_VAR(properties); phalcon_call_method(properties, reflection, "getproperties"); if (phalcon_fast_count_ev(properties TSRMLS_CC)) { /** * Line declaration for properties isn't available */ PHALCON_INIT_NVAR(line); ZVAL_LONG(line, 1); PHALCON_INIT_VAR(annotations_properties); array_init(annotations_properties); phalcon_is_iterable(properties, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(property); /** * Read comment from method */ PHALCON_INIT_NVAR(comment); phalcon_call_method(comment, property, "getdoccomment"); if (Z_TYPE_P(comment) == IS_STRING) { /** * Get the file where the property was declared */ PHALCON_INIT_NVAR(file); phalcon_call_method(file, reflection, "getfilename"); /** * Read annotations from the docblock */ PHALCON_INIT_NVAR(property_annotations); if (phannot_parse_annotations(property_annotations, comment, file, line TSRMLS_CC) == FAILURE) { return; } if (Z_TYPE_P(property_annotations) == IS_ARRAY) { PHALCON_OBS_NVAR(name); phalcon_read_property(&name, property, SL("name"), PH_NOISY_CC); phalcon_array_update_zval(&annotations_properties, name, &property_annotations, PH_COPY | PH_SEPARATE); } } zend_hash_move_forward_ex(ah0, &hp0); } if (phalcon_fast_count_ev(annotations_properties TSRMLS_CC)) { phalcon_array_update_string(&annotations, SL("properties"), &annotations_properties, PH_COPY | PH_SEPARATE); } } /** * Get the class methods */ PHALCON_INIT_VAR(methods); phalcon_call_method(methods, reflection, "getmethods"); if (phalcon_fast_count_ev(methods TSRMLS_CC)) { PHALCON_INIT_VAR(annotations_methods); array_init(annotations_methods); phalcon_is_iterable(methods, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(method); /** * Read comment from method */ PHALCON_INIT_NVAR(comment); phalcon_call_method(comment, method, "getdoccomment"); if (Z_TYPE_P(comment) == IS_STRING) { /** * Get the file where the method was declared */ PHALCON_INIT_NVAR(file); phalcon_call_method(file, method, "getfilename"); /** * Get the line where the method was declared */ PHALCON_INIT_NVAR(line); phalcon_call_method(line, method, "getstartline"); /** * Read annotations from class */ PHALCON_INIT_NVAR(method_annotations); if (phannot_parse_annotations(method_annotations, comment, file, line TSRMLS_CC) == FAILURE) { return; } if (Z_TYPE_P(method_annotations) == IS_ARRAY) { PHALCON_OBS_NVAR(name); phalcon_read_property(&name, method, SL("name"), PH_NOISY_CC); phalcon_array_update_zval(&annotations_methods, name, &method_annotations, PH_COPY | PH_SEPARATE); } } zend_hash_move_forward_ex(ah1, &hp1); } if (phalcon_fast_count_ev(annotations_methods TSRMLS_CC)) { phalcon_array_update_string(&annotations, SL("methods"), &annotations_methods, PH_COPY | PH_SEPARATE); } } RETURN_CTOR(annotations); }
/** * Reads annotations from the class dockblocks, its methods and/or properties */ PHP_METHOD(Phalcon_Annotations_Reader, parse) { HashTable *_3$$5, *_9$$10; HashPosition _2$$5, _8$$10; int ZEPHIR_LAST_CALL_STATUS, line = 0; zval *className_param = NULL, *annotations = NULL, *reflection = NULL, *comment = NULL, *properties = NULL, *methods = NULL, *property = NULL, *method = NULL, *classAnnotations = NULL, *annotationsProperties = NULL, *propertyAnnotations = NULL, *annotationsMethods = NULL, *methodAnnotations = NULL, *_0$$3 = NULL, *_1$$3 = NULL, **_4$$5, *_5$$7 = NULL, *_6$$7 = NULL, *_7$$8 = NULL, **_10$$10, *_11$$12 = NULL, *_12$$12 = NULL, *_13$$13 = NULL; zval *className = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &className_param); zephir_get_strval(className, className_param); ZEPHIR_INIT_VAR(annotations); array_init(annotations); ZEPHIR_INIT_VAR(reflection); object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC)); ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 66, className); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&comment, reflection, "getdoccomment", NULL, 89); zephir_check_call_status(); if (Z_TYPE_P(comment) == IS_STRING) { ZEPHIR_INIT_VAR(classAnnotations); ZEPHIR_CALL_METHOD(&_0$$3, reflection, "getfilename", NULL, 90); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1$$3, reflection, "getstartline", NULL, 91); zephir_check_call_status(); ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(classAnnotations, comment, _0$$3, _1$$3 TSRMLS_CC); zephir_check_call_status(); if (Z_TYPE_P(classAnnotations) == IS_ARRAY) { zephir_array_update_string(&annotations, SL("class"), &classAnnotations, PH_COPY | PH_SEPARATE); } } ZEPHIR_CALL_METHOD(&properties, reflection, "getproperties", NULL, 92); zephir_check_call_status(); if (zephir_fast_count_int(properties TSRMLS_CC)) { line = 1; ZEPHIR_INIT_VAR(annotationsProperties); array_init(annotationsProperties); zephir_is_iterable(properties, &_3$$5, &_2$$5, 0, 0, "phalcon/annotations/reader.zep", 96); for ( ; zephir_hash_get_current_data_ex(_3$$5, (void**) &_4$$5, &_2$$5) == SUCCESS ; zephir_hash_move_forward_ex(_3$$5, &_2$$5) ) { ZEPHIR_GET_HVALUE(property, _4$$5); ZEPHIR_CALL_METHOD(&comment, property, "getdoccomment", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(comment) == IS_STRING) { ZEPHIR_INIT_NVAR(propertyAnnotations); ZEPHIR_CALL_METHOD(&_5$$7, reflection, "getfilename", NULL, 90); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_6$$7); ZVAL_LONG(_6$$7, line); ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(propertyAnnotations, comment, _5$$7, _6$$7 TSRMLS_CC); zephir_check_call_status(); if (Z_TYPE_P(propertyAnnotations) == IS_ARRAY) { ZEPHIR_OBS_NVAR(_7$$8); zephir_read_property(&_7$$8, property, SL("name"), PH_NOISY_CC); zephir_array_update_zval(&annotationsProperties, _7$$8, &propertyAnnotations, PH_COPY | PH_SEPARATE); } } } if (zephir_fast_count_int(annotationsProperties TSRMLS_CC)) { zephir_array_update_string(&annotations, SL("properties"), &annotationsProperties, PH_COPY | PH_SEPARATE); } } ZEPHIR_CALL_METHOD(&methods, reflection, "getmethods", NULL, 93); zephir_check_call_status(); if (zephir_fast_count_int(methods TSRMLS_CC)) { ZEPHIR_INIT_VAR(annotationsMethods); array_init(annotationsMethods); zephir_is_iterable(methods, &_9$$10, &_8$$10, 0, 0, "phalcon/annotations/reader.zep", 126); for ( ; zephir_hash_get_current_data_ex(_9$$10, (void**) &_10$$10, &_8$$10) == SUCCESS ; zephir_hash_move_forward_ex(_9$$10, &_8$$10) ) { ZEPHIR_GET_HVALUE(method, _10$$10); ZEPHIR_CALL_METHOD(&comment, method, "getdoccomment", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(comment) == IS_STRING) { ZEPHIR_INIT_NVAR(methodAnnotations); ZEPHIR_CALL_METHOD(&_11$$12, method, "getfilename", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_12$$12, method, "getstartline", NULL, 0); zephir_check_call_status(); ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(methodAnnotations, comment, _11$$12, _12$$12 TSRMLS_CC); zephir_check_call_status(); if (Z_TYPE_P(methodAnnotations) == IS_ARRAY) { ZEPHIR_OBS_NVAR(_13$$13); zephir_read_property(&_13$$13, method, SL("name"), PH_NOISY_CC); zephir_array_update_zval(&annotationsMethods, _13$$13, &methodAnnotations, PH_COPY | PH_SEPARATE); } } } if (zephir_fast_count_int(annotationsMethods TSRMLS_CC)) { zephir_array_update_string(&annotations, SL("methods"), &annotationsMethods, PH_COPY | PH_SEPARATE); } } RETURN_CCTOR(annotations); }
/** * Reads annotations from the class dockblocks, its methods and/or properties * * @param string $className * @return array */ PHP_METHOD(Phalcon_Annotations_Reader, parse){ zval *class_name, *annotations; zval *class_annotations, *annotations_properties, *annotations_methods; zend_class_entry *class_ce; const char *file; zend_uint line; phalcon_fetch_params(0, 1, 0, &class_name); if (unlikely(Z_TYPE_P(class_name) != IS_STRING)) { PHALCON_THROW_EXCEPTION_STRW(phalcon_annotations_exception_ce, "The class name must be a string"); return; } class_ce = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_SILENT TSRMLS_CC); if (!class_ce) { zend_throw_exception_ex(phalcon_annotations_exception_ce, 0 TSRMLS_CC, "Class %s does not exist", Z_STRVAL_P(class_name)); return; } if (class_ce->type != ZEND_USER_CLASS) { array_init(return_value); return; } PHALCON_MM_GROW(); PHALCON_INIT_VAR(annotations); array_init(annotations); file = phalcon_get_class_filename(class_ce); if (!file) { file = "(unknown)"; } /* Class info */ { const char *cmt; zend_uint cmt_len; if (phalcon_get_class_doc_comment(class_ce, &cmt, &cmt_len)) { line = phalcon_get_class_startline(class_ce); PHALCON_INIT_VAR(class_annotations); RETURN_MM_ON_FAILURE(phannot_parse_annotations(class_annotations, cmt, cmt_len, file, line TSRMLS_CC)); if (Z_TYPE_P(class_annotations) == IS_ARRAY) { phalcon_array_update_string(&annotations, SL("class"), class_annotations, PH_COPY); } } } /* Get class properties */ { HashTable *props = &class_ce->properties_info; if (zend_hash_num_elements(props) > 0) { HashPosition hp; zend_property_info *property; PHALCON_INIT_VAR(annotations_properties); array_init_size(annotations_properties, zend_hash_num_elements(props)); for ( zend_hash_internal_pointer_reset_ex(props, &hp); zend_hash_get_current_data_ex(props, (void**)&property, &hp) != FAILURE; zend_hash_move_forward_ex(props, &hp) ) { const char *cmt; zend_uint cmt_len; if (phalcon_get_property_doc_comment(property, &cmt, &cmt_len)) { zval *property_annotations; MAKE_STD_ZVAL(property_annotations); if (FAILURE == phannot_parse_annotations(property_annotations, cmt, cmt_len, file, 0 TSRMLS_CC)) { zval_ptr_dtor(&property_annotations); RETURN_MM(); } if (Z_TYPE_P(property_annotations) == IS_ARRAY) { #if PHP_VERSION_ID >= 50400 { const char *prop_name, *class_name; if (zend_unmangle_property_name(property->name, property->name_length - 1, &class_name, &prop_name) == SUCCESS) { add_assoc_zval_ex(annotations_properties, prop_name, strlen(prop_name) + 1, property_annotations); } } #else { char *prop_name, *class_name; if (zend_unmangle_property_name(property->name, property->name_length - 1, &class_name, &prop_name) == SUCCESS) { add_assoc_zval_ex(annotations_properties, prop_name, strlen(prop_name) + 1, property_annotations); } } #endif } else { zval_ptr_dtor(&property_annotations); } } } if (zend_hash_num_elements(Z_ARRVAL_P(annotations_properties))) { phalcon_array_update_string(&annotations, SL("properties"), annotations_properties, PH_COPY); } } } /* Get class methods */ { HashTable *methods = &class_ce->function_table; if (zend_hash_num_elements(methods) > 0) { HashPosition hp; zend_function *method; PHALCON_INIT_VAR(annotations_methods); array_init_size(annotations_methods, zend_hash_num_elements(methods)); for ( zend_hash_internal_pointer_reset_ex(methods, &hp); zend_hash_get_current_data_ex(methods, (void**)&method, &hp) != FAILURE; zend_hash_move_forward_ex(methods, &hp) ) { const char *cmt; zend_uint cmt_len; if (phalcon_get_function_doc_comment(method, &cmt, &cmt_len)) { zval *method_annotations; line = phalcon_get_function_startline(method); MAKE_STD_ZVAL(method_annotations); if (FAILURE == phannot_parse_annotations(method_annotations, cmt, cmt_len, file, line TSRMLS_CC)) { zval_ptr_dtor(&method_annotations); RETURN_MM(); } if (Z_TYPE_P(method_annotations) == IS_ARRAY) { add_assoc_zval_ex(annotations_methods, method->common.function_name, strlen(method->common.function_name) + 1, method_annotations); } else { zval_ptr_dtor(&method_annotations); } } } if (zend_hash_num_elements(Z_ARRVAL_P(annotations_methods))) { phalcon_array_update_string(&annotations, SL("methods"), annotations_methods, PH_COPY); } } } RETURN_CTOR(annotations); }