summaryrefslogtreecommitdiff
path: root/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp.cxx')
-rw-r--r--bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp.cxx595
1 files changed, 0 insertions, 595 deletions
diff --git a/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp.cxx b/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp.cxx
index 471fc339fdcb..1ab4839fd88d 100644
--- a/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp.cxx
+++ b/bridges/source/cpp_uno/gcc3_ios_arm/uno2cpp.cxx
@@ -17,13 +17,6 @@
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
-
-#include <stdio.h>
-
-#include <com/sun/star/uno/genfunc.hxx>
-#include "com/sun/star/uno/RuntimeException.hpp"
-#include <uno/data.h>
-
#include "bridges/cpp_uno/shared/bridge.hxx"
#include "bridges/cpp_uno/shared/types.hxx"
#include "bridges/cpp_uno/shared/unointerfaceproxy.hxx"
@@ -31,594 +24,6 @@
#include "share.hxx"
-using namespace ::rtl;
using namespace ::com::sun::star::uno;
-#ifdef __arm
-
-namespace arm
-{
- bool is_complex_struct(const typelib_TypeDescription * type)
- {
- const typelib_CompoundTypeDescription * p
- = reinterpret_cast< const typelib_CompoundTypeDescription * >(type);
- for (sal_Int32 i = 0; i < p->nMembers; ++i)
- {
- if (p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_STRUCT ||
- p->ppTypeRefs[i]->eTypeClass == typelib_TypeClass_EXCEPTION)
- {
- typelib_TypeDescription * t = 0;
- TYPELIB_DANGER_GET(&t, p->ppTypeRefs[i]);
- bool b = is_complex_struct(t);
- TYPELIB_DANGER_RELEASE(t);
- if (b) {
- return true;
- }
- }
- else if (!bridges::cpp_uno::shared::isSimpleType(p->ppTypeRefs[i]->eTypeClass))
- return true;
- }
- if (p->pBaseTypeDescription != 0)
- return is_complex_struct(&p->pBaseTypeDescription->aBase);
- return false;
- }
-
-#ifdef __ARM_PCS_VFP
- bool is_float_only_struct(const typelib_TypeDescription * type)
- {
- const typelib_CompoundTypeDescription * p
- = reinterpret_cast< const typelib_CompoundTypeDescription * >(type);
- for (sal_Int32 i = 0; i < p->nMembers; ++i)
- {
- if (p->ppTypeRefs[i]->eTypeClass != typelib_TypeClass_FLOAT &&
- p->ppTypeRefs[i]->eTypeClass != typelib_TypeClass_DOUBLE)
- return false;
- }
- return true;
- }
-#endif
- bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef )
- {
- if (bridges::cpp_uno::shared::isSimpleType(pTypeRef))
- return false;
- else if (pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION)
- {
- typelib_TypeDescription * pTypeDescr = 0;
- TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
-
- //A Composite Type not larger than 4 bytes is returned in r0
- bool bRet = pTypeDescr->nSize > 4 || is_complex_struct(pTypeDescr);
-
-#ifdef __ARM_PCS_VFP
- // In the VFP ABI, structs with only float/double values that fit in
- // 16 bytes are returned in registers
- if( pTypeDescr->nSize <= 16 && is_float_only_struct(pTypeDescr))
- bRet = false;
-#endif
-
- TYPELIB_DANGER_RELEASE( pTypeDescr );
- return bRet;
- }
- return true;
- }
-}
-
-void MapReturn(sal_uInt32 r0, sal_uInt32 r1, typelib_TypeDescriptionReference * pReturnType, sal_uInt32* pRegisterReturn)
-{
- switch( pReturnType->eTypeClass )
- {
- case typelib_TypeClass_HYPER:
- case typelib_TypeClass_UNSIGNED_HYPER:
- pRegisterReturn[1] = r1;
- case typelib_TypeClass_LONG:
- case typelib_TypeClass_UNSIGNED_LONG:
- case typelib_TypeClass_ENUM:
- case typelib_TypeClass_CHAR:
- case typelib_TypeClass_SHORT:
- case typelib_TypeClass_UNSIGNED_SHORT:
- case typelib_TypeClass_BOOLEAN:
- case typelib_TypeClass_BYTE:
- pRegisterReturn[0] = r0;
- break;
- case typelib_TypeClass_FLOAT:
-#if !defined(__ARM_PCS_VFP) && (defined(__ARM_EABI__) || defined(__SOFTFP__))
- pRegisterReturn[0] = r0;
-#else
- register float fret asm("s0");
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wuninitialized"
- *(float*)pRegisterReturn = fret;
-#pragma GCC diagnostic pop
-#endif
- break;
- case typelib_TypeClass_DOUBLE:
-#if !defined(__ARM_PCS_VFP) && (defined(__ARM_EABI__) || defined(__SOFTFP__))
- pRegisterReturn[1] = r1;
- pRegisterReturn[0] = r0;
-#else
- register double dret asm("d0");
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wuninitialized"
- *(double*)pRegisterReturn = dret;
-#pragma GCC diagnostic pop
-#endif
- break;
- case typelib_TypeClass_STRUCT:
- case typelib_TypeClass_EXCEPTION:
- {
- if (!arm::return_in_hidden_param(pReturnType))
- pRegisterReturn[0] = r0;
- break;
- }
- default:
- break;
- }
-}
-
-#endif
-
-namespace
-{
-
-//==================================================================================================
-// The call instruction within the asm section of callVirtualMethod may throw
-// exceptions. So that the compiler handles this correctly, it is important
-// that (a) callVirtualMethod might call dummy_can_throw_anything (although this
-// never happens at runtime), which in turn can throw exceptions, and (b)
-// callVirtualMethod is not inlined at its call site (so that any exceptions are
-// caught which are thrown from the instruction calling callVirtualMethod):
-void callVirtualMethod(
- void * pAdjustedThisPtr,
- sal_Int32 nVtableIndex,
- void * pRegisterReturn,
- typelib_TypeDescription * pReturnTypeDescr, bool bSimpleReturn,
- sal_Int32 * pStackLongs,
- sal_Int32 nStackLongs ) __attribute__((noinline));
-
-void callVirtualMethod(
- void * pAdjustedThisPtr,
- sal_Int32 nVtableIndex,
- void * pRegisterReturn,
- typelib_TypeDescription * pReturnTypeDescr, bool bSimpleReturn,
- sal_Int32 * pStackLongs,
- sal_Int32 nStackLongs )
-{
- // parameter list is mixed list of * and values
- // reference parameters are pointers
-
- OSL_ENSURE( pStackLongs && pAdjustedThisPtr, "### null ptr!" );
- OSL_ENSURE( (sizeof(void *) == 4) && (sizeof(sal_Int32) == 4), "### unexpected size of int!" );
- OSL_ENSURE( nStackLongs && pStackLongs, "### no stack in callVirtualMethod !" );
-
- // never called
- if (! pAdjustedThisPtr) CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something
-
-#ifdef __arm
-
- // Implement!!!
- abort();
- (void) nVtableIndex;
- (void) pRegisterReturn;
- (void) pReturnTypeDescr;
- (void) bSimpleReturn;
-
-#else
- volatile long edx = 0, eax = 0; // for register returns
- void * stackptr = 0;
- asm volatile (
- "mov %%esp, %6\n\t"
- "mov %0, %%eax\n\t"
- "mov %%eax, %%edx\n\t"
- // stack padding to keep stack aligned:
- "shl $2, %%eax\n\t"
- "neg %%eax\n\t"
- "add %%esp, %%eax\n\t"
- "and $0xf, %%eax\n\t"
- "sub %%eax, %%esp\n\t"
- // copy:
- "mov %%edx, %%eax\n\t"
- "dec %%edx\n\t"
- "shl $2, %%edx\n\t"
- "add %1, %%edx\n"
- "Lcopy:\n\t"
- "pushl 0(%%edx)\n\t"
- "sub $4, %%edx\n\t"
- "dec %%eax\n\t"
- "jne Lcopy\n\t"
- // do the actual call
- "mov %2, %%edx\n\t"
- "mov 0(%%edx), %%edx\n\t"
- "mov %3, %%eax\n\t"
- "shl $2, %%eax\n\t"
- "add %%eax, %%edx\n\t"
- "mov 0(%%edx), %%edx\n\t"
- "call *%%edx\n\t"
- // save return registers
- "mov %%eax, %4\n\t"
- "mov %%edx, %5\n\t"
- // cleanup stack
- "mov %6, %%esp\n\t"
- :
- : "m"(nStackLongs), "m"(pStackLongs), "m"(pAdjustedThisPtr),
- "m"(nVtableIndex), "m"(eax), "m"(edx), "m"(stackptr)
- : "eax", "edx" );
- switch( pReturnTypeDescr->eTypeClass )
- {
- case typelib_TypeClass_VOID:
- break;
- case typelib_TypeClass_HYPER:
- case typelib_TypeClass_UNSIGNED_HYPER:
- ((long*)pRegisterReturn)[1] = edx;
- case typelib_TypeClass_LONG:
- case typelib_TypeClass_UNSIGNED_LONG:
- case typelib_TypeClass_CHAR:
- case typelib_TypeClass_ENUM:
- ((long*)pRegisterReturn)[0] = eax;
- break;
- case typelib_TypeClass_SHORT:
- case typelib_TypeClass_UNSIGNED_SHORT:
- *(unsigned short*)pRegisterReturn = eax;
- break;
- case typelib_TypeClass_BOOLEAN:
- case typelib_TypeClass_BYTE:
- *(unsigned char*)pRegisterReturn = eax;
- break;
- case typelib_TypeClass_FLOAT:
- asm ( "fstps %0" : : "m"(*(char *)pRegisterReturn) );
- break;
- case typelib_TypeClass_DOUBLE:
- asm ( "fstpl %0\n\t" : : "m"(*(char *)pRegisterReturn) );
- break;
- default: {
- sal_Int32 const nRetSize = pReturnTypeDescr->nSize;
- if (bSimpleReturn && nRetSize <= 8 && nRetSize > 0) {
- if (nRetSize > 4)
- static_cast<long *>(pRegisterReturn)[1] = edx;
- static_cast<long *>(pRegisterReturn)[0] = eax;
- }
- break;
- }
- }
-#endif
-}
-
-//==================================================================================================
-static void cpp_call(
- bridges::cpp_uno::shared::UnoInterfaceProxy * pThis,
- bridges::cpp_uno::shared::VtableSlot aVtableSlot,
- typelib_TypeDescriptionReference * pReturnTypeRef,
- sal_Int32 nParams, typelib_MethodParameter * pParams,
- void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
-{
- // max space for: [complex ret ptr], values|ptr ...
- char * pCppStack =
- (char *)alloca( sizeof(sal_Int32) + ((nParams+2) * sizeof(sal_Int64)) );
- char * pCppStackStart = pCppStack;
-
- // return
- typelib_TypeDescription * pReturnTypeDescr = 0;
- TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
- OSL_ENSURE( pReturnTypeDescr, "### expected return type description!" );
-
- void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
- bool bSimpleReturn = true;
-
- if (pReturnTypeDescr)
- {
-#ifdef __arm
- if (arm::return_in_hidden_param( pReturnTypeRef ) )
- bSimpleReturn = false;
-#else
- bSimpleReturn = CPPU_CURRENT_NAMESPACE::isSimpleReturnType(
- pReturnTypeDescr);
-#endif
- if (bSimpleReturn)
- {
- pCppReturn = pUnoReturn; // direct way for simple types
- }
- else
- {
- pCppReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(
- pReturnTypeDescr )
- ? alloca( pReturnTypeDescr->nSize )
- : pUnoReturn); // direct way
- // complex return via ptr
- *(void **)pCppStack = pCppReturn;
- pCppStack += sizeof(void *);
- }
- }
- // push this
- void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
- + aVtableSlot.offset;
- *(void**)pCppStack = pAdjustedThisPtr;
- pCppStack += sizeof( void* );
-
- // stack space
- OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
- // args
- void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams );
- // indizes of values this have to be converted (interface conversion cpp<=>uno)
- sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
- // type descriptions for reconversions
- typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
-
- sal_Int32 nTempIndizes = 0;
-
- for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
- {
- const typelib_MethodParameter & rParam = pParams[nPos];
- typelib_TypeDescription * pParamTypeDescr = 0;
- TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
-
- if (!rParam.bOut
- && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
- {
- uno_copyAndConvertData( pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTypeDescr,
- pThis->getBridge()->getUno2Cpp() );
-
- switch (pParamTypeDescr->eTypeClass)
- {
- case typelib_TypeClass_HYPER:
- case typelib_TypeClass_UNSIGNED_HYPER:
- case typelib_TypeClass_DOUBLE:
- pCppStack += sizeof(sal_Int32); // extra long
- default:
- break;
- }
- // no longer needed
- TYPELIB_DANGER_RELEASE( pParamTypeDescr );
- }
- else // ptr to complex value | ref
- {
- if (! rParam.bIn) // is pure out
- {
- // cpp out is constructed mem, uno out is not!
- uno_constructData(
- *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
- pParamTypeDescr );
- pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
- // will be released at reconversion
- ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
- }
- // is in/inout
- else if (bridges::cpp_uno::shared::relatesToInterfaceType(
- pParamTypeDescr ))
- {
- uno_copyAndConvertData(
- *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
- pUnoArgs[nPos], pParamTypeDescr,
- pThis->getBridge()->getUno2Cpp() );
-
- pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
- // will be released at reconversion
- ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
- }
- else // direct way
- {
- *(void **)pCppStack = pCppArgs[nPos] = pUnoArgs[nPos];
- // no longer needed
- TYPELIB_DANGER_RELEASE( pParamTypeDescr );
- }
- }
- pCppStack += sizeof(sal_Int32); // standard parameter length
- }
-
- try
- {
- OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic)" );
- callVirtualMethod(
- pAdjustedThisPtr, aVtableSlot.index,
- pCppReturn, pReturnTypeDescr, bSimpleReturn,
- (sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) );
- // NO exception occurred...
- *ppUnoExc = 0;
-
- // reconvert temporary params
- for ( ; nTempIndizes--; )
- {
- sal_Int32 nIndex = pTempIndizes[nTempIndizes];
- typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
-
- if (pParams[nIndex].bIn)
- {
- if (pParams[nIndex].bOut) // inout
- {
- uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
- uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
- pThis->getBridge()->getCpp2Uno() );
- }
- }
- else // pure out
- {
- uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
- pThis->getBridge()->getCpp2Uno() );
- }
- // destroy temp cpp param => cpp: every param was constructed
- uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
-
- TYPELIB_DANGER_RELEASE( pParamTypeDescr );
- }
- // return value
- if (pCppReturn && pUnoReturn != pCppReturn)
- {
- uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
- pThis->getBridge()->getCpp2Uno() );
- uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
- }
- }
- catch (...)
- {
-#if OSL_DEBUG_LEVEL > 1
- fprintf( stderr, "caught C++ exception\n" );
-#endif
- // fill uno exception
- fillUnoException( CPPU_CURRENT_NAMESPACE::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
-
- // temporary params
- for ( ; nTempIndizes--; )
- {
- sal_Int32 nIndex = pTempIndizes[nTempIndizes];
- // destroy temp cpp param => cpp: every param was constructed
- uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
- TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
- }
- // return type
- if (pReturnTypeDescr)
- TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
- }
-}
-
-}
-
-namespace CPPU_CURRENT_NAMESPACE {
-bool isSimpleReturnType(typelib_TypeDescription * pTD, bool recursive)
-{
- if (bridges::cpp_uno::shared::isSimpleType( pTD ))
- return true;
- // Only structs of exactly 1, 2, 4, or 8 bytes are returned through
- // registers, see <http://developer.apple.com/documentation/DeveloperTools/
- // Conceptual/LowLevelABI/Articles/IA32.html>:
- if (pTD->eTypeClass == typelib_TypeClass_STRUCT &&
- (recursive || pTD->nSize <= 2 || pTD->nSize == 4 || pTD->nSize == 8))
- {
- typelib_CompoundTypeDescription *const pCompTD =
- (typelib_CompoundTypeDescription *) pTD;
- for ( sal_Int32 pos = pCompTD->nMembers; pos--; ) {
- typelib_TypeDescription * pMemberTD = 0;
- TYPELIB_DANGER_GET( &pMemberTD, pCompTD->ppTypeRefs[pos] );
- bool const b = isSimpleReturnType(pMemberTD, true);
- TYPELIB_DANGER_RELEASE( pMemberTD );
- if (! b)
- return false;
- }
- return true;
- }
- return false;
-}
-}
-
-//==================================================================================================
-
-namespace bridges { namespace cpp_uno { namespace shared {
-void unoInterfaceProxyDispatch(
- uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
- void * pReturn, void * pArgs[], uno_Any ** ppException )
-{
- // is my surrogate
- bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
- = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
-
- switch (pMemberDescr->eTypeClass)
- {
- case typelib_TypeClass_INTERFACE_ATTRIBUTE:
- {
- VtableSlot aVtableSlot(
- getVtableSlot(
- reinterpret_cast<
- typelib_InterfaceAttributeTypeDescription const * >(
- pMemberDescr)));
- if (pReturn)
- {
- // dependent dispatch
- cpp_call(
- pThis, aVtableSlot,
- ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
- 0, 0, // no params
- pReturn, pArgs, ppException );
- }
- else
- {
- // is SET
- typelib_MethodParameter aParam;
- aParam.pTypeRef =
- ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
- aParam.bIn = sal_True;
- aParam.bOut = sal_False;
-
- typelib_TypeDescriptionReference * pReturnTypeRef = 0;
- OUString aVoidName( RTL_CONSTASCII_USTRINGPARAM("void") );
- typelib_typedescriptionreference_new(
- &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
-
- // dependent dispatch
- aVtableSlot.index += 1; // get, then set method
- cpp_call(
- pThis, aVtableSlot,
- pReturnTypeRef,
- 1, &aParam,
- pReturn, pArgs, ppException );
-
- typelib_typedescriptionreference_release( pReturnTypeRef );
- }
-
- break;
- }
- case typelib_TypeClass_INTERFACE_METHOD:
- {
- VtableSlot aVtableSlot(
- getVtableSlot(
- reinterpret_cast<
- typelib_InterfaceMethodTypeDescription const * >(
- pMemberDescr)));
- switch (aVtableSlot.index)
- {
- // standard calls
- case 1: // acquire uno interface
- (*pUnoI->acquire)( pUnoI );
- *ppException = 0;
- break;
- case 2: // release uno interface
- (*pUnoI->release)( pUnoI );
- *ppException = 0;
- break;
- case 0: // queryInterface() opt
- {
- typelib_TypeDescription * pTD = 0;
- TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );
- if (pTD)
- {
- uno_Interface * pInterface = 0;
- (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
- pThis->pBridge->getUnoEnv(),
- (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
-
- if (pInterface)
- {
- ::uno_any_construct(
- reinterpret_cast< uno_Any * >( pReturn ),
- &pInterface, pTD, 0 );
- (*pInterface->release)( pInterface );
- TYPELIB_DANGER_RELEASE( pTD );
- *ppException = 0;
- break;
- }
- TYPELIB_DANGER_RELEASE( pTD );
- }
- } // else perform queryInterface()
- default:
- // dependent dispatch
- cpp_call(
- pThis, aVtableSlot,
- ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
- ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
- ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
- pReturn, pArgs, ppException );
- }
- break;
- }
- default:
- {
- ::com::sun::star::uno::RuntimeException aExc(
- OUString( RTL_CONSTASCII_USTRINGPARAM("illegal member type description!") ),
- ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );
-
- Type const & rExcType = ::getCppuType( &aExc );
- // binary identical null reference
- ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
- }
- }
-}
-
-} } }
-
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-14 15:53:52 +0000