summaryrefslogtreecommitdiff
path: root/src/lib/apps_std_skel.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/apps_std_skel.c')
-rw-r--r--src/lib/apps_std_skel.c1093
1 files changed, 1093 insertions, 0 deletions
diff --git a/src/lib/apps_std_skel.c b/src/lib/apps_std_skel.c
new file mode 100644
index 0000000..bd5873b
--- /dev/null
+++ b/src/lib/apps_std_skel.c
@@ -0,0 +1,1093 @@
+/*
+* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice,
+* this list of conditions and the following disclaimer.
+*
+* 2. 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.
+*
+* 3. Neither the name of the copyright holder 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 BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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_STD_SKEL_H
+#define _APPS_STD_SKEL_H
+
+#include "apps_std.h"
+#ifndef _QAIC_ENV_H
+#define _QAIC_ENV_H
+
+#ifdef __GNUC__
+#ifdef __clang__
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#else
+#pragma GCC diagnostic ignored "-Wpragmas"
+#endif
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+#ifndef _ATTRIBUTE_UNUSED
+
+#ifdef _WIN32
+#define _ATTRIBUTE_UNUSED
+#else
+#define _ATTRIBUTE_UNUSED __attribute__ ((unused))
+#endif
+
+#endif // _ATTRIBUTE_UNUSED
+
+#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__
+#include <stdio.h>
+#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 _COPYIF(dst, dof, src, sof, sz) \
+ do {\
+ if(_OFFSET(dst, dof) != _OFFSET(src, sof)) {\
+ _COPY(dst, dof, src, sof, sz); \
+ } \
+ } while (0)
+
+_ATTRIBUTE_UNUSED
+static __inline void _qaic_memmove(void *dst, void *src, int size)
+{
+ int i;
+ for (i = 0; i < size; ++i)
+ {
+ ((char *)dst)[i] = ((char *)src)[i];
+ }
+}
+
+#define _MEMMOVEIF(dst, src, sz) \
+ do {\
+ if(dst != src) {\
+ _qaic_memmove(dst, src, sz);\
+ } \
+ } 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__ ":%d:error:%d:%s\n", __LINE__, (int)(ee),#func));\
+ 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
+
+
+#endif // _QAIC_ENV_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;
+
+_ATTRIBUTE_UNUSED
+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))
+
+_ATTRIBUTE_UNUSED
+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);
+ }
+}
+
+_ATTRIBUTE_UNUSED
+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);
+ }
+}
+
+_ATTRIBUTE_UNUSED
+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_IFPTR32(is32,is64) (sizeof(uintptr_t) == 4 ? (is32) : (is64))
+#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_STD_SLIM_H
+#define _APPS_STD_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[2];
+static const SequenceType sequenceTypes[1] = {{&(types[1]), 0x0, 0x4, 0x4, 0x0}};
+static const Type types[2] = {{0x1, {{(const uintptr_t)0, (const uintptr_t)0}}, 2, 0x1}, {SLIM_IFPTR32(0x8, 0x10), {{(const uintptr_t)0x0, 0}}, 4, SLIM_IFPTR32(0x4, 0x8)}};
+static const Parameter parameters[12] = {{SLIM_IFPTR32(0x8, 0x10), {{(const uintptr_t)0x0, 0}}, 4, SLIM_IFPTR32(0x4, 0x8), 0, 0}, {0x4, {{(const uintptr_t)0, (const uintptr_t)1}}, 2, 0x4, 3, 0}, {0x4, {{(const uintptr_t)0, (const uintptr_t)1}}, 2, 0x4, 0, 0}, {SLIM_IFPTR32(0x8, 0x10), {{(const uintptr_t) &(types[0]), (const uintptr_t)0x0}}, 9, SLIM_IFPTR32(0x4, 0x8), 3, 0}, {SLIM_IFPTR32(0x8, 0x10), {{(const uintptr_t) &(types[0]), (const uintptr_t)0x0}}, 9, SLIM_IFPTR32(0x4, 0x8), 0, 0}, {0x4, {{0, 0}}, 3, 0x4, 0, 0}, {0x8, {{(const uintptr_t)0, (const uintptr_t)0}}, 2, 0x8, 3, 0}, {SLIM_IFPTR32(0x8, 0x10), {{(const uintptr_t)0x0, 0}}, 4, SLIM_IFPTR32(0x4, 0x8), 3, 0}, {SLIM_IFPTR32(0x8, 0x10), {{(const uintptr_t) &(sequenceTypes[0]), 0}}, 25, SLIM_IFPTR32(0x4, 0x8), 3, 0}, {0x4, {{(const uintptr_t)0, (const uintptr_t)0}}, 2, 0x4, 3, 0}, {0x2, {{(const uintptr_t)0, (const uintptr_t)0}}, 2, 0x2, 3, 0}, {0x1, {{(const uintptr_t)0, (const uintptr_t)0}}, 2, 0x1, 3, 0}};
+static const Parameter *const parameterArrays[37] = {(&(parameters[0])), (&(parameters[0])), (&(parameters[8])), (&(parameters[9])), (&(parameters[10])), (&(parameters[0])), (&(parameters[0])), (&(parameters[0])), (&(parameters[0])), (&(parameters[1])), (&(parameters[2])), (&(parameters[4])), (&(parameters[1])), (&(parameters[1])), (&(parameters[2])), (&(parameters[3])), (&(parameters[1])), (&(parameters[1])), (&(parameters[2])), (&(parameters[0])), (&(parameters[0])), (&(parameters[1])), (&(parameters[0])), (&(parameters[0])), (&(parameters[2])), (&(parameters[0])), (&(parameters[7])), (&(parameters[1])), (&(parameters[2])), (&(parameters[2])), (&(parameters[5])), (&(parameters[0])), (&(parameters[11])), (&(parameters[2])), (&(parameters[6])), (&(parameters[2])), (&(parameters[1]))};
+static const Method methods[16] = {{REMOTE_SCALARS_MAKEX(0, 0, 0x3, 0x1, 0x0, 0x0), 0x8, 0x4, 3, 3, (&(parameterArrays[7])), 0x4, 0x4}, {REMOTE_SCALARS_MAKEX(0, 0, 0x3, 0x1, 0x0, 0x0), 0xc, 0x4, 4, 4, (&(parameterArrays[18])), 0x4, 0x4}, {REMOTE_SCALARS_MAKEX(0, 0, 0x1, 0x0, 0x0, 0x0), 0x4, 0x0, 1, 1, (&(parameterArrays[10])), 0x4, 0x0}, {REMOTE_SCALARS_MAKEX(0, 0, 0x1, 0x2, 0x0, 0x0), 0x8, 0x8, 6, 4, (&(parameterArrays[14])), 0x4, 0x4}, {REMOTE_SCALARS_MAKEX(0, 0, 0x2, 0x1, 0x0, 0x0), 0x8, 0x8, 5, 4, (&(parameterArrays[10])), 0x4, 0x4}, {REMOTE_SCALARS_MAKEX(0, 0, 0x1, 0x2, 0x0, 0x0), 0x8, 0x4, 5, 3, (&(parameterArrays[14])), 0x4, 0x4}, {REMOTE_SCALARS_MAKEX(0, 0, 0x2, 0x0, 0x0, 0x0), 0x8, 0x0, 3, 2, (&(parameterArrays[10])), 0x4, 0x0}, {REMOTE_SCALARS_MAKEX(0, 0, 0x1, 0x1, 0x0, 0x0), 0x4, 0x4, 2, 2, (&(parameterArrays[35])), 0x4, 0x4}, {REMOTE_SCALARS_MAKEX(0, 0, 0x1, 0x0, 0x0, 0x0), 0xc, 0x0, 3, 3, (&(parameterArrays[28])), 0x4, 0x0}, {REMOTE_SCALARS_MAKEX(0, 0, 0x1, 0x1, 0x0, 0x0), 0x4, 0x8, 2, 2, (&(parameterArrays[33])), 0x4, 0x8}, {REMOTE_SCALARS_MAKEX(0, 0, 0x2, 0x0, 0x0, 0x0), 0x4, 0x0, 1, 1, (&(parameterArrays[0])), 0x4, 0x0}, {REMOTE_SCALARS_MAKEX(0, 0, 0x2, 0x2, 0x0, 0x0), 0x8, 0x4, 5, 3, (&(parameterArrays[25])), 0x4, 0x4}, {REMOTE_SCALARS_MAKEX(0, 0, 0x3, 0x0, 0x0, 0x0), 0xc, 0x0, 3, 3, (&(parameterArrays[22])), 0x4, 0x0}, {REMOTE_SCALARS_MAKEX(0, 0, 0x5, 0x1, 0x0, 0x0), 0x10, 0x4, 5, 5, (&(parameterArrays[5])), 0x4, 0x4}, {REMOTE_SCALARS_MAKEX(0, 0, 255, 255, 15, 15), 0xc, 0x6, 7, 5, (&(parameterArrays[0])), 0x4, 0x4}, {REMOTE_SCALARS_MAKEX(0, 0, 0x2, 0x1, 0x0, 0x0), 0x4, 0x1, 2, 2, (&(parameterArrays[31])), 0x4, 0x1}};
+static const Method *const methodArrays[23] = {&(methods[0]), &(methods[1]), &(methods[2]), &(methods[2]), &(methods[3]), &(methods[4]), &(methods[5]), &(methods[6]), &(methods[7]), &(methods[8]), &(methods[9]), &(methods[2]), &(methods[7]), &(methods[7]), &(methods[2]), &(methods[10]), &(methods[11]), &(methods[12]), &(methods[10]), &(methods[13]), &(methods[5]), &(methods[14]), &(methods[15])};
+static const char strings[342] = "get_search_paths_with_env\0fopen_with_env\0print_string\0bytesWritten\0fileExists\0maxPathLen\0envvarname\0valLenReq\0posLenReq\0bytesRead\0numPaths\0unsetenv\0override\0clearerr\0fsetpos\0fgetpos\0freopen\0exists\0getenv\0ferror\0rewind\0whence\0offset\0fwrite\0fclose\0fflush\0paths\0fgets\0delim\0fseek\0ftell\0fread\0psout\0fopen\0path\0feof\0flen\0bEOF\0mode\0val\0str\0buf\0sin\0";
+static const uint16_t methodStrings[81] = {0, 89, 265, 253, 130, 78, 26, 89, 265, 95, 321, 289, 232, 338, 334, 54, 316, 283, 338, 334, 120, 316, 182, 338, 95, 321, 289, 259, 338, 334, 316, 141, 95, 326, 148, 197, 95, 326, 100, 271, 338, 225, 218, 174, 338, 170, 110, 295, 95, 321, 289, 67, 301, 190, 204, 338, 162, 306, 338, 316, 311, 338, 312, 277, 338, 170, 166, 338, 170, 139, 95, 41, 330, 157, 338, 211, 338, 239, 338, 246, 338};
+static const uint16_t methodStringsArrays[23] = {47, 22, 79, 77, 17, 12, 43, 66, 63, 39, 60, 75, 57, 54, 73, 71, 35, 31, 69, 6, 27, 0, 51};
+__QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(apps_std_slim) = {23, &(methodArrays[0]), 0, 0, &(methodStringsArrays [0]), methodStrings, strings};
+#endif //_APPS_STD_SLIM_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+static __inline int _skel_method(int (*_pfn)(char *, uint8_t *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ char *_in0[1];
+ uint32_t _in0Len[1];
+ uint8_t _rout1[1];
+ uint32_t *_primIn;
+ int _numIn[1];
+ uint8_t *_primROut;
+ remote_arg *_praIn;
+ 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 >= 4);
+ _primIn = _pra[0].buf.pv;
+ _ASSERT(_nErr, _pra[(_numIn[0] + 1)].buf.nLen >= 1);
+ _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;
+ }
+ _TRY(_nErr, _pfn(*_in0, _rout1));
+ _COPY(_primROut, 0, _rout1, 0, 1);
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_pack(remote_arg *_praROutPost, remote_arg *_ppraROutPost[1], void *_primROut, char *_rout0[1], uint32_t _rout0Len[1])
+{
+ int _nErr = 0;
+ remote_arg *_praROutPostStart = _praROutPost;
+ remote_arg **_ppraROutPostStart = _ppraROutPost;
+ _ppraROutPost = &_praROutPost;
+ _ppraROutPostStart[0] += (_praROutPost - _praROutPostStart) + 1;
+ return _nErr;
+}
+static __inline int _skel_unpack(_allocator *_al, remote_arg *_praIn, remote_arg *_ppraIn[1], remote_arg *_praROut, remote_arg *_ppraROut[1], void *_primIn, void *_primROut, char *_rout0[1], uint32_t _rout0Len[1])
+{
+ int _nErr = 0;
+ remote_arg *_praInStart = _praIn;
+ remote_arg **_ppraInStart = _ppraIn;
+ remote_arg *_praROutStart = _praROut;
+ remote_arg **_ppraROutStart = _ppraROut;
+ _ppraIn = &_praIn;
+ _ppraROut = &_praROut;
+ _COPY(_rout0Len, 0, _primIn, 0, 4);
+ _ASSERT(_nErr, (int)((_praROut[0].buf.nLen / 1)) >= (int)(_rout0Len[0]));
+ _rout0[0] = _praROut[0].buf.pv;
+ _ppraInStart[0] += (_praIn - _praInStart) + 0;
+ _ppraROutStart[0] += (_praROut - _praROutStart) + 1;
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_1(int (*_pfn)(char *, char *, void *, uint32_t, uint32_t *, uint16_t *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ char *_in0[1];
+ uint32_t _in0Len[1];
+ char *_in1[1];
+ uint32_t _in1Len[1];
+ void *_rout2[1];
+ uint32_t _rout2Len[1];
+ uint32_t _rout3[1];
+ uint16_t _rout4[1];
+ uint32_t *_primIn;
+ int _numIn[1];
+ uint32_t *_primROut;
+ remote_arg *_praIn;
+ remote_arg *_praROut;
+ remote_arg *_praROutPost;
+ remote_arg **_ppraROutPost = &_praROutPost;
+ _allocator _al[1] = {{0}};
+ remote_arg **_ppraIn = &_praIn;
+ remote_arg **_ppraROut = &_praROut;
+ char *_seq_primIn2;
+ char *_seq_nat2;
+ int _ii;
+ int _nErr = 0;
+ _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
+ _ASSERT(_nErr, (_pra + 5) <= _praEnd);
+ _numIn[0] = (REMOTE_SCALARS_INBUFS(_sc) - 1);
+ _ASSERT(_nErr, _pra[0].buf.nLen >= 12);
+ _primIn = _pra[0].buf.pv;
+ _ASSERT(_nErr, _pra[(_numIn[0] + 1)].buf.nLen >= 6);
+ _primROut = _pra[(_numIn[0] + 1)].buf.pv;
+ _praIn = (_pra + 1);
+ _praROut = (_praIn + _numIn[0] + 1);
+ _praROutPost = _praROut;
+ _COPY(_in0Len, 0, _primIn, 0, 4);
+ _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(_in1Len, 0, _primIn, 4, 4);
+ _ASSERT(_nErr, (int)((_praIn[1].buf.nLen / 1)) >= (int)(_in1Len[0]));
+ _in1[0] = _praIn[1].buf.pv;
+ if (_in1Len[0] > 0)
+ _in1[0][(_in1Len[0] - 1)] = 0;
+ _COPY(_rout2Len, 0, _primIn, 8, 4);
+ _allocator_init(_al, 0, 0);
+ _ASSERT(_nErr, (int)((_praIn[2].buf.nLen / 4)) >= (int)(_rout2Len[0]));
+ _ALLOCATE(_nErr, _al, (_rout2Len[0] * SLIM_IFPTR32(8, 16)), SLIM_IFPTR32(4, 8), _rout2[0]);
+ for (_ii = 0, _seq_primIn2 = (char *)_praIn[2].buf.pv, _seq_nat2 = (char *)_rout2[0]; _ii < (int)_rout2Len[0]; ++_ii, _seq_primIn2 = (_seq_primIn2 + 4), _seq_nat2 = (_seq_nat2 + SLIM_IFPTR32(8, 16)))
+ {
+ _TRY(_nErr, _skel_unpack(_al, (_praIn + 3), _ppraIn, (_praROut + 0), _ppraROut, _seq_primIn2, 0, SLIM_IFPTR32((char **) & (((uint32_t *)_seq_nat2)[0]), (char **) & (((uint64_t *)_seq_nat2)[0])), SLIM_IFPTR32((uint32_t *) & (((uint32_t *)_seq_nat2)[1]), (uint32_t *) & (((uint32_t *)_seq_nat2)[2]))));
+ }
+ _TRY(_nErr, _pfn(*_in0, *_in1, *_rout2, *_rout2Len, _rout3, _rout4));
+ for (_ii = 0, _seq_nat2 = (char *)_rout2[0]; _ii < (int)_rout2Len[0]; ++_ii, _seq_nat2 = (_seq_nat2 + SLIM_IFPTR32(8, 16)))
+ {
+ _TRY(_nErr, _skel_pack((_praROutPost + 0), _ppraROutPost, 0, SLIM_IFPTR32((char **) & (((uint32_t *)_seq_nat2)[0]), (char **) & (((uint64_t *)_seq_nat2)[0])), SLIM_IFPTR32((uint32_t *) & (((uint32_t *)_seq_nat2)[1]), (uint32_t *) & (((uint32_t *)_seq_nat2)[2]))));
+ }
+ _COPY(_primROut, 0, _rout3, 0, 4);
+ _COPY(_primROut, 4, _rout4, 0, 2);
+ _CATCH(_nErr) {}
+ _allocator_deinit(_al);
+ return _nErr;
+}
+static __inline int _skel_method_2(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_3(int (*_pfn)(char *, char *, char *, char *, uint32_t *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ char *_in0[1];
+ uint32_t _in0Len[1];
+ char *_in1[1];
+ uint32_t _in1Len[1];
+ char *_in2[1];
+ uint32_t _in2Len[1];
+ char *_in3[1];
+ uint32_t _in3Len[1];
+ uint32_t _rout4[1];
+ uint32_t *_primIn;
+ int _numIn[1];
+ uint32_t *_primROut;
+ remote_arg *_praIn;
+ int _nErr = 0;
+ _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
+ _ASSERT(_nErr, (_pra + 6) <= _praEnd);
+ _numIn[0] = (REMOTE_SCALARS_INBUFS(_sc) - 1);
+ _ASSERT(_nErr, _pra[0].buf.nLen >= 16);
+ _primIn = _pra[0].buf.pv;
+ _ASSERT(_nErr, _pra[(_numIn[0] + 1)].buf.nLen >= 4);
+ _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(_in1Len, 0, _primIn, 4, 4);
+ _ASSERT(_nErr, (int)((_praIn[1].buf.nLen / 1)) >= (int)(_in1Len[0]));
+ _in1[0] = _praIn[1].buf.pv;
+ if (_in1Len[0] > 0)
+ _in1[0][(_in1Len[0] - 1)] = 0;
+ _COPY(_in2Len, 0, _primIn, 8, 4);
+ _ASSERT(_nErr, (int)((_praIn[2].buf.nLen / 1)) >= (int)(_in2Len[0]));
+ _in2[0] = _praIn[2].buf.pv;
+ if (_in2Len[0] > 0)
+ _in2[0][(_in2Len[0] - 1)] = 0;
+ _COPY(_in3Len, 0, _primIn, 12, 4);
+ _ASSERT(_nErr, (int)((_praIn[3].buf.nLen / 1)) >= (int)(_in3Len[0]));
+ _in3[0] = _praIn[3].buf.pv;
+ if (_in3Len[0] > 0)
+ _in3[0][(_in3Len[0] - 1)] = 0;
+ _TRY(_nErr, _pfn(*_in0, *_in1, *_in2, *_in3, _rout4));
+ _COPY(_primROut, 0, _rout4, 0, 4);
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_4(int (*_pfn)(char *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ char *_in0[1];
+ uint32_t _in0Len[1];
+ uint32_t *_primIn;
+ remote_arg *_praIn;
+ int _nErr = 0;
+ _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
+ _ASSERT(_nErr, (_pra + 2) <= _praEnd);
+ _ASSERT(_nErr, _pra[0].buf.nLen >= 4);
+ _primIn = _pra[0].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;
+ }
+ _TRY(_nErr, _pfn(*_in0));
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_5(int (*_pfn)(char *, char *, uint32_t), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ char *_in0[1];
+ uint32_t _in0Len[1];
+ char *_in1[1];
+ uint32_t _in1Len[1];
+ uint32_t _in2[1];
+ uint32_t *_primIn;
+ remote_arg *_praIn;
+ int _nErr = 0;
+ _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
+ _ASSERT(_nErr, (_pra + 3) <= _praEnd);
+ _ASSERT(_nErr, _pra[0].buf.nLen >= 12);
+ _primIn = _pra[0].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(_in1Len, 0, _primIn, 4, 4);
+ _ASSERT(_nErr, (int)((_praIn[1].buf.nLen / 1)) >= (int)(_in1Len[0]));
+ _in1[0] = _praIn[1].buf.pv;
+ if (_in1Len[0] > 0)
+ _in1[0][(_in1Len[0] - 1)] = 0;
+ _COPY(_in2, 0, _primIn, 8, 4);
+ _TRY(_nErr, _pfn(*_in0, *_in1, *_in2));
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_6(int (*_pfn)(char *, char *, uint32_t, uint32_t *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ char *_in0[1];
+ uint32_t _in0Len[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 + 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 >= 4);
+ _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(_rout1Len, 0, _primIn, 4, 4);
+ _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_7(int (*_pfn)(uint32_t), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ uint32_t _in0[1];
+ uint32_t *_primIn;
+ int _nErr = 0;
+ _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
+ _ASSERT(_nErr, (_pra + 1) <= _praEnd);
+ _ASSERT(_nErr, _pra[0].buf.nLen >= 4);
+ _primIn = _pra[0].buf.pv;
+ _COPY(_in0, 0, _primIn, 0, 4);
+ _TRY(_nErr, _pfn(*_in0));
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_8(int (*_pfn)(uint32_t, uint32_t *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ uint32_t _in0[1];
+ uint32_t _rout1[1];
+ uint32_t *_primIn;
+ int _numIn[1];
+ uint32_t *_primROut;
+ int _nErr = 0;
+ _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
+ _ASSERT(_nErr, (_pra + 2) <= _praEnd);
+ _numIn[0] = (REMOTE_SCALARS_INBUFS(_sc) - 1);
+ _ASSERT(_nErr, _pra[0].buf.nLen >= 4);
+ _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);
+ _TRY(_nErr, _pfn(*_in0, _rout1));
+ _COPY(_primROut, 0, _rout1, 0, 4);
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_9(int (*_pfn)(uint32_t, uint64_t *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ uint32_t _in0[1];
+ uint64_t _rout1[1];
+ uint32_t *_primIn;
+ int _numIn[1];
+ uint64_t *_primROut;
+ int _nErr = 0;
+ _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
+ _ASSERT(_nErr, (_pra + 2) <= _praEnd);
+ _numIn[0] = (REMOTE_SCALARS_INBUFS(_sc) - 1);
+ _ASSERT(_nErr, _pra[0].buf.nLen >= 4);
+ _primIn = _pra[0].buf.pv;
+ _ASSERT(_nErr, _pra[(_numIn[0] + 1)].buf.nLen >= 8);
+ _primROut = _pra[(_numIn[0] + 1)].buf.pv;
+ _COPY(_in0, 0, _primIn, 0, 4);
+ _TRY(_nErr, _pfn(*_in0, _rout1));
+ _COPY(_primROut, 0, _rout1, 0, 8);
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_10(int (*_pfn)(uint32_t, uint32_t, uint32_t), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ uint32_t _in0[1];
+ uint32_t _in1[1];
+ uint32_t _in2[1];
+ uint32_t *_primIn;
+ int _nErr = 0;
+ _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
+ _ASSERT(_nErr, (_pra + 1) <= _praEnd);
+ _ASSERT(_nErr, _pra[0].buf.nLen >= 12);
+ _primIn = _pra[0].buf.pv;
+ _COPY(_in0, 0, _primIn, 0, 4);
+ _COPY(_in1, 0, _primIn, 4, 4);
+ _COPY(_in2, 0, _primIn, 8, 4);
+ _TRY(_nErr, _pfn(*_in0, *_in1, *_in2));
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_11(int (*_pfn)(uint32_t, char *, uint32_t), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ uint32_t _in0[1];
+ char *_in1[1];
+ uint32_t _in1Len[1];
+ uint32_t *_primIn;
+ remote_arg *_praIn;
+ int _nErr = 0;
+ _praEnd = ((_pra + REMOTE_SCALARS_INBUFS(_sc)) + REMOTE_SCALARS_OUTBUFS(_sc));
+ _ASSERT(_nErr, (_pra + 2) <= _praEnd);
+ _ASSERT(_nErr, _pra[0].buf.nLen >= 8);
+ _primIn = _pra[0].buf.pv;
+ _COPY(_in0, 0, _primIn, 0, 4);
+ _COPY(_in1Len, 0, _primIn, 4, 4);
+ _praIn = (_pra + 1);
+ _ASSERT(_nErr, (int)((_praIn[0].buf.nLen / 1)) >= (int)(_in1Len[0]));
+ _in1[0] = _praIn[0].buf.pv;
+ _TRY(_nErr, _pfn(*_in0, *_in1, *_in1Len));
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_12(int (*_pfn)(uint32_t, char *, uint32_t, uint32_t *, uint32_t *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ uint32_t _in0[1];
+ char *_in1[1];
+ uint32_t _in1Len[1];
+ uint32_t _rout2[1];
+ uint32_t _rout3[1];
+ uint32_t *_primIn;
+ int _numIn[1];
+ uint32_t *_primROut;
+ remote_arg *_praIn;
+ 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 >= 8);
+ _primROut = _pra[(_numIn[0] + 1)].buf.pv;
+ _COPY(_in0, 0, _primIn, 0, 4);
+ _COPY(_in1Len, 0, _primIn, 4, 4);
+ _praIn = (_pra + 1);
+ _ASSERT(_nErr, (int)((_praIn[0].buf.nLen / 1)) >= (int)(_in1Len[0]));
+ _in1[0] = _praIn[0].buf.pv;
+ _TRY(_nErr, _pfn(*_in0, *_in1, *_in1Len, _rout2, _rout3));
+ _COPY(_primROut, 0, _rout2, 0, 4);
+ _COPY(_primROut, 4, _rout3, 0, 4);
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_13(int (*_pfn)(uint32_t, char *, uint32_t, 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 _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 + 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 >= 8);
+ _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, _rout3));
+ _COPY(_primROut, 0, _rout2, 0, 4);
+ _COPY(_primROut, 4, _rout3, 0, 4);
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_14(int (*_pfn)(uint32_t, char *, char *, uint32_t *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ uint32_t _in0[1];
+ char *_in1[1];
+ uint32_t _in1Len[1];
+ char *_in2[1];
+ uint32_t _in2Len[1];
+ uint32_t _rout3[1];
+ uint32_t *_primIn;
+ int _numIn[1];
+ uint32_t *_primROut;
+ remote_arg *_praIn;
+ 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 >= 12);
+ _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(_in1Len, 0, _primIn, 4, 4);
+ _praIn = (_pra + 1);
+ _ASSERT(_nErr, (int)((_praIn[0].buf.nLen / 1)) >= (int)(_in1Len[0]));
+ _in1[0] = _praIn[0].buf.pv;
+ if (_in1Len[0] > 0)
+ {
+ _in1[0][(_in1Len[0] - 1)] = 0;
+ }
+ _COPY(_in2Len, 0, _primIn, 8, 4);
+ _ASSERT(_nErr, (int)((_praIn[1].buf.nLen / 1)) >= (int)(_in2Len[0]));
+ _in2[0] = _praIn[1].buf.pv;
+ if (_in2Len[0] > 0)
+ _in2[0][(_in2Len[0] - 1)] = 0;
+ _TRY(_nErr, _pfn(*_in0, *_in1, *_in2, _rout3));
+ _COPY(_primROut, 0, _rout3, 0, 4);
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+static __inline int _skel_method_15(int (*_pfn)(char *, char *, uint32_t *), uint32_t _sc, remote_arg *_pra)
+{
+ remote_arg *_praEnd;
+ char *_in0[1];
+ uint32_t _in0Len[1];
+ char *_in1[1];
+ uint32_t _in1Len[1];
+ uint32_t _rout2[1];
+ uint32_t *_primIn;
+ int _numIn[1];
+ uint32_t *_primROut;
+ remote_arg *_praIn;
+ 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 >= 4);
+ _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(_in1Len, 0, _primIn, 4, 4);
+ _ASSERT(_nErr, (int)((_praIn[1].buf.nLen / 1)) >= (int)(_in1Len[0]));
+ _in1[0] = _praIn[1].buf.pv;
+ if (_in1Len[0] > 0)
+ _in1[0][(_in1Len[0] - 1)] = 0;
+ _TRY(_nErr, _pfn(*_in0, *_in1, _rout2));
+ _COPY(_primROut, 0, _rout2, 0, 4);
+ _CATCH(_nErr) {}
+ return _nErr;
+}
+__QAIC_SKEL_EXPORT int __QAIC_SKEL(apps_std_skel_invoke)(uint32_t _sc, remote_arg *_pra) __QAIC_SKEL_ATTRIBUTE
+{
+ switch (REMOTE_SCALARS_METHOD(_sc))
+ {
+ case 0:
+ return _skel_method_15((void *)__QAIC_IMPL(apps_std_fopen), _sc, _pra);
+ case 1:
+ return _skel_method_14((void *)__QAIC_IMPL(apps_std_freopen), _sc, _pra);
+ case 2:
+ return _skel_method_7((void *)__QAIC_IMPL(apps_std_fflush), _sc, _pra);
+ case 3:
+ return _skel_method_7((void *)__QAIC_IMPL(apps_std_fclose), _sc, _pra);
+ case 4:
+ return _skel_method_13((void *)__QAIC_IMPL(apps_std_fread), _sc, _pra);
+ case 5:
+ return _skel_method_12((void *)__QAIC_IMPL(apps_std_fwrite), _sc, _pra);
+ case 6:
+ return _skel_method_2((void *)__QAIC_IMPL(apps_std_fgetpos), _sc, _pra);
+ case 7:
+ return _skel_method_11((void *)__QAIC_IMPL(apps_std_fsetpos), _sc, _pra);
+ case 8:
+ return _skel_method_8((void *)__QAIC_IMPL(apps_std_ftell), _sc, _pra);
+ case 9:
+ return _skel_method_10((void *)__QAIC_IMPL(apps_std_fseek), _sc, _pra);
+ case 10:
+ return _skel_method_9((void *)__QAIC_IMPL(apps_std_flen), _sc, _pra);
+ case 11:
+ return _skel_method_7((void *)__QAIC_IMPL(apps_std_rewind), _sc, _pra);
+ case 12:
+ return _skel_method_8((void *)__QAIC_IMPL(apps_std_feof), _sc, _pra);
+ case 13:
+ return _skel_method_8((void *)__QAIC_IMPL(apps_std_ferror), _sc, _pra);
+ case 14:
+ return _skel_method_7((void *)__QAIC_IMPL(apps_std_clearerr), _sc, _pra);
+ case 15:
+ return _skel_method_4((void *)__QAIC_IMPL(apps_std_print_string), _sc, _pra);
+ case 16:
+ return _skel_method_6((void *)__QAIC_IMPL(apps_std_getenv), _sc, _pra);
+ case 17:
+ return _skel_method_5((void *)__QAIC_IMPL(apps_std_setenv), _sc, _pra);
+ case 18:
+ return _skel_method_4((void *)__QAIC_IMPL(apps_std_unsetenv), _sc, _pra);
+ case 19:
+ return _skel_method_3((void *)__QAIC_IMPL(apps_std_fopen_with_env), _sc, _pra);
+ case 20:
+ return _skel_method_2((void *)__QAIC_IMPL(apps_std_fgets), _sc, _pra);
+ case 21:
+ return _skel_method_1((void *)__QAIC_IMPL(apps_std_get_search_paths_with_env), _sc, _pra);
+ case 22:
+ return _skel_method((void *)__QAIC_IMPL(apps_std_fileExists), _sc, _pra);
+ }
+ return AEE_EUNSUPPORTED;
+}
+#ifdef __cplusplus
+}
+#endif
+#endif //_APPS_STD_SKEL_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-07 08:45:17 +0000