Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:124893
Precedence: bulk
MIME-Version: 1.0
References: <CAAKU0unG1ZOmzE=YnbTTmNpsuJr1PX--79fjByC473KHzN008w@mail.gmail.com>
 <3F5C5B7F-6EE5-437D-9E4A-4C86EC103E7A@getmailspring.com>
In-Reply-To: <3F5C5B7F-6EE5-437D-9E4A-4C86EC103E7A@getmailspring.com>
Date: Mon, 12 Aug 2024 10:27:25 -0600
Message-ID: <CAM7F2--3o6kD+2QgV+KuWZsU=CLPh9vsNU8xqApcswTDqAvoVw@mail.gmail.com>
Subject: Re: [PHP-DEV] [DISCUSSION] C++ Enhancements in Zend API
To: John Coggeshall <john@coggeshall.org>
Cc: Levi Morrison <levi.morrison@datadoghq.com>, PHP internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary="00000000000080f91f061f7ef8a5"
From: lnearwaju@gmail.com (Lanre)

--00000000000080f91f061f7ef8a5
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Mon, Aug 12, 2024 at 9:58=E2=80=AFAM John Coggeshall <john@coggeshall.or=
g> wrote:

>
> > I=E2=80=99m considering adding some C++ enhancements to the Zend API.
>
>
> I would definitely like to see an RFC for this if it was to be considered=
.
> To me, adding a whole new way of doing things internally without complete=
ly
> removing the old way is just asking for a more brittle, potentially less
> secure, and harder to maintain codebase. The win of making it easier /
> "nicer" on a subset of developers who might prefer a C++ interface isn't
> anywhere near worth the risk IMO.
>

You aren't making any sense. Why would we remove the old way? Or why should
that be a prerequisite to improving the current API? How are functions that
simply proxy the C API inherently 'more brittle, potentially less secure,
and harder to maintain'? You haven't even seen the code in question?

```cxx
    TVal(const zval *other) : TVal() { ZVAL_COPY(this, other); }
    TVal(zend_long value) : TVal() { ZVAL_LONG(this, value); }
    TVal(int value) : TVal() { ZVAL_LONG(this, value); }
    TVal(size_t value) : TVal() { ZVAL_LONG(this, value); }
    TVal(bool value) : TVal() { ZVAL_BOOL(this, value); }
    TVal(std::string_view value) : TVal() { ZVAL_STRINGL(this,
value.data(), value.size()); }
    TVal(double value) : TVal() { ZVAL_DOUBLE(this, value); }
    TVal(const char *value) : TVal() { ZVAL_STRING(this, value); }
    TVal(const std::string &value) : TVal() { ZVAL_STRINGL(this,
value.c_str(), value.size()); }
    bool IsNull() const { return Z_TYPE_P(this) =3D=3D IS_NULL; }
    bool IsTrue() const { return Z_TYPE_P(this) =3D=3D IS_TRUE; }
    bool IsFalse() const { return Z_TYPE_P(this) =3D=3D IS_FALSE; }
    bool IsBool() const { return Z_TYPE_P(this) =3D=3D IS_TRUE ||
Z_TYPE_P(this) =3D=3D IS_FALSE; }
    bool IsLong() const { return Z_TYPE_P(this) =3D=3D IS_LONG; }
    bool IsDouble() const { return Z_TYPE_P(this) =3D=3D IS_DOUBLE; }
    bool IsString() const { return Z_TYPE_P(this) =3D=3D IS_STRING; }
    bool IsArray() const { return Z_TYPE_P(this) =3D=3D IS_ARRAY; }
    bool IsObject() const { return Z_TYPE_P(this) =3D=3D IS_OBJECT; }
    bool IsInstanceOf(zend_class_entry *ce) const {
        return Z_TYPE_P(this) =3D=3D IS_OBJECT && (ce =3D=3D Z_OBJCE_P(this=
) ||
instanceof_function(Z_OBJCE_P(this), ce));
    }
    bool IsCallable() const { return zend_is_callable((zval *) this, 0,
nullptr); }
    bool IsResource() const { return Z_TYPE_P(this) =3D=3D IS_RESOURCE; }
    bool IsReference() const { return Z_ISREF_P(this); }
```

The above is a snippet from my current implementation, so please elaborate
on which part of that is so crazy to you.

Cheers,
Lanre.

--00000000000080f91f061f7ef8a5
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div dir=3D"ltr"><br></div><br><div class=3D"gmail_quote">=
<div dir=3D"ltr" class=3D"gmail_attr">On Mon, Aug 12, 2024 at 9:58=E2=80=AF=
AM John Coggeshall &lt;<a href=3D"mailto:john@coggeshall.org">john@coggesha=
ll.org</a>&gt; wrote:<br></div><blockquote class=3D"gmail_quote" style=3D"m=
argin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left=
:1ex"><br><blockquote><div><div>&gt; I=E2=80=99m considering adding some C+=
+ enhancements to the Zend API.</div></div></blockquote><br><div>I would de=
finitely like to see an RFC for this if it was to be considered. To me, add=
ing a whole new way of doing things internally without completely removing =
the old way is just asking for a more brittle, potentially less secure, and=
 harder to maintain codebase. The win of making it easier / &quot;nicer&quo=
t; on a subset of developers who might prefer a C++ interface isn&#39;t any=
where near worth the risk IMO.</div></blockquote><div><br></div><div>You ar=
en&#39;t making any sense. Why would we remove the old way? Or why should t=
hat be a prerequisite to improving the current API? How are functions that =
simply proxy the C API inherently &#39;more brittle, potentially less secur=
e, and harder to maintain&#39;? You haven&#39;t even seen the code in quest=
ion?</div><div><br></div><div>```cxx</div><div>=C2=A0 =C2=A0 TVal(const zva=
l *other) : TVal() { ZVAL_COPY(this, other); }<br>=C2=A0 =C2=A0 TVal(zend_l=
ong value) : TVal() { ZVAL_LONG(this, value); }<br>=C2=A0 =C2=A0 TVal(int v=
alue) : TVal() { ZVAL_LONG(this, value); }<br>=C2=A0 =C2=A0 TVal(size_t val=
ue) : TVal() { ZVAL_LONG(this, value); }<br>=C2=A0 =C2=A0 TVal(bool value) =
: TVal() { ZVAL_BOOL(this, value); }<br>=C2=A0 =C2=A0 TVal(std::string_view=
 value) : TVal() { ZVAL_STRINGL(this, value.data(), value.size()); }<br>=C2=
=A0 =C2=A0 TVal(double value) : TVal() { ZVAL_DOUBLE(this, value); }<br>=C2=
=A0 =C2=A0 TVal(const char *value) : TVal() { ZVAL_STRING(this, value); }<b=
r>=C2=A0 =C2=A0 TVal(const std::string &amp;value) : TVal() { ZVAL_STRINGL(=
this, value.c_str(), value.size()); }<br>=C2=A0 =C2=A0 bool IsNull() const =
{ return Z_TYPE_P(this) =3D=3D IS_NULL; }<br>=C2=A0 =C2=A0 bool IsTrue() co=
nst { return Z_TYPE_P(this) =3D=3D IS_TRUE; }<br>=C2=A0 =C2=A0 bool IsFalse=
() const { return Z_TYPE_P(this) =3D=3D IS_FALSE; }<br>=C2=A0 =C2=A0 bool I=
sBool() const { return Z_TYPE_P(this) =3D=3D IS_TRUE || Z_TYPE_P(this) =3D=
=3D IS_FALSE; }<br>=C2=A0 =C2=A0 bool IsLong() const { return Z_TYPE_P(this=
) =3D=3D IS_LONG; }<br>=C2=A0 =C2=A0 bool IsDouble() const { return Z_TYPE_=
P(this) =3D=3D IS_DOUBLE; }<br>=C2=A0 =C2=A0 bool IsString() const { return=
 Z_TYPE_P(this) =3D=3D IS_STRING; }<br>=C2=A0 =C2=A0 bool IsArray() const {=
 return Z_TYPE_P(this) =3D=3D IS_ARRAY; }<br>=C2=A0 =C2=A0 bool IsObject() =
const { return Z_TYPE_P(this) =3D=3D IS_OBJECT; }<br>=C2=A0 =C2=A0 bool IsI=
nstanceOf(zend_class_entry *ce) const {<br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 retu=
rn Z_TYPE_P(this) =3D=3D IS_OBJECT &amp;&amp; (ce =3D=3D Z_OBJCE_P(this) ||=
 instanceof_function(Z_OBJCE_P(this), ce));<br>=C2=A0 =C2=A0 }<br>=C2=A0 =
=C2=A0 bool IsCallable() const { return zend_is_callable((zval *) this, 0, =
nullptr); }<br>=C2=A0 =C2=A0 bool IsResource() const { return Z_TYPE_P(this=
) =3D=3D IS_RESOURCE; }<br>=C2=A0 =C2=A0 bool IsReference() const { return =
Z_ISREF_P(this); }<br></div><div>```</div><div><br></div><div>The above is =
a snippet from my current implementation, so please elaborate on which part=
 of that is so crazy to you.</div><div><br></div><div>Cheers,<br>Lanre.</di=
v><div><br></div></div></div>

--00000000000080f91f061f7ef8a5--