src/apps_remotectl_skel.c - platform/external/fastrpc - Git at Google


            
            /*

            
             * Copyright (c) 2019, The Linux Foundation. All rights reserved.

            
             *

            
             * Redistribution and use in source and binary forms, with or without

            
             * modification, are permitted provided that the following conditions are

            
             * met:

            
             *    * Redistributions of source code must retain the above copyright

            
             *      notice, this list of conditions and the following disclaimer.

            
             *    * Redistributions in binary form must reproduce the above

            
             *      copyright notice, this list of conditions and the following

            
             *      disclaimer in the documentation and/or other materials provided

            
             *      with the distribution.

            
             *    * Neither the name of The Linux Foundation nor the names of its

            
             *      contributors may be used to endorse or promote products derived

            
             *      from this software without specific prior written permission.

            
             *

            
             * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED

            
             * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

            
             * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT

            
             * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS

            
             * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

            
             * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

            
             * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

            
             * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

            
             * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE

            
             * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN

            
             * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

            
             */

            
            #ifndef _APPS_REMOTECTL_SKEL_H

            
            #define _APPS_REMOTECTL_SKEL_H

            
            #include "apps_remotectl.h"

            
            #include "remote.h"

            
            #include <string.h>

            
            #ifndef ALLOCATOR_H

            
            #define ALLOCATOR_H


            #include <stdlib.h>

            
            #include <stdint.h>


            typedef struct _heap _heap;

            
            struct _heap {

            
               _heap* pPrev;

            
               const char* loc;

            
               uint64_t buf;

            
            };


            typedef struct allocator {

            
               _heap* pheap;

            
               uint8_t* stack;

            
               uint8_t* stackEnd;

            
               int nSize;

            
            } allocator;


            static __inline int _heap_alloc(_heap** ppa, const char* loc, int size, void** ppbuf) {

            
               _heap* pn = 0;

            
               pn = malloc(size + sizeof(_heap) - sizeof(uint64_t));

            
               if(pn != 0) {

            
                  pn->pPrev = *ppa;

            
                  pn->loc = loc;

            
                  *ppa = pn;

            
                  *ppbuf = (void*)&(pn->buf);

            
                  return 0;

            
               } else {

            
                  return -1;

            
               }

            
            }

            
            #define _ALIGN_SIZE(x, y) (((x) + (y-1)) & ~(y-1))


            static __inline int allocator_alloc(allocator* me,

            
                                                const char* loc,

            
                                                int size,

            
                                                unsigned int al,

            
                                                void** ppbuf) {

            
               if(size < 0) {

            
                  return -1;

            
               } else if (size == 0) {

            
                  *ppbuf = 0;

            
                  return 0;

            
               }

            
               if((_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size) < (uintptr_t)me->stack + me->nSize) {

            
                  *ppbuf = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al);

            
                  me->stackEnd = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size;

            
                  return 0;

            
               } else {

            
                  return _heap_alloc(&me->pheap, loc, size, ppbuf);

            
               }

            
            }


            static __inline void allocator_deinit(allocator* me) {

            
               _heap* pa = me->pheap;

            
               while(pa != 0) {

            
                  _heap* pn = pa;

            
                  const char* loc = pn->loc;

            
                  (void)loc;

            
                  pa = pn->pPrev;

            
                  free(pn);

            
               }

            
            }


            static __inline void allocator_init(allocator* me, uint8_t* stack, int stackSize) {

            
               me->stack =  stack;

            
               me->stackEnd =  stack + stackSize;

            
               me->nSize = stackSize;

            
               me->pheap = 0;

            
            }


            #endif // ALLOCATOR_H


            #ifndef SLIM_H

            
            #define SLIM_H


            #include <stdint.h>


            //a C data structure for the idl types that can be used to implement

            
            //static and dynamic language bindings fairly efficiently.

            
            //

            
            //the goal is to have a minimal ROM and RAM footprint and without

            
            //doing too many allocations.  A good way to package these things seemed

            
            //like the module boundary, so all the idls within  one module can share

            
            //all the type references.


            #define PARAMETER_IN       0x0

            
            #define PARAMETER_OUT      0x1

            
            #define PARAMETER_INOUT    0x2

            
            #define PARAMETER_ROUT     0x3

            
            #define PARAMETER_INROUT   0x4


            //the types that we get from idl

            
            #define TYPE_OBJECT             0x0

            
            #define TYPE_INTERFACE          0x1

            
            #define TYPE_PRIMITIVE          0x2

            
            #define TYPE_ENUM               0x3

            
            #define TYPE_STRING             0x4

            
            #define TYPE_WSTRING            0x5

            
            #define TYPE_STRUCTURE          0x6

            
            #define TYPE_UNION              0x7

            
            #define TYPE_ARRAY              0x8

            
            #define TYPE_SEQUENCE           0x9


            //these require the pack/unpack to recurse

            
            //so it's a hint to those languages that can optimize in cases where

            
            //recursion isn't necessary.

            
            #define TYPE_COMPLEX_STRUCTURE  (0x10 | TYPE_STRUCTURE)

            
            #define TYPE_COMPLEX_UNION      (0x10 | TYPE_UNION)

            
            #define TYPE_COMPLEX_ARRAY      (0x10 | TYPE_ARRAY)

            
            #define TYPE_COMPLEX_SEQUENCE   (0x10 | TYPE_SEQUENCE)


            typedef struct Type Type;


            #define INHERIT_TYPE\

            
               int32_t nativeSize;                /*in the simple case its the same as wire size and alignment*/\

            
               union {\

            
                  struct {\

            
                     const uintptr_t         p1;\

            
                     const uintptr_t         p2;\

            
                  } _cast;\

            
                  struct {\

            
                     uint32_t  iid;\

            
                     uint32_t  bNotNil;\

            
                  } object;\

            
                  struct {\

            
                     const Type  *arrayType;\

            
                     int32_t      nItems;\

            
                  } array;\

            
                  struct {\

            
                     const Type *seqType;\

            
                     int32_t      nMaxLen;\

            
                  } seqSimple; \

            
                  struct {\

            
                     uint32_t bFloating;\

            
                     uint32_t bSigned;\

            
                  } prim; \

            
                  const SequenceType* seqComplex;\

            
                  const UnionType  *unionType;\

            
                  const StructType *structType;\

            
                  int32_t         stringMaxLen;\

            
                  uint8_t        bInterfaceNotNil;\

            
               } param;\

            
               uint8_t    type;\

            
               uint8_t    nativeAlignment\


            typedef struct UnionType UnionType;

            
            typedef struct StructType StructType;

            
            typedef struct SequenceType SequenceType;

            
            struct Type {

            
               INHERIT_TYPE;

            
            };


            struct SequenceType {

            
               const Type *         seqType;

            
               uint32_t               nMaxLen;

            
               uint32_t               inSize;

            
               uint32_t               routSizePrimIn;

            
               uint32_t               routSizePrimROut;

            
            };


            //byte offset from the start of the case values for

            
            //this unions case value array.  it MUST be aligned

            
            //at the alignment requrements for the descriptor

            
            //

            
            //if negative it means that the unions cases are

            
            //simple enumerators, so the value read from the descriptor

            
            //can be used directly to find the correct case

            
            typedef union CaseValuePtr CaseValuePtr;

            
            union CaseValuePtr {

            
               const uint8_t*   value8s;

            
               const uint16_t*  value16s;

            
               const uint32_t*  value32s;

            
               const uint64_t*  value64s;

            
            };


            //these are only used in complex cases

            
            //so I pulled them out of the type definition as references to make

            
            //the type smaller

            
            struct UnionType {

            
               const Type           *descriptor;

            
               uint32_t               nCases;

            
               const CaseValuePtr   caseValues;

            
               const Type * const   *cases;

            
               int32_t               inSize;

            
               int32_t               routSizePrimIn;

            
               int32_t               routSizePrimROut;

            
               uint8_t                inAlignment;

            
               uint8_t                routAlignmentPrimIn;

            
               uint8_t                routAlignmentPrimROut;

            
               uint8_t                inCaseAlignment;

            
               uint8_t                routCaseAlignmentPrimIn;

            
               uint8_t                routCaseAlignmentPrimROut;

            
               uint8_t                nativeCaseAlignment;

            
               uint8_t              bDefaultCase;

            
            };


            struct StructType {

            
               uint32_t               nMembers;

            
               const Type * const   *members;

            
               int32_t               inSize;

            
               int32_t               routSizePrimIn;

            
               int32_t               routSizePrimROut;

            
               uint8_t                inAlignment;

            
               uint8_t                routAlignmentPrimIn;

            
               uint8_t                routAlignmentPrimROut;

            
            };


            typedef struct Parameter Parameter;

            
            struct Parameter {

            
               INHERIT_TYPE;

            
               uint8_t    mode;

            
               uint8_t  bNotNil;

            
            };


            #define SLIM_SCALARS_IS_DYNAMIC(u) (((u) & 0x00ffffff) == 0x00ffffff)


            typedef struct Method Method;

            
            struct Method {

            
               uint32_t                    uScalars;            //no method index

            
               int32_t                     primInSize;

            
               int32_t                     primROutSize;

            
               int                         maxArgs;

            
               int                         numParams;

            
               const Parameter * const     *params;

            
               uint8_t                       primInAlignment;

            
               uint8_t                       primROutAlignment;

            
            };


            typedef struct Interface Interface;


            struct Interface {

            
               int                            nMethods;

            
               const Method  * const          *methodArray;

            
               int                            nIIds;

            
               const uint32_t                   *iids;

            
               const uint16_t*                  methodStringArray;

            
               const uint16_t*                  methodStrings;

            
               const char*                    strings;

            
            };


            #endif //SLIM_H


            #ifndef _APPS_REMOTECTL_SLIM_H

            
            #define _APPS_REMOTECTL_SLIM_H

            
            #include "remote.h"

            
            #include <stdint.h>


            #ifndef __QAIC_SLIM

            
            #define __QAIC_SLIM(ff) ff

            
            #endif

            
            #ifndef __QAIC_SLIM_EXPORT

            
            #define __QAIC_SLIM_EXPORT

            
            #endif


            static const Type types[1];

            
            static const Type types[1] = {{0x1,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x1}};

            
            static const Parameter parameters[4] = {{0x8,{{(const uintptr_t)0x0,0}}, 4,0x4,0,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x4,3,0},{0x8,{{(const uintptr_t)&(types[0]),(const uintptr_t)0x0}}, 9,0x4,3,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x4,0,0}};

            
            static const Parameter* const parameterArrays[7] = {(&(parameters[0])),(&(parameters[1])),(&(parameters[2])),(&(parameters[1])),(&(parameters[3])),(&(parameters[2])),(&(parameters[1]))};

            
            static const Method methods[2] = {{REMOTE_SCALARS_MAKEX(0,0,0x2,0x2,0x0,0x0),0x8,0x8,6,4,(&(parameterArrays[0])),0x4,0x4},{REMOTE_SCALARS_MAKEX(0,0,0x1,0x2,0x0,0x0),0x8,0x4,5,3,(&(parameterArrays[4])),0x4,0x4}};

            
            static const Method* const methodArrays[2] = {&(methods[0]),&(methods[1])};

            
            static const char strings[36] = "dlerror\0handle\0close\0nErr\0name\0open\0";

            
            static const uint16_t methodStrings[9] = {31,26,8,0,21,15,8,0,21};

            
            static const uint16_t methodStringsArrays[2] = {0,5};

            
            __QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(apps_remotectl_slim) = {2,&(methodArrays[0]),0,0,&(methodStringsArrays [0]),methodStrings,strings};

            
            #endif //_APPS_REMOTECTL_SLIM_H

            
            #ifdef __GNUC__

            
            #pragma GCC diagnostic ignored "-Wpragmas"

            
            #pragma GCC diagnostic ignored "-Wuninitialized"

            
            #pragma GCC diagnostic ignored "-Wunused-parameter"

            
            #endif


            #ifndef __QAIC_REMOTE

            
            #define __QAIC_REMOTE(ff) ff

            
            #endif //__QAIC_REMOTE


            #ifndef __QAIC_HEADER

            
            #define __QAIC_HEADER(ff) ff

            
            #endif //__QAIC_HEADER


            #ifndef __QAIC_HEADER_EXPORT

            
            #define __QAIC_HEADER_EXPORT

            
            #endif // __QAIC_HEADER_EXPORT


            #ifndef __QAIC_HEADER_ATTRIBUTE

            
            #define __QAIC_HEADER_ATTRIBUTE

            
            #endif // __QAIC_HEADER_ATTRIBUTE


            #ifndef __QAIC_IMPL

            
            #define __QAIC_IMPL(ff) ff

            
            #endif //__QAIC_IMPL


            #ifndef __QAIC_IMPL_EXPORT

            
            #define __QAIC_IMPL_EXPORT

            
            #endif // __QAIC_IMPL_EXPORT


            #ifndef __QAIC_IMPL_ATTRIBUTE

            
            #define __QAIC_IMPL_ATTRIBUTE

            
            #endif // __QAIC_IMPL_ATTRIBUTE


            #ifndef __QAIC_STUB

            
            #define __QAIC_STUB(ff) ff

            
            #endif //__QAIC_STUB


            #ifndef __QAIC_STUB_EXPORT

            
            #define __QAIC_STUB_EXPORT

            
            #endif // __QAIC_STUB_EXPORT


            #ifndef __QAIC_STUB_ATTRIBUTE

            
            #define __QAIC_STUB_ATTRIBUTE

            
            #endif // __QAIC_STUB_ATTRIBUTE


            #ifndef __QAIC_SKEL

            
            #define __QAIC_SKEL(ff) ff

            
            #endif //__QAIC_SKEL__


            #ifndef __QAIC_SKEL_EXPORT

            
            #define __QAIC_SKEL_EXPORT

            
            #endif // __QAIC_SKEL_EXPORT


            #ifndef __QAIC_SKEL_ATTRIBUTE

            
            #define __QAIC_SKEL_ATTRIBUTE

            
            #endif // __QAIC_SKEL_ATTRIBUTE


            #ifdef __QAIC_DEBUG__

            
               #ifndef __QAIC_DBG_PRINTF__

            
               #define __QAIC_DBG_PRINTF__( ee ) do { printf ee ; } while(0)

            
               #endif

            
            #else

            
               #define __QAIC_DBG_PRINTF__( ee ) (void)0

            
            #endif


            #define _OFFSET(src, sof)  ((void*)(((char*)(src)) + (sof)))


            #define _COPY(dst, dof, src, sof, sz)  \

            
               do {\

            
                     struct __copy { \

            
                        char ar[sz]; \

            
                     };\

            
                     *(struct __copy*)_OFFSET(dst, dof) = *(struct __copy*)_OFFSET(src, sof);\

            
               } while (0)


            #define _ASSIGN(dst, src, sof)  \

            
               do {\

            
                  dst = OFFSET(src, sof); \

            
               } while (0)


            #define _STD_STRLEN_IF(str) (str == 0 ? 0 : strlen(str))


            #include "AEEStdErr.h"


            #define _TRY(ee, func) \

            
               do { \

            
                  if (AEE_SUCCESS != ((ee) = func)) {\

            
                     __QAIC_DBG_PRINTF__((__FILE_LINE__  ": error: %d\n", (int)(ee)));\

            
                     goto ee##bail;\

            
                  } \

            
               } while (0)


            #define _CATCH(exception) exception##bail: if (exception != AEE_SUCCESS)


            #define _ASSERT(nErr, ff) _TRY(nErr, 0 == (ff) ? AEE_EBADPARM : AEE_SUCCESS)


            #ifdef __QAIC_DEBUG__

            
            #define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, allocator_alloc(pal, __FILE_LINE__, size, alignment, (void**)&pv))

            
            #else

            
            #define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, allocator_alloc(pal, 0, size, alignment, (void**)&pv))

            
            #endif


            #ifdef __cplusplus

            
            extern "C" {

            
            #endif

            
            static __inline int _skel_method(int (*_pfn)(uint32_t, char*, uint32_t, uint32_t*), uint32_t _sc, remote_arg* _pra) {

            
               remote_arg* _praEnd;

            
               uint32_t _in0[1];

            
               char* _rout1[1];

            
               uint32_t _rout1Len[1];

            
               uint32_t _rout2[1];

            
               uint32_t* _primIn;

            
               int _numIn[1];

            
               uint32_t* _primROut;

            
               remote_arg* _praIn;

            
               remote_arg* _praROut;

            
               int _nErr = 0;

            
               _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));

            
               _ASSERT(_nErr, (_pra + 3) <= _praEnd);

            
               _numIn[0] = (REMOTE_SCALARS_INBUFS(_sc) - 1);

            
               _ASSERT(_nErr, _pra[0].buf.nLen >= 8);

            
               _primIn = _pra[0].buf.pv;

            
               _ASSERT(_nErr, _pra[(_numIn[0] + 1)].buf.nLen >= 4);

            
               _primROut = _pra[(_numIn[0] + 1)].buf.pv;

            
               _COPY(_in0, 0, _primIn, 0, 4);

            
               _COPY(_rout1Len, 0, _primIn, 4, 4);

            
               _praIn = (_pra + 1);

            
               _praROut = (_praIn + _numIn[0] + 1);

            
               _ASSERT(_nErr, (int)((_praROut[0].buf.nLen / 1)) >= (int)(_rout1Len[0]));

            
               _rout1[0] = _praROut[0].buf.pv;

            
               _TRY(_nErr, _pfn(*_in0, *_rout1, *_rout1Len, _rout2));

            
               _COPY(_primROut, 0, _rout2, 0, 4);

            
               _CATCH(_nErr) {}

            
               return _nErr;

            
            }

            
            static __inline int _skel_method_1(int (*_pfn)(char*, uint32_t*, char*, uint32_t, uint32_t*), uint32_t _sc, remote_arg* _pra) {

            
               remote_arg* _praEnd;

            
               char* _in0[1];

            
               uint32_t _in0Len[1];

            
               uint32_t _rout1[1];

            
               char* _rout2[1];

            
               uint32_t _rout2Len[1];

            
               uint32_t _rout3[1];

            
               uint32_t* _primIn;

            
               int _numIn[1];

            
               uint32_t* _primROut;

            
               remote_arg* _praIn;

            
               remote_arg* _praROut;

            
               int _nErr = 0;

            
               _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));

            
               _ASSERT(_nErr, (_pra + 4) <= _praEnd);

            
               _numIn[0] = (REMOTE_SCALARS_INBUFS(_sc) - 1);

            
               _ASSERT(_nErr, _pra[0].buf.nLen >= 8);

            
               _primIn = _pra[0].buf.pv;

            
               _ASSERT(_nErr, _pra[(_numIn[0] + 1)].buf.nLen >= 8);

            
               _primROut = _pra[(_numIn[0] + 1)].buf.pv;

            
               _COPY(_in0Len, 0, _primIn, 0, 4);

            
               _praIn = (_pra + 1);

            
               _ASSERT(_nErr, (int)((_praIn[0].buf.nLen / 1)) >= (int)(_in0Len[0]));

            
               _in0[0] = _praIn[0].buf.pv;

            
               if(_in0Len[0] > 0)

            
               {

            
                  _in0[0][(_in0Len[0] - 1)] = 0;

            
               }

            
               _COPY(_rout2Len, 0, _primIn, 4, 4);

            
               _praROut = (_praIn + _numIn[0] + 1);

            
               _ASSERT(_nErr, (int)((_praROut[0].buf.nLen / 1)) >= (int)(_rout2Len[0]));

            
               _rout2[0] = _praROut[0].buf.pv;

            
               _TRY(_nErr, _pfn(*_in0, _rout1, *_rout2, *_rout2Len, _rout3));

            
               _COPY(_primROut, 0, _rout1, 0, 4);

            
               _COPY(_primROut, 4, _rout3, 0, 4);

            
               _CATCH(_nErr) {}

            
               return _nErr;

            
            }

            
            __QAIC_SKEL_EXPORT int __QAIC_SKEL(apps_remotectl_skel_invoke)(uint32_t _sc, remote_arg* _pra) __QAIC_SKEL_ATTRIBUTE {

            
               switch(REMOTE_SCALARS_METHOD(_sc))

            
               {

            
                  case 0:

            
                  return _skel_method_1((void*)__QAIC_IMPL(apps_remotectl_open), _sc, _pra);

            
                  case 1:

            
                  return _skel_method((void*)__QAIC_IMPL(apps_remotectl_close), _sc, _pra);

            
               }

            
               return AEE_EUNSUPPORTED;

            
            }

            
            #ifdef __cplusplus

            
            }

            
            #endif

            
            #endif //_APPS_REMOTECTL_SKEL_H
	/*
	* Copyright (c) 2019, The Linux Foundation. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials provided
	* with the distribution.
	* * Neither the name of The Linux Foundation nor the names of its
	* contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
	* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/
	#ifndef _APPS_REMOTECTL_SKEL_H
	#define _APPS_REMOTECTL_SKEL_H
	#include "apps_remotectl.h"
	#include "remote.h"
	#include <string.h>
	#ifndef ALLOCATOR_H
	#define ALLOCATOR_H

	#include <stdlib.h>
	#include <stdint.h>

	typedef struct _heap _heap;
	struct _heap {
	_heap* pPrev;
	const char* loc;
	uint64_t buf;
	};

	typedef struct allocator {
	_heap* pheap;
	uint8_t* stack;
	uint8_t* stackEnd;
	int nSize;
	} allocator;

	static __inline int _heap_alloc(_heap** ppa, const char* loc, int size, void** ppbuf) {
	_heap* pn = 0;
	pn = malloc(size + sizeof(_heap) - sizeof(uint64_t));
	if(pn != 0) {
	pn->pPrev = *ppa;
	pn->loc = loc;
	*ppa = pn;
	ppbuf = (void)&(pn->buf);
	return 0;
	} else {
	return -1;
	}
	}
	#define _ALIGN_SIZE(x, y) (((x) + (y-1)) & ~(y-1))


	static __inline int allocator_alloc(allocator* me,
	const char* loc,
	int size,
	unsigned int al,
	void** ppbuf) {
	if(size < 0) {
	return -1;
	} else if (size == 0) {
	*ppbuf = 0;
	return 0;
	}
	if((_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size) < (uintptr_t)me->stack + me->nSize) {
	ppbuf = (uint8_t)_ALIGN_SIZE((uintptr_t)me->stackEnd, al);
	me->stackEnd = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size;
	return 0;
	} else {
	return _heap_alloc(&me->pheap, loc, size, ppbuf);
	}
	}


	static __inline void allocator_deinit(allocator* me) {
	_heap* pa = me->pheap;
	while(pa != 0) {
	_heap* pn = pa;
	const char* loc = pn->loc;
	(void)loc;
	pa = pn->pPrev;
	free(pn);
	}
	}

	static __inline void allocator_init(allocator* me, uint8_t* stack, int stackSize) {
	me->stack = stack;
	me->stackEnd = stack + stackSize;
	me->nSize = stackSize;
	me->pheap = 0;
	}


	#endif // ALLOCATOR_H

	#ifndef SLIM_H
	#define SLIM_H

	#include <stdint.h>

	//a C data structure for the idl types that can be used to implement
	//static and dynamic language bindings fairly efficiently.
	//
	//the goal is to have a minimal ROM and RAM footprint and without
	//doing too many allocations. A good way to package these things seemed
	//like the module boundary, so all the idls within one module can share
	//all the type references.


	#define PARAMETER_IN 0x0
	#define PARAMETER_OUT 0x1
	#define PARAMETER_INOUT 0x2
	#define PARAMETER_ROUT 0x3
	#define PARAMETER_INROUT 0x4

	//the types that we get from idl
	#define TYPE_OBJECT 0x0
	#define TYPE_INTERFACE 0x1
	#define TYPE_PRIMITIVE 0x2
	#define TYPE_ENUM 0x3
	#define TYPE_STRING 0x4
	#define TYPE_WSTRING 0x5
	#define TYPE_STRUCTURE 0x6
	#define TYPE_UNION 0x7
	#define TYPE_ARRAY 0x8
	#define TYPE_SEQUENCE 0x9

	//these require the pack/unpack to recurse
	//so it's a hint to those languages that can optimize in cases where
	//recursion isn't necessary.
	#define TYPE_COMPLEX_STRUCTURE (0x10 \| TYPE_STRUCTURE)
	#define TYPE_COMPLEX_UNION (0x10 \| TYPE_UNION)
	#define TYPE_COMPLEX_ARRAY (0x10 \| TYPE_ARRAY)
	#define TYPE_COMPLEX_SEQUENCE (0x10 \| TYPE_SEQUENCE)


	typedef struct Type Type;

	#define INHERIT_TYPE\
	int32_t nativeSize; /in the simple case its the same as wire size and alignment/\
	union {\
	struct {\
	const uintptr_t p1;\
	const uintptr_t p2;\
	} _cast;\
	struct {\
	uint32_t iid;\
	uint32_t bNotNil;\
	} object;\
	struct {\
	const Type *arrayType;\
	int32_t nItems;\
	} array;\
	struct {\
	const Type *seqType;\
	int32_t nMaxLen;\
	} seqSimple; \
	struct {\
	uint32_t bFloating;\
	uint32_t bSigned;\
	} prim; \
	const SequenceType* seqComplex;\
	const UnionType *unionType;\
	const StructType *structType;\
	int32_t stringMaxLen;\
	uint8_t bInterfaceNotNil;\
	} param;\
	uint8_t type;\
	uint8_t nativeAlignment\

	typedef struct UnionType UnionType;
	typedef struct StructType StructType;
	typedef struct SequenceType SequenceType;
	struct Type {
	INHERIT_TYPE;
	};

	struct SequenceType {
	const Type * seqType;
	uint32_t nMaxLen;
	uint32_t inSize;
	uint32_t routSizePrimIn;
	uint32_t routSizePrimROut;
	};

	//byte offset from the start of the case values for
	//this unions case value array. it MUST be aligned
	//at the alignment requrements for the descriptor
	//
	//if negative it means that the unions cases are
	//simple enumerators, so the value read from the descriptor
	//can be used directly to find the correct case
	typedef union CaseValuePtr CaseValuePtr;
	union CaseValuePtr {
	const uint8_t* value8s;
	const uint16_t* value16s;
	const uint32_t* value32s;
	const uint64_t* value64s;
	};

	//these are only used in complex cases
	//so I pulled them out of the type definition as references to make
	//the type smaller
	struct UnionType {
	const Type *descriptor;
	uint32_t nCases;
	const CaseValuePtr caseValues;
	const Type * const *cases;
	int32_t inSize;
	int32_t routSizePrimIn;
	int32_t routSizePrimROut;
	uint8_t inAlignment;
	uint8_t routAlignmentPrimIn;
	uint8_t routAlignmentPrimROut;
	uint8_t inCaseAlignment;
	uint8_t routCaseAlignmentPrimIn;
	uint8_t routCaseAlignmentPrimROut;
	uint8_t nativeCaseAlignment;
	uint8_t bDefaultCase;
	};

	struct StructType {
	uint32_t nMembers;
	const Type * const *members;
	int32_t inSize;
	int32_t routSizePrimIn;
	int32_t routSizePrimROut;
	uint8_t inAlignment;
	uint8_t routAlignmentPrimIn;
	uint8_t routAlignmentPrimROut;
	};

	typedef struct Parameter Parameter;
	struct Parameter {
	INHERIT_TYPE;
	uint8_t mode;
	uint8_t bNotNil;
	};

	#define SLIM_SCALARS_IS_DYNAMIC(u) (((u) & 0x00ffffff) == 0x00ffffff)

	typedef struct Method Method;
	struct Method {
	uint32_t uScalars; //no method index
	int32_t primInSize;
	int32_t primROutSize;
	int maxArgs;
	int numParams;
	const Parameter * const *params;
	uint8_t primInAlignment;
	uint8_t primROutAlignment;
	};

	typedef struct Interface Interface;

	struct Interface {
	int nMethods;
	const Method * const *methodArray;
	int nIIds;
	const uint32_t *iids;
	const uint16_t* methodStringArray;
	const uint16_t* methodStrings;
	const char* strings;
	};


	#endif //SLIM_H


	#ifndef _APPS_REMOTECTL_SLIM_H
	#define _APPS_REMOTECTL_SLIM_H
	#include "remote.h"
	#include <stdint.h>

	#ifndef __QAIC_SLIM
	#define __QAIC_SLIM(ff) ff
	#endif
	#ifndef __QAIC_SLIM_EXPORT
	#define __QAIC_SLIM_EXPORT
	#endif

	static const Type types[1];
	static const Type types[1] = {{0x1,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x1}};
	static const Parameter parameters[4] = {{0x8,{{(const uintptr_t)0x0,0}}, 4,0x4,0,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x4,3,0},{0x8,{{(const uintptr_t)&(types[0]),(const uintptr_t)0x0}}, 9,0x4,3,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x4,0,0}};
	static const Parameter* const parameterArrays[7] = {(&(parameters[0])),(&(parameters[1])),(&(parameters[2])),(&(parameters[1])),(&(parameters[3])),(&(parameters[2])),(&(parameters[1]))};
	static const Method methods[2] = {{REMOTE_SCALARS_MAKEX(0,0,0x2,0x2,0x0,0x0),0x8,0x8,6,4,(&(parameterArrays[0])),0x4,0x4},{REMOTE_SCALARS_MAKEX(0,0,0x1,0x2,0x0,0x0),0x8,0x4,5,3,(&(parameterArrays[4])),0x4,0x4}};
	static const Method* const methodArrays[2] = {&(methods[0]),&(methods[1])};
	static const char strings[36] = "dlerror\0handle\0close\0nErr\0name\0open\0";
	static const uint16_t methodStrings[9] = {31,26,8,0,21,15,8,0,21};
	static const uint16_t methodStringsArrays[2] = {0,5};
	__QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(apps_remotectl_slim) = {2,&(methodArrays[0]),0,0,&(methodStringsArrays [0]),methodStrings,strings};
	#endif //_APPS_REMOTECTL_SLIM_H
	#ifdef __GNUC__
	#pragma GCC diagnostic ignored "-Wpragmas"
	#pragma GCC diagnostic ignored "-Wuninitialized"
	#pragma GCC diagnostic ignored "-Wunused-parameter"
	#endif

	#ifndef __QAIC_REMOTE
	#define __QAIC_REMOTE(ff) ff
	#endif //__QAIC_REMOTE

	#ifndef __QAIC_HEADER
	#define __QAIC_HEADER(ff) ff
	#endif //__QAIC_HEADER

	#ifndef __QAIC_HEADER_EXPORT
	#define __QAIC_HEADER_EXPORT
	#endif // __QAIC_HEADER_EXPORT

	#ifndef __QAIC_HEADER_ATTRIBUTE
	#define __QAIC_HEADER_ATTRIBUTE
	#endif // __QAIC_HEADER_ATTRIBUTE

	#ifndef __QAIC_IMPL
	#define __QAIC_IMPL(ff) ff
	#endif //__QAIC_IMPL

	#ifndef __QAIC_IMPL_EXPORT
	#define __QAIC_IMPL_EXPORT
	#endif // __QAIC_IMPL_EXPORT

	#ifndef __QAIC_IMPL_ATTRIBUTE
	#define __QAIC_IMPL_ATTRIBUTE
	#endif // __QAIC_IMPL_ATTRIBUTE

	#ifndef __QAIC_STUB
	#define __QAIC_STUB(ff) ff
	#endif //__QAIC_STUB

	#ifndef __QAIC_STUB_EXPORT
	#define __QAIC_STUB_EXPORT
	#endif // __QAIC_STUB_EXPORT

	#ifndef __QAIC_STUB_ATTRIBUTE
	#define __QAIC_STUB_ATTRIBUTE
	#endif // __QAIC_STUB_ATTRIBUTE

	#ifndef __QAIC_SKEL
	#define __QAIC_SKEL(ff) ff
	#endif //__QAIC_SKEL__

	#ifndef __QAIC_SKEL_EXPORT
	#define __QAIC_SKEL_EXPORT
	#endif // __QAIC_SKEL_EXPORT

	#ifndef __QAIC_SKEL_ATTRIBUTE
	#define __QAIC_SKEL_ATTRIBUTE
	#endif // __QAIC_SKEL_ATTRIBUTE

	#ifdef __QAIC_DEBUG__
	#ifndef __QAIC_DBG_PRINTF__
	#define __QAIC_DBG_PRINTF__( ee ) do { printf ee ; } while(0)
	#endif
	#else
	#define __QAIC_DBG_PRINTF__( ee ) (void)0
	#endif


	#define _OFFSET(src, sof) ((void)(((char)(src)) + (sof)))

	#define _COPY(dst, dof, src, sof, sz) \
	do {\
	struct __copy { \
	char ar[sz]; \
	};\
	(struct __copy)_OFFSET(dst, dof) = (struct __copy)_OFFSET(src, sof);\
	} while (0)

	#define _ASSIGN(dst, src, sof) \
	do {\
	dst = OFFSET(src, sof); \
	} while (0)

	#define _STD_STRLEN_IF(str) (str == 0 ? 0 : strlen(str))

	#include "AEEStdErr.h"

	#define _TRY(ee, func) \
	do { \
	if (AEE_SUCCESS != ((ee) = func)) {\
	__QAIC_DBG_PRINTF__((__FILE_LINE__ ": error: %d\n", (int)(ee)));\
	goto ee##bail;\
	} \
	} while (0)

	#define _CATCH(exception) exception##bail: if (exception != AEE_SUCCESS)

	#define _ASSERT(nErr, ff) _TRY(nErr, 0 == (ff) ? AEE_EBADPARM : AEE_SUCCESS)

	#ifdef __QAIC_DEBUG__
	#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, allocator_alloc(pal, __FILE_LINE__, size, alignment, (void**)&pv))
	#else
	#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, allocator_alloc(pal, 0, size, alignment, (void**)&pv))
	#endif


	#ifdef __cplusplus
	extern "C" {
	#endif
	static __inline int _skel_method(int (_pfn)(uint32_t, char, uint32_t, uint32_t), uint32_t _sc, remote_arg _pra) {
	remote_arg* _praEnd;
	uint32_t _in0[1];
	char* _rout1[1];
	uint32_t _rout1Len[1];
	uint32_t _rout2[1];
	uint32_t* _primIn;
	int _numIn[1];
	uint32_t* _primROut;
	remote_arg* _praIn;
	remote_arg* _praROut;
	int _nErr = 0;
	_praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
	_ASSERT(_nErr, (_pra + 3) <= _praEnd);
	_numIn[0] = (REMOTE_SCALARS_INBUFS(_sc) - 1);
	_ASSERT(_nErr, _pra[0].buf.nLen >= 8);
	_primIn = _pra[0].buf.pv;
	_ASSERT(_nErr, _pra[(_numIn[0] + 1)].buf.nLen >= 4);
	_primROut = _pra[(_numIn[0] + 1)].buf.pv;
	_COPY(_in0, 0, _primIn, 0, 4);
	_COPY(_rout1Len, 0, _primIn, 4, 4);
	_praIn = (_pra + 1);
	_praROut = (_praIn + _numIn[0] + 1);
	_ASSERT(_nErr, (int)((_praROut[0].buf.nLen / 1)) >= (int)(_rout1Len[0]));
	_rout1[0] = _praROut[0].buf.pv;
	_TRY(_nErr, _pfn(_in0, _rout1, *_rout1Len, _rout2));
	_COPY(_primROut, 0, _rout2, 0, 4);
	_CATCH(_nErr) {}
	return _nErr;
	}
	static __inline int _skel_method_1(int (_pfn)(char, uint32_t, char, uint32_t, uint32_t), uint32_t _sc, remote_arg _pra) {
	remote_arg* _praEnd;
	char* _in0[1];
	uint32_t _in0Len[1];
	uint32_t _rout1[1];
	char* _rout2[1];
	uint32_t _rout2Len[1];
	uint32_t _rout3[1];
	uint32_t* _primIn;
	int _numIn[1];
	uint32_t* _primROut;
	remote_arg* _praIn;
	remote_arg* _praROut;
	int _nErr = 0;
	_praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
	_ASSERT(_nErr, (_pra + 4) <= _praEnd);
	_numIn[0] = (REMOTE_SCALARS_INBUFS(_sc) - 1);
	_ASSERT(_nErr, _pra[0].buf.nLen >= 8);
	_primIn = _pra[0].buf.pv;
	_ASSERT(_nErr, _pra[(_numIn[0] + 1)].buf.nLen >= 8);
	_primROut = _pra[(_numIn[0] + 1)].buf.pv;
	_COPY(_in0Len, 0, _primIn, 0, 4);
	_praIn = (_pra + 1);
	_ASSERT(_nErr, (int)((_praIn[0].buf.nLen / 1)) >= (int)(_in0Len[0]));
	_in0[0] = _praIn[0].buf.pv;
	if(_in0Len[0] > 0)
	{
	_in0[0][(_in0Len[0] - 1)] = 0;
	}
	_COPY(_rout2Len, 0, _primIn, 4, 4);
	_praROut = (_praIn + _numIn[0] + 1);
	_ASSERT(_nErr, (int)((_praROut[0].buf.nLen / 1)) >= (int)(_rout2Len[0]));
	_rout2[0] = _praROut[0].buf.pv;
	_TRY(_nErr, _pfn(_in0, _rout1, _rout2, *_rout2Len, _rout3));
	_COPY(_primROut, 0, _rout1, 0, 4);
	_COPY(_primROut, 4, _rout3, 0, 4);
	_CATCH(_nErr) {}
	return _nErr;
	}
	__QAIC_SKEL_EXPORT int __QAIC_SKEL(apps_remotectl_skel_invoke)(uint32_t _sc, remote_arg* _pra) __QAIC_SKEL_ATTRIBUTE {
	switch(REMOTE_SCALARS_METHOD(_sc))
	{
	case 0:
	return _skel_method_1((void*)__QAIC_IMPL(apps_remotectl_open), _sc, _pra);
	case 1:
	return _skel_method((void*)__QAIC_IMPL(apps_remotectl_close), _sc, _pra);
	}
	return AEE_EUNSUPPORTED;
	}
	#ifdef __cplusplus
	}
	#endif
	#endif //_APPS_REMOTECTL_SKEL_H