🏮 🤜🏻 🈲 Extensión PHP y Kotlin Native. Segunda parte, consciente 💇🏾 👃🏽 🤨

Resumen de la primera parte :

Instalación y configuración de herramientas.
Escribir la función helloWorld() en Kotlin Native y compilarla en una biblioteca compartida.
Acceda a esta función desde el código C de la extensión PHP.

En este artículo, hablaré sobre la creación de herramientas para escribir una extensión PHP sin tener que tocar C, exclusivamente en K / N.

A quién le importa, bienvenido a cat.
Quien lee no está interesado, pero solo quiere verlo - bienvenido a github

Al principio, quiero agradecer a Nikolai Igotti por las respuestas rápidas y de alta calidad a mis preguntas, a veces tontas e ingenuas, en el canal de Kotlin Native.

Inmediatamente haga una reserva que no pretendo crear un marco completo (tal vez más adelante), por lo tanto, limitaremos la funcionalidad de esta manera:

Creación de funciones que se pueden invocar desde código PHP.
Definición de constantes.
Operamos solo con tipos PHP simples: string , boolean , int , float (y null ). Sin matrices, objetos, recursos, transferencias por referencia, etc. - Te diré por qué a continuación.

Lo específico del desarrollo de extensiones PHP es que casi todo el código de utilidad y la comunicación con el zend engine escritos en macros. Por un lado, facilita enormemente la escritura de extensiones en C y, por otro lado, hace que sea muy difícil hacer lo mismo en todos los demás lenguajes de programación.

Con tal introducción, la solución más obvia era usar el coderinario. Y, dado que Kotlin ofrece posibilidades muy amplias para crear DSL, el proceso de describir la estructura de extensión puede hacerse simple e intuitivo.

Para construir la biblioteca de extensiones de una manera clásica (phpize, configure, make), se necesitan al menos dos artefactos: el código de extensión en C y el archivo config.m4 .

El escenario de uso será así:

Usando DSL, describimos la extensión.
Escribimos la implementación de funciones en K / N.
Según la descripción, generamos extension.c y config.m4 . El código en extencion.c se ocupará de la representación banal de llamadas a funciones.
De acuerdo con la descripción, generamos constants.kt , que nos permite usar las constantes dadas en nuestras funciones en K / N.
Compilamos código K / N en una biblioteca estática.
Poner todo junto y compilarlo en una biblioteca de extensiones.

Vamos!

Para implementar nuestro plan, necesitamos obtener algo como esta estructura:

 (, ) 1 2 ... 1(,  ) 1 2 ... 1 ...

Creo que no sería difícil para cualquiera que trabaje con Kotlin escribir el DSL apropiado. Por lo demás, hay una gran cantidad de artículos especializados en los que este tema se trata con mucho más detalle que si trato de hacer esto como parte de este artículo.

El siguiente paso es convertir este DSL en los artefactos necesarios. Para hacer esto, escribiremos un generador en el mismo K / N, compilaremos un archivo ejecutable a partir de él y nuestro DSL y lo ejecutaremos, ¡listo! La solución no es la más elegante, pero aún no se me ha ocurrido nada más simple y confiable.

Bueno, entonces todo es simple: compilamos la biblioteca con funciones y recopilamos la extensión de forma regular, incluyéndola allí.

Para facilitar su uso, toda la magia con la compilación está oculta en un script de shell.

Lo que vino de eso

Un ejemplo de la descripción y el código generado para la extensión simple descrita en este DSL ( para una mejor comprensión, todos los argumentos se dan en una forma con nombre ).

konfigure.kt - Extensiones DSL

 import php.extension.dsl.* val dsl = extension(name = "example", version = "0.1") { constant(name = "HELLO_EN", value = "Hello") constant(name = "HELLO_ES", value = "Hola") constant(name = "HELLO_RU", value = "") function(name = "hello", returnType = ArgumentType.STRING) { arg(type = ArgumentType.STRING, name = "name") arg(type = ArgumentType.STRING, name = "lang", optional = true) } } fun main(args: Array<String>) = dsl.make()

example.kt - Implementando funciones

 fun hello(name: String, lang: String?) = "${if (lang ?: "" == "") HELLO_EN else lang} $name!!!\n"

Tenga en cuenta el extraño algoritmo para determinar el valor de `lang`. Esto se debe a un error en la versión actual de K / N, que no permite pasar una variable no inicializada de tipo `char *` como argumento de C. - tiene que pasar una cadena vacía.

config.m4 - archivo generado

 PHP_ARG_ENABLE(example, whether to enable example support,[ --enable-example Enable hello support]) if test "$PHP_EXAMPLE" != "no"; then PHP_ADD_INCLUDE(.) PHP_ADD_LIBRARY_WITH_PATH(example_kt, ., EXAMPLE_SHARED_LIBADD) PHP_SUBST(EXAMPLE_SHARED_LIBADD) PHP_NEW_EXTENSION(example, example.c, $ext_shared) fi

example_generated_constants.kt - archivo generado con constantes de Kotlin

 const val HELLO_EN = "Hello" const val HELLO_ES = "Hola" const val HELLO_RU = ""

ejemplo.c: archivo generado con código C

 #include "php.h" #include "example_kt_api.h" PHP_FUNCTION(hello); static zend_function_entry example_functions[] = { PHP_FE(hello, NULL) {NULL,NULL,NULL} }; PHP_MINIT_FUNCTION(example); zend_module_entry example_module_entry = { #if ZEND_MODULE_API_NO >= 20010901 STANDARD_MODULE_HEADER, #endif "example", example_functions, PHP_MINIT(example), NULL, NULL, NULL, NULL, #if ZEND_MODULE_API_NO >= 20010901 "0.1", #endif STANDARD_MODULE_PROPERTIES }; ZEND_GET_MODULE(example) PHP_MINIT_FUNCTION(example) { REGISTER_STRING_CONSTANT("HELLO_EN", "Hello", CONST_CS|CONST_PERSISTENT); REGISTER_STRING_CONSTANT("HELLO_ES", "Hola", CONST_CS|CONST_PERSISTENT); REGISTER_STRING_CONSTANT("HELLO_RU", "", CONST_CS|CONST_PERSISTENT); return SUCCESS; } PHP_FUNCTION(hello){ //-,      char*  K/N char *name = malloc(1); name[0] = '\0'; size_t name_len=0; char *lang = malloc(1); lang[0] = '\0'; size_t lang_len=0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &name, &name_len, &lang, &lang_len) == FAILURE) { return; } RETURN_STRING(example_kt_symbols()->kotlin.root.hello(name, lang)); }

Acerca de por qué solo los tipos simples

Porque están asignados uno a uno a los tipos nativos de Kotlin. Hasta la fecha, el proyecto implementa, de hecho, interoperabilidad solo en una dirección, es decir llamando a funciones K / N desde C. Para procesar tipos complejos, como zend_value , zend_class_entry o zend_fcall_info , debe importar las estructuras correspondientes en el proyecto K / N y escribir los contenedores apropiados para trabajar con ellos, y también están todas las macros, etc.

Tarro con alquitrán. Se adjunta una cuchara.

Documentación nativa de Kotlin. Parece estar allí, pero ... Hasta ahora, el medio más confiable de estudiar es leer la fuente.
El tamaño de la extensión resultante no es tan pequeño. Para el ejemplo anterior, se obtiene una biblioteca de aproximadamente 500 KB.
Ni siquiera tiene que esperar que las extensiones escritas en K / N terminen en la biblioteca de extensiones PHP. El producto se obtiene, por así decirlo, solo para uso interno.

Que sigue

Implemente todo lo que se describe en la sección "Acerca de por qué solo los tipos simples".

Una vez más, un enlace al repositorio .

Gracias por su atención, deséenme buena suerte :)