├── .gitignore ├── .gitmodules ├── CMakeLists.txt ├── LICENSE ├── README.md ├── assets ├── images │ ├── blank.png │ ├── qq.png │ ├── unicornteam.png │ ├── wechat.png │ ├── zendapi.png │ ├── zendapi.svg │ └── zzusoftboy.png └── php.ini.in ├── cmake └── modules │ ├── AddLibZendApi.cmake │ ├── DetectPhpInfo.cmake │ ├── zendAPIConfig.cmake.in │ ├── zendAPIConfigBuildTree.cmake.in │ └── zendAPIConfigVersion.cmake.in ├── config.doxygen ├── include ├── CMakeLists.txt ├── apidoc.h └── zapi │ ├── CompilerDetection.h │ ├── Config.h.in │ ├── Global.h │ ├── PhpHeaders.h │ ├── ProcessorDetection.h │ ├── SystemDetection.h │ ├── Typedefs.h │ ├── Version.h.in │ ├── ZendApi.h │ ├── ds │ ├── ArrayItemProxy.h │ ├── ArrayVariant.h │ ├── BoolVariant.h │ ├── CallableVariant.h │ ├── DoubleVariant.h │ ├── NumericVariant.h │ ├── ObjectVariant.h │ ├── StringVariant.h │ ├── Variant.h │ └── internal │ │ ├── ArrayItemProxyPrivate.h │ │ └── VariantPrivate.h │ ├── kernel │ ├── Exception.h │ ├── FatalError.h │ ├── Meta.h │ ├── NotImplemented.h │ ├── OrigException.h │ └── StreamBuffer.h │ ├── lang │ ├── Argument.h │ ├── Class.h │ ├── Constant.h │ ├── Extension.h │ ├── Function.h │ ├── Ini.h │ ├── Interface.h │ ├── Method.h │ ├── Namespace.h │ ├── Parameters.h │ ├── StdClass.h │ ├── Type.h │ └── internal │ │ ├── ExtensionPrivate.h │ │ ├── NamespacePrivate.h │ │ └── StdClassPrivate.h │ ├── protocol │ ├── AbstractIterator.h │ ├── ArrayAccess.h │ ├── Countable.h │ ├── Interfaces.h │ ├── Serializable.h │ └── Traversable.h │ ├── stdext │ ├── Functional.h │ ├── Tuple.h │ ├── TypeTraits.h │ └── internal │ │ ├── FunctionalPrivate.h │ │ └── TuplePrivate.h │ ├── utils │ ├── CommonFuncs.h │ ├── InternalFuncs.h │ └── PhpFuncs.h │ └── vm │ ├── AbstractClass.h │ ├── AbstractMember.h │ ├── BoolMember.h │ ├── Callable.h │ ├── Closure.h │ ├── Engine.h │ ├── ExecStateGuard.h │ ├── FloatMember.h │ ├── InvokeBridge.h │ ├── IteratorBridge.h │ ├── NullMember.h │ ├── NumericMember.h │ ├── ObjectBinder.h │ ├── Property.h │ ├── StringMember.h │ ├── ZValMember.h │ └── internal │ ├── AbstractClassPrivate.h │ ├── AbstractMemberPrivate.h │ └── CallablePrivate.h ├── scripts ├── CMakeLists.txt └── build │ └── retrieve_php_info.php ├── src ├── CMakeLists.txt ├── Global.cpp ├── ds │ ├── ArrayItemProxy.cpp │ ├── ArrayVariant.cpp │ ├── BoolVariant.cpp │ ├── CallableVariant.cpp │ ├── DoubleVariant.cpp │ ├── NumericVariant.cpp │ ├── ObjectVariant.cpp │ ├── StringVariant.cpp │ └── Variant.cpp ├── kernel │ ├── Exception.cpp │ ├── FatalError.cpp │ ├── Meta.cpp │ └── StreamBuffer.cpp ├── lang │ ├── Argument.cpp │ ├── Class.cpp │ ├── Constant.cpp │ ├── Extension.cpp │ ├── Function.cpp │ ├── Ini.cpp │ ├── Interface.cpp │ ├── Method.cpp │ ├── Namespace.cpp │ ├── Parameters.cpp │ ├── StdClass.cpp │ └── Type.cpp ├── protocol │ ├── AbstractIterator.cpp │ └── ArrayAccess.cpp ├── utils │ ├── CommonFuncs.cpp │ ├── InternalFuncs.cpp │ └── PhpFuncs.cpp └── vm │ ├── AbstractClass.cpp │ ├── AbstractMember.cpp │ ├── BoolMember.cpp │ ├── Callable.cpp │ ├── Closure.cpp │ ├── Engine.cpp │ ├── FloatMember.cpp │ ├── FloatMember.h │ ├── InvokeBridge.cpp │ ├── IteratorBridge.cpp │ ├── NullMember.cpp │ ├── NumericMember.cpp │ ├── ObjectBinder.cpp │ ├── Property.cpp │ ├── StringMember.cpp │ └── ZValMember.cpp ├── tests ├── CMakeLists.txt ├── dummyext │ ├── CMakeLists.txt │ ├── ClassTestcases.cpp │ ├── ClassTestcases.h │ ├── ConstantTestcases.cpp │ ├── ConstantTestcases.h │ ├── CycleHandlerTestcases.cpp │ ├── CycleHandlerTestcases.h │ ├── Entry.cpp │ ├── FunctionTestcases.cpp │ ├── FunctionTestcases.h │ ├── IniTestcases.cpp │ ├── IniTestcases.h │ ├── InterfaceTestcases.cpp │ ├── InterfaceTestcases.h │ ├── NamespaceTestcases.cpp │ ├── NamespaceTestcases.h │ ├── NativeClasses.cpp │ ├── NativeClasses.h │ ├── NativeFunctions.cpp │ └── NativeFunctions.h ├── entry.php ├── ext │ ├── CMakeLists.txt │ ├── ExtensionHandlerTest.phpt │ ├── ExtensionInfoTest.phpt │ └── IniTest.phpt └── lang │ ├── CMakeLists.txt │ ├── class │ ├── ClassArrayAccessTest.phpt │ ├── ClassCallParentMethodTest.phpt │ ├── ClassCallParentMethodWithReturnTest.phpt │ ├── ClassCallParentPassRefArgTest.phpt │ ├── ClassClosureTest.phpt │ ├── ClassConstantTest.phpt │ ├── ClassConstantTypeTest.phpt │ ├── ClassCountTest.phpt │ ├── ClassExistTest.phpt │ ├── ClassFinalTest.phpt │ ├── ClassGetVariantPtrTest.phpt │ ├── ClassImplementTest.phpt │ ├── ClassInheritPropertyTest.phpt │ ├── ClassInheritTest.phpt │ ├── ClassIteratorTest.phpt │ ├── ClassMagicCallStaticTest.phpt │ ├── ClassMagicCallTest.phpt │ ├── ClassMagicCastTest.phpt │ ├── ClassMagicCloneTest.phpt │ ├── ClassMagicCompareTest.phpt │ ├── ClassMagicConstructAndDestructTest.phpt │ ├── ClassMagicDebugInfoTest.phpt │ ├── ClassMagicGetTest.phpt │ ├── ClassMagicInvokeTest.phpt │ ├── ClassMagicIssetTest.phpt │ ├── ClassMagicSerializeTest.phpt │ ├── ClassMagicSetTest.phpt │ ├── ClassMagicUnsetTest.phpt │ ├── ClassMethodAccessLevelTest.phpt │ ├── ClassMethodExistTest.phpt │ ├── ClassMethodInvokeTest.phpt │ ├── ClassMethodVisibilityTest.phpt │ ├── ClassPolymorphicTest.phpt │ ├── ClassPropGetterAndSetterTest.phpt │ ├── ClassPropertyTest.phpt │ ├── ClassPropertyTypeTest.phpt │ ├── ClassPropertyVisibilityTest.phpt │ ├── ClassStaticMethodExistTest.phpt │ ├── ClassStaticPropertyTest.phpt │ ├── ObjectVariantDerivedFromTest.phpt │ ├── ObjectVariantInstanceOfTest.phpt │ ├── ObjectVariantInvokeTest.phpt │ ├── ObjectVariantNoArgsCallTest.phpt │ └── ObjectVariantVarArgsCallTest.phpt │ ├── const │ ├── ConstantExistTest.phpt │ ├── ConstantNsTest.phpt │ └── ConstantTypeTest.phpt │ ├── func │ ├── FunctionArgsTest.phpt │ ├── FunctionDefaultArgTest.phpt │ ├── FunctionDefaultTest.phpt │ ├── FunctionExistTest.phpt │ ├── FunctionRefArgTest.phpt │ ├── FunctionReturnTest.phpt │ └── FunctionVarArgsTest.phpt │ └── interface │ ├── InterfaceExistTest.phpt │ └── InterfaceInheritTest.phpt └── unittests ├── CMakeLists.txt ├── EmbedPhpTest.cpp ├── ds ├── ArrayVariantTest.cpp ├── BoolVariantTest.cpp ├── CMakeLists.txt ├── CallableVariantTest.cpp ├── DoubleVariantTest.cpp ├── HashTableTest.cpp ├── NumericVariantTest.cpp ├── ObjectVariantTest.cpp ├── StringVariantTest.cpp └── VariantTest.cpp ├── lang ├── ArgumentTest.cpp ├── CMakeLists.txt ├── ConstantTest.cpp ├── ExtensionTest.cpp ├── FunctionTest.cpp ├── NamespaceTest.cpp └── TypeTest.cpp ├── std ├── CMakeLists.txt ├── InvokeTest.cpp └── TypeTraitsTest.cpp ├── utils ├── CMakeLists.txt └── InternalTest.cpp └── vm ├── CMakeLists.txt ├── EngineTest.cpp └── InvokeBridgeTest.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | # Created by .ignore support plugin (hsz.mobi) 2 | ### C++ template 3 | # Compiled Object files 4 | *.slo 5 | *.lo 6 | *.o 7 | *.obj 8 | 9 | # Precompiled Headers 10 | *.gch 11 | *.pch 12 | 13 | # Compiled Dynamic libraries 14 | *.so 15 | *.dylib 16 | *.dll 17 | 18 | # Fortran module files 19 | *.mod 20 | *.smod 21 | 22 | # Compiled Static libraries 23 | *.lai 24 | *.la 25 | *.a 26 | *.lib 27 | 28 | # Executables 29 | *.exe 30 | *.out 31 | *.app 32 | 33 | CMakeLists.txt.user 34 | .idea/ 35 | cmake-build-debug/ 36 | *~ 37 | .DS_Store 38 | temp/ 39 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "utils/unittest"] 2 | path = utils/unittest 3 | url = https://github.com/google/googletest.git 4 | -------------------------------------------------------------------------------- /assets/images/blank.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qcoreteam/zendapi/b73fed92c2327d965bd545d5e34f8157e4389a6b/assets/images/blank.png -------------------------------------------------------------------------------- /assets/images/qq.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qcoreteam/zendapi/b73fed92c2327d965bd545d5e34f8157e4389a6b/assets/images/qq.png -------------------------------------------------------------------------------- /assets/images/unicornteam.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qcoreteam/zendapi/b73fed92c2327d965bd545d5e34f8157e4389a6b/assets/images/unicornteam.png -------------------------------------------------------------------------------- /assets/images/wechat.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qcoreteam/zendapi/b73fed92c2327d965bd545d5e34f8157e4389a6b/assets/images/wechat.png -------------------------------------------------------------------------------- /assets/images/zendapi.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qcoreteam/zendapi/b73fed92c2327d965bd545d5e34f8157e4389a6b/assets/images/zendapi.png -------------------------------------------------------------------------------- /assets/images/zzusoftboy.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qcoreteam/zendapi/b73fed92c2327d965bd545d5e34f8157e4389a6b/assets/images/zzusoftboy.png -------------------------------------------------------------------------------- /cmake/modules/zendAPIConfig.cmake.in: -------------------------------------------------------------------------------- 1 | # - Config file for the Libevent package 2 | # It defines the following variables 3 | # ZAPI_INCLUDE_DIRS - include directories for FooBar 4 | # ZAPI_LIBRARIES - libraries to link against 5 | 6 | # Get the path of the current file. 7 | get_filename_component(ZAPI_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) 8 | 9 | # Set the include directories. 10 | set(ZAPI_INCLUDE_DIRS "@ZAPI_INSTALL_INCLUDE_DIR@") 11 | set(ZAPI_PHP_INCLUDE_PATHS "@ZAPI_PHP_INCLUDE_PATHS@") 12 | set(ZAPI_PHP_EXTENSION_DIR "@ZAPI_PHP_EXTENSION_DIR@") 13 | set(ZAPI_PHP_EXECUTABLE "@ZAPI_PHP_EXECUTABLE@") 14 | set(ZAPI_PHP_SUPPORT_SAPIS "@ZAPI_PHP_SUPPORT_SAPIS@") 15 | 16 | # Include the project Targets file, this contains definitions for IMPORTED targets. 17 | include(${ZAPI_CMAKE_DIR}/zendAPITargets.cmake) 18 | 19 | # IMPORTED targets from ZendApiTargets.cmake 20 | set(ZAPI_LIBRARY zapi) 21 | -------------------------------------------------------------------------------- /cmake/modules/zendAPIConfigBuildTree.cmake.in: -------------------------------------------------------------------------------- 1 | # - Config file for the Libevent package 2 | # It defines the following variables 3 | # ZAPI_INCLUDE_DIRS - include directories for FooBar 4 | # ZAPI_LIBRARIES - libraries to link against 5 | 6 | # Get the path of the current file. 7 | get_filename_component(ZAPI_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) 8 | 9 | # Set the include directories. 10 | set(ZAPI_INCLUDE_DIRS "@ZAPI_INCLUDE_DIRS@") 11 | 12 | # Include the project Targets file, this contains definitions for IMPORTED targets. 13 | 14 | # IMPORTED targets from ZendApiTargets.cmake 15 | set(ZAPI_LIBRARIES zapi) 16 | 17 | -------------------------------------------------------------------------------- /cmake/modules/zendAPIConfigVersion.cmake.in: -------------------------------------------------------------------------------- 1 | set(PACKAGE_VERSION "@ZAPI_PACKAGE_VERSION@") 2 | 3 | if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}") 4 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 5 | else() 6 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 7 | if("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}") 8 | set(PACKAGE_VERSION_EXACT TRUE) 9 | endif() 10 | endif() -------------------------------------------------------------------------------- /config.doxygen: -------------------------------------------------------------------------------- 1 | OUTPUT_DIRECTORY = ./temp/apidoc 2 | PROJECT_NAME = zendAPI 3 | QUIET = YES 4 | ## CREATE_SUBDIRS = YES 5 | JAVADOC_AUTOBRIEF = YES 6 | BUILTIN_STL_SUPPORT = YES 7 | GROUP_NESTED_COMPOUNDS = YES 8 | EXTRACT_ALL = YES 9 | ## EXTRACT_PRIVATE = YES 10 | EXTRACT_PACKAGE = YES 11 | EXTRACT_STATIC = YES 12 | SHOW_GROUPED_MEMB_INC = YES 13 | INPUT = ./include ./src 14 | RECURSIVE = YES 15 | SOURCE_BROWSER = YES 16 | ## INLINE_SOURCES = YES 17 | ## CLANG_ASSISTED_PARSING = YES 18 | SEARCH_INCLUDES = YES 19 | INCLUDE_PATH = /usr/local/php7/include/ 20 | GENERATE_HTML = YES 21 | GENERATE_LATEX = NO 22 | GENERATE_XML = YES 23 | XML_PROGRAMLISTING = YES 24 | EXPAND_ONLY_PREDEF = YES 25 | ## PREDEFINED 26 | ## EXPAND_AS_DEFINED 27 | CLASS_DIAGRAMS = NO 28 | MARKDOWN_SUPPORT = NO 29 | -------------------------------------------------------------------------------- /include/apidoc.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // This header is not for included in CPP source, 15 | // We describe the zapi module and namespaces doc. Then we need not to describe these 16 | // Doxygen entity in other headers 17 | 18 | /** 19 | * \namespace zapi 20 | */ 21 | /** 22 | * \namespace zapi::ds 23 | */ 24 | 25 | /** 26 | * \namespace zapi::lang 27 | */ 28 | 29 | /** 30 | * \namespace zapi::utils 31 | */ 32 | 33 | /** 34 | * \namespace zapi::vm 35 | */ 36 | 37 | /** 38 | * \namespace zapi::kernel 39 | */ 40 | 41 | /** 42 | * \defgroup API 43 | */ 44 | 45 | /** 46 | * \defgroup Kernel 47 | */ 48 | /** 49 | * \defgroup ZendVM 50 | */ -------------------------------------------------------------------------------- /include/zapi/Config.h.in: -------------------------------------------------------------------------------- 1 | // Copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 5/18/17. 15 | 16 | #ifndef ZAPI_CONFIG_H 17 | #define ZAPI_CONFIG_H 18 | 19 | #endif //ZAPI_CONFIG_H 20 | -------------------------------------------------------------------------------- /include/zapi/PhpHeaders.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/09/18. 15 | // 16 | 17 | #ifndef ZAPI_PHP_HEADERS_H 18 | #define ZAPI_PHP_HEADERS_H 19 | 20 | #include "zapi/CompilerDetection.h" 21 | 22 | extern "C" 23 | { 24 | #include 25 | #include "php/main/php.h" 26 | #include "php/Zend/zend_API.h" 27 | #include "php/Zend/zend_types.h" 28 | #include "php/Zend/zend_compile.h" 29 | } 30 | 31 | #endif // ZAPI_PHP_HEADERS_H 32 | -------------------------------------------------------------------------------- /include/zapi/Version.h.in: -------------------------------------------------------------------------------- 1 | // Copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 5/26/17. 15 | 16 | #ifndef ZAPI_VERSION_H 17 | #define ZAPI_VERSION_H 18 | 19 | #define ZAPI_VERSION_MAJOR @ZAPI_VERSION_MAJOR@ 20 | #define ZAPI_VERSION_MINOR @ZAPI_VERSION_MINOR@ 21 | #define ZAPI_VERSION_PATCH @ZAPI_VERSION_PATCH@ 22 | 23 | // string representation of the zapi version 24 | #define ZAPI_PACKAGE_VERSION "@ZAPI_PACKAGE_VERSION@" 25 | 26 | // Numeric representation of the zapi version 27 | #define ZAPI_NUMERIC_VERSION @ZAPI_NUMERIC_VERSION@ 28 | 29 | // The full version str of zapi 30 | #define ZAPI_VERSION "@ZAPI_VERSION@" 31 | 32 | #define ZAPI_PACKAGE_NAME "zapi" 33 | 34 | #define ZAPI_PAKCAGE "zapi @ZAPI_VERSION@" 35 | 36 | #define ZAPI_API_VERSION @ZAPI_API_VERSION@ 37 | #define ZAPI_PHP_API_VERSION PHP_API_VERSION 38 | #define ZAPI_ZEND_MODULE_API_NO ZEND_MODULE_API_NO 39 | #define ZAPI_ZEND_EXTENSION_API_NO ZEND_EXTENSION_API_NO 40 | 41 | #endif //ZAPI_VERSION_H 42 | -------------------------------------------------------------------------------- /include/zapi/ZendApi.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 27/05/2017. 15 | 16 | #ifndef ZAPI_ZENDAPI_H 17 | #define ZAPI_ZENDAPI_H 18 | 19 | #include "zapi/Global.h" 20 | #include "zapi/utils/PhpFuncs.h" 21 | #include "zapi/ds/Variant.h" 22 | #include "zapi/ds/StringVariant.h" 23 | #include "zapi/ds/NumericVariant.h" 24 | #include "zapi/ds/BoolVariant.h" 25 | #include "zapi/ds/DoubleVariant.h" 26 | #include "zapi/ds/ArrayVariant.h" 27 | #include "zapi/ds/ArrayItemProxy.h" 28 | #include "zapi/ds/CallableVariant.h" 29 | #include "zapi/lang/Constant.h" 30 | #include "zapi/lang/Parameters.h" 31 | #include "zapi/lang/Class.h" 32 | #include "zapi/lang/StdClass.h" 33 | #include "zapi/lang/Interface.h" 34 | #include "zapi/lang/Namespace.h" 35 | #include "zapi/lang/Ini.h" 36 | #include "zapi/lang/Extension.h" 37 | #include "zapi/kernel/StreamBuffer.h" 38 | #include "zapi/protocol/AbstractIterator.h" 39 | #include "zapi/protocol/ArrayAccess.h" 40 | #include "zapi/protocol/Countable.h" 41 | #include "zapi/protocol/Serializable.h" 42 | #include "zapi/protocol/Traversable.h" 43 | 44 | #endif //ZAPI_ZENDAPI_H 45 | -------------------------------------------------------------------------------- /include/zapi/ds/BoolVariant.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/08/08. 15 | 16 | #ifndef ZAPI_DS_INTERNAL_BOOL_VARIANT_H 17 | #define ZAPI_DS_INTERNAL_BOOL_VARIANT_H 18 | 19 | #include "zapi/ds/Variant.h" 20 | 21 | namespace zapi 22 | { 23 | namespace ds 24 | { 25 | 26 | class ArrayItemProxy; 27 | 28 | class ZAPI_DECL_EXPORT BoolVariant final : public Variant 29 | { 30 | public: 31 | BoolVariant(); 32 | BoolVariant(const BoolVariant &other); 33 | BoolVariant(BoolVariant &other, bool isRef); 34 | BoolVariant(BoolVariant &&other) ZAPI_DECL_NOEXCEPT; 35 | BoolVariant(const Variant &other); 36 | BoolVariant(Variant &&other); 37 | BoolVariant(bool value); 38 | BoolVariant(zval &other, bool isRef = false); 39 | BoolVariant(zval &&other, bool isRef = false); 40 | BoolVariant(zval *other, bool isRef = false); 41 | virtual bool toBool() const ZAPI_DECL_NOEXCEPT override; 42 | operator bool () const override; 43 | BoolVariant &operator=(const BoolVariant &other); 44 | BoolVariant &operator=(const Variant &other); 45 | BoolVariant &operator=(ArrayItemProxy &&other); 46 | BoolVariant &operator=(bool value); 47 | virtual ~BoolVariant(); 48 | }; 49 | 50 | ZAPI_DECL_EXPORT bool operator ==(const BoolVariant &lhs, const BoolVariant &rhs); 51 | ZAPI_DECL_EXPORT bool operator !=(const BoolVariant &lhs, const BoolVariant &rhs); 52 | } // ds 53 | } // zapi 54 | 55 | #endif // ZAPI_DS_INTERNAL_BOOL_VARIANT_H -------------------------------------------------------------------------------- /include/zapi/ds/CallableVariant.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/08/08. 15 | 16 | #ifndef ZAPI_DS_CALLABLE_VARIANT_H 17 | #define ZAPI_DS_CALLABLE_VARIANT_H 18 | 19 | #include "zapi/ds/Variant.h" 20 | #include "zapi/stdext/TypeTraits.h" 21 | #include "zapi/vm/Closure.h" 22 | 23 | namespace zapi 24 | { 25 | namespace lang 26 | { 27 | 28 | class Parameters; 29 | 30 | } // lang 31 | } // zapi 32 | 33 | namespace zapi 34 | { 35 | namespace ds 36 | { 37 | 38 | using zapi::vm::Closure; 39 | using zapi::lang::Parameters; 40 | 41 | class ZAPI_DECL_EXPORT CallableVariant final : public Variant 42 | { 43 | public: 44 | using HaveArgCallable = Variant(Parameters &); 45 | using NoArgCallable = Variant(); 46 | CallableVariant(HaveArgCallable callable); 47 | CallableVariant(NoArgCallable callable); 48 | 49 | CallableVariant(const Variant &other); 50 | CallableVariant(const CallableVariant &other); 51 | CallableVariant(Variant &&other); 52 | CallableVariant(CallableVariant &&other) ZAPI_DECL_NOEXCEPT; 53 | CallableVariant(zval &other); 54 | CallableVariant(zval &&other); 55 | CallableVariant(zval *other); 56 | 57 | CallableVariant &operator =(const CallableVariant &other); 58 | CallableVariant &operator =(const Variant &other); 59 | CallableVariant &operator =(CallableVariant &&other) ZAPI_DECL_NOEXCEPT; 60 | CallableVariant &operator =(Variant &&other); 61 | 62 | Variant operator ()() const; 63 | template 64 | Variant operator ()(Args&&... args); 65 | virtual ~CallableVariant(); 66 | protected: 67 | Variant exec(int argc, Variant *argv) const; 68 | }; 69 | 70 | template 71 | Variant CallableVariant::operator ()(Args&&... args) 72 | { 73 | Variant vargs[] = { static_cast(args)... }; 74 | return exec(sizeof...(Args), vargs); 75 | } 76 | 77 | 78 | } // ds 79 | } // zapi 80 | 81 | #endif // ZAPI_DS_CALLABLE_VARIANT_H 82 | -------------------------------------------------------------------------------- /include/zapi/ds/internal/VariantPrivate.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // @copyright 2013, 2014 Copernica BV 3 | // Emiel Bruijntjes 4 | // 5 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 6 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 7 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 8 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 9 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 10 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 11 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 12 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 13 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 14 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 15 | // 16 | // Created by softboy on 2017/08/06. 17 | 18 | #ifndef ZAPI_DS_INTERNAL_VARIANT_PRIVATE_H 19 | #define ZAPI_DS_INTERNAL_VARIANT_PRIVATE_H 20 | 21 | #include 22 | #include "php/Zend/zend_types.h" 23 | #include 24 | 25 | namespace zapi 26 | { 27 | namespace ds 28 | { 29 | namespace internal 30 | { 31 | 32 | class VariantPrivate 33 | { 34 | public: 35 | VariantPrivate() 36 | { 37 | std::memset(&m_buffer, 0, sizeof(m_buffer)); 38 | } 39 | 40 | operator _zval_struct *() const &; 41 | operator const _zval_struct *() const &; 42 | _zval_struct &operator*() const &; 43 | _zval_struct *dereference() const; 44 | //std::aligned_storage<16>::type m_buffer; 45 | zval m_buffer; 46 | }; 47 | 48 | } // internal 49 | } // ds 50 | } // zapi 51 | 52 | #endif // ZAPI_DS_INTERNAL_VARIANT_PRIVATE_H 53 | -------------------------------------------------------------------------------- /include/zapi/kernel/FatalError.h: -------------------------------------------------------------------------------- 1 | // @author Emiel Bruijntjes 2 | // @copyright 2014 Copernica BV 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 07/06/2017. 18 | 19 | #ifndef ZAPI_KERNEL_FATALERROR_H 20 | #define ZAPI_KERNEL_FATALERROR_H 21 | 22 | #include "zapi/kernel/Exception.h" 23 | 24 | namespace zapi 25 | { 26 | namespace kernel 27 | { 28 | 29 | class ZAPI_DECL_EXPORT FatalError : public Exception 30 | { 31 | public: 32 | /** 33 | * Constructor 34 | * @param message 35 | */ 36 | FatalError(const std::string &message); 37 | 38 | /** 39 | * Destructor 40 | */ 41 | virtual ~FatalError(); 42 | 43 | /** 44 | * Is this a native exception (one that was thrown from C++ code) 45 | * @return bool 46 | */ 47 | virtual bool native() const override; 48 | 49 | /** 50 | * Report this error as a fatal error 51 | * @return bool 52 | */ 53 | virtual bool report() const override; 54 | }; 55 | 56 | } // kernel 57 | } // zapi 58 | 59 | #endif //ZAPI_KERNEL_FATALERROR_H 60 | -------------------------------------------------------------------------------- /include/zapi/kernel/Meta.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 5/26/17. 15 | 16 | #ifndef ZAPI_KERNEL_META_H 17 | #define ZAPI_KERNEL_META_H 18 | 19 | #include "zapi/Global.h" 20 | 21 | namespace zapi 22 | { 23 | namespace kernel 24 | { 25 | 26 | class ZAPI_DECL_EXPORT Meta 27 | { 28 | public: 29 | void getLoadedExtensions(); 30 | void getPhpVersion(); 31 | }; 32 | 33 | } // kernel 34 | } // zapi 35 | 36 | #endif //ZAPI_KERNEL_META_H 37 | -------------------------------------------------------------------------------- /include/zapi/kernel/NotImplemented.h: -------------------------------------------------------------------------------- 1 | // @author Emiel Bruijntjes 2 | // @copyright 2014 Copernica BV 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 08/06/2017. 18 | 19 | #ifndef ZAPI_KERNEL_NOTIMPLEMENTED_H 20 | #define ZAPI_KERNEL_NOTIMPLEMENTED_H 21 | 22 | #include 23 | 24 | #include "zapi/Global.h" 25 | 26 | namespace zapi 27 | { 28 | namespace kernel 29 | { 30 | 31 | class ZAPI_DECL_EXPORT NotImplemented : public std::exception 32 | { 33 | public: 34 | NotImplemented(); 35 | 36 | virtual ~NotImplemented() ZAPI_DECL_NOEXCEPT; 37 | }; 38 | 39 | } // kernel 40 | } // zapi 41 | 42 | #endif //ZAPI_KERNEL_NOTIMPLEMENTED_H 43 | -------------------------------------------------------------------------------- /include/zapi/kernel/StreamBuffer.h: -------------------------------------------------------------------------------- 1 | // @author Emiel Bruijntjes 2 | // @copyright 2014 Copernica BV 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 27/05/2017. 18 | 19 | #ifndef ZAPI_KERNEL_STREAMBUFFER_H 20 | #define ZAPI_KERNEL_STREAMBUFFER_H 21 | 22 | #include 23 | #include 24 | #include 25 | #include 26 | 27 | #include "zapi/Global.h" 28 | 29 | namespace zapi 30 | { 31 | namespace kernel 32 | { 33 | 34 | class ZAPI_DECL_EXPORT StreamBuffer : public std::streambuf 35 | { 36 | public: 37 | StreamBuffer(int error); 38 | StreamBuffer(const StreamBuffer &buffer) = delete; 39 | StreamBuffer(StreamBuffer &&buffer) = delete; 40 | StreamBuffer &operator=(const StreamBuffer &buffer) = delete; 41 | StreamBuffer &operator=(StreamBuffer &&buffer) = delete; 42 | virtual ~StreamBuffer(); 43 | protected: 44 | virtual int overflow(int c = EOF) override; 45 | virtual int sync() override; 46 | 47 | private: 48 | int m_error; 49 | std::array m_buffer{}; 50 | static std::mutex m_mutex; 51 | }; 52 | 53 | } // kernel 54 | } // zapi 55 | 56 | #endif // ZAPI_KERNEL_STREAMBUFFER_H 57 | -------------------------------------------------------------------------------- /include/zapi/lang/Constant.h: -------------------------------------------------------------------------------- 1 | // @author Emiel Bruijntjes 2 | // @copyright 2014 Copernica BV 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by softboy on 5/26/17. 18 | 19 | #ifndef ZAPI_LANG_CONSTANT_H 20 | #define ZAPI_LANG_CONSTANT_H 21 | 22 | #include "zapi/Global.h" 23 | 24 | // forward declare with namespace 25 | namespace zapi 26 | { 27 | namespace lang 28 | { 29 | namespace internal 30 | { 31 | class ExtensionPrivate; 32 | class ConstantPrivate; 33 | class NamespacePrivate; 34 | } // internal 35 | } // lang 36 | } //zapi 37 | // end forward declare 38 | 39 | namespace zapi 40 | { 41 | namespace lang 42 | { 43 | 44 | using internal::ConstantPrivate; 45 | 46 | class ZAPI_DECL_EXPORT Constant final 47 | { 48 | public: 49 | Constant(const char *name, std::nullptr_t value = nullptr); 50 | Constant(const char *name, bool value); 51 | Constant(const char *name, int32_t value); 52 | Constant(const char *name, int64_t value); 53 | Constant(const char *name, double value); 54 | Constant(const char *name, const char *value); 55 | Constant(const char *name, const char *value, size_t size); 56 | Constant(const char *name, const std::string &value); 57 | Constant(const Constant &other); 58 | Constant(Constant &&other) ZAPI_DECL_NOEXCEPT; 59 | Constant &operator=(const Constant &other); 60 | Constant &operator=(Constant &&other) ZAPI_DECL_NOEXCEPT; 61 | const std::string &getName() const; 62 | const zend_constant &getZendConstant() const; 63 | virtual ~Constant(); 64 | private: 65 | void initialize(const std::string &prefix, int moduleNumber); 66 | void initialize(int moduleNumber); 67 | private: 68 | ZAPI_DECLARE_PRIVATE(Constant) 69 | std::shared_ptr m_implPtr; 70 | friend class zapi::lang::internal::ExtensionPrivate; 71 | friend class zapi::lang::internal::NamespacePrivate; 72 | }; 73 | 74 | } // lang 75 | } // zapi 76 | 77 | #endif //ZAPI_LANG_CONSTANT_H 78 | -------------------------------------------------------------------------------- /include/zapi/lang/Function.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 27/07/2017. 15 | 16 | #ifndef ZAPI_LANG_FUNCTION_H 17 | #define ZAPI_LANG_FUNCTION_H 18 | 19 | #include "zapi/vm/Callable.h" 20 | 21 | namespace zapi 22 | { 23 | namespace lang 24 | { 25 | 26 | using zapi::lang::internal::ExtensionPrivate; 27 | using zapi::ds::Variant; 28 | class FunctionPrivate; 29 | 30 | class ZAPI_DECL_EXPORT Function : public zapi::vm::Callable 31 | { 32 | public: 33 | Function(const char *name, zapi::ZendCallable callable, const Arguments &arguments = {}); 34 | Function(const char *name, const Arguments &arguments = {}); 35 | Function(const Function &other); 36 | Function &operator=(const Function &other); 37 | virtual Variant invoke(Parameters ¶meters); 38 | virtual ~Function(); 39 | private: 40 | ZAPI_DECLARE_PRIVATE(Function) 41 | }; 42 | 43 | } // lang 44 | } // zapi 45 | 46 | #endif //ZAPI_LANG_FUNCTION_H 47 | -------------------------------------------------------------------------------- /include/zapi/lang/Interface.h: -------------------------------------------------------------------------------- 1 | // @author Emiel Bruijntjes 2 | // @copyright 2014 Copernica BV 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by softboy on 2017/08/02. 18 | 19 | #ifndef ZAPI_LANG_INTERFACE_H 20 | #define ZAPI_LANG_INTERFACE_H 21 | 22 | #include "zapi/vm/AbstractClass.h" 23 | 24 | namespace zapi 25 | { 26 | namespace lang 27 | { 28 | 29 | using zapi::vm::AbstractClass; 30 | 31 | class ZAPI_DECL_EXPORT Interface final : public AbstractClass 32 | { 33 | public: 34 | Interface(const char *name); 35 | virtual ~Interface(); 36 | public: 37 | Interface ®isterMethod(const char *name, const Arguments args = {}); 38 | Interface ®isterMethod(const char *name, Modifier flags, const Arguments args = {}); 39 | Interface ®isterBaseInterface(const Interface &interface); 40 | protected: 41 | template friend class Class; 42 | }; 43 | 44 | } // lang 45 | } // zapi 46 | 47 | #endif //ZAPI_LANG_INTERFACE_H 48 | -------------------------------------------------------------------------------- /include/zapi/lang/Method.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 6 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 7 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 8 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 9 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 10 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 11 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 12 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 13 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 14 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 15 | // 16 | // Created by softboy on 2017/08/01. 17 | 18 | #ifndef ZAPI_LANG_METHOD_H 19 | #define ZAPI_LANG_METHOD_H 20 | 21 | #include "zapi/Global.h" 22 | #include "zapi/vm/Callable.h" 23 | 24 | // forward declare with namespace 25 | namespace zapi 26 | { 27 | 28 | namespace lang 29 | { 30 | namespace internal 31 | { 32 | class MethodPrivate; 33 | } // internal 34 | } // lang 35 | 36 | namespace vm 37 | { 38 | namespace internal 39 | { 40 | class AbstractClassPrivate; 41 | } // internal 42 | } // vm 43 | 44 | } // zapi 45 | // end forward declare 46 | 47 | namespace zapi 48 | { 49 | namespace lang 50 | { 51 | 52 | using internal::MethodPrivate; 53 | using zapi::ds::Variant; 54 | 55 | class ZAPI_DECL_EXPORT Method : public zapi::vm::Callable 56 | { 57 | public: 58 | Method(const char *name, zapi::ZendCallable callback, Modifier flags, const Arguments &args); 59 | Method(const char *name, Modifier flags, const Arguments &args); 60 | Method(const Method &other); 61 | Method &operator=(const Method &other); 62 | virtual ~Method(); 63 | virtual Variant invoke(Parameters ¶meters) override; 64 | protected: 65 | void initialize(zend_function_entry *entry, const char *className); 66 | private: 67 | ZAPI_DECLARE_PRIVATE(Method) 68 | friend class zapi::vm::internal::AbstractClassPrivate; 69 | }; 70 | 71 | } // lang 72 | } // zapi 73 | 74 | #endif // ZAPI_LANG_METHOD_H 75 | -------------------------------------------------------------------------------- /include/zapi/lang/internal/StdClassPrivate.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // @copyright 2013, 2014 Copernica BV 3 | // Emiel Bruijntjes 4 | // 5 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 6 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 7 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 8 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 9 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 10 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 11 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 12 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 13 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 14 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 15 | // 16 | // Created by softboy on 2017/08/01. 17 | 18 | #ifndef ZAPI_LANG_INTERNAL_STDCLASS_PRIVATE_H 19 | #define ZAPI_LANG_INTERNAL_STDCLASS_PRIVATE_H 20 | 21 | #include "zapi/Global.h" 22 | 23 | // class forware declare with namespace 24 | namespace zapi 25 | { 26 | namespace ds 27 | { 28 | 29 | class ObjectVariant; 30 | 31 | } // ds 32 | } // zapi 33 | 34 | namespace zapi 35 | { 36 | namespace lang 37 | { 38 | namespace internal 39 | { 40 | 41 | using zapi::ds::ObjectVariant; 42 | 43 | class StdClassPrivate 44 | { 45 | public: 46 | StdClassPrivate(); 47 | zend_object *m_zendObject = nullptr; 48 | std::unique_ptr m_objVariant; 49 | }; 50 | } // internal 51 | } // lang 52 | } // zapi 53 | 54 | #endif // ZAPI_LANG_INTERNAL_STDCLASS_PRIVATE_H 55 | -------------------------------------------------------------------------------- /include/zapi/protocol/AbstractIterator.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/03. 18 | 19 | #ifndef ZAPI_PROTOCOL_ABSTRACT_ITERATOR_H 20 | #define ZAPI_PROTOCOL_ABSTRACT_ITERATOR_H 21 | 22 | #include "zapi/ds/Variant.h" 23 | 24 | // forward declare with namespace 25 | namespace zapi 26 | { 27 | 28 | namespace lang 29 | { 30 | class StdClass; 31 | } // lang 32 | 33 | namespace protocol 34 | { 35 | namespace internal 36 | { 37 | class AbstractIteratorPrivate; 38 | } // internal 39 | } // protocol 40 | 41 | } // zapi 42 | // end forward declare 43 | 44 | namespace zapi 45 | { 46 | namespace protocol 47 | { 48 | 49 | using zapi::lang::StdClass; 50 | using zapi::ds::Variant; 51 | using internal::AbstractIteratorPrivate; 52 | 53 | class ZAPI_DECL_EXPORT AbstractIterator 54 | { 55 | public: 56 | AbstractIterator(StdClass *nativeObject); 57 | virtual ~AbstractIterator(); 58 | 59 | virtual bool valid() = 0; 60 | virtual Variant current() = 0; 61 | virtual Variant key() = 0; 62 | virtual void next() = 0; 63 | virtual void rewind() = 0; 64 | 65 | protected: 66 | ZAPI_DECLARE_PRIVATE(AbstractIterator) 67 | std::unique_ptr m_implPtr; 68 | }; 69 | 70 | } // protocol 71 | } // zapi 72 | 73 | #endif // ZAPI_PROTOCOL_ABSTRACT_ITERATOR_H 74 | -------------------------------------------------------------------------------- /include/zapi/protocol/ArrayAccess.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/23. 18 | 19 | #ifndef ZAPI_PROTOCOL_ARRAY_ACCESS_H 20 | #define ZAPI_PROTOCOL_ARRAY_ACCESS_H 21 | 22 | #include "zapi/Global.h" 23 | 24 | namespace zapi 25 | { 26 | 27 | // forward declare with namespace 28 | namespace ds 29 | { 30 | class Variant; 31 | } // ds 32 | 33 | namespace protocol 34 | { 35 | 36 | using zapi::ds::Variant; 37 | 38 | class ZAPI_DECL_EXPORT ArrayAccess 39 | { 40 | public: 41 | virtual bool offsetExists(Variant offset) = 0; 42 | virtual void offsetSet(Variant offset, Variant value) = 0; 43 | virtual Variant offsetGet(Variant offset) = 0; 44 | virtual void offsetUnset(Variant offset) = 0; 45 | virtual ~ArrayAccess(); 46 | }; 47 | 48 | 49 | } // protocol 50 | } // zapi 51 | 52 | 53 | #endif // ZAPI_PROTOCOL_ARRAY_ACCESS_H 54 | -------------------------------------------------------------------------------- /include/zapi/protocol/Countable.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/23. 18 | 19 | #ifndef ZAPI_PROTOCOL_COUNTABLE_H 20 | #define ZAPI_PROTOCOL_COUNTABLE_H 21 | 22 | #include "zapi/Global.h" 23 | 24 | namespace zapi 25 | { 26 | namespace protocol 27 | { 28 | 29 | class ZAPI_DECL_EXPORT Countable 30 | { 31 | public: 32 | virtual zapi_long count() = 0; 33 | virtual ~Countable() 34 | {} 35 | }; 36 | 37 | } // protocol 38 | } // zapi 39 | 40 | 41 | #endif // ZAPI_PROTOCOL_COUNTABLE_H 42 | -------------------------------------------------------------------------------- /include/zapi/protocol/Interfaces.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/22. 15 | 16 | #ifndef ZAPI_VM_INTERFACES_H 17 | #define ZAPI_VM_INTERFACES_H 18 | 19 | #include "zapi/Global.h" 20 | 21 | namespace zapi 22 | { 23 | 24 | // forward declare with namespace 25 | namespace kernel 26 | { 27 | class AbstractIterator; 28 | } // kernel 29 | 30 | namespace ds 31 | { 32 | class Variant; 33 | } // ds 34 | 35 | namespace vm 36 | { 37 | 38 | using zapi::kernel::AbstractIterator; 39 | using zapi::ds::Variant; 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | } // vm 48 | } // zapi 49 | 50 | #endif // ZAPI_VM_INTERFACES_H -------------------------------------------------------------------------------- /include/zapi/protocol/Serializable.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/23. 18 | 19 | #ifndef ZAPI_PROTOCOL_SERIALIZABLE_H 20 | #define ZAPI_PROTOCOL_SERIALIZABLE_H 21 | 22 | #include "zapi/Global.h" 23 | 24 | namespace zapi 25 | { 26 | namespace protocol 27 | { 28 | 29 | class ZAPI_DECL_EXPORT Serializable 30 | { 31 | public: 32 | virtual std::string serialize() = 0; 33 | virtual void unserialize(const char *input, size_t size) = 0; 34 | virtual ~Serializable() 35 | {} 36 | }; 37 | 38 | } // protocol 39 | } // zapi 40 | 41 | 42 | #endif // ZAPI_PROTOCOL_SERIALIZABLE_H 43 | -------------------------------------------------------------------------------- /include/zapi/protocol/Traversable.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/23. 18 | 19 | #ifndef ZAPI_PROTOCOL_TRAVERSABLE_H 20 | #define ZAPI_PROTOCOL_TRAVERSABLE_H 21 | 22 | #include "zapi/Global.h" 23 | 24 | namespace zapi 25 | { 26 | namespace protocol 27 | { 28 | 29 | class AbstractIterator; 30 | 31 | class ZAPI_DECL_EXPORT Traversable 32 | { 33 | public: 34 | virtual AbstractIterator *getIterator() = 0; 35 | virtual ~Traversable() 36 | {} 37 | }; 38 | 39 | } // protocol 40 | } // zapi 41 | 42 | 43 | #endif // ZAPI_PROTOCOL_TRAVERSABLE_H 44 | -------------------------------------------------------------------------------- /include/zapi/stdext/Functional.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/08/24. 15 | // 16 | 17 | #ifndef ZAPI_STDEXT_FUNCTIONAL_H 18 | #define ZAPI_STDEXT_FUNCTIONAL_H 19 | 20 | #include "zapi/stdext/internal/FunctionalPrivate.h" 21 | 22 | namespace zapi 23 | { 24 | namespace stdext 25 | { 26 | 27 | template 28 | typename std::result_of::type 29 | invoke(FuncType&& func, ArgTypes&& ...args) 30 | noexcept(noexcept(internal::invoke(std::forward(func), std::forward(args)...))) 31 | { 32 | return internal::invoke(std::forward(func), std::forward(args)...); 33 | } 34 | 35 | } // stdext 36 | } // zapi 37 | 38 | #endif // ZAPI_STDEXT_FUNCTIONAL_H -------------------------------------------------------------------------------- /include/zapi/stdext/internal/FunctionalPrivate.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/08/24. 15 | // 16 | 17 | #ifndef ZAPI_STDEXT_INTERNAL_FUNCTIONAL_PRIVATE_H 18 | #define ZAPI_STDEXT_INTERNAL_FUNCTIONAL_PRIVATE_H 19 | 20 | #include 21 | #include 22 | #include "zapi/stdext/TypeTraits.h" 23 | 24 | namespace zapi 25 | { 26 | namespace stdext 27 | { 28 | namespace internal 29 | { 30 | 31 | template 32 | struct has_result_type 33 | { 34 | private: 35 | struct TwoMark { 36 | char c; 37 | char c2; 38 | }; 39 | template 40 | static TwoMark test(...); 41 | template 42 | static char test(typename SourcePointer::result_type * = nullptr); 43 | public: 44 | static const bool value = sizeof(test(nullptr)) == 1; 45 | }; 46 | 47 | } // internal 48 | } // stdext 49 | } // zapi 50 | 51 | #endif // ZAPI_STDEXT_INTERNAL_FUNCTIONAL_PRIVATE_H -------------------------------------------------------------------------------- /include/zapi/utils/CommonFuncs.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/10. 15 | 16 | #ifndef ZAPI_UTILS_COMMON_FUNCS_H 17 | #define ZAPI_UTILS_COMMON_FUNCS_H 18 | 19 | #include "zapi/Global.h" 20 | 21 | namespace zapi 22 | { 23 | // forward declare with namespace 24 | namespace ds 25 | { 26 | class Variant; 27 | } // ds 28 | } // zapi 29 | // end forward declare 30 | 31 | namespace zapi 32 | { 33 | namespace utils 34 | { 35 | 36 | ZAPI_DECL_EXPORT void std_php_memory_deleter(void *ptr); 37 | ZAPI_DECL_EXPORT void std_zend_string_deleter(zend_string *str); 38 | ZAPI_DECL_EXPORT void std_zend_string_force_deleter(zend_string *str); 39 | 40 | ZAPI_DECL_EXPORT char *str_toupper(char *str) ZAPI_DECL_NOEXCEPT; 41 | ZAPI_DECL_EXPORT char *str_toupper(char *str, size_t length) ZAPI_DECL_NOEXCEPT; 42 | ZAPI_DECL_EXPORT std::string &str_toupper(std::string &str) ZAPI_DECL_NOEXCEPT; 43 | ZAPI_DECL_EXPORT char *str_tolower(char *str) ZAPI_DECL_NOEXCEPT; 44 | ZAPI_DECL_EXPORT char *str_tolower(char *str, size_t length) ZAPI_DECL_NOEXCEPT; 45 | ZAPI_DECL_EXPORT std::string &str_tolower(std::string &str) ZAPI_DECL_NOEXCEPT; 46 | ZAPI_DECL_EXPORT std::string get_zval_type_str(const zval *valuePtr) ZAPI_DECL_NOEXCEPT; 47 | ZAPI_DECL_EXPORT bool zval_type_is_valid(const zval *valuePtr) ZAPI_DECL_NOEXCEPT; 48 | 49 | struct ZAPI_DECL_EXPORT VariantKeyLess 50 | { 51 | bool operator ()(const zapi::ds::Variant &lhs, const zapi::ds::Variant &rhs) const; 52 | }; 53 | 54 | } // utils 55 | } // zapi 56 | 57 | #endif // ZAPI_UTILS_COMMON_FUNCS_H -------------------------------------------------------------------------------- /include/zapi/utils/InternalFuncs.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #ifndef ZAPI_UTILS_INTERNAL_FUNCS_H 17 | #define ZAPI_UTILS_INTERNAL_FUNCS_H 18 | 19 | #include 20 | #include 21 | 22 | namespace zapi 23 | { 24 | namespace internal 25 | { 26 | 27 | bool parse_namespaces(const std::string &ns, std::list &parts); 28 | 29 | } // internal 30 | } // zapi 31 | 32 | #endif // ZAPI_UTILS_INTERNAL_FUNCS_H 33 | -------------------------------------------------------------------------------- /include/zapi/vm/AbstractMember.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/02. 15 | 16 | #ifndef ZAPI_VM_ABSTRACT_MEMBER_H 17 | #define ZAPI_VM_ABSTRACT_MEMBER_H 18 | 19 | #include "zapi/Global.h" 20 | 21 | // forward declare with namespace 22 | namespace zapi 23 | { 24 | namespace vm 25 | { 26 | namespace internal 27 | { 28 | class AbstractMemberPrivate; 29 | class AbstractClassPrivate; 30 | } // internal 31 | } // vm 32 | } // zapi 33 | // end forward declare 34 | 35 | namespace zapi 36 | { 37 | namespace vm 38 | { 39 | 40 | using zapi::lang::Modifier; 41 | using zapi::vm::internal::AbstractMemberPrivate; 42 | 43 | class AbstractMember 44 | { 45 | public: 46 | AbstractMember(); 47 | AbstractMember(const char *name, Modifier flags); 48 | AbstractMember(const AbstractMember &other); 49 | AbstractMember(AbstractMember &&other) ZAPI_DECL_EXPORT; 50 | virtual ~AbstractMember(); 51 | AbstractMember &operator=(const AbstractMember &other); 52 | AbstractMember &operator=(AbstractMember &&other) ZAPI_DECL_EXPORT; 53 | protected: 54 | AbstractMember(AbstractMemberPrivate *implPtr); 55 | void initialize(zend_class_entry *entry); 56 | virtual void setupConstant(zend_class_entry *entry) = 0; 57 | virtual void setupProperty(zend_class_entry *entry) = 0; 58 | 59 | ZAPI_DECLARE_PRIVATE(AbstractMember) 60 | std::shared_ptr m_implPtr; 61 | friend class zapi::vm::internal::AbstractClassPrivate; 62 | }; 63 | 64 | } // vm 65 | } // zapi 66 | 67 | #endif // ZAPI_VM_ABSTRACT_MEMBER_H -------------------------------------------------------------------------------- /include/zapi/vm/BoolMember.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/04. 18 | 19 | #ifndef ZAPI_VM_BOOL_MEMBER_H 20 | #define ZAPI_VM_BOOL_MEMBER_H 21 | 22 | #include "zapi/vm/AbstractMember.h" 23 | 24 | namespace zapi 25 | { 26 | namespace vm 27 | { 28 | 29 | namespace internal 30 | { 31 | class BoolMemberPrivate; 32 | } // internal 33 | 34 | using internal::BoolMemberPrivate; 35 | 36 | class BoolMember : public AbstractMember 37 | { 38 | public: 39 | BoolMember(const char *name, double value, Modifier flags); 40 | BoolMember(const BoolMember &other); 41 | BoolMember &operator=(const BoolMember &other); 42 | virtual ~BoolMember(); 43 | protected: 44 | virtual void setupConstant(zend_class_entry *entry) override; 45 | virtual void setupProperty(zend_class_entry *entry) override; 46 | ZAPI_DECLARE_PRIVATE(BoolMember) 47 | }; 48 | 49 | } // vm 50 | } // zapi 51 | 52 | #endif // ZAPI_VM_BOOL_MEMBER_H 53 | -------------------------------------------------------------------------------- /include/zapi/vm/Closure.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/09/11. 18 | 19 | #ifndef ZAPI_VM_CLOSURE_H 20 | #define ZAPI_VM_CLOSURE_H 21 | 22 | #include 23 | #include "zapi/Global.h" 24 | #include "zapi/lang/StdClass.h" 25 | #include "zapi/stdext/TypeTraits.h" 26 | 27 | // forward declare class with namespace 28 | namespace zapi 29 | { 30 | namespace ds 31 | { 32 | class Variant; 33 | } // ds 34 | 35 | namespace lang 36 | { 37 | class Parameters; 38 | namespace internal 39 | { 40 | class ExtensionPrivate; 41 | } // internal 42 | } // lang 43 | } // zapi 44 | 45 | namespace zapi 46 | { 47 | namespace vm 48 | { 49 | 50 | using zapi::ds::Variant; 51 | using zapi::lang::internal::ExtensionPrivate; 52 | using zapi::lang::Parameters; 53 | using zapi::stdext::is_function_pointer; 54 | using ClosureCallableType = std::function; 55 | 56 | class Closure final : public zapi::lang::StdClass 57 | { 58 | public: 59 | Closure(const ClosureCallableType &callable); 60 | Variant __invoke(Parameters ¶ms) const; 61 | virtual ~Closure(); 62 | static zend_class_entry *getClassEntry(); 63 | private: 64 | static void registerToZendNg(int moduleNumber); 65 | static void unregisterFromZendNg(); 66 | private: 67 | friend class ExtensionPrivate; 68 | static zend_class_entry *m_entry; 69 | const ClosureCallableType m_callable; 70 | }; 71 | 72 | } // vm 73 | } // zapi 74 | 75 | #endif // ZAPI_VM_CLOSURE_H 76 | -------------------------------------------------------------------------------- /include/zapi/vm/Engine.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 26/07/2017. 15 | 16 | #ifndef ZAPI_VM_ENGING_H 17 | #define ZAPI_VM_ENGING_H 18 | 19 | #include "zapi/Global.h" 20 | #include "php/Zend/zend_compile.h" 21 | 22 | // forward declare with namespace 23 | namespace zapi 24 | { 25 | 26 | namespace ds 27 | { 28 | class Variant; 29 | } // ds 30 | } // zapi 31 | // end forward declare 32 | 33 | namespace zapi 34 | { 35 | namespace vm 36 | { 37 | 38 | using zapi::ds::Variant; 39 | 40 | class ZAPI_DECL_EXPORT Engine 41 | { 42 | public: 43 | 44 | enum class ScriptExecuteType : unsigned int 45 | { 46 | Eval = ZEND_EVAL, 47 | Include = ZEND_INCLUDE, 48 | IncludeOnce = ZEND_INCLUDE_ONCE, 49 | Require = ZEND_REQUIRE, 50 | RequireOnce = ZEND_REQUIRE_ONCE 51 | }; 52 | 53 | public: 54 | static Variant eval(const std::string &code); 55 | private: 56 | static Variant executeOpCodes(std::shared_ptr opcodes); 57 | }; 58 | 59 | } // vm 60 | } // zapi 61 | 62 | #endif // ZAPI_VM_ENGING_H -------------------------------------------------------------------------------- /include/zapi/vm/ExecStateGuard.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 26/07/2017. 15 | 16 | #ifndef ZAPI_VM_EXEC_STATE_GUARD_H 17 | #define ZAPI_VM_EXEC_STATE_GUARD_H 18 | 19 | #include "zapi/Global.h" 20 | #include "php/Zend/zend_compile.h" 21 | 22 | namespace zapi 23 | { 24 | namespace vm 25 | { 26 | 27 | class ExecStateGuard 28 | { 29 | public: 30 | ExecStateGuard() = delete; 31 | ExecStateGuard(int noExtensions) 32 | { 33 | m_activeOpArray = CG(active_op_array) ? CG(active_op_array) : nullptr; 34 | m_retValue = EG(current_execute_data) ? EG(current_execute_data)->return_value: nullptr; 35 | m_opline = EG(current_execute_data) ? EG(current_execute_data)->opline : nullptr; 36 | m_noExtensions = noExtensions; 37 | } 38 | 39 | ~ExecStateGuard() 40 | { 41 | EG(no_extensions) = m_noExtensions; 42 | if (EG(current_execute_data)) { 43 | EG(current_execute_data)->opline = m_opline; 44 | EG(current_execute_data)->return_value = m_retValue; 45 | } 46 | CG(active_op_array) = m_activeOpArray; 47 | } 48 | 49 | private: 50 | zend_op_array *m_activeOpArray; 51 | zval *m_retValue; 52 | const zend_op *m_opline; 53 | int m_noExtensions; 54 | }; 55 | 56 | } // vm 57 | } // zapi 58 | 59 | #endif // ZAPI_VM_EXEC_STATE_GUARD_H -------------------------------------------------------------------------------- /include/zapi/vm/FloatMember.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/04. 18 | 19 | #ifndef ZAPI_VM_FLOAT_MEMBER_H 20 | #define ZAPI_VM_FLOAT_MEMBER_H 21 | 22 | #include "zapi/vm/AbstractMember.h" 23 | 24 | namespace zapi 25 | { 26 | namespace vm 27 | { 28 | 29 | namespace internal 30 | { 31 | class FloatMemberPrivate; 32 | } // internal 33 | 34 | using internal::FloatMemberPrivate; 35 | 36 | class FloatMember : public AbstractMember 37 | { 38 | public: 39 | FloatMember(const char *name, double value, Modifier flags); 40 | FloatMember(const FloatMember &other); 41 | FloatMember &operator=(const FloatMember &other); 42 | virtual ~FloatMember(); 43 | protected: 44 | virtual void setupConstant(zend_class_entry *entry) override; 45 | virtual void setupProperty(zend_class_entry *entry) override; 46 | ZAPI_DECLARE_PRIVATE(FloatMember) 47 | }; 48 | 49 | } // vm 50 | } // zapi 51 | 52 | #endif // ZAPI_VM_FLOAT_MEMBER_H 53 | -------------------------------------------------------------------------------- /include/zapi/vm/IteratorBridge.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/03. 15 | 16 | #ifndef ZAPI_VM_ITERATOR_BRIDGE_H 17 | #define ZAPI_VM_ITERATOR_BRIDGE_H 18 | 19 | #include "zapi/Global.h" 20 | #include "zapi/ds/Variant.h" 21 | 22 | // forward declare with namespace 23 | namespace zapi 24 | { 25 | 26 | namespace protocol 27 | { 28 | class AbstractIterator; 29 | } // protocol 30 | 31 | } // zapi 32 | // end forward declare 33 | 34 | namespace zapi 35 | { 36 | namespace vm 37 | { 38 | 39 | using zapi::protocol::AbstractIterator; 40 | using zapi::ds::Variant; 41 | 42 | class IteratorBridge 43 | { 44 | public: 45 | IteratorBridge(zval *object, AbstractIterator *iterator); 46 | ~IteratorBridge(); 47 | zend_object_iterator *getZendIterator(); 48 | static zend_object_iterator_funcs *getIteratorFuncs(); 49 | private: 50 | bool valid(); 51 | Variant ¤t(); 52 | Variant key(); 53 | void next(); 54 | void rewind(); 55 | void invalidate(); 56 | private: 57 | static IteratorBridge *getSelfPtr(zend_object_iterator *iterator); 58 | static void destructor(zend_object_iterator *iterator); 59 | static int valid(zend_object_iterator *iterator); 60 | static zval *current(zend_object_iterator *iterator); 61 | static void key(zend_object_iterator *iterator, zval *data); 62 | static void next(zend_object_iterator *iterator); 63 | static void rewind(zend_object_iterator *iterator); 64 | static void invalidate(zend_object_iterator *iterator); 65 | private: 66 | zend_object_iterator m_iterator; 67 | AbstractIterator *m_userspaceIterator; 68 | Variant m_current; 69 | }; 70 | 71 | } // vm 72 | } // zapi 73 | 74 | #endif // ZAPI_VM_ITERATOR_BRIDGE_H 75 | -------------------------------------------------------------------------------- /include/zapi/vm/NullMember.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/04. 18 | 19 | #ifndef ZAPI_VM_NULL_MEMBER_H 20 | #define ZAPI_VM_NULL_MEMBER_H 21 | 22 | #include "zapi/vm/AbstractMember.h" 23 | 24 | namespace zapi 25 | { 26 | namespace vm 27 | { 28 | 29 | class NullMember : public AbstractMember 30 | { 31 | public: 32 | NullMember(const char *name, Modifier flags); 33 | virtual ~NullMember(); 34 | protected: 35 | virtual void setupConstant(zend_class_entry *entry); 36 | virtual void setupProperty(zend_class_entry *entry); 37 | }; 38 | 39 | } // vm 40 | } // zapi 41 | 42 | #endif // ZAPI_VM_NULL_MEMBER_H 43 | -------------------------------------------------------------------------------- /include/zapi/vm/NumericMember.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/04. 18 | 19 | #ifndef ZAPI_VM_NUMERIC_MEMBER_H 20 | #define ZAPI_VM_NUMERIC_MEMBER_H 21 | 22 | #include "zapi/vm/AbstractMember.h" 23 | 24 | namespace zapi 25 | { 26 | namespace vm 27 | { 28 | namespace internal 29 | { 30 | class NumericMemberPrivate; 31 | } // internal 32 | using internal::NumericMemberPrivate; 33 | class NumericMember : public AbstractMember 34 | { 35 | public: 36 | NumericMember(const char *name, double value, Modifier flags); 37 | NumericMember(const NumericMember &other); 38 | NumericMember &operator=(const NumericMember &other); 39 | virtual ~NumericMember(); 40 | protected: 41 | virtual void setupConstant(zend_class_entry *entry) override; 42 | virtual void setupProperty(zend_class_entry *entry) override; 43 | ZAPI_DECLARE_PRIVATE(NumericMember) 44 | }; 45 | 46 | } // vm 47 | } // zapi 48 | 49 | #endif // ZAPI_VM_NUMERIC_MEMBER_H 50 | -------------------------------------------------------------------------------- /include/zapi/vm/ObjectBinder.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/03. 15 | 16 | #ifndef ZAPI_VM_OBJECT_BINDER_H 17 | #define ZAPI_VM_OBJECT_BINDER_H 18 | 19 | #include "zapi/Global.h" 20 | 21 | namespace zapi 22 | { 23 | 24 | namespace lang 25 | { 26 | class StdClass; 27 | } // lang 28 | 29 | namespace vm 30 | { 31 | 32 | using zapi::lang::StdClass; 33 | class ObjectBinder 34 | { 35 | public: 36 | ObjectBinder(zend_class_entry *entry, std::shared_ptr nativeObject, 37 | const zend_object_handlers *objectHandlers, uint32_t refCount); 38 | ~ObjectBinder(); 39 | void destroy(); 40 | zend_object *getZendObject() const; 41 | StdClass *getNativeObject() const; 42 | static ObjectBinder *retrieveSelfPtr(const zend_object *object); 43 | static ObjectBinder *retrieveSelfPtr(zval *object); 44 | static constexpr size_t calculateZendObjectOffset() 45 | { 46 | return offsetof(Container, m_zendObject); 47 | } 48 | 49 | private: 50 | struct Container 51 | { 52 | ObjectBinder *m_self; 53 | zend_object m_zendObject; 54 | } *m_container; 55 | std::shared_ptr m_nativeObject; 56 | }; 57 | 58 | } // vm 59 | } // zapi 60 | 61 | #endif // ZAPI_VM_OBJECT_BINDER_H 62 | -------------------------------------------------------------------------------- /include/zapi/vm/StringMember.h: -------------------------------------------------------------------------------- 1 | // @copyright 2013, 2014 Copernica BV 2 | // Emiel Bruijntjes 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 6 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 7 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 8 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 9 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 10 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 11 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 12 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 13 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 14 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 15 | // 16 | // Created by softboy on 2017/08/02. 17 | 18 | #ifndef ZAPI_VM_STRING_MEMBER_H 19 | #define ZAPI_VM_STRING_MEMBER_H 20 | 21 | #include "zapi/Global.h" 22 | #include "zapi/vm/AbstractMember.h" 23 | 24 | namespace zapi 25 | { 26 | namespace vm 27 | { 28 | 29 | namespace internal 30 | { 31 | class StringMemberPrivate; 32 | } // internal 33 | 34 | using zapi::vm::AbstractMember; 35 | using zapi::vm::internal::StringMemberPrivate; 36 | 37 | class ZAPI_DECL_EXPORT StringMember : public AbstractMember 38 | { 39 | public: 40 | StringMember(const char *name, const char *value, size_t size, Modifier flags); 41 | StringMember(const char *name, const char *value, Modifier flags); 42 | StringMember(const char *name, const std::string &value, Modifier flags); 43 | StringMember(const StringMember &other); 44 | StringMember &operator=(const StringMember &other); 45 | virtual ~StringMember(); 46 | protected: 47 | virtual void setupConstant(zend_class_entry *entry) override; 48 | virtual void setupProperty(zend_class_entry *entry) override; 49 | ZAPI_DECLARE_PRIVATE(StringMember) 50 | }; 51 | 52 | } // vm 53 | } // zapi 54 | 55 | #endif // ZAPI_VM_STRING_MEMBER_H 56 | -------------------------------------------------------------------------------- /include/zapi/vm/ZValMember.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/09/01. 15 | 16 | #ifndef ZAPI_VM_ZVAL_MEMBER_H 17 | #define ZAPI_VM_ZVAL_MEMBER_H 18 | 19 | #include "zapi/vm/AbstractMember.h" 20 | 21 | namespace zapi 22 | { 23 | namespace vm 24 | { 25 | 26 | namespace internal 27 | { 28 | class ZvalMemberPrivate; 29 | } // internal 30 | 31 | using zapi::vm::AbstractMember; 32 | using zapi::vm::internal::ZvalMemberPrivate; 33 | 34 | class ZAPI_DECL_EXPORT ZvalMember : public AbstractMember 35 | { 36 | public: 37 | ZvalMember(const char *name, zval *value, Modifier flags); 38 | ZvalMember(const ZvalMember &other); 39 | ZvalMember &operator=(const ZvalMember &other); 40 | virtual ~ZvalMember(); 41 | protected: 42 | virtual void setupConstant(zend_class_entry *entry) override; 43 | virtual void setupProperty(zend_class_entry *entry) override; 44 | ZAPI_DECLARE_PRIVATE(ZvalMember) 45 | }; 46 | 47 | 48 | } // vm 49 | } // zapi 50 | 51 | #endif // ZAPI_VM_ZVAL_MEMBER_H -------------------------------------------------------------------------------- /include/zapi/vm/internal/AbstractMemberPrivate.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/02. 15 | 16 | #ifndef ZAPI_VM_INTERNAL_ABSTRACT_MEMBER_PRIVATE_H 17 | #define ZAPI_VM_INTERNAL_ABSTRACT_MEMBER_PRIVATE_H 18 | 19 | #include "zapi/Global.h" 20 | #include 21 | 22 | namespace zapi 23 | { 24 | namespace vm 25 | { 26 | namespace internal 27 | { 28 | 29 | using zapi::lang::Modifier; 30 | 31 | class AbstractMemberPrivate 32 | { 33 | public: 34 | AbstractMemberPrivate(std::string name, Modifier flags) 35 | : m_flags(flags), 36 | m_name(name) 37 | {} 38 | 39 | Modifier m_flags; 40 | std::string m_name; 41 | }; 42 | 43 | } // internal 44 | } // vm 45 | } // zapi 46 | 47 | #endif // ZAPI_VM_INTERNAL_ABSTRACT_MEMBER_PRIVATE_H -------------------------------------------------------------------------------- /include/zapi/vm/internal/CallablePrivate.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 27/07/2017. 15 | 16 | #ifndef ZAPI_VM_INTERNAL_CALLABLE_PRIVATE_H 17 | #define ZAPI_VM_INTERNAL_CALLABLE_PRIVATE_H 18 | 19 | #include "zapi/Global.h" 20 | #include "zapi/lang/Argument.h" 21 | 22 | // forware declare with namespace 23 | namespace zapi 24 | { 25 | namespace lang 26 | { 27 | class Argument; 28 | } // lang 29 | } // zapi 30 | // end forware declare 31 | 32 | namespace zapi 33 | { 34 | namespace vm 35 | { 36 | namespace internal 37 | { 38 | 39 | using zapi::lang::Type; 40 | using zapi::lang::Argument; 41 | using zapi::lang::Arguments; 42 | 43 | class CallablePrivate 44 | { 45 | public: 46 | CallablePrivate(const char *name, ZendCallable callable, const Arguments &arguments); 47 | CallablePrivate(const char *name, const Arguments &arguments); 48 | void setupCallableArgInfo(zend_internal_arg_info *info, const Argument &arg) const; 49 | void initialize(zend_function_entry *entry, const char *className = nullptr, int flags = 0) const; 50 | void initialize(zend_internal_function_info *info, const char *className = nullptr) const; 51 | void initialize(const std::string &prefix, zend_function_entry *entry); 52 | CallablePrivate &operator=(const CallablePrivate &other); 53 | CallablePrivate &operator=(CallablePrivate &&other) ZAPI_DECL_NOEXCEPT; 54 | zapi::ZendCallable m_callable; 55 | std::string m_name; 56 | Type m_returnType = Type::Undefined; 57 | uint32_t m_required = 0; 58 | std::string m_retClsName; 59 | int m_argc = 0; 60 | std::unique_ptr m_argv; 61 | }; 62 | 63 | } // internal 64 | } // vm 65 | } // zapi 66 | 67 | #endif // ZAPI_VM_INTERNAL_CALLABLE_PRIVATE_H 68 | -------------------------------------------------------------------------------- /scripts/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_custom_target(scripts 2 | SOURCES 3 | build/retrieve_php_info.php) 4 | -------------------------------------------------------------------------------- /src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(ZAPI_SRC 2 | Global.cpp 3 | kernel/Meta.cpp 4 | kernel/StreamBuffer.cpp 5 | kernel/FatalError.cpp 6 | kernel/Exception.cpp 7 | protocol/AbstractIterator.cpp 8 | protocol/ArrayAccess.cpp 9 | lang/Extension.cpp 10 | lang/Ini.cpp 11 | lang/Class.cpp 12 | lang/Interface.cpp 13 | lang/Method.cpp 14 | lang/Parameters.cpp 15 | lang/Function.cpp 16 | lang/Argument.cpp 17 | lang/Constant.cpp 18 | lang/Namespace.cpp 19 | lang/Method.cpp 20 | lang/Type.cpp 21 | lang/StdClass.cpp 22 | ds/Variant.cpp 23 | ds/StringVariant.cpp 24 | ds/BoolVariant.cpp 25 | ds/NumericVariant.cpp 26 | ds/DoubleVariant.cpp 27 | ds/ObjectVariant.cpp 28 | ds/CallableVariant.cpp 29 | ds/ArrayVariant.cpp 30 | ds/ArrayItemProxy.cpp 31 | vm/AbstractClass.cpp 32 | vm/AbstractMember.cpp 33 | vm/ZValMember.cpp 34 | vm/StringMember.cpp 35 | vm/BoolMember.cpp 36 | vm/FloatMember.cpp 37 | vm/NumericMember.cpp 38 | vm/NullMember.cpp 39 | vm/Property.cpp 40 | vm/InvokeBridge.cpp 41 | vm/Callable.cpp 42 | vm/Engine.cpp 43 | vm/IteratorBridge.cpp 44 | vm/ObjectBinder.cpp 45 | vm/Closure.cpp 46 | utils/PhpFuncs.cpp 47 | utils/CommonFuncs.cpp 48 | utils/InternalFuncs.cpp 49 | ) 50 | 51 | if(BUILD_SHARED_LIBS) 52 | set(ZAPI_BUILD_TYPE SHARED) 53 | else() 54 | set(ZAPI_BUILD_TYPE STATIC) 55 | endif() 56 | zapi_add_library(${ZAPI_PROJECT_NAME} ${ZAPI_BUILD_TYPE} ${ZAPI_SRC} ${ZAPI_PUBLIC_HEADERS}) 57 | 58 | # setup zapi property 59 | target_compile_options(${ZAPI_PROJECT_NAME} 60 | INTERFACE -Wno-deprecated-declarations 61 | INTERFACE -Wno-macro-redefined) 62 | 63 | if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") 64 | target_compile_options(${ZAPI_PROJECT_NAME} 65 | INTERFACE -stdlib=libc++) 66 | endif() 67 | 68 | target_include_directories(${ZAPI_PROJECT_NAME} BEFORE INTERFACE ${ZAPI_PHP_INCLUDE_PATHS}) 69 | target_include_directories(${ZAPI_PROJECT_NAME} BEFORE INTERFACE ${ZAPI_INSTALL_INCLUDE_DIR}) 70 | 71 | export(TARGETS ${ZAPI_PROJECT_NAME} 72 | FILE "${ZAPI_BINARY_DIR}/zendAPITargets.cmake") 73 | export(PACKAGE ${ZAPI_PROJECT_NAME}) 74 | 75 | file(RELATIVE_PATH 76 | REL_INCLUDE_DIR 77 | "${ZAPI_INSTALL_CMAKE_DIR}" 78 | "${ZAPI_INSTALL_INCLUDE_DIR}") 79 | 80 | # 81 | # Install targets 82 | # 83 | install(TARGETS ${ZAPI_PROJECT_NAME} 84 | EXPORT zendAPITargets 85 | RUNTIME DESTINATION "${ZAPI_INSTALL_BIN_DIR}" COMPONENT bin 86 | LIBRARY DESTINATION "${ZAPI_INSTALL_LIB_DIR}" COMPONENT lib 87 | ARCHIVE DESTINATION "${ZAPI_INSTALL_LIB_DIR}" COMPONENT lib) 88 | 89 | # Install exports for the install-tree. 90 | install(EXPORT zendAPITargets 91 | DESTINATION 92 | "${ZAPI_INSTALL_CMAKE_DIR}" 93 | COMPONENT dev) 94 | -------------------------------------------------------------------------------- /src/Global.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 05/06/2017. 15 | 16 | #include "zapi/Global.h" 17 | 18 | #include 19 | #include "zapi/kernel/StreamBuffer.h" 20 | 21 | namespace zapi 22 | { 23 | using zapi::kernel::StreamBuffer; 24 | 25 | void assert_x(const char *where, const char *what, const char *file, int line) ZAPI_DECL_NOEXCEPT 26 | { 27 | std::cerr << "ASSERT failure in " << where << ": \"" << what 28 | << "\", file " << file << ", line "<< line << std::endl; 29 | } 30 | 31 | StreamBuffer bufferOut(0); 32 | StreamBuffer bufferError(E_ERROR); 33 | StreamBuffer bufferWarning(E_WARNING); 34 | StreamBuffer bufferNotice(E_NOTICE); 35 | StreamBuffer bufferDeprecated(E_DEPRECATED); 36 | 37 | std::ostream out(&bufferOut); 38 | std::ostream error(&bufferError); 39 | std::ostream warning(&bufferWarning); 40 | std::ostream notice(&bufferNotice); 41 | std::ostream deprecated(&bufferDeprecated); 42 | 43 | } // zapi -------------------------------------------------------------------------------- /src/kernel/FatalError.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/06/07. 15 | 16 | #include "php/Zend/zend.h" 17 | #include "zapi/kernel/FatalError.h" 18 | 19 | namespace zapi 20 | { 21 | namespace kernel 22 | { 23 | 24 | /** 25 | * Report this error as a fatal error 26 | * @return bool 27 | */ 28 | bool FatalError::report() const 29 | { 30 | zend_error(E_ERROR, "%s", what()); 31 | return true; 32 | } 33 | 34 | } // kernel 35 | } // zapi -------------------------------------------------------------------------------- /src/kernel/Meta.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 25/07/2017. 15 | 16 | namespace zapi 17 | { 18 | namespace kernel 19 | { 20 | 21 | } 22 | } // zapi 23 | -------------------------------------------------------------------------------- /src/kernel/StreamBuffer.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 26/07/2017. 15 | 16 | #include 17 | #include "zapi/kernel/StreamBuffer.h" 18 | 19 | namespace zapi 20 | { 21 | namespace kernel 22 | { 23 | 24 | StreamBuffer::StreamBuffer(int error) 25 | : m_error(error) 26 | { 27 | setp(m_buffer.begin(), m_buffer.end()); 28 | } 29 | 30 | int StreamBuffer::overflow(int c) 31 | { 32 | std::lock_guard guard(m_mutex); 33 | std::char_traits::int_type eof = std::char_traits::eof(); 34 | if (m_error) { 35 | return c; 36 | } 37 | if (c == eof) { 38 | return sync(), eof; 39 | } 40 | *pptr() = c; 41 | pbump(1); 42 | return sync() == -1 ? eof : c; 43 | } 44 | 45 | int StreamBuffer::sync() 46 | { 47 | std::lock_guard guard(m_mutex); 48 | size_t size = pptr() - pbase(); 49 | if (m_error) { 50 | zend_error(m_error, "%.*s", static_cast(size), pbase()); 51 | } else { 52 | zend_write(pbase(), size); 53 | } 54 | // reset the buffer 55 | pbump(-size); 56 | return 0; 57 | } 58 | 59 | StreamBuffer::~StreamBuffer() 60 | {} 61 | 62 | std::mutex StreamBuffer::m_mutex; 63 | 64 | } // kernel 65 | } // zapi -------------------------------------------------------------------------------- /src/lang/Class.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/07/27. -------------------------------------------------------------------------------- /src/lang/Function.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/07/27. 15 | 16 | #include "zapi/lang/Function.h" 17 | #include "zapi/vm/internal/CallablePrivate.h" 18 | #include "zapi/ds/Variant.h" 19 | 20 | namespace zapi 21 | { 22 | namespace lang 23 | { 24 | using zapi::vm::internal::CallablePrivate; 25 | 26 | class FunctionPrivate : public CallablePrivate 27 | { 28 | public: 29 | using CallablePrivate::CallablePrivate; 30 | }; 31 | 32 | Function::Function(const char *name, zapi::ZendCallable callable, const Arguments &arguments) 33 | : Callable(new FunctionPrivate(name, callable, arguments)) 34 | {} 35 | 36 | Function::Function(const char *name, const Arguments &arguments) 37 | : Callable(new FunctionPrivate(name, nullptr, arguments)) 38 | {} 39 | 40 | Function::Function(const Function &other) 41 | : Callable(other) 42 | { 43 | } 44 | 45 | Function &Function::operator=(const Function &other) 46 | { 47 | if (this != &other) { 48 | Callable::operator=(other); 49 | } 50 | return *this; 51 | } 52 | 53 | Variant Function::invoke(Parameters ¶meters) 54 | { 55 | // now we just do nothing 56 | return nullptr; 57 | } 58 | 59 | Function::~Function() 60 | {} 61 | 62 | } // lang 63 | } // zapi -------------------------------------------------------------------------------- /src/lang/Interface.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/07/27. 15 | 16 | #include "zapi/lang/Interface.h" 17 | 18 | namespace zapi 19 | { 20 | namespace lang 21 | { 22 | 23 | Interface::Interface(const char *name) 24 | : AbstractClass(name, ClassType::Interface) 25 | {} 26 | 27 | Interface::~Interface() 28 | {} 29 | 30 | Interface &Interface::registerMethod(const char *name, const Arguments arguments) 31 | { 32 | AbstractClass::registerMethod(name, Modifier::Abstract | Modifier::Public, arguments); 33 | return *this; 34 | } 35 | 36 | Interface &Interface::registerMethod(const char *name, Modifier flags, const Arguments arguments) 37 | { 38 | AbstractClass::registerMethod(name, (flags | Modifier::Public | Modifier::Abstract), arguments); 39 | return *this; 40 | } 41 | 42 | Interface &Interface::registerBaseInterface(const Interface &interface) 43 | { 44 | AbstractClass::registerInterface(interface); 45 | return *this; 46 | } 47 | 48 | } // lang 49 | } // zapi -------------------------------------------------------------------------------- /src/lang/Parameters.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 27/05/2017. 15 | 16 | #include "zapi/lang/Parameters.h" 17 | #include "zapi/vm/ObjectBinder.h" 18 | 19 | namespace zapi 20 | { 21 | namespace lang 22 | { 23 | 24 | using zapi::vm::ObjectBinder; 25 | 26 | Parameters::Parameters(zval *thisPtr, uint32_t argc) 27 | : Parameters(nullptr != thisPtr ? ObjectBinder::retrieveSelfPtr(thisPtr)->getNativeObject() : nullptr) 28 | { 29 | m_data.reserve(argc); 30 | std::unique_ptr arguments(new zval[argc]); 31 | zend_get_parameters_array_ex(argc, arguments.get()); 32 | for (uint32_t i = 0; i < argc; i++) 33 | { 34 | // append value 35 | m_data.emplace_back(&arguments[i]); 36 | } 37 | } 38 | 39 | Parameters::Reference Parameters::at(SizeType pos) 40 | { 41 | return m_data.at(pos); 42 | } 43 | 44 | Parameters::ConstReference Parameters::at(SizeType pos) const 45 | { 46 | return m_data.at(pos); 47 | } 48 | 49 | bool Parameters::empty() const ZAPI_DECL_NOEXCEPT 50 | { 51 | return m_data.empty(); 52 | } 53 | 54 | Parameters::SizeType Parameters::size() const ZAPI_DECL_NOEXCEPT 55 | { 56 | return m_data.size(); 57 | } 58 | 59 | } // lang 60 | } // zapi 61 | -------------------------------------------------------------------------------- /src/lang/Type.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/07/26. 15 | 16 | #include "zapi/lang/Type.h" 17 | 18 | namespace zapi 19 | { 20 | namespace lang 21 | { 22 | 23 | Modifier operator~(Modifier modifier) 24 | { 25 | return static_cast(~static_cast(modifier)); 26 | } 27 | 28 | Modifier operator|(Modifier left, Modifier right) 29 | { 30 | return static_cast(static_cast(left) | static_cast(right)); 31 | } 32 | 33 | Modifier operator&(Modifier left, Modifier right) 34 | { 35 | return static_cast(static_cast(left) & static_cast(right)); 36 | } 37 | 38 | Modifier &operator|=(Modifier &left, Modifier right) 39 | { 40 | left = static_cast(static_cast(left) | static_cast(right)); 41 | return left; 42 | } 43 | 44 | Modifier &operator&=(Modifier &left, Modifier right) 45 | { 46 | left = static_cast(static_cast(left) & static_cast(right)); 47 | return left; 48 | } 49 | 50 | bool operator==(unsigned long value, Modifier right) 51 | { 52 | return static_cast(right) == value; 53 | } 54 | 55 | bool operator==(Modifier left, unsigned long value) 56 | { 57 | return static_cast(left) == value; 58 | } 59 | 60 | bool operator==(Modifier left, Modifier right) 61 | { 62 | return static_cast(left) == static_cast(right); 63 | } 64 | 65 | } // lang 66 | } // zapi 67 | -------------------------------------------------------------------------------- /src/protocol/AbstractIterator.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/03. 15 | 16 | #include "zapi/protocol/AbstractIterator.h" 17 | 18 | namespace zapi 19 | { 20 | namespace protocol 21 | { 22 | namespace internal 23 | { 24 | 25 | using zapi::ds::Variant; 26 | using zapi::lang::StdClass; 27 | 28 | class AbstractIteratorPrivate 29 | { 30 | public: 31 | AbstractIteratorPrivate(StdClass *nativeObject) 32 | : m_object(nativeObject) 33 | {} 34 | // here we just prevent during iterator zend_object being destroy 35 | // any better method to do this 36 | Variant m_object; 37 | }; 38 | 39 | } // internal 40 | 41 | AbstractIterator::AbstractIterator(StdClass *nativeObject) 42 | : m_implPtr(new AbstractIteratorPrivate(nativeObject)) 43 | {} 44 | 45 | AbstractIterator::~AbstractIterator() 46 | {} 47 | 48 | } // protocol 49 | } // zapi 50 | -------------------------------------------------------------------------------- /src/protocol/ArrayAccess.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/23. 15 | 16 | #include "zapi/protocol/ArrayAccess.h" 17 | 18 | namespace zapi 19 | { 20 | namespace protocol 21 | { 22 | 23 | ArrayAccess::~ArrayAccess() 24 | {} 25 | 26 | } // protocol 27 | } // zapi -------------------------------------------------------------------------------- /src/utils/InternalFuncs.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #include "zapi/utils/InternalFuncs.h" 17 | 18 | namespace zapi 19 | { 20 | namespace internal 21 | { 22 | 23 | bool parse_namespaces(const std::string &ns, std::list &parts) 24 | { 25 | std::string::size_type markPos = 0; 26 | int cycleSepCount = 0; 27 | std::string::value_type curChar; 28 | std::string::size_type len = ns.size(); 29 | if (0 == len) { 30 | return true; 31 | } 32 | if (ns[len - 1] == ':') { 33 | return false; 34 | } 35 | std::string::size_type i = 0; 36 | for (; i < ns.size(); i++) { 37 | curChar = ns[i]; 38 | if (':' == curChar) { 39 | if (cycleSepCount == 0 && (i - markPos > 0)) { 40 | parts.push_back(ns.substr(markPos, i - markPos)); 41 | } 42 | cycleSepCount++; 43 | } else { 44 | if (cycleSepCount == 1 || cycleSepCount > 2) { 45 | parts.clear(); 46 | return false; 47 | } else if (cycleSepCount == 2) { 48 | markPos = i; 49 | cycleSepCount = 0; 50 | } 51 | } 52 | } 53 | if (i > markPos) { 54 | parts.push_back(ns.substr(markPos, i - markPos)); 55 | } 56 | return true; 57 | } 58 | 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /src/vm/AbstractMember.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/02. 15 | 16 | #include "zapi/vm/AbstractMember.h" 17 | #include "zapi/vm/internal/AbstractMemberPrivate.h" 18 | 19 | namespace zapi 20 | { 21 | namespace vm 22 | { 23 | 24 | using zapi::vm::internal::AbstractMemberPrivate; 25 | 26 | AbstractMember::AbstractMember() 27 | {} 28 | 29 | AbstractMember::AbstractMember(const char *name, lang::Modifier flags) 30 | : m_implPtr(new AbstractMemberPrivate(name, flags)) 31 | {} 32 | 33 | AbstractMember::AbstractMember(const AbstractMember &other) 34 | : m_implPtr(other.m_implPtr) 35 | {} 36 | 37 | AbstractMember::AbstractMember(AbstractMember &&other) ZAPI_DECL_EXPORT 38 | : m_implPtr(std::move(other.m_implPtr)) 39 | {} 40 | 41 | AbstractMember::AbstractMember(AbstractMemberPrivate *implPtr) 42 | : m_implPtr(implPtr) 43 | {} 44 | 45 | AbstractMember &AbstractMember::operator=(const AbstractMember &other) 46 | { 47 | if (this != &other) { 48 | m_implPtr = other.m_implPtr; 49 | } 50 | return *this; 51 | } 52 | 53 | AbstractMember &AbstractMember::operator=(AbstractMember &&other) ZAPI_DECL_EXPORT 54 | { 55 | assert(this != &other); 56 | m_implPtr = std::move(other.m_implPtr); 57 | return *this; 58 | } 59 | 60 | void AbstractMember::initialize(zend_class_entry *entry) 61 | { 62 | ZAPI_D(AbstractMember); 63 | if (implPtr->m_flags == Modifier::Const) { 64 | setupConstant(entry); 65 | } else { 66 | setupProperty(entry); 67 | } 68 | } 69 | 70 | AbstractMember::~AbstractMember() 71 | {} 72 | 73 | } // vm 74 | } // zapi 75 | -------------------------------------------------------------------------------- /src/vm/BoolMember.cpp: -------------------------------------------------------------------------------- 1 | // @author Emiel Bruijntjes 2 | // @copyright 2014 Copernica BV 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/07/27. 18 | 19 | #include "zapi/vm/BoolMember.h" 20 | #include "zapi/vm/internal/AbstractMemberPrivate.h" 21 | 22 | namespace zapi 23 | { 24 | namespace vm 25 | { 26 | namespace internal 27 | { 28 | class BoolMemberPrivate : public AbstractMemberPrivate 29 | { 30 | public: 31 | BoolMemberPrivate(const char *name, double value, Modifier flags) 32 | : AbstractMemberPrivate(name, flags), 33 | m_value(value) 34 | {} 35 | BoolMemberPrivate(const BoolMemberPrivate &other) = default; 36 | bool m_value; 37 | }; 38 | 39 | } // internal 40 | 41 | using internal::BoolMemberPrivate; 42 | 43 | BoolMember::BoolMember(const char *name, double value, Modifier flags) 44 | : AbstractMember(new BoolMemberPrivate(name, value, flags)) 45 | {} 46 | 47 | BoolMember::BoolMember(const BoolMember &other) 48 | : AbstractMember(other) 49 | {} 50 | 51 | BoolMember &BoolMember::operator=(const BoolMember &other) 52 | { 53 | if (this != &other) { 54 | AbstractMember::operator=(other); 55 | } 56 | return *this; 57 | } 58 | 59 | void BoolMember::setupConstant(zend_class_entry *entry) 60 | { 61 | ZAPI_D(BoolMember); 62 | zend_declare_class_constant_bool(entry, implPtr->m_name.c_str(), implPtr->m_name.size(), 63 | implPtr->m_value); 64 | } 65 | 66 | void BoolMember::setupProperty(zend_class_entry *entry) 67 | { 68 | ZAPI_D(BoolMember); 69 | zend_declare_property_bool(entry, implPtr->m_name.c_str(), implPtr->m_name.size(), 70 | implPtr->m_value, static_cast(implPtr->m_flags)); 71 | } 72 | 73 | BoolMember::~BoolMember() 74 | {} 75 | 76 | } // vm 77 | } // zapi 78 | -------------------------------------------------------------------------------- /src/vm/Closure.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/09/11. 15 | 16 | #include "zapi/vm/Closure.h" 17 | #include "zapi/vm/AbstractClass.h" 18 | #include "zapi/lang/Class.h" 19 | 20 | namespace zapi 21 | { 22 | namespace vm 23 | { 24 | 25 | using zapi::lang::Class; 26 | using zapi::lang::ClassType; 27 | 28 | zend_class_entry *Closure::m_entry = nullptr; 29 | 30 | Closure::Closure(const ClosureCallableType &callable) 31 | : m_callable(callable) 32 | {} 33 | 34 | Variant Closure::__invoke(Parameters ¶ms) const 35 | { 36 | return m_callable(params); 37 | } 38 | 39 | void Closure::registerToZendNg(int moduleNumber) 40 | { 41 | // here we register ourself to zend engine 42 | if (m_entry) { 43 | return; 44 | } 45 | // @mark we save meta class as local static is really ok ? 46 | static std::unique_ptr closureWrapper(new Class("ZapiClosure", ClassType::Final)); 47 | m_entry = closureWrapper->initialize(moduleNumber); 48 | } 49 | 50 | void Closure::unregisterFromZendNg() 51 | { 52 | m_entry = nullptr; 53 | } 54 | 55 | zend_class_entry *Closure::getClassEntry() 56 | { 57 | return m_entry; 58 | } 59 | 60 | Closure::~Closure() 61 | {} 62 | 63 | } // vm 64 | } // zapi 65 | -------------------------------------------------------------------------------- /src/vm/FloatMember.cpp: -------------------------------------------------------------------------------- 1 | // @author Emiel Bruijntjes 2 | // @copyright 2014 Copernica BV 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/04. 18 | 19 | #include "zapi/vm/FloatMember.h" 20 | #include "zapi/vm/internal/AbstractMemberPrivate.h" 21 | 22 | namespace zapi 23 | { 24 | namespace vm 25 | { 26 | namespace internal 27 | { 28 | class FloatMemberPrivate : public AbstractMemberPrivate 29 | { 30 | public: 31 | FloatMemberPrivate(const char *name, double value, Modifier flags) 32 | : AbstractMemberPrivate(name, flags), 33 | m_value(value) 34 | {} 35 | double m_value; 36 | }; 37 | 38 | } // internal 39 | 40 | using internal::FloatMemberPrivate; 41 | 42 | FloatMember::FloatMember(const char *name, double value, Modifier flags) 43 | : AbstractMember(new FloatMemberPrivate(name, value, flags)) 44 | {} 45 | 46 | FloatMember::FloatMember(const FloatMember &other) 47 | : AbstractMember(other) 48 | {} 49 | 50 | FloatMember &FloatMember::operator=(const FloatMember &other) 51 | { 52 | if (this != &other) { 53 | AbstractMember::operator=(other); 54 | } 55 | return *this; 56 | } 57 | 58 | void FloatMember::setupConstant(zend_class_entry *entry) 59 | { 60 | ZAPI_D(FloatMember); 61 | zend_declare_class_constant_double(entry, implPtr->m_name.c_str(), implPtr->m_name.size(), 62 | implPtr->m_value); 63 | } 64 | 65 | void FloatMember::setupProperty(zend_class_entry *entry) 66 | { 67 | ZAPI_D(FloatMember); 68 | zend_declare_property_double(entry, implPtr->m_name.c_str(), implPtr->m_name.size(), 69 | implPtr->m_value, static_cast(implPtr->m_flags)); 70 | } 71 | 72 | FloatMember::~FloatMember() 73 | {} 74 | 75 | } // vm 76 | } // zapi 77 | -------------------------------------------------------------------------------- /src/vm/FloatMember.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qcoreteam/zendapi/b73fed92c2327d965bd545d5e34f8157e4389a6b/src/vm/FloatMember.h -------------------------------------------------------------------------------- /src/vm/InvokeBridge.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/07/26. 15 | 16 | #include 17 | #include "zapi/vm/InvokeBridge.h" 18 | #include "zapi/kernel/OrigException.h" 19 | #include "zapi/vm/ObjectBinder.h" 20 | 21 | namespace zapi 22 | { 23 | namespace vm 24 | { 25 | 26 | } // vm 27 | } // zapi 28 | 29 | -------------------------------------------------------------------------------- /src/vm/NullMember.cpp: -------------------------------------------------------------------------------- 1 | // @author Emiel Bruijntjes 2 | // @copyright 2014 Copernica BV 3 | // 4 | // @copyright 2017-2018 zzu_softboy 5 | // 6 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 7 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 8 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 9 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 10 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 11 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 12 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 13 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 14 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 15 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | // 17 | // Created by zzu_softboy on 2017/08/04. 18 | 19 | #include "zapi/vm/NullMember.h" 20 | #include "zapi/vm/internal/AbstractMemberPrivate.h" 21 | 22 | namespace zapi 23 | { 24 | namespace vm 25 | { 26 | 27 | using zapi::vm::internal::AbstractMemberPrivate; 28 | 29 | NullMember::NullMember(const char *name, Modifier flags) 30 | : AbstractMember(name, flags) 31 | {} 32 | 33 | void NullMember::setupConstant(zend_class_entry *entry) 34 | { 35 | 36 | zend_declare_class_constant_null(entry, m_implPtr->m_name.c_str(), m_implPtr->m_name.size()); 37 | } 38 | 39 | void NullMember::setupProperty(zend_class_entry *entry) 40 | { 41 | zend_declare_property_null(entry, m_implPtr->m_name.c_str(), m_implPtr->m_name.size(), 42 | static_cast(m_implPtr->m_flags)); 43 | } 44 | 45 | NullMember::~NullMember() 46 | {} 47 | 48 | } // vm 49 | } // zapi 50 | -------------------------------------------------------------------------------- /src/vm/ZValMember.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/09/01. 15 | 16 | #include "zapi/vm/ZValMember.h" 17 | #include "zapi/vm/internal/AbstractMemberPrivate.h" 18 | 19 | namespace zapi 20 | { 21 | namespace vm 22 | { 23 | 24 | using zapi::vm::internal::AbstractMemberPrivate; 25 | 26 | namespace internal 27 | { 28 | 29 | class ZvalMemberPrivate : public AbstractMemberPrivate 30 | { 31 | public: 32 | ZvalMemberPrivate(const char *name, zval *value, Modifier flags) 33 | : AbstractMemberPrivate(name, flags), 34 | m_value(value) 35 | {} 36 | zval *m_value; 37 | }; 38 | 39 | } // internal 40 | 41 | using zapi::vm::AbstractMember; 42 | using zapi::vm::internal::ZvalMemberPrivate; 43 | 44 | ZvalMember::ZvalMember(const char *name, zval *value, Modifier flags) 45 | : AbstractMember(new ZvalMemberPrivate(name, value, flags)) 46 | {} 47 | 48 | ZvalMember::ZvalMember(const ZvalMember &other) 49 | : AbstractMember(other) 50 | { 51 | ZAPI_D(ZvalMember); 52 | Z_TRY_ADDREF_P(implPtr->m_value); 53 | } 54 | 55 | ZvalMember &ZvalMember::operator=(const ZvalMember &other) 56 | { 57 | if (this != &other) { 58 | AbstractMember::operator=(other); 59 | } 60 | return *this; 61 | } 62 | 63 | ZvalMember::~ZvalMember() 64 | {} 65 | 66 | void ZvalMember::setupConstant(zend_class_entry *entry) 67 | { 68 | ZAPI_D(ZvalMember); 69 | zend_declare_class_constant(entry, implPtr->m_name.c_str(), implPtr->m_name.size(), implPtr->m_value); 70 | } 71 | 72 | void ZvalMember::setupProperty(zend_class_entry *entry) 73 | { 74 | ZAPI_D(ZvalMember); 75 | zend_declare_property(entry, implPtr->m_name.c_str(), implPtr->m_name.size(), 76 | implPtr->m_value, static_cast(implPtr->m_flags)); 77 | } 78 | 79 | } // vm 80 | } // zapi -------------------------------------------------------------------------------- /tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(lang) 2 | add_subdirectory(ext) 3 | add_subdirectory(dummyext) 4 | 5 | # just for show php test files 6 | add_custom_target(ZapiRuntimeTests SOURCES ${ZAPI_PHP_TESTS}) 7 | 8 | set(ZAPI_RT_TESTCASES 9 | ext/IniTest.phpt 10 | ext/ExtensionHandlerTest.phpt 11 | ext/ExtensionInfoTest.phpt) 12 | 13 | file(GLOB_RECURSE ZAPI_RT_TESTCASES 14 | LIST_DIRECTORIES false 15 | RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} 16 | *.phpt) 17 | 18 | # add the runtime tests 19 | foreach(testcase ${ZAPI_RT_TESTCASES}) 20 | add_test(NAME ${testcase} COMMAND ${ZAPI_PHP_EXECUTABLE} -c ${ZAPI_PHP_INI_FILENAME} ${testcase} 21 | WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) 22 | endforeach() 23 | -------------------------------------------------------------------------------- /tests/dummyext/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(DUMMYEXT_SRCS 2 | Entry.cpp 3 | CycleHandlerTestcases.h 4 | CycleHandlerTestcases.cpp 5 | ClassTestcases.h 6 | ClassTestcases.cpp 7 | FunctionTestcases.h 8 | FunctionTestcases.cpp 9 | IniTestcases.h 10 | IniTestcases.cpp 11 | InterfaceTestcases.h 12 | InterfaceTestcases.cpp 13 | NamespaceTestcases.h 14 | NamespaceTestcases.cpp 15 | ConstantTestcases.h 16 | ConstantTestcases.cpp 17 | NativeFunctions.h 18 | NativeFunctions.cpp 19 | NativeClasses.h 20 | NativeClasses.cpp) 21 | 22 | add_library(dummyext MODULE 23 | ${DUMMYEXT_SRCS}) 24 | 25 | target_link_libraries(dummyext ${PTHREAD_LIB} ${ZAPI_PROJECT_NAME}) 26 | set(BUILD_ETC_DIR ${ZAPI_BINARY_DIR}/etc) 27 | set_target_properties(dummyext PROPERTIES 28 | RUNTIME_OUTPUT_DIRECTORY ${ZAPI_BINARY_DIR}/extensions 29 | LIBRARY_OUTPUT_DIRECTORY ${ZAPI_BINARY_DIR}/extensions 30 | PREFIX "" 31 | ) 32 | -------------------------------------------------------------------------------- /tests/dummyext/ClassTestcases.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #ifndef ZAPI_TEST_DUMMYEXT_CLASS_TESTCASES_H 17 | #define ZAPI_TEST_DUMMYEXT_CLASS_TESTCASES_H 18 | 19 | #include "zapi/ZendApi.h" 20 | 21 | namespace dummyext 22 | { 23 | 24 | using zapi::lang::Extension; 25 | 26 | ZAPI_DECL_EXPORT void register_class_testcases(Extension &extension); 27 | void register_basic_classes(Extension &extension); 28 | void register_construct_and_destruct_classes(Extension &extension); 29 | void register_namespace_classes(Extension &extension); 30 | void register_inherit_test_classes(Extension &extension); 31 | void register_iterator_test_classes(Extension &extension); 32 | void register_closure_test_classes(Extension &extension); 33 | void register_visibility_test_classes(Extension &extension); 34 | void register_magic_method_test_classes(Extension &extension); 35 | void register_props_test_classes(Extension &extension); 36 | void register_object_variant_test_classes(Extension &extension); 37 | 38 | } // dummyext 39 | 40 | #endif // ZAPI_TEST_DUMMYEXT_CLASS_TESTCASES_H 41 | -------------------------------------------------------------------------------- /tests/dummyext/ConstantTestcases.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/02. 15 | 16 | #include "ConstantTestcases.h" 17 | 18 | namespace dummyext 19 | { 20 | 21 | using zapi::lang::Constant; 22 | using zapi::lang::Namespace; 23 | 24 | void register_constant_testcases(Extension &extension) 25 | { 26 | extension.registerConstant(Constant("MY_CONST", 12333)); 27 | extension.registerConstant(Constant("PI", 3.14)); 28 | Constant nameConst("ZAPI_NAME", "zapi"); 29 | extension.registerConstant(nameConst); 30 | extension.registerConstant(Constant("ZAPI_VERSION", "v0.0.1")); 31 | extension.registerConstant(Constant("QIHOO", "beijing qihoo")); 32 | // register constant in namespace 33 | Namespace *zapi = extension.findNamespace("zapi"); 34 | Namespace *io = zapi->findNamespace("io"); 35 | io->registerConstant(Constant("IO_TYPE", "ASYNC")); 36 | io->registerConstant(Constant("NATIVE_STREAM", true)); 37 | zapi->registerConstant(Constant("SYS_VERSION", "0.1.1-alpha")); 38 | } 39 | 40 | } // dummyext 41 | -------------------------------------------------------------------------------- /tests/dummyext/ConstantTestcases.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/02. 15 | 16 | #ifndef ZAPI_TEST_DUMMYEXT_CONSTANT_TESTCASES_H 17 | #define ZAPI_TEST_DUMMYEXT_CONSTANT_TESTCASES_H 18 | 19 | #include "zapi/ZendApi.h" 20 | 21 | namespace dummyext 22 | { 23 | 24 | using zapi::lang::Extension; 25 | 26 | ZAPI_DECL_EXPORT void register_constant_testcases(Extension &extension); 27 | 28 | } // dummyext 29 | 30 | #endif // ZAPI_TEST_DUMMYEXT_CONSTANT_TESTCASES_H 31 | -------------------------------------------------------------------------------- /tests/dummyext/CycleHandlerTestcases.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #ifndef ZAPI_TEST_DUMMYEXT_CYCLE_HANDLER_TESTCASES_H 17 | #define ZAPI_TEST_DUMMYEXT_CYCLE_HANDLER_TESTCASES_H 18 | 19 | #include "zapi/ZendApi.h" 20 | 21 | namespace dummyext 22 | { 23 | 24 | using zapi::lang::Extension; 25 | using zapi::lang::Variant; 26 | 27 | ZAPI_DECL_EXPORT void register_cyclehandler_testcases(Extension &extension); 28 | 29 | void startup_handler(); 30 | void shutdown_handler(); 31 | void request_startup_handler(); 32 | void request_shutdown_handler(); 33 | void module_info_handler(); 34 | void add_mhandler_info(const std::string &msg); 35 | Variant get_ext_handler_msgs(); 36 | 37 | } // dummyext 38 | 39 | #endif // ZAPI_TEST_DUMMYEXT_CYCLE_HANDLER_TESTCASES_H 40 | -------------------------------------------------------------------------------- /tests/dummyext/Entry.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #include "zapi/ZendApi.h" 17 | #include "IniTestcases.h" 18 | #include "CycleHandlerTestcases.h" 19 | #include "NamespaceTestcases.h" 20 | #include "FunctionTestcases.h" 21 | #include "ClassTestcases.h" 22 | #include "InterfaceTestcases.h" 23 | #include "ConstantTestcases.h" 24 | 25 | using zapi::lang::Extension; 26 | 27 | extern "C" { 28 | 29 | ZAPI_DECL_EXPORT void *get_module() 30 | { 31 | static Extension extension("dummyext", "1.0"); 32 | dummyext::register_ini_testcases(extension); 33 | dummyext::register_cyclehandler_testcases(extension); 34 | dummyext::register_namespace_testcases(extension); 35 | dummyext::register_constant_testcases(extension); 36 | dummyext::register_interface_testcases(extension); 37 | dummyext::register_function_testcases(extension); 38 | dummyext::register_class_testcases(extension); 39 | return extension; 40 | } 41 | 42 | } 43 | -------------------------------------------------------------------------------- /tests/dummyext/FunctionTestcases.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #ifndef ZAPI_TEST_DUMMYEXT_FUNCTION_TESTCASES_H 17 | #define ZAPI_TEST_DUMMYEXT_FUNCTION_TESTCASES_H 18 | 19 | #include "zapi/ZendApi.h" 20 | 21 | namespace dummyext 22 | { 23 | 24 | using zapi::lang::Extension; 25 | 26 | ZAPI_DECL_EXPORT void register_function_testcases(Extension &extension); 27 | 28 | } // dummyext 29 | 30 | #endif // ZAPI_TEST_DUMMYEXT_FUNCTION_TESTCASES_H 31 | -------------------------------------------------------------------------------- /tests/dummyext/IniTestcases.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #include "IniTestcases.h" 17 | #include "zapi/lang/Ini.h" 18 | 19 | namespace dummyext 20 | { 21 | 22 | void register_ini_testcases(Extension &extension) 23 | { 24 | // this have no effect we write this in php.ini 25 | extension.registerIni(zapi::lang::Ini("zapi_author", "xiuxiu")); 26 | // rewrite in php.ini 27 | extension.registerIni(zapi::lang::Ini("zapi_team_address", "beijing")); 28 | // register but empty value 29 | extension.registerIni(zapi::lang::Ini("zapi_product", "")); 30 | extension.registerIni(zapi::lang::Ini("zapi_enable_gpu", "off")); 31 | extension.registerIni(zapi::lang::Ini("zapi_name", "zzu_xiuxiu")); 32 | extension.registerIni(zapi::lang::Ini("zapi_age", 1)); 33 | // int type 34 | extension.registerIni(zapi::lang::Ini("zapi_string_value", "stringvalue")); 35 | extension.registerIni(zapi::lang::Ini("zapi_int_value", 2017)); 36 | extension.registerIni(zapi::lang::Ini("zapi_bool_value", true)); 37 | extension.registerIni(zapi::lang::Ini("zapi_double_value", 3.14)); 38 | } 39 | 40 | } // dummyext 41 | -------------------------------------------------------------------------------- /tests/dummyext/IniTestcases.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #ifndef ZAPI_TEST_DUMMYEXT_INI_TESTCASES_H 17 | #define ZAPI_TEST_DUMMYEXT_INI_TESTCASES_H 18 | 19 | #include "zapi/ZendApi.h" 20 | 21 | namespace dummyext 22 | { 23 | 24 | using zapi::lang::Extension; 25 | 26 | ZAPI_DECL_EXPORT void register_ini_testcases(Extension &extension); 27 | 28 | } // dummyext 29 | 30 | #endif // ZAPI_TEST_DUMMYEXT_INI_TESTCASES_H 31 | -------------------------------------------------------------------------------- /tests/dummyext/InterfaceTestcases.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #include "InterfaceTestcases.h" 17 | 18 | namespace dummyext 19 | { 20 | 21 | using zapi::lang::Interface; 22 | using zapi::lang::Modifier; 23 | 24 | void register_interface_testcases(Extension &extension) 25 | { 26 | Interface interfaceA("InterfaceA"); 27 | Interface interfaceB("InterfaceB"); 28 | Interface interfaceC("InterfaceC"); 29 | Interface infoInterface("InfoProvider"); 30 | 31 | interfaceA.registerMethod("methodOfA"); 32 | interfaceA.registerMethod("protectedMethodOfA", Modifier::Protected); 33 | interfaceA.registerMethod("privateMethodOfA", Modifier::Private); 34 | interfaceB.registerMethod("methodOfB"); 35 | interfaceB.registerMethod("protectedMethodOfB", Modifier::Protected); 36 | interfaceB.registerMethod("privateMethodOfB", Modifier::Private); 37 | interfaceC.registerMethod("methodOfC"); 38 | interfaceC.registerMethod("protectedMethodOfC", Modifier::Protected); 39 | interfaceC.registerMethod("privateMethodOfC", Modifier::Private); 40 | interfaceC.registerBaseInterface(interfaceB); 41 | interfaceB.registerBaseInterface(interfaceA); 42 | 43 | extension.registerInterface(infoInterface); 44 | extension.registerInterface(interfaceA); 45 | extension.registerInterface(interfaceB); 46 | extension.registerInterface(interfaceC); 47 | } 48 | 49 | } // dummyext 50 | -------------------------------------------------------------------------------- /tests/dummyext/InterfaceTestcases.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #ifndef ZAPI_TEST_DUMMYEXT_INTERFACE_TESTCASES_H 17 | #define ZAPI_TEST_DUMMYEXT_INTERFACE_TESTCASES_H 18 | 19 | #include "zapi/ZendApi.h" 20 | 21 | namespace dummyext 22 | { 23 | 24 | using zapi::lang::Extension; 25 | 26 | ZAPI_DECL_EXPORT void register_interface_testcases(Extension &extension); 27 | 28 | } // dummyext 29 | 30 | #endif // ZAPI_TEST_DUMMYEXT_INTERFACE_TESTCASES_H 31 | -------------------------------------------------------------------------------- /tests/dummyext/NamespaceTestcases.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #include "NamespaceTestcases.h" 17 | 18 | namespace dummyext 19 | { 20 | 21 | using zapi::lang::Namespace; 22 | 23 | void register_namespace_testcases(Extension &extension) 24 | { 25 | Namespace zapi("zapi"); 26 | Namespace io("io"); 27 | zapi.registerNamespace(io); 28 | extension.registerNamespace(zapi); 29 | } 30 | 31 | } // dummyext 32 | -------------------------------------------------------------------------------- /tests/dummyext/NamespaceTestcases.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #ifndef ZAPI_TEST_DUMMYEXT_NAMESPACE_TESTCASES_H 17 | #define ZAPI_TEST_DUMMYEXT_NAMESPACE_TESTCASES_H 18 | 19 | #include "zapi/ZendApi.h" 20 | 21 | namespace dummyext 22 | { 23 | 24 | using zapi::lang::Extension; 25 | 26 | ZAPI_DECL_EXPORT void register_namespace_testcases(Extension &extension); 27 | 28 | } // dummyext 29 | 30 | #endif // ZAPI_TEST_DUMMYEXT_NAMESPACE_TESTCASES_H 31 | -------------------------------------------------------------------------------- /tests/dummyext/NativeFunctions.h: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/02. 15 | 16 | #ifndef ZAPI_TEST_DUMMYEXT_NATIVE_FUNCTIONS_H 17 | #define ZAPI_TEST_DUMMYEXT_NATIVE_FUNCTIONS_H 18 | 19 | #include "zapi/ZendApi.h" 20 | 21 | namespace dummyext 22 | { 23 | 24 | using zapi::ds::StringVariant; 25 | using zapi::ds::NumericVariant; 26 | 27 | ZAPI_DECL_EXPORT Variant return_arg(Variant &value); 28 | ZAPI_DECL_EXPORT void show_something(); 29 | ZAPI_DECL_EXPORT Variant get_name(); 30 | ZAPI_DECL_EXPORT void get_value_ref(NumericVariant &number); 31 | ZAPI_DECL_EXPORT void passby_value(NumericVariant &number); 32 | ZAPI_DECL_EXPORT void print_sum(NumericVariant argQuantity, ...); 33 | ZAPI_DECL_EXPORT void print_name(const StringVariant &name); 34 | ZAPI_DECL_EXPORT void print_name_and_age(const StringVariant &name, const NumericVariant &age); 35 | ZAPI_DECL_EXPORT Variant calculate_sum(NumericVariant argQuantity, ...); 36 | ZAPI_DECL_EXPORT Variant add_two_number(const NumericVariant &num1, const NumericVariant &num2); 37 | ZAPI_DECL_EXPORT void say_hello(StringVariant &name); 38 | ZAPI_DECL_EXPORT Variant print_something(); 39 | ZAPI_DECL_EXPORT Variant have_ret_and_have_arg(Parameters ¶ms); 40 | 41 | } 42 | 43 | #endif // ZAPI_TEST_DUMMYEXT_NATIVE_FUNCTIONS_H 44 | -------------------------------------------------------------------------------- /tests/ext/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(ZAPI_PHP_TESTS 2 | ${ZAPI_PHP_TESTS} 3 | ext/ExtensionInfoTest.phpt 4 | ext/ExtensionHandlerTest.phpt 5 | PARENT_SCOPE) 6 | -------------------------------------------------------------------------------- /tests/ext/ExtensionHandlerTest.phpt: -------------------------------------------------------------------------------- 1 | getName() != "dummyext") { 5 | goto error; 6 | } 7 | if ($refl->getVersion() != "1.0") { 8 | goto error; 9 | } 10 | 11 | ob_start(); 12 | phpinfo(); 13 | $text = ob_get_clean(); 14 | if (-1 == strpos($text, "dummyext support => enabled")) { 15 | goto error; 16 | } 17 | if (-1 == strpos($text, "dummyext team => qcoreteam")) { 18 | goto error; 19 | } 20 | 21 | success: 22 | exit(0); 23 | error: 24 | exit(1); 25 | -------------------------------------------------------------------------------- /tests/ext/IniTest.phpt: -------------------------------------------------------------------------------- 1 | printInfo(); 7 | } 8 | $ret = trim(ob_get_clean()); 9 | $expect = <<<'EOF' 10 | class A and class B and class C exist 11 | C::printInfo been called 12 | B::printInfo been called 13 | B::showSomething been called 14 | EOF; 15 | 16 | if ($ret != $expect) { 17 | exit(1); 18 | } 19 | -------------------------------------------------------------------------------- /tests/lang/class/ClassCallParentMethodWithReturnTest.phpt: -------------------------------------------------------------------------------- 1 | testCallParentWithReturn(); 7 | } 8 | $ret = trim(ob_get_clean()); 9 | $expect = <<<'EOF' 10 | class A and class B and class C exist 11 | C::testCallParentWithReturn been called 12 | B::addTwoNumber been called 13 | after call addTwoNumber get : 24 14 | EOF; 15 | 16 | if ($ret != $expect) { 17 | exit(1); 18 | } 19 | -------------------------------------------------------------------------------- /tests/lang/class/ClassCallParentPassRefArgTest.phpt: -------------------------------------------------------------------------------- 1 | testCallParentPassRefArg(); 7 | } 8 | $ret = trim(ob_get_clean()); 9 | $expect = <<<'EOF' 10 | class A and class B and class C exist 11 | C::testCallParentPassRefArg been called 12 | before call changeNameByRef : xxxx 13 | A::changeNameByRef been called 14 | get ref arg 15 | after call changeNameByRef : hello, zapi 16 | before call calculateSumByRef : 0 17 | C::calculateSumByRef been called 18 | got 4 args 19 | retval is reference arg 20 | after call calculateSumByRef : 47 21 | EOF; 22 | 23 | if ($ret != $expect) { 24 | exit(1); 25 | } 26 | -------------------------------------------------------------------------------- /tests/lang/class/ClassClosureTest.phpt: -------------------------------------------------------------------------------- 1 | isFinal()) { 7 | echo "class ZapiClosure is final\n"; 8 | } 9 | } 10 | if (class_exists("\ClosureTestClass")) { 11 | echo "internal class ClosureTestClass exists\n"; 12 | $obj = new \ClosureTestClass(); 13 | $obj->testClosureCallable(); 14 | $callable = $obj->getNoArgAndReturnCallable(); 15 | if (is_callable($callable)) { 16 | echo "\$callable is callable\n"; 17 | $ret = $callable(); 18 | echo "the return of callable is " . $ret."\n"; 19 | } 20 | $hasParamCallable = $obj->getArgAndReturnCallable(); 21 | if (is_callable($hasParamCallable)) { 22 | echo "\$hasParamCallable is callable\n"; 23 | $ret = $hasParamCallable(); 24 | echo "the return of hasParamCallable is " . $ret."\n"; 25 | $ret = $hasParamCallable(123); 26 | echo "the return of hasParamCallable is " . $ret."\n"; 27 | $ret = $hasParamCallable(3.14); 28 | echo "the return of hasParamCallable is " . $ret."\n"; 29 | $ret = $hasParamCallable(true); 30 | echo "the return of hasParamCallable is " . $ret."\n"; 31 | } 32 | } 33 | 34 | $ret = trim(ob_get_clean()); 35 | $expect = <<<'EOF' 36 | internal class ZapiClosure exists 37 | class ZapiClosure is final 38 | internal class ClosureTestClass exists 39 | $callable is callable 40 | print_something called 41 | the return of callable is print_some 42 | $hasParamCallable is callable 43 | have_ret_and_have_arg called 44 | the return of hasParamCallable is have_ret_and_have_arg 45 | have_ret_and_have_arg called 46 | the return of hasParamCallable is 123 47 | have_ret_and_have_arg called 48 | the return of hasParamCallable is 3.14 49 | have_ret_and_have_arg called 50 | the return of hasParamCallable is 1 51 | EOF; 52 | 53 | if ($ret != $expect) { 54 | exit(1); 55 | } 56 | -------------------------------------------------------------------------------- /tests/lang/class/ClassConstantTest.phpt: -------------------------------------------------------------------------------- 1 | isFinal()) { 7 | echo "class FinalTestClass is final\n"; 8 | } 9 | } 10 | if (class_exists("\VisibilityClass")) { 11 | echo "VisibilityClass exists\n"; 12 | $refl = new ReflectionClass("VisibilityClass"); 13 | $mrefl = $refl->getMethod("finalMethod"); 14 | if ($mrefl->isFinal()) { 15 | echo "method VisibilityClass::finalMethod is final\n"; 16 | } 17 | } 18 | // class xx extends FinalTestClass 19 | // {} 20 | // PHP Fatal error: Class xx may not inherit from final class (FinalTestClass) 21 | $ret = trim(ob_get_clean()); 22 | $expect = <<testGetObjectVaraintPtr(); 7 | } 8 | 9 | $ret = trim(ob_get_clean()); 10 | $expect = << 23 | string(10) "InterfaceA" 24 | } 25 | $obj instanceof InterfaceA 26 | method C::methodOfA exists 27 | method C::protectedMethodOfA exists 28 | method C::privateMethodOfA exists 29 | EOF; 30 | if ($ret != $expect) { 31 | exit(1); 32 | } 33 | -------------------------------------------------------------------------------- /tests/lang/class/ClassInheritPropertyTest.phpt: -------------------------------------------------------------------------------- 1 | name ."\n"; 7 | if (property_exists($obj, "protectedName")) { 8 | echo "property protectedName exists\n"; 9 | } 10 | if (!property_exists($obj, "privateName")) { 11 | echo "property privateName not exists\n"; 12 | } 13 | if (property_exists($obj, "propsFromB")) { 14 | echo "property propsFromB exists\n"; 15 | } 16 | 17 | // $obj->protectedName; fata error 18 | } 19 | $ret = trim(ob_get_clean()); 20 | $expect = <<<'EOF' 21 | class A and class B and class C exist 22 | the public property name is : zapi 23 | property protectedName exists 24 | property privateName not exists 25 | property propsFromB exists 26 | EOF; 27 | if ($ret != $expect) { 28 | exit(1); 29 | } 30 | -------------------------------------------------------------------------------- /tests/lang/class/ClassInheritTest.phpt: -------------------------------------------------------------------------------- 1 | getParentClass(); 10 | if ($parentOfClsB->getName() == "A") { 11 | echo "The parent class of class B is class A\n"; 12 | } 13 | $reflClsC = new ReflectionClass("C"); 14 | $parentOfClsC = $reflClsC->getParentClass(); 15 | if ($parentOfClsC->getName() == "B") { 16 | echo "The parent class of class C is class B\n"; 17 | } 18 | if (new C instanceof \B) { 19 | echo "object of class C is instance of B\n"; 20 | } 21 | if (new C instanceof \A) { 22 | echo "object of class C is instance of A\n"; 23 | } 24 | } 25 | $ret = trim(ob_get_clean()); 26 | $expect = <<<'EOF' 27 | class A and class B and class C exist 28 | object of class B is instance of A 29 | The parent class of class B is class A 30 | The parent class of class C is class B 31 | object of class C is instance of B 32 | object of class C is instance of A 33 | EOF; 34 | if ($ret != $expect) { 35 | exit(1); 36 | } 37 | 38 | 39 | -------------------------------------------------------------------------------- /tests/lang/class/ClassIteratorTest.phpt: -------------------------------------------------------------------------------- 1 | $value) { 6 | echo "key: $key value: $value\n"; 7 | } 8 | } 9 | $ret = trim(ob_get_clean()); 10 | $expect = <<<'EOF' 11 | IterateTestClass::rewind called 12 | IterateTestClass::valid called 13 | IterateTestClass::current called 14 | IterateTestClass::key called 15 | key: key1 value: value1 16 | IterateTestClass::next called 17 | IterateTestClass::valid called 18 | IterateTestClass::current called 19 | IterateTestClass::key called 20 | key: key2 value: value2 21 | IterateTestClass::next called 22 | IterateTestClass::valid called 23 | IterateTestClass::current called 24 | IterateTestClass::key called 25 | key: key3 value: value3 26 | IterateTestClass::next called 27 | IterateTestClass::valid called 28 | IterateTestClass::current called 29 | IterateTestClass::key called 30 | key: key4 value: value4 31 | IterateTestClass::next called 32 | IterateTestClass::valid called 33 | EOF; 34 | if ($ret != $expect) { 35 | exit(1); 36 | } 37 | 38 | 39 | -------------------------------------------------------------------------------- /tests/lang/class/ClassMagicCallStaticTest.phpt: -------------------------------------------------------------------------------- 1 | calculateSum(1, 2, 3); // fata error 6 | $magicMethodClass = new MagicMethodClass(); 7 | $sum = $magicMethodClass->calculateSum(1, 2, 4); 8 | echo "the sum is " . $sum ."\n"; 9 | $ret = $magicMethodClass->notProcessCase("zapi"); 10 | if (is_null($ret)) { 11 | echo "magicMethodClass notProcessCase('zapi') return null\n"; 12 | } 13 | } 14 | $ret = trim(ob_get_clean()); 15 | $expect = << 13 | // string(4) "zapi" 14 | // ["address"]=> 15 | // string(7) "beijing" 16 | //} 17 | //object(FinalTestClass)#2 (0) { 18 | //} 19 | } 20 | $ret = trim(ob_get_clean()); 21 | $expect = <<<'EOF' 22 | class MagicMethodClass exists 23 | EOF; 24 | 25 | if ($ret != $expect) { 26 | exit(1); 27 | } 28 | -------------------------------------------------------------------------------- /tests/lang/class/ClassMagicGetTest.phpt: -------------------------------------------------------------------------------- 1 | prop1; Notice: Undefined property: NonMagicMethodClass::$prop1 6 | if (!property_exists($nonMagicMethodObject, "prop1")) { 7 | echo "\$nonMagicMethodObject->prop1 is not exist\n"; 8 | } 9 | $magicMethodObject = new MagicMethodClass(); 10 | if (property_exists($magicMethodObject, "prop1")) { 11 | echo "\$magicMethodObject->prop1 is exist\n"; 12 | echo "the value of \$magicMethodObject->prop1 is ".$magicMethodObject->prop1."\n"; 13 | } 14 | } 15 | $ret = trim(ob_get_clean()); 16 | $expect = <<<'EOF' 17 | $nonMagicMethodObject->prop1 is not exist 18 | MagicMethodClass::__isset is called 19 | $magicMethodObject->prop1 is exist 20 | MagicMethodClass::__get is called 21 | the value of $magicMethodObject->prop1 is zapi 22 | EOF; 23 | 24 | if ($ret != $expect) { 25 | exit(1); 26 | } 27 | 28 | 29 | -------------------------------------------------------------------------------- /tests/lang/class/ClassMagicInvokeTest.phpt: -------------------------------------------------------------------------------- 1 | prop1; Notice: Undefined property: NonMagicMethodClass::$prop1 6 | if (!property_exists($nonMagicMethodObject, "prop1")) { 7 | echo "\$nonMagicMethodObject->prop1 is not exist\n"; 8 | } 9 | $magicMethodObject = new MagicMethodClass(); 10 | if (property_exists($magicMethodObject, "prop1")) { 11 | echo "\$magicMethodObject->prop1 is exist\n"; 12 | } 13 | if (!property_exists($magicMethodObject, "notExistProp")) { 14 | echo "\$magicMethodObject->notExistProp is not exist\n"; 15 | } 16 | } 17 | $ret = trim(ob_get_clean()); 18 | $expect = <<<'EOF' 19 | $nonMagicMethodObject->prop1 is not exist 20 | MagicMethodClass::__isset is called 21 | $magicMethodObject->prop1 is exist 22 | MagicMethodClass::__isset is called 23 | $magicMethodObject->notExistProp is not exist 24 | EOF; 25 | 26 | if ($ret != $expect) { 27 | exit(1); 28 | } 29 | -------------------------------------------------------------------------------- /tests/lang/class/ClassMagicSerializeTest.phpt: -------------------------------------------------------------------------------- 1 | address is not exist\n"; 7 | } 8 | $magicMethodObject->address = "beijing"; 9 | if (property_exists($magicMethodObject, "address")) { 10 | echo "\$magicMethodObject->address is exist\n"; 11 | echo "\$magicMethodObject->address value is {$magicMethodObject->address}\n"; 12 | } 13 | } 14 | $ret = trim(ob_get_clean()); 15 | $expect = <<<'EOF' 16 | MagicMethodClass::__isset is called 17 | $magicMethodObject->address is not exist 18 | MagicMethodClass::__set is called 19 | MagicMethodClass::__isset is called 20 | $magicMethodObject->address is exist 21 | MagicMethodClass::__get is called 22 | $magicMethodObject->address value is beijing 23 | EOF; 24 | 25 | if ($ret != $expect) { 26 | exit(1); 27 | } 28 | 29 | -------------------------------------------------------------------------------- /tests/lang/class/ClassMagicUnsetTest.phpt: -------------------------------------------------------------------------------- 1 | teamName; Notice: Undefined property: NonMagicMethodClass::$teamName 6 | if (!property_exists($nonMagicMethodObject, "teamName")) { 7 | echo "\$nonMagicMethodObject->teamName is not exist\n"; 8 | } 9 | $magicMethodObject = new MagicMethodClass(); 10 | if (property_exists($magicMethodObject, "teamName")) { 11 | echo "\$magicMethodObject->teamName is exist\n"; 12 | } 13 | unset($magicMethodObject->teamName); 14 | if (!property_exists($magicMethodObject, "teamName")) { 15 | echo "\$magicMethodObject->teamName is not exist\n"; 16 | } 17 | } 18 | $ret = trim(ob_get_clean()); 19 | $expect = <<<'EOF' 20 | $nonMagicMethodObject->teamName is not exist 21 | MagicMethodClass::__isset is called 22 | $magicMethodObject->teamName is exist 23 | MagicMethodClass::__unset is called 24 | MagicMethodClass::__isset is called 25 | $magicMethodObject->teamName is not exist 26 | EOF; 27 | 28 | if ($ret != $expect) { 29 | exit(1); 30 | } 31 | 32 | -------------------------------------------------------------------------------- /tests/lang/class/ClassMethodAccessLevelTest.phpt: -------------------------------------------------------------------------------- 1 | isStatic()) { 7 | echo "Person::protectedMethod is an instance method\n"; 8 | } 9 | if ($pmRefl->isProtected()) { 10 | echo "Person::protectedMethod is an protected method\n"; 11 | } 12 | } 13 | if (method_exists("Person", "privateMethod")) { 14 | $pmRefl = new ReflectionMethod("Person", "privateMethod"); 15 | if (!$pmRefl->isStatic()) { 16 | echo "Person::privateMethod is an instance method\n"; 17 | } 18 | if ($pmRefl->isPrivate()) { 19 | echo "Person::privateMethod is an private method\n"; 20 | } 21 | } 22 | 23 | if (method_exists("Person", "staticProtectedMethod")) { 24 | $pmRefl = new ReflectionMethod("Person", "staticProtectedMethod"); 25 | if ($pmRefl->isStatic()) { 26 | echo "Person::staticProtectedMethod is an static method\n"; 27 | } 28 | if ($pmRefl->isProtected()) { 29 | echo "Person::staticProtectedMethod is an protected method\n"; 30 | } 31 | } 32 | if (method_exists("Person", "staticPrivateMethod")) { 33 | $pmRefl = new ReflectionMethod("Person", "staticPrivateMethod"); 34 | if ($pmRefl->isStatic()) { 35 | echo "Person::staticPrivateMethod is an static method\n"; 36 | } 37 | if ($pmRefl->isPrivate()) { 38 | echo "Person::staticPrivateMethod is an private method\n"; 39 | } 40 | } 41 | } 42 | $ret = trim(ob_get_clean()); 43 | $expect = <<<'EOF' 44 | Person::protectedMethod is an instance method 45 | Person::protectedMethod is an protected method 46 | Person::privateMethod is an instance method 47 | Person::privateMethod is an private method 48 | Person::staticProtectedMethod is an static method 49 | Person::staticProtectedMethod is an protected method 50 | Person::staticPrivateMethod is an static method 51 | Person::staticPrivateMethod is an private method 52 | EOF; 53 | 54 | if ($ret != $expect) { 55 | exit(1); 56 | } 57 | 58 | -------------------------------------------------------------------------------- /tests/lang/class/ClassMethodExistTest.phpt: -------------------------------------------------------------------------------- 1 | showName(); 8 | } 9 | if (method_exists($object, "print_sum")) { 10 | $object->print_sum(1, 2, 3, 5); 11 | } 12 | if (method_exists($object, "getAge")) { 13 | echo "the original age is " . $object->getAge()."\n"; 14 | } 15 | if (method_exists($object, "setAge")) { 16 | $object->setAge(27); 17 | } 18 | if (method_exists($object, "getAge")) { 19 | echo "the new age is " . $object->getAge()."\n"; 20 | } 21 | if (method_exists($object, "getName")) { 22 | echo "the name is " . $object->getName()."\n"; 23 | } 24 | if (method_exists($object, "addTwoNum")) { 25 | echo "the sum of 1 and 99 is " . $object->addTwoNum(1, 99)."\n"; 26 | } 27 | if (method_exists($object, "addSum")) { 28 | echo "the sum of 1, 2, 3, 4, 5, 6, 7 is " . $object->addSum(1, 2, 3, 4, 5, 6, 7)."\n"; 29 | echo "the sum of 1, 2, 3 is " . $object->addSum(1, 2, 3)."\n"; 30 | } 31 | // static method invoke 32 | if (method_exists("Person", "staticShowName")) { 33 | Person::staticShowName(); 34 | } 35 | 36 | if (method_exists("Person", "concatStr")) { 37 | echo "the concat of abc and def is " . Person::concatStr("abc", "def"); 38 | } 39 | 40 | } 41 | $ret = trim(ob_get_clean()); 42 | $expect = <<<'EOF' 43 | my name is zapi 44 | the sum is 11 45 | the original age is 0 46 | the new age is 27 47 | the name is zzu_softboy 48 | the sum of 1 and 99 is 100 49 | the sum of 1, 2, 3, 4, 5, 6, 7 is 28 50 | the sum of 1, 2, 3 is 6 51 | static my name is zapi 52 | the concat of abc and def is abcdef 53 | EOF; 54 | 55 | if ($ret != $expect) { 56 | exit(1); 57 | } 58 | 59 | -------------------------------------------------------------------------------- /tests/lang/class/ClassMethodVisibilityTest.phpt: -------------------------------------------------------------------------------- 1 | getMethod("publicMethod"); 7 | $protectedMethod = $refl->getMethod("protectedMethod"); 8 | $privateMethod = $refl->getMethod("privateMethod"); 9 | if ($publicMethod->isPublic()) { 10 | echo "VisibilityClass::publicMethod is public\n"; 11 | } 12 | if ($protectedMethod->isProtected()) { 13 | echo "VisibilityClass::protectedMethod is protected\n"; 14 | } 15 | if ($privateMethod->isPrivate()) { 16 | echo "VisibilityClass::privateMethod is private\n"; 17 | } 18 | } 19 | $ret = trim(ob_get_clean()); 20 | $expect = <<<'EOF' 21 | class VisibilityClass exists 22 | VisibilityClass::publicMethod is public 23 | VisibilityClass::protectedMethod is protected 24 | VisibilityClass::privateMethod is private 25 | EOF; 26 | 27 | if ($ret != $expect) { 28 | exit(1); 29 | } 30 | 31 | 32 | -------------------------------------------------------------------------------- /tests/lang/class/ClassPolymorphicTest.phpt: -------------------------------------------------------------------------------- 1 | printInfo(); 6 | } 7 | 8 | if (class_exists("A") && class_exists("B") && class_exists("C")) { 9 | echo "class A and class B and class C exist\n"; 10 | print_info(new A); 11 | print_info(new B); 12 | print_info(new C); 13 | } 14 | $ret = trim(ob_get_clean()); 15 | $expect = <<<'EOF' 16 | class A and class B and class C exist 17 | A::printInfo been called 18 | B::printInfo been called 19 | C::printInfo been called 20 | B::printInfo been called 21 | B::showSomething been called 22 | EOF; 23 | 24 | if ($ret != $expect) { 25 | exit(1); 26 | } 27 | 28 | -------------------------------------------------------------------------------- /tests/lang/class/ClassPropGetterAndSetterTest.phpt: -------------------------------------------------------------------------------- 1 | name}\n"; 8 | } 9 | if (property_exists($object, "name")) { 10 | $object->name = "unicornteam"; 11 | echo "PropsTestClass::name value : {$object->name}\n"; 12 | } 13 | if (!property_exists($object, "notExistsProp")) { 14 | echo "PropsTestClass::notExistsProp is not exist\n"; 15 | } 16 | $object->notExistsProp = 123; 17 | if (property_exists($object, "notExistsProp")) { 18 | echo "PropsTestClass::notExistsProp is exist\n"; 19 | echo "PropsTestClass::notExistsProp value : {$object->notExistsProp}\n"; 20 | } 21 | } 22 | $ret = trim(ob_get_clean()); 23 | $expect = <<<'EOF' 24 | PropsTestClass::name is exist 25 | PropsTestClass::name value : 26 | PropsTestClass::name value : zapi:unicornteam 27 | PropsTestClass::notExistsProp is not exist 28 | PropsTestClass::notExistsProp is exist 29 | PropsTestClass::notExistsProp value : 123 30 | EOF; 31 | 32 | if ($ret != $expect) { 33 | exit(1); 34 | } 35 | 36 | -------------------------------------------------------------------------------- /tests/lang/class/ClassPropertyTest.phpt: -------------------------------------------------------------------------------- 1 | nullProp) ? "null\n" : "notnull\n"); 9 | } 10 | if (property_exists($object, "trueProp")) { 11 | echo "PropsTestClass::trueProp is exist\n"; 12 | echo "PropsTestClass::trueProp value : " . ($object->trueProp ? "true" : "false"); 13 | echo "\n"; 14 | } 15 | if (property_exists($object, "falseProp")) { 16 | echo "PropsTestClass::falseProp is exist\n"; 17 | echo "PropsTestClass::falseProp value : " . ($object->falseProp ? "true" : "false"); 18 | echo "\n"; 19 | } 20 | if (property_exists($object, "numProp")) { 21 | echo "PropsTestClass::numProp is exist\n"; 22 | echo "PropsTestClass::numProp value : {$object->numProp}\n"; 23 | } 24 | if (property_exists($object, "doubleProp")) { 25 | echo "PropsTestClass::doubleProp is exist\n"; 26 | echo "PropsTestClass::doubleProp value : {$object->doubleProp}\n"; 27 | } 28 | if (property_exists($object, "strProp")) { 29 | echo "PropsTestClass::strProp is exist\n"; 30 | echo "PropsTestClass::strProp value : {$object->strProp}\n"; 31 | } 32 | 33 | if (property_exists($object, "strProp1")) { 34 | echo "PropsTestClass::strProp1 is exist\n"; 35 | echo "PropsTestClass::strProp1 value : {$object->strProp1}\n"; 36 | } 37 | } 38 | $ret = trim(ob_get_clean()); 39 | $expect = <<<'EOF' 40 | PropsTestClass::nullProp is exist 41 | PropsTestClass::nullProp value : null 42 | PropsTestClass::trueProp is exist 43 | PropsTestClass::trueProp value : true 44 | PropsTestClass::falseProp is exist 45 | PropsTestClass::falseProp value : false 46 | PropsTestClass::numProp is exist 47 | PropsTestClass::numProp value : 2017 48 | PropsTestClass::doubleProp is exist 49 | PropsTestClass::doubleProp value : 3.1415 50 | PropsTestClass::strProp is exist 51 | PropsTestClass::strProp value : zapi 52 | EOF; 53 | 54 | if ($ret != $expect) { 55 | exit(1); 56 | } 57 | 58 | 59 | -------------------------------------------------------------------------------- /tests/lang/class/ClassPropertyVisibilityTest.phpt: -------------------------------------------------------------------------------- 1 | getProperty("publicProp"); 7 | $protectedProp = $refl->getProperty("protectedProp"); 8 | $privateProp = $refl->getProperty("privateProp"); 9 | if ($publicProp->isPublic()) { 10 | echo "VisibilityClass::publicProp is public\n"; 11 | } 12 | if ($protectedProp->isProtected()) { 13 | echo "VisibilityClass::protectedProp is protected\n"; 14 | } 15 | if ($privateProp->isPrivate()) { 16 | echo "VisibilityClass::privateProp is private\n"; 17 | } 18 | } 19 | $ret = trim(ob_get_clean()); 20 | $expect = <<<'EOF' 21 | class VisibilityClass exists 22 | VisibilityClass::publicProp is public 23 | VisibilityClass::protectedProp is protected 24 | VisibilityClass::privateProp is private 25 | EOF; 26 | 27 | if ($ret != $expect) { 28 | exit(1); 29 | } 30 | 31 | -------------------------------------------------------------------------------- /tests/lang/class/ClassStaticMethodExistTest.phpt: -------------------------------------------------------------------------------- 1 | testDerivedFrom(); 6 | } 7 | $ret = trim(ob_get_clean()); 8 | $expect = <<<'EOF' 9 | A is not derived from A 10 | B is not derived from B 11 | C is not derived from C 12 | B is derived from A 13 | C is derived from B 14 | C is derived from A 15 | A is not derived from B 16 | C is not derived from B 17 | C is not derived from A 18 | EOF; 19 | 20 | if ($ret != $expect) { 21 | exit(1); 22 | } 23 | -------------------------------------------------------------------------------- /tests/lang/class/ObjectVariantInstanceOfTest.phpt: -------------------------------------------------------------------------------- 1 | testInstanceOf(); 6 | } 7 | $ret = trim(ob_get_clean()); 8 | $expect = <<<'EOF' 9 | A is instance of A 10 | B is instance of B 11 | C is instance of C 12 | B is instance of A 13 | C is instance of B 14 | C is instance of A 15 | A is not instance of B 16 | C is not instance of B 17 | C is not instance of A 18 | EOF; 19 | 20 | if ($ret != $expect) { 21 | exit(1); 22 | } 23 | -------------------------------------------------------------------------------- /tests/lang/class/ObjectVariantInvokeTest.phpt: -------------------------------------------------------------------------------- 1 | forwardInvoke(); 6 | } 7 | $ret = trim(ob_get_clean()); 8 | $expect = <<<'EOF' 9 | begin invoke ObjectVariant::classInvoke : the text is xxx 10 | ObjectVariantClass::__invoke invoked 11 | after invoke ObjectVariant::classInvoke : this text is zapi 12 | EOF; 13 | 14 | if ($ret != $expect) { 15 | exit(1); 16 | } 17 | -------------------------------------------------------------------------------- /tests/lang/class/ObjectVariantNoArgsCallTest.phpt: -------------------------------------------------------------------------------- 1 | testNoArgCall(); 6 | } 7 | $ret = trim(ob_get_clean()); 8 | $expect = <<<'EOF' 9 | ObjectVariantClass::printName been called 10 | ObjectVariantClass::getName been called 11 | the result of ObjectVariantClass::getName is hello, zapi 12 | EOF; 13 | 14 | if ($ret != $expect) { 15 | exit(1); 16 | } 17 | -------------------------------------------------------------------------------- /tests/lang/class/ObjectVariantVarArgsCallTest.phpt: -------------------------------------------------------------------------------- 1 | testVarArgsCall(); 6 | } 7 | $ret = trim(ob_get_clean()); 8 | $expect = <<<'EOF' 9 | ObjectVariantClass::printSum been called 10 | got 3 args 11 | the result is 36 12 | ObjectVariantClass::calculateSum been called 13 | got 3 args 14 | the result is 7 15 | the result of ObjectVariantClass::calculateSum is 7 16 | before call by ref arg zapi 17 | ObjectVariantClass::changeNameByRef been called 18 | get ref arg 19 | after call by ref arg hello, zapi 20 | EOF; 21 | 22 | if ($ret != $expect) { 23 | exit(1); 24 | } 25 | -------------------------------------------------------------------------------- /tests/lang/const/ConstantExistTest.phpt: -------------------------------------------------------------------------------- 1 | 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 05/06/2017. 15 | 16 | #include "php/sapi/embed/php_embed.h" 17 | #include "gtest/gtest.h" 18 | 19 | 20 | int main(int argc, char **argv) { 21 | PHP_EMBED_START_BLOCK(argc,argv); 22 | char * script = const_cast(" function show_version (){echo 'hello zend api: v0.0.1';} show_version();"); 23 | zend_eval_string(script, NULL, 24 | const_cast("Simple Hello World App") TSRMLS_CC); 25 | PHP_EMBED_END_BLOCK(); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /unittests/ds/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # data structure tests 2 | set(DS_TEST_SRCS 3 | BoolVariantTest.cpp 4 | DoubleVariantTest.cpp 5 | NumericVariantTest.cpp 6 | StringVariantTest.cpp 7 | ArrayVariantTest.cpp 8 | VariantTest.cpp 9 | ObjectVariantTest.cpp 10 | CallableVariantTest.cpp 11 | ) 12 | zapi_add_unittest(UnitTests DsTest ${DS_TEST_SRCS}) 13 | -------------------------------------------------------------------------------- /unittests/ds/CallableVariantTest.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/09/11. 15 | 16 | #include "php/sapi/embed/php_embed.h" 17 | #include "gtest/gtest.h" 18 | #include "zapi/ds/CallableVariant.h" 19 | #include 20 | #include 21 | 22 | using zapi::ds::CallableVariant; 23 | 24 | void print_name() 25 | { 26 | zapi::out << "zapi" << std::endl; 27 | } 28 | 29 | int get_height() 30 | { 31 | return 28; 32 | } 33 | 34 | void print_two_number_sum(int lhs, int rhs) 35 | { 36 | zapi::out << lhs + rhs << std::endl; 37 | } 38 | 39 | int add_two_number(int lhs, int rhs) 40 | { 41 | return lhs + rhs; 42 | } 43 | 44 | class Handler 45 | { 46 | public: 47 | static void print_name() 48 | { 49 | zapi::out << "zapi" << std::endl; 50 | } 51 | static int get_height() 52 | { 53 | return 28; 54 | } 55 | static void print_two_number_sum(int lhs, int rhs) 56 | { 57 | zapi::out << lhs + rhs << std::endl; 58 | } 59 | static int add_two_number(int lhs, int rhs) 60 | { 61 | return lhs + rhs; 62 | } 63 | }; 64 | 65 | TEST(CallableVariantTest, testConstruct) 66 | { 67 | // CallableVariant getNameHandler(print_name); 68 | // CallableVariant getHeight(get_height); 69 | // CallableVariant printSumHandler(print_two_number_sum); 70 | // CallableVariant addTwoNumber(add_two_number); 71 | // CallableVariant clsGetNameHandler(&Handler::print_name); 72 | // CallableVariant clsGetHeight(&Handler::get_height); 73 | // CallableVariant clsPrintSumHandler(&Handler::print_two_number_sum); 74 | // CallableVariant clsAddTwoNumber(&Handler::add_two_number); 75 | // call it 76 | //getNameHandler(); 77 | } 78 | -------------------------------------------------------------------------------- /unittests/lang/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(LANG_TEST_SRCS 2 | ArgumentTest.cpp 3 | FunctionTest.cpp 4 | ConstantTest.cpp 5 | TypeTest.cpp 6 | ExtensionTest.cpp 7 | NamespaceTest.cpp) 8 | zapi_add_unittest(UnitTests LangTest ${LANG_TEST_SRCS}) 9 | -------------------------------------------------------------------------------- /unittests/lang/ConstantTest.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/07/27. 15 | 16 | #include "zapi/lang/Constant.h" 17 | #include "gtest/gtest.h" 18 | 19 | using zapi::lang::Type; 20 | using zapi::lang::Constant; 21 | 22 | TEST(ConstantTest, test) 23 | { 24 | { 25 | Constant constant("MY_NAME", "zzu_softboy"); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /unittests/lang/FunctionTest.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 27/07/2017. 15 | 16 | #include "zapi/lang/Function.h" 17 | #include "gtest/gtest.h" 18 | 19 | using zapi::lang::Function; 20 | using zapi::lang::Arguments; 21 | using zapi::lang::Type; 22 | using zapi::lang::ValueArgument; 23 | using zapi::lang::RefArgument; 24 | 25 | void dummy_func(struct _zend_execute_data *executeData, struct _zval_struct *returnValue) 26 | {} 27 | 28 | TEST(FunctionTest, testConstructor) 29 | { 30 | { 31 | // Function func("zapi_version", dummy_func); 32 | // zend_function_entry funcEntry; 33 | // func.initialize(&funcEntry); 34 | // ASSERT_STREQ(funcEntry.fname, "zapi_version"); 35 | // ASSERT_EQ(funcEntry.handler, &dummy_func); 36 | // ASSERT_EQ(funcEntry.num_args, 0); 37 | // ASSERT_EQ(funcEntry.flags, 0); 38 | } 39 | // add argument 40 | { 41 | // Arguments args{ 42 | // ValueArgument("name", Type::String), 43 | // RefArgument("age", Type::Numeric, true) 44 | // }; 45 | // Function func("zapi_version", dummy_func, args); 46 | // zend_function_entry funcEntry; 47 | // func.initialize(&funcEntry); 48 | // ASSERT_STREQ(funcEntry.fname, "zapi_version"); 49 | // ASSERT_EQ(funcEntry.handler, &dummy_func); 50 | // ASSERT_EQ(funcEntry.num_args, 2); 51 | // ASSERT_EQ(funcEntry.flags, 0); 52 | // const struct _zend_internal_arg_info arg1 = funcEntry.arg_info[1]; 53 | // const struct _zend_internal_arg_info arg2 = funcEntry.arg_info[2]; 54 | // ASSERT_STREQ(arg1.name, "name"); 55 | // ASSERT_EQ(arg1.type_hint, static_cast(Type::String)); 56 | // ASSERT_FALSE(arg1.pass_by_reference); 57 | // ASSERT_STREQ(arg2.name, "age"); 58 | // ASSERT_EQ(arg2.type_hint, static_cast(Type::Numeric)); 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /unittests/lang/NamespaceTest.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/11/02. 15 | 16 | #include "php/sapi/embed/php_embed.h" 17 | #include "zapi/lang/Namespace.h" 18 | #include "zapi/lang/Class.h" 19 | #include "zapi/lang/StdClass.h" 20 | #include "zapi/vm/AbstractClass.h" 21 | #include "gtest/gtest.h" 22 | 23 | using zapi::lang::Namespace; 24 | using zapi::lang::Class; 25 | using zapi::lang::StdClass; 26 | using zapi::vm::AbstractClass; 27 | 28 | class ClassA : public StdClass 29 | {}; 30 | 31 | class ClassB : public StdClass 32 | {}; 33 | 34 | TEST(NamespaceTest, testFindNamespace) 35 | { 36 | Namespace zapi("zapi"); 37 | Namespace kernel("kernel"); 38 | Namespace net("net"); 39 | zapi.registerNamespace(kernel); 40 | zapi.registerNamespace(net); 41 | Namespace *result = nullptr; 42 | result = zapi.findNamespace("NotExistNamespace"); 43 | ASSERT_EQ(result, nullptr); 44 | result = zapi.findNamespace("kernel"); 45 | ASSERT_NE(result, nullptr); 46 | ASSERT_EQ(result->getName(), "kernel"); 47 | result = nullptr; 48 | result = zapi.findNamespace("net"); 49 | ASSERT_NE(result, nullptr); 50 | ASSERT_EQ(result->getName(), "net"); 51 | } 52 | 53 | TEST(NamespaceTest, testFindClass) 54 | { 55 | Namespace zapi("zapi"); 56 | Class classA("ClassA"); 57 | Class classB("ClassB"); 58 | zapi.registerClass(classA); 59 | zapi.registerClass(classB); 60 | AbstractClass *resultCls = nullptr; 61 | resultCls = zapi.findClass("NotExistClass"); 62 | ASSERT_EQ(resultCls, nullptr); 63 | resultCls = zapi.findClass("ClassA"); 64 | ASSERT_NE(resultCls, nullptr); 65 | ASSERT_EQ(resultCls->getClassName(), "ClassA"); 66 | resultCls = nullptr; 67 | resultCls = zapi.findClass("ClassB"); 68 | ASSERT_NE(resultCls, nullptr); 69 | ASSERT_EQ(resultCls->getClassName(), "ClassB"); 70 | } 71 | -------------------------------------------------------------------------------- /unittests/lang/TypeTest.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 2017/08/01. 15 | 16 | #include "zapi/lang/Type.h" 17 | #include "gtest/gtest.h" 18 | 19 | using zapi::lang::Modifier; 20 | 21 | TEST(TypeTest, testModifierOperator) 22 | { 23 | { 24 | Modifier modifier = Modifier::Abstract; 25 | ASSERT_TRUE(modifier == Modifier::Abstract); 26 | modifier |= Modifier::Public; 27 | ASSERT_TRUE(modifier == 0x02 | 0x100); 28 | } 29 | ASSERT_EQ(Modifier::Abstract | Modifier::Public, (0x02 | 0x100)); 30 | ASSERT_EQ(Modifier::MethodModifiers, Modifier::Final | Modifier::Public | Modifier::Protected | Modifier::Private | Modifier::Static); 31 | ASSERT_EQ(Modifier::PropertyModifiers, Modifier::Final | Modifier::Public | Modifier::Protected | Modifier::Private | Modifier::Const | Modifier::Static); 32 | { 33 | Modifier modifier = Modifier::Public; 34 | ASSERT_TRUE((modifier & Modifier::Public) == Modifier::Public); 35 | modifier |= Modifier::Const; 36 | ASSERT_TRUE((modifier & Modifier::Const) == Modifier::Const); 37 | ASSERT_FALSE((modifier & Modifier::Const) == Modifier::Protected); 38 | modifier &= Modifier::Const; 39 | ASSERT_TRUE(modifier == Modifier::Const); 40 | ASSERT_TRUE((Modifier::MethodModifiers & Modifier::Final) == Modifier::Final); 41 | ASSERT_TRUE((Modifier::MethodModifiers & Modifier::Public) == Modifier::Public); 42 | ASSERT_FALSE((Modifier::MethodModifiers & Modifier::Const) == Modifier::Const); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /unittests/std/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(STD_TEST_SRCS 2 | InvokeTest.cpp 3 | TypeTraitsTest.cpp) 4 | zapi_add_unittest(UnitTests ZapiStd ${STD_TEST_SRCS}) -------------------------------------------------------------------------------- /unittests/utils/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(UTILS_TEST_SRCS 2 | InternalTest.cpp) 3 | zapi_add_unittest(UnitTests UtilsTest ${UTILS_TEST_SRCS}) 4 | -------------------------------------------------------------------------------- /unittests/utils/InternalTest.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by softboy on 2017/11/01. 15 | 16 | #include "php/sapi/embed/php_embed.h" 17 | #include "gtest/gtest.h" 18 | #include "zapi/utils/InternalFuncs.h" 19 | #include 20 | #include 21 | 22 | using zapi::internal::parse_namespaces; 23 | 24 | TEST(UtilsInternalTest, testParseNamespace) 25 | { 26 | std::list parts; 27 | std::string ns("::::"); 28 | bool parseStatus = true; 29 | parseStatus = parse_namespaces(ns, parts); 30 | ASSERT_FALSE(parseStatus); 31 | ns = "zapi::"; 32 | parseStatus = parse_namespaces(ns, parts); 33 | ASSERT_FALSE(parseStatus); 34 | ns = "zapi:kernel"; 35 | parseStatus = parse_namespaces(ns, parts); 36 | ASSERT_FALSE(parseStatus); 37 | ns = "zapi::kernel:io"; 38 | parseStatus = parse_namespaces(ns, parts); 39 | ASSERT_FALSE(parseStatus); 40 | ns = "zapi"; 41 | parseStatus = parse_namespaces(ns, parts); 42 | ASSERT_TRUE(parseStatus); 43 | ASSERT_EQ(parts, std::list{"zapi"}); 44 | parts.clear(); 45 | ns = "zapi::kernel::io"; 46 | parseStatus = parse_namespaces(ns, parts); 47 | ASSERT_TRUE(parseStatus); 48 | ASSERT_EQ(parts, std::list({"zapi", "kernel", "io"})); 49 | } 50 | 51 | int main(int argc, char **argv) 52 | { 53 | int retCode = 0; 54 | PHP_EMBED_START_BLOCK(argc,argv); 55 | ::testing::InitGoogleTest(&argc, argv); 56 | retCode = RUN_ALL_TESTS(); 57 | PHP_EMBED_END_BLOCK(); 58 | return retCode; 59 | } 60 | -------------------------------------------------------------------------------- /unittests/vm/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(VM_TEST_SRCS 2 | EngineTest.cpp 3 | InvokeBridgeTest.cpp) 4 | zapi_add_unittest(UnitTests VmTest ${VM_TEST_SRCS}) -------------------------------------------------------------------------------- /unittests/vm/EngineTest.cpp: -------------------------------------------------------------------------------- 1 | // @copyright 2017-2018 zzu_softboy 2 | // 3 | // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 4 | // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 5 | // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 6 | // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 7 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 8 | // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 9 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 10 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 11 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 12 | // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 13 | // 14 | // Created by zzu_softboy on 27/07/2017. 15 | 16 | #include "php/sapi/embed/php_embed.h" 17 | #include "gtest/gtest.h" 18 | 19 | #include "zapi/vm/Engine.h" 20 | #include "zapi/ds/Variant.h" 21 | #include 22 | 23 | using zapi::vm::Engine; 24 | 25 | TEST(EngineTest, testEval) 26 | { 27 | std::string code; 28 | code += "$name = \"zapi\";" 29 | "echo $name;"; 30 | // Engine::eval(code); 31 | } 32 | 33 | int main(int argc, char **argv) 34 | { 35 | int retCode = 0; 36 | PHP_EMBED_START_BLOCK(argc,argv); 37 | ::testing::InitGoogleTest(&argc, argv); 38 | retCode = RUN_ALL_TESTS(); 39 | PHP_EMBED_END_BLOCK(); 40 | return retCode; 41 | } --------------------------------------------------------------------------------