Big-Data-HPC-Platform/ecl/hqlcpp/hqlcppsys.ecl

/*##############################################################################

    HPCC SYSTEMS software Copyright (C) 2012 HPCC Systems.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
############################################################################## */
#ifndef HQLCPPSYS_HPP
#define HQLCPPSYS_HPP

const char * cppSystemText[]  = {
    //Definition of all the system functions that are explicitly called by the code generator
    //Should consider moving this to a reserved module within the ecllibrary.
    "shared dummyRecord := { string1 x };",

    //typedefs to clarify the prototypes.  One day these will become real classes.
    "shared IOutputRowSerializer := boolean;",
    "shared IOutputRowDeserializer := boolean;",
    "shared IHThorHashLookupInfo := boolean;",
    
    "export InternalCppService := SERVICE",
    //  searchTableStringN(unsigned4 num, string table, string search) : library='eclrtl';
    //  memcpy(void * target, void * src, unsigned len);
    //internal code generation helper functions...
    "   unsigned4 an2l4(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlStrToUInt4';",
    "   unsigned8 an2l8(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlStrToUInt8';",
    "   integer4 an2ls4(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlStrToInt4';",
    "   integer8 an2ls8(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlStrToInt8';",
    "   real8 an2f(const string src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlStrToReal';",
    "   boolean an2b(const string src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlStrToBool';",

    "   unsigned4 en2l4(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlEStrToUInt4';",
    "   unsigned8 en2l8(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlEStrToUInt8';",
    "   integer4 en2ls4(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlEStrToInt4';",
    "   integer8 en2ls8(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlEStrToInt8';",
    "   real8 en2f(const string src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlEStrToReal';",

    "   real8 ex2f(const varstring src) :   eclrtl,pure,library='eclrtl',entrypoint='rtl_ex2f';",

    "   unsigned4 vn2l4(const varstring src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlVStrToUInt4';",
    "   unsigned8 vn2l8(const varstring src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlVStrToUInt8';",
    "   integer4 vn2ls4(const varstring src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlVStrToInt4';",
    "   integer8 vn2ls8(const varstring src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlVStrToInt8';",
    "   real8 vn2f(const varstring src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlVStrToReal';",
    "   boolean vn2b(const varstring src) : eclrtl,pure,library='eclrtl',entrypoint='rtlVStrToBool';",

    "   string _intformat(integer8 value, unsigned4 width, unsigned4 flags) : eclrtl,pure,library='eclrtl',entrypoint='rtlIntFormat';",
    "   string _realformat(real8 value, unsigned4 width, unsigned4 places) : eclrtl,pure,library='eclrtl',entrypoint='rtlRealFormat';",
    "   l42an(string target, unsigned integer4 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUInt4ToStr';",
    "   l82an(string target, unsigned integer8 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUInt8ToStr';",
    "   ls42an(string target, integer4 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlInt4ToStr';",
    "   ls82an(string target, integer8 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlInt8ToStr';",

    "   l42vn(string target, unsigned integer4 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUInt4ToVStr';",
    "   l82vn(string target, unsigned integer8 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUInt8ToVStr';",
    "   ls42vn(string target, integer4 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlInt4ToVStr';",
    "   ls82vn(string target, integer8 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlInt8ToVStr';",

    "   varstring l42vx(unsigned integer4 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlUInt4ToVStrX';",
    "   varstring l82vx(unsigned integer8 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlUInt8ToVStrX';",
    "   varstring ls42vx(integer4 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlInt4ToVStrX';",
    "   varstring ls82vx(integer8 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlInt8ToVStrX';",

    "   string l42ax(unsigned integer4 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUInt4ToStrX';",
    "   string l82ax(unsigned integer8 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUInt8ToStrX';",
    "   string ls42ax(integer4 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlInt4ToStrX';",
    "   string ls82ax(integer8 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlInt8ToStrX';",

    "   f2an(string target, real8 val) :    eclrtl,pure,library='eclrtl',entrypoint='rtlRealToStr';",
    "   string _f2ax(real8 val) :   eclrtl,pure,library='eclrtl',entrypoint='rtlRealToStrX';",
    "   f2vn(string target, real8 val) :    eclrtl,pure,library='eclrtl',entrypoint='rtlRealToVStr';",
    "   varstring f2vx(real8 val) : eclrtl,pure,library='eclrtl',entrypoint='rtlRealToVStrX';",

    "   string str2StrX(const data src) :   eclrtl,pure,include,library='eclrtl',entrypoint='rtlStrToStrX';",
    "   data str2DataX(const data src) :    eclrtl,pure,include,library='eclrtl',entrypoint='rtlStrToDataX';",
    "   varstring str2VStrX(const data src) :   eclrtl,pure,include,library='eclrtl',entrypoint='rtlStrToVStrX';",
    "   varstring estr2VStrX(const ebcdic string src) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlEStrToVStrX';",
    "   string ebcdic2asciiX(const ebcdic string src) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlEStrToStrX';",
    "   ebcdic string ascii2ebcdicX(const string src) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlStrToEStrX';",

    "   strToQStr(qstring tgt, const data src) :    eclrtl,pure,include,library='eclrtl',entrypoint='rtlStrToQStr';",
    "   qstring strToQStrX(const data src) :    eclrtl,pure,include,library='eclrtl',entrypoint='rtlStrToQStrX';",
    "   string qstr2StrX(const qstring src) :   eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrToStrX';",
    "   data qstr2DataX(const qstring src) :    eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrToDataX';",
    "   boolean qstr2Bool(const qstring src) :  eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrToBool';",
    "   qstr2Data(data tgt, const qstring src) :    eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrToData';",
    "   qstr2Str(string tgt, const qstring src) :   eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrToStr';",
    "   qstrToQStr(qstring tgt, const qstring src) :    eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrToQStr';",
    "   qstring qstrToQStrX(const qstring src) :    eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrToQStrX';",
    "   qstr2VStr(string tgt, const qstring src) :  eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrToVStr';",
    "   unsigned4 qstrLength(unsigned4 sz) :    eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrLength';",
    "   unsigned4 qstrSize(unsigned4 len) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlQStrSize';",

    "   DecPushQString(const data src) :    eclrtl,library='eclrtl',entrypoint='rtlDecPushQStr';",
    "   DecPushUnicode(const unicode src) : eclrtl,library='eclrtl',entrypoint='rtlDecPushUnicode';",

    // a lie, actually has ... parameters.
    "   string concat(string tgt) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlConcat';",
    "   varstring concatVStr(string tgt) :  eclrtl,pure,include,library='eclrtl',entrypoint='rtlConcatVStr';",
    "   unicode concatUnicode(unicode tgt) :    eclrtl,pure,include,library='eclrtl',entrypoint='rtlConcatUnicode';",
    "   varunicode concatVUnicode(varunicode tgt) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlConcatVUnicode';",
    "   utf8 concatUtf8(utf8 tgt) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlConcatUtf8';",
    "   varstring createQuotedString(string tgt) :  eclrtl,pure,library='eclrtl',entrypoint='rtlCreateQuotedString';",
    "   concatExtend(boolean prev, const string src) :  eclrtl,pure,library='eclrtl',include,entrypoint='rtlConcatExtend';",
    "   concatStrF(data tgt) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlConcatStrF';",
    "   concatVStrF(string tgt) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlConcatVStrF';",
    "   concatUnicodeF(unicode tgt) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlConcatUnicodeF';",
    "   concatVUNicodeF(unicode tgt) : eclrtl,pure,include,library='eclrtl',entrypoint='rtlConcatVUnicodeF';",

    "   string concatStrExtend(const string src) :  eclrtl,extend,pure,library='eclrtl',include,entrypoint='rtlConcatExtend';",
    "   unicode concatUnicodeExtend(const unicode src) :  eclrtl,extend,pure,library='eclrtl',include,entrypoint='rtlConcatUnicodeExtend';",

    "   unsigned4 concatStr2Str(string tgt, unsigned4 idx, const string src) :  eclrtl,library='eclrtl',entrypoint='rtlConcatStrToStr';",
    "   unsigned4 concatVStr2Str(string tgt, unsigned4 idx, const varstring src) : eclrtl,library='eclrtl',entrypoint='rtlConcatVStrToStr';",
    "   unsigned4 concatUtf8ToUtf8(utf8 tgt, unsigned4 idx, const utf8 src) : eclrtl,library='eclrtl',entrypoint='rtlConcatUtf8ToUtf8';",
    "   unsigned4 concatUnicodeToUnicode(unicode tgt, unsigned4 idx, const unicode src) : eclrtl,library='eclrtl',entrypoint='rtlConcatUnicodeToUnicode';",
    "   unsigned4 concatVUnicodeToUnicode(unicode tgt, unsigned4 idx, const varunicode src) : eclrtl,library='eclrtl',entrypoint='rtlConcatVUnicodeToUnicode';",
    "   codepage2Unicode(unicode tgt, const string src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlCodepageToUnicode';",
    "   codepage2VUnicode(unicode tgt, const string src, const varstring codepage) :    eclrtl,pure,library='eclrtl',entrypoint='rtlCodepageToVUnicode';",
    "   vcodepage2Unicode(unicode tgt, const varstring src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlVCodepageToUnicode';",
    "   vcodepage2VUnicode(unicode tgt, const varstring src, const varstring codepage) :    eclrtl,pure,library='eclrtl',entrypoint='rtlVCodepageToVUnicode';",
    "   unicode2Codepage(string tgt, const unicode src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToCodepage';",
    "   unicode2Data(data tgt, const unicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToData';",
    "   unicode2VCodepage(string tgt, const unicode src, const varstring codepage) :    eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToVCodepage';",
    "   vunicode2Codepage(string tgt, const varunicode src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlVUnicodeToCodepage';",
    "   vunicode2Data(data tgt, const varunicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlVUnicodeToData';",
    "   vunicode2VCodepage(string tgt, const varunicode src, const varstring codepage) :    eclrtl,pure,library='eclrtl',entrypoint='rtlVUnicodeToVCodepage';",
    "   unicode2Unicode(unicode tgt, const unicode src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToUnicode';",
    "   unicode2VUnicode(unicode tgt, const unicode src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToVUnicode';",
    "   vunicode2Unicode(unicode tgt, const varunicode src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlVUnicodeToUnicode';",
    "   vunicode2VUnicode(unicode tgt, const varunicode src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlVUnicodeToVUnicode';",
    "   unicode codepage2UnicodeX(const string src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlCodepageToUnicodeX';",
    "   varunicode codepage2VUnicodeX(const string src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlCodepageToVUnicodeX';",
    "   unicode vcodepage2UnicodeX(const varstring src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlVCodepageToUnicodeX';",
    "   varunicode vcodepage2VUnicodeX(const varstring src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlVCodepageToVUnicodeX';",
    "   string unicode2CodepageX(const unicode src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToCodepageX';",
    "   data unicode2DataX(const unicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToDataX';",
    "   varstring unicode2VCodepageX(const unicode src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToVCodepageX';",
    "   string vunicode2CodepageX(const varunicode src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlVUnicodeToCodepageX';",
    "   varstring vunicode2VCodepageX(const varunicode src, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlVUnicodeToVCodepageX';",
    "   unicode unicode2UnicodeX(const unicode src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToUnicodeX';",
    "   varunicode unicode2VUnicodeX(const unicode src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToVUnicodeX';",
    "   unicode vunicode2UnicodeX(const varunicode src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlVUnicodeToUnicodeX';",
    "   varunicode vunicode2VUnicodeX(const varunicode src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlVUnicodeToVUnicodeX';",
    "   unicodeStrcpy(varunicode tgt, const varunicode src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeStrcpy';",
    "   unsigned4 unicodeStrlen(const varunicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeStrlen';",
    "   data keyUnicodeX(const unicode src, const varstring loc) :  eclrtl,library='eclrtl',entrypoint='rtlKeyUnicodeX';",
    "   data keyUnicodeStrengthX(const unicode src, const varstring loc, unsigned4 str) :   eclrtl,library='eclrtl',entrypoint='rtlKeyUnicodeStrengthX';",

    "   l2vn4(string target, unsigned integer4 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtl_l2vn4';",
    "   l2vn8(string target, unsigned integer8 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtl_l2vn8';",
    "   pack(string target, const string src) : eclrtl,library='eclrtl',entrypoint='rtlPack';",
    "   integer4 searchDataTable(unsigned4 num, unsigned4 elemlen, const string entries, const string search) : eclrtl,pure,library='eclrtl',include='eclrtl.hpp',entrypoint='rtlNewSearchDataTable';",
    "   integer4 searchEStringTable(unsigned4 num, unsigned4 elemlen, const string entries, const string search) : eclrtl,pure,library='eclrtl',include='eclrtl.hpp',entrypoint='rtlNewSearchEStringTable';",
    "   integer4 searchQStringTable(unsigned4 num, unsigned4 elemlen, const string entries, const string search) : eclrtl,pure,library='eclrtl',include='eclrtl.hpp',entrypoint='rtlNewSearchQStringTable';",
    "   integer4 searchStringTable(unsigned4 num, unsigned4 elemlen, const string entries, const string search) : eclrtl,pure,library='eclrtl',include='eclrtl.hpp',entrypoint='rtlNewSearchStringTable';",
    "   integer4 searchVStringTable(unsigned4 num, const varstring entries, const varstring search) : eclrtl,pure,library='eclrtl',include='eclrtl.hpp',entrypoint='rtlSearchTableVStringN';",
    "   integer4 searchUnicodeTable(unsigned4 num, unsigned4 elemlen, const unicode entries, const unicode search) : eclrtl,pure,library='eclrtl',include='eclrtl.hpp',entrypoint='rtlNewSearchUnicodeTable';",
    "   integer4 searchUtf8Table(unsigned4 num, unsigned4 elemlen, const utf8 entries, const utf8 search) : eclrtl,pure,library='eclrtl',include='eclrtl.hpp',entrypoint='rtlNewSearchUtf8Table';",
    "   integer4 searchVUnicodeTable(unsigned4 num, const varunicode entries, const varunicode search) : eclrtl,pure,library='eclrtl',include='eclrtl.hpp',entrypoint='rtlNewSearchVUnicodeTable';",

    "   integer4 searchTableInteger4(set of integer4 values, integer4 search) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlSearchTableInteger4',oldSetFormat;",
    "   integer4 searchTableInteger8(set of integer8 values, integer8 search) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlSearchTableInteger8',oldSetFormat;",
    "   integer4 searchTableUInteger4(set of unsigned4 values, unsigned4 search) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlSearchTableUInteger4',oldSetFormat;",
    "   integer4 searchTableUInteger8(set of unsigned8 values, unsigned8 search) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlSearchTableUInteger8',oldSetFormat;",

    "   unpack(string target, const string src) :   eclrtl,library='eclrtl',entrypoint='rtlUnpack';",
    "   ebcdic2ascii(string target, const ebcdic string src) :  eclrtl,library='eclrtl',entrypoint='rtlEStrToStr';",
    "   ascii2ebcdic(ebcdic string target, const string src) :  eclrtl,library='eclrtl',entrypoint='rtlStrToEStr';",

    "   unsigned4 trimStrLen(const string src): eclrtl,pure,library='eclrtl',entrypoint='rtlTrimStrLen';",
    "   unsigned4 trimUnicodeStrLen(const unicode src): eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUnicodeStrLen';",
    "   unsigned4 trimUtf8StrLen(const utf8 src):   eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUtf8StrLen';",
    "   unsigned4 trimVStrLen(const varstring src): eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVStrLen';",
    "   unsigned4 trimVUnicodeStrLen(const varunicode src): eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVUnicodeStrLen';",
    "   string trimRight(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimRight';",
    "   unicode trimUnicodeRight(const unicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUnicodeRight';",
    "   utf8 trimUtf8Right(const utf8 src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUtf8Right';",
    "   string trimVRight(const varstring src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVRight';",
    "   unicode trimVUnicodeRight(const varunicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVUnicodeRight';",
    "   string trimLeft(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimLeft';",
    "   unicode trimUnicodeLeft(const unicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUnicodeLeft';",
    "   unicode trimUtf8Left(const utf8 src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUtf8Left';",
    "   string trimVLeft(const varstring src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVLeft';",
    "   unicode trimVUnicodeLeft(const varunicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVUnicodeLeft';",
    "   string trimBoth(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimBoth';",
    "   unicode trimUnicodeBoth(const unicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUnicodeBoth';",
    "   utf8 trimUtf8Both(const utf8 src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUtf8Both';",
    "   string trimVBoth(const varstring src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVBoth';",
    "   unicode trimVUnicodeBoth(const varunicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVUnicodeBoth';",
    "   string trimAll(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimAll';",
    "   unicode trimUnicodeAll(const unicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUnicodeAll';",
    "   utf8 trimUtf8All(const utf8 src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimUtf8All';",
    "   string trimVAll(const varstring src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVAll';",
    "   unicode trimVUnicodeAll(const varunicode src) : eclrtl,pure,library='eclrtl',entrypoint='rtlTrimVUnicodeAll';",
    "   data subDataFTX(const data src, unsigned4 from, unsigned4 to) : eclrtl,pure,library='eclrtl',entrypoint='rtlSubDataFTX';",
    "   data subDataFX(const data src, unsigned4 from) : eclrtl,pure,library='eclrtl',entrypoint='rtlSubDataFX';",
    "   subDataFT(data tgt, const data src, unsigned4 from, unsigned4 to) : eclrtl,pure,library='eclrtl',entrypoint='rtlSubDataFT';",
    "   string subStrFTX(const string src, unsigned4 from, unsigned4 to) : eclrtl,pure,library='eclrtl',entrypoint='rtlSubStrFTX';",
    "   string subStrFX(const string src, unsigned4 from) : eclrtl,pure,library='eclrtl',entrypoint='rtlSubStrFX';",
    "   subStrFT(string tgt, const string src, unsigned4 from, unsigned4 to) : eclrtl,pure,library='eclrtl',entrypoint='rtlSubStrFT';",
    "   qstring subQStrFTX(const qstring src, unsigned4 from, unsigned4 to) : eclrtl,pure,library='eclrtl',entrypoint='rtlSubQStrFTX';",
    "   qstring subQStrFX(const qstring src, unsigned4 from) : eclrtl,pure,library='eclrtl',entrypoint='rtlSubQStrFX';",
    "   subQStrFT(qstring tgt, const qstring src, unsigned4 from, unsigned4 to) : eclrtl,pure,library='eclrtl',entrypoint='rtlSubQStrFT';",
    "   unicode unicodeSubStrFTX(const unicode src, unsigned4 from, unsigned4 to) : eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeSubStrFTX';",
    "   unicode unicodeSubStrFX(const unicode src, unsigned4 from) : eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeSubStrFX';",
    "   unsigned4 rtlMax(unsigned4 idx, unsigned4 len) : eclrtl,pure,entrypoint='rtlMax',include;",
    "   unsigned4 rtlMin(unsigned4 idx, unsigned4 len) : eclrtl,pure,entrypoint='rtlMin',include;",

    "   integer4 compareStrStr(const string l, const string r) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareStrStr';",
    "   integer4 compareVStrVStr(const varstring l, const varstring r) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareVStrVStr';",
    "   integer4 compareStrBlank(const string l) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareStrBlank';",
    "   integer4 compareDataData(const data l, const data r) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareDataData';",
    "   integer4 compareEStrEStr(const string l, const string r) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareEStrEStr';",
    "   integer4 compareQStrQStr(const data l, const data r) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareQStrQStr';",
    "   integer4 compareUnicodeUnicode(const unicode l, const unicode r, const varstring loc) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareUnicodeUnicode';",
    "   integer4 compareUnicodeUnicodeStrength(const unicode l, const unicode r, const varstring loc, unsigned4 str) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareUnicodeUnicodeStrength';",
    "   integer4 compareVUnicodeVUnicode(const varunicode l, const varunicode r, const varstring loc) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareVUnicodeVUnicode';",
    "   integer4 compareVUnicodeVUnicodeStrength(const varunicode l, const varunicode r, const varstring loc, unsigned4 str) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareVUnicodeVUnicodeStrength';",

    "   integer4 prefixDiffStr(const string l, const string r, unsigned4 origin) : eclrtl,pure,library='eclrtl',entrypoint='rtlPrefixDiffStrEx';",
    "   integer4 prefixDiffUnicode(const unicode l, const unicode r, const varstring loc, unsigned4 origin) : eclrtl,pure,library='eclrtl',entrypoint='rtlPrefixDiffUnicodeEx';",

    "   createOrder(data1 tgt, const data1 src, unsigned4 num, unsigned4 width, const data1 compare) : eclrtl,library='eclrtl',entrypoint='rtlCreateOrder';",
    "   unsigned4 rankFromOrder(unsigned4 idx, unsigned4 num, const data1 order) : eclrtl,pure,library='eclrtl',entrypoint='rtlRankFromOrder';",
    "   unsigned4 rankedFromOrder(unsigned4 idx, unsigned4 num, const data1 order) : eclrtl,pure,library='eclrtl',entrypoint='rtlRankedFromOrder';",
        
    "   boolean data2Bool(const data src) : eclrtl,pure,library='eclrtl',entrypoint='rtlDataToBool';",
    "   bool2Data(data tgt, boolean src) :  eclrtl,library='eclrtl',entrypoint='rtlBoolToData';",
    "   bool2Str(data tgt, boolean src) :   eclrtl,library='eclrtl',entrypoint='rtlBoolToStr';",
    "   bool2VStr(varstring tgt, boolean src) : eclrtl,library='eclrtl',entrypoint='rtlBoolToVStr';",
    "   str2Data(data tgt, const data src) :    eclrtl,library='eclrtl',entrypoint='rtlStrToData';",
    "   str2Str(data tgt, const data src) : eclrtl,library='eclrtl',entrypoint='rtlStrToStr';",
    "   eStr2EStr(data tgt, const data src) :   eclrtl,library='eclrtl',entrypoint='rtlEStrToEStr';",
    "   eStr2VStr(data tgt, const ebcdic string src) :  eclrtl,library='eclrtl',entrypoint='rtlEStrToVStr';",
    "   str2VStr(data tgt, const data src) :    eclrtl,library='eclrtl',entrypoint='rtlStrToVStr';",
    "   vStr2Data(data tgt, const varstring src) :  eclrtl,library='eclrtl',entrypoint='rtlVStrToData';",
    "   vStr2Str(data tgt, const varstring src) :   eclrtl,library='eclrtl',entrypoint='rtlVStrToStr';",
    "   vStr2VStr(data tgt, const varstring src) :  eclrtl,library='eclrtl',entrypoint='rtlVStrToVStr';",

    "   boolean csvStr2Bool(const string src) : eclrtl,pure,library='eclrtl',entrypoint='rtlCsvStrToBool';",
    "   string bool2StrX(boolean src) : eclrtl,library='eclrtl',entrypoint='rtlBoolToStrX';",
    "   varstring bool2VStrX(boolean src) : eclrtl,library='eclrtl',entrypoint='rtlBoolToVStrX';",

    "   integer4 readInt3(const data1 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlReadInt3';",
    "   integer8 readInt5(const data1 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlReadInt5';",
    "   integer8 readInt6(const data1 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlReadInt6';",
    "   integer8 readInt7(const data1 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlReadInt7';",
    "   unsigned4 readUInt3(const data1 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlReadUInt3';",
    "   unsigned8 readUInt5(const data1 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlReadUInt5';",
    "   unsigned8 readUInt6(const data1 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlReadUInt6';",
    "   unsigned8 readUInt7(const data1 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlReadUInt7';",
    "   writeInt3(data1 src, unsigned4 value) : eclrtl,library='eclrtl',entrypoint='rtlWriteInt3';",
    "   writeInt5(data1 src, unsigned8 value) : eclrtl,library='eclrtl',entrypoint='rtlWriteInt5';",
    "   writeInt6(data1 src, unsigned8 value) : eclrtl,library='eclrtl',entrypoint='rtlWriteInt6';",
    "   writeInt7(data1 src, unsigned8 value) : eclrtl,library='eclrtl',entrypoint='rtlWriteInt7';",

    "   integer8 getPackedSigned(const data1 src) : eclrtl,library='eclrtl',entrypoint='rtlGetPackedSigned';",
    "   unsigned8 getPackedUnsigned(const data1 src) :  eclrtl,library='eclrtl',entrypoint='rtlGetPackedUnsigned';",
    "   setPackedSigned(data1 src, integer8 value) :    eclrtl,library='eclrtl',entrypoint='rtlSetPackedSigned';",
    "   setPackedUnsigned(data1 src, unsigned8 value) : eclrtl,library='eclrtl',entrypoint='rtlSetPackedUnsigned';",
    "   unsigned4 getPackedSize(const data1 src) :  eclrtl,library='eclrtl',entrypoint='rtlGetPackedSize';",

    #if 0 // Not yet needed....
    "   integer4 readSwapInt3(const data1 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlReadSwapInt3';",
    "   integer8 readSwapInt5(const data1 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlReadSwapInt5';",
    "   integer8 readSwapInt6(const data1 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlReadSwapInt6';",
    "   integer8 readSwapInt7(const data1 src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlReadSwapInt7';",
    "   unsigned4 readSwapUInt3(const data1 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlReadSwapUInt3';",
    "   unsigned8 readSwapUInt5(const data1 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlReadSwapUInt5';",
    "   unsigned8 readSwapUInt6(const data1 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlReadSwapUInt6';",
    "   unsigned8 readSwapUInt7(const data1 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlReadSwapUInt7';",
    "   writeSwapInt3(data1 src, unsigned4 value) : eclrtl,library='eclrtl',entrypoint='rtlWriteSwapInt3';",
    "   writeSwapInt5(data1 src, unsigned8 value) : eclrtl,library='eclrtl',entrypoint='rtlWriteSwapInt5';",
    "   writeSwapInt6(data1 src, unsigned8 value) : eclrtl,library='eclrtl',entrypoint='rtlWriteSwapInt6';",
    "   writeSwapInt7(data1 src, unsigned8 value) : eclrtl,library='eclrtl',entrypoint='rtlWriteSwapInt7';",
    #endif

    "   integer2 revInt2(const data1 src) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevInt2';",
    "   integer4 revInt3(const data1 src) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevInt3';",
    "   integer4 revInt4(const data1 src) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevInt4';",
    "   integer8 revInt5(const data1 src) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevInt5';",
    "   integer8 revInt6(const data1 src) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevInt6';",
    "   integer8 revInt7(const data1 src) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevInt7';",
    "   integer8 revInt8(const data1 src) : eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevInt8';",
    "   unsigned2 revUInt2(const data1 src) :   eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevUInt2';",
    "   unsigned4 revUInt3(const data1 src) :   eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevUInt3';",
    "   unsigned4 revUInt4(const data1 src) :   eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevUInt4';",
    "   unsigned8 revUInt5(const data1 src) :   eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevUInt5';",
    "   unsigned8 revUInt6(const data1 src) :   eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevUInt6';",
    "   unsigned8 revUInt7(const data1 src) :   eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevUInt7';",
    "   unsigned8 revUInt8(const data1 src) :   eclrtl,pure,library='eclrtl',include,entrypoint='rtlRevUInt8';",

    "   integer4 castInt3(integer4 value) : eclrtl,pure,library='eclrtl',include,entrypoint='rtliCastInt3';",
    "   integer8 castInt5(integer8 value) : eclrtl,pure,library='eclrtl',include,entrypoint='rtliCastInt5';",
    "   integer8 castInt6(integer8 value) : eclrtl,pure,library='eclrtl',include,entrypoint='rtliCastInt6';",
    "   integer8 castInt7(integer8 value) : eclrtl,pure,library='eclrtl',include,entrypoint='rtliCastInt7';",
    "   unsigned4 castUInt3(unsigned4 value) :  eclrtl,pure,library='eclrtl',include,entrypoint='rtliCastUInt3';",
    "   unsigned8 castUInt5(unsigned8 value) :  eclrtl,pure,library='eclrtl',include,entrypoint='rtliCastUInt5';",
    "   unsigned8 castUInt6(unsigned8 value) :  eclrtl,pure,library='eclrtl',include,entrypoint='rtliCastUInt6';",
    "   unsigned8 castUInt7(unsigned8 value) :  eclrtl,pure,library='eclrtl',include,entrypoint='rtliCastUInt7';",

    "   DecAbs() :  eclrtl,library='eclrtl',entrypoint='DecAbs';",
    "   DecAdd() :  eclrtl,library='eclrtl',entrypoint='DecAdd';",
    "   integer4 DecCompareDecimal(const data v1, const data1 v2) : eclrtl,pure,library='eclrtl',entrypoint='DecCompareDecimal';",
    "   integer4 DecCompareUDecimal(const data v1, const data1 v2) : eclrtl,pure,library='eclrtl',entrypoint='DecCompareUDecimal';",
    "   integer4 DecCompareNull() : eclrtl,library='eclrtl',entrypoint='DecCompareNull';",
    "   integer4 DecDistinct() :    eclrtl,library='eclrtl',entrypoint='DecDistinct';",
    "   integer4 DecDistinctR() :   eclrtl,library='eclrtl',entrypoint='DecDistinctR';",
    "   DecDivide(unsigned1 dbz) :   eclrtl,library='eclrtl',entrypoint='DecDivide';",
    "   DecModulus(unsigned1 dbz) :  eclrtl,library='eclrtl',entrypoint='DecModulus';",
    "   DecSub() :  eclrtl,library='eclrtl',entrypoint='DecSub';",
    "   DecSubR() : eclrtl,library='eclrtl',entrypoint='DecSubR';",
    "   DecNegate() :   eclrtl,library='eclrtl',entrypoint='DecNegate';",
    "   unsigned4 DecPopString(string tgt) :    eclrtl,library='eclrtl',entrypoint='DecPopString';",
    "   DecPopVString(string tgt) : eclrtl,library='eclrtl',entrypoint='DecPopCString';",
    "   varstring DecPopVStringX() :    eclrtl,library='eclrtl',entrypoint='DecPopCStringX';",
    "   integer8 DecPopInt64() :    eclrtl,library='eclrtl',entrypoint='DecPopInt64';",
    "   DecPopDecimal(data1 tgt,unsigned1 len,unsigned1 prec) : eclrtl,library='eclrtl',entrypoint='DecPopDecimal';",
    "   DecPopUDecimal(data1 tgt,unsigned1 len,unsigned1 prec) : eclrtl,library='eclrtl',entrypoint='DecPopUDecimal';",
    "   unsigned4 DecPopUlong() :   eclrtl,library='eclrtl',entrypoint='DecPopUlong';",
    "   real8 DecPopReal() :    eclrtl,library='eclrtl',entrypoint='DecPopReal';",
    "   DecPushString(const string tgt) :   eclrtl,library='eclrtl',entrypoint='DecPushString';",
    "   DecPushCString(const varstring src) :   eclrtl,library='eclrtl',entrypoint='DecPushCString';",
    "   DecPushInt64(integer8 src) :    eclrtl,library='eclrtl',entrypoint='DecPushInt64';",
    "   DecPushLong(integer4 src) : eclrtl,library='eclrtl',entrypoint='DecPushLong';",
    "   DecPushDecimal(const data1 src, unsigned1 declen, unsigned1 prec) : eclrtl,library='eclrtl',entrypoint='DecPushDecimal';",
    "   DecPushUDecimal(const data1 src, unsigned1 declen, unsigned1 prec) : eclrtl,library='eclrtl',entrypoint='DecPushUDecimal';",
    "   DecPushUInt64(unsigned8 src) :  eclrtl,library='eclrtl',entrypoint='DecPushUInt64';",
    "   DecPushULong(unsigned4 src) :   eclrtl,library='eclrtl',entrypoint='DecPushULong';",
    "   DecRound() :    eclrtl,library='eclrtl',entrypoint='DecRound';",
    "   DecRoundUp() :  eclrtl,library='eclrtl',entrypoint='DecRoundUp';",
    "   DecRoundTo(unsigned4 places) :  eclrtl,library='eclrtl',entrypoint='DecRoundTo';",
    "   DecDup() :  eclrtl,library='eclrtl',entrypoint='DecDup';",
    "   DecMul() :  eclrtl,library='eclrtl',entrypoint='DecMul';",
    "   DecDivideR(unsigned1 dbz) :  eclrtl,library='eclrtl',entrypoint='DecDivideR';",
    "   DecLongPower(integer4 pow) :    eclrtl,library='eclrtl',entrypoint='DecLongPower';",
    "   DecPushReal(real8 d) :  eclrtl,library='eclrtl',entrypoint='DecPushReal';",
    "   DecPushUtf8(utf8 d) :   eclrtl,library='eclrtl',entrypoint='rtlDecPushUtf8';",
    "   DecTruncate() :    eclrtl,library='eclrtl',entrypoint='DecTruncate';",
    "   DecTruncateAt(unsigned4 places) :  eclrtl,library='eclrtl',entrypoint='DecTruncateAt';",

    "   DecSetPrecision(unsigned1 len, unsigned1 prec) : eclrtl,library='eclrtl',entrypoint='DecSetPrecision';",
    "   integer4 DecPopLong() : eclrtl,library='eclrtl',entrypoint='DecPopLong';",
    "   DecSwap() : eclrtl,library='eclrtl',entrypoint='DecSwap';",
    "   DecUint4Power(unsigned4 pow) :  eclrtl,library='eclrtl',entrypoint='DecUint4Power';",
    "   string DecPopStringX() :    eclrtl,library='eclrtl',entrypoint='DecPopStringX';",
    "   DecLock() : eclrtl,library='eclrtl',entrypoint='DecLock';",
    "   DecUnlock() :   eclrtl,library='eclrtl',entrypoint='DecUnlock';",
    "   boolean DecValid(boolean isSigned, const data src) : eclrtl,pure,library='eclrtl',entrypoint='DecValid';",
    "   boolean DecValidTos() : eclrtl,pure,library='eclrtl',entrypoint='DecValidTos';",

    "   integer8 _ROUND(real8 arg) :    eclrtl,pure,library='eclrtl',entrypoint='rtlRound';",
    "   real8 roundTo(real8 arg, integer4 _places) : eclrtl,pure,library='eclrtl',entrypoint='rtlRoundTo';",
    "   integer8 _ROUNDUP(real8 arg) :  eclrtl,pure,library='eclrtl',entrypoint='rtlRoundUp';",
    "   integer8 _TRUNCATE(real8 arg) : eclrtl,pure,library='eclrtl',entrypoint='rtlRoundDown';",
    "   unsigned4 rtlRandom() : eclrtl,library='eclrtl',entrypoint='rtlRandom';",
    "   _fail(integer4 code, const varstring msg) : eclrtl,library='eclrtl',entrypoint='rtlFail';",
    "   sysFail(integer4 code, const varstring msg) :   eclrtl,library='eclrtl',entrypoint='rtlSysFail';",
    "   failDivideByZero() : eclrtl,library='eclrtl',entrypoint='rtlFailDivideByZero';",

    "   unsigned4 crcData(const data src, unsigned4 initval) :  eclrtl,pure,library='eclrtl',entrypoint='rtlCrcData';",
    "   unsigned4 crcUnicode(const unicode src, unsigned4 initval) :    eclrtl,pure,library='eclrtl',entrypoint='rtlCrcUnicode';",
    "   unsigned4 crcVStr(const varstring src, unsigned4 initval) : eclrtl,pure,library='eclrtl',entrypoint='rtlCrcVStr';",
    "   unsigned4 crcVUnicode(const varunicode src, unsigned4 initval) :    eclrtl,pure,library='eclrtl',entrypoint='rtlCrcVUnicode';",
    "   unsigned4 crcUtf8(const utf8 src, unsigned4 initval) :  eclrtl,pure,library='eclrtl',entrypoint='rtlCrcUtf8';",
    "   unsigned4 hashData(const data src, unsigned4 initval) : eclrtl,pure,library='eclrtl',entrypoint='rtlHashData';",
    "   unsigned4 hashUnicode(const unicode src, unsigned4 initval) :   eclrtl,pure,library='eclrtl',entrypoint='rtlHashUnicode';",
    "   unsigned4 hashVStr(const varstring src, unsigned4 initval) :    eclrtl,pure,library='eclrtl',entrypoint='rtlHashVStr';",
    "   unsigned4 hashVUnicode(const varunicode src, unsigned4 initval) :   eclrtl,pure,library='eclrtl',entrypoint='rtlHashVUnicode';",
    "   unsigned4 hashDataNC(const data src, unsigned4 initval) :   eclrtl,pure,library='eclrtl',entrypoint='rtlHashDataNC';",
    "   unsigned4 hashVStrNC(const varstring src, unsigned4 initval) :  eclrtl,pure,library='eclrtl',entrypoint='rtlHashVStrNC';",
    "   unsigned4 hashUtf8(const utf8 src, unsigned4 initval) : eclrtl,pure,library='eclrtl',entrypoint='rtlHashUtf8';",

    "   unsigned4 hash32Data(const data src, unsigned4 initval) :   eclrtl,pure,library='eclrtl',entrypoint='rtlHash32Data';",
    "   unsigned4 hash32Unicode(const unicode src, unsigned4 initval) : eclrtl,pure,library='eclrtl',entrypoint='rtlHash32Unicode';",
    "   unsigned4 hash32VStr(const varstring src, unsigned4 initval) :  eclrtl,pure,library='eclrtl',entrypoint='rtlHash32VStr';",
    "   unsigned4 hash32VUnicode(const varunicode src, unsigned4 initval) : eclrtl,pure,library='eclrtl',entrypoint='rtlHash32VUnicode';",
    "   unsigned4 hash32Utf8(const utf8 src, unsigned4 initval) :   eclrtl,pure,library='eclrtl',entrypoint='rtlHash32Utf8';",
    "   unsigned4 hash32Data1(const data1 src, unsigned4 initval) : eclrtl,pure,include,entrypoint='rtlHash32Data1';",
    "   unsigned4 hash32Data2(const data2 src, unsigned4 initval) : eclrtl,pure,include,entrypoint='rtlHash32Data2';",
    "   unsigned4 hash32Data3(const data3 src, unsigned4 initval) : eclrtl,pure,include,entrypoint='rtlHash32Data3';",
    "   unsigned4 hash32Data4(const data4 src, unsigned4 initval) : eclrtl,pure,include,entrypoint='rtlHash32Data4';",
    "   unsigned4 hash32Data5(const data4 src, unsigned4 initval) : eclrtl,pure,include,entrypoint='rtlHash32Data5';",
    "   unsigned4 hash32Data6(const data4 src, unsigned4 initval) : eclrtl,pure,include,entrypoint='rtlHash32Data6';",
    "   unsigned4 hash32Data7(const data4 src, unsigned4 initval) : eclrtl,pure,include,entrypoint='rtlHash32Data7';",
    "   unsigned4 hash32Data8(const data8 src, unsigned4 initval) : eclrtl,pure,include,entrypoint='rtlHash32Data8';",

    "   unsigned8 hash64Data(const data src, unsigned8 initval) :   eclrtl,pure,library='eclrtl',entrypoint='rtlHash64Data';",
    "   unsigned8 hash64Unicode(const unicode src, unsigned8 initval) : eclrtl,pure,library='eclrtl',entrypoint='rtlHash64Unicode';",
    "   unsigned8 hash64VStr(const varstring src, unsigned8 initval) :  eclrtl,pure,library='eclrtl',entrypoint='rtlHash64VStr';",
    "   unsigned8 hash64VUnicode(const varunicode src, unsigned8 initval) : eclrtl,pure,library='eclrtl',entrypoint='rtlHash64VUnicode';",
    "   unsigned8 hash64Utf8(const utf8 src, unsigned8 initval) :   eclrtl,pure,library='eclrtl',entrypoint='rtlHash64Utf8';",

    "   hashMd5Init(data _state) :  eclrtl,entrypoint='rtlHashMd5Init';",
    "   hashMd5Data(const data _value, data _state) :   eclrtl,entrypoint='rtlHashMd5Data';",
    "   data16 hashMd5Finish(data _state) : eclrtl,entrypoint='rtlHashMd5Finish';",

    "   boolean validReal(const data src) : eclrtl,pure,library='eclrtl',entrypoint='rtlIsValidReal';",
    "   real8 createRealNull() : eclrtl,pure,library='eclrtl',entrypoint='rtlCreateRealNull';",

    "   deserializeRaw(data field, boolean o) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeRaw';",
    "   data deserializeDataX(boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeDataX';",
    "   dataset deserializeDatasetX(boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeDataX';",
    "   _linkcounted_ dictionary deserializeDictionaryX(boolean _deserializer, boolean _input) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeDictionaryX';",
    "   grouped dataset deserializeGroupedDatasetX(boolean o) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeDataX';",
    "   _linkcounted_ dataset deserializeRowsetX(boolean _deserializer, boolean _input) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeRowsetX';",
    "   _linkcounted_ grouped dataset deserializeGroupedRowsetX(boolean _deserializer, boolean _input) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeGroupedRowsetX';",
    "   varstring deserializeCStringX(boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeCStringX';",
    "   string deserializeStringX(boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeStringX';",
    "   qstring deserializeQStrX(boolean o) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeQStrX';",
    "   unicode deserializeUnicodeX(boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeUnicodeX';",
    "   utf8 deserializeUtf8X(boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeUtf8X';",
    "   varunicode deserializeVUnicodeX(boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeVUnicodeX';",
    "   _linkcounted_ row(dummyRecord) deserializeRow(boolean _deserializer, boolean _in) : eclrtl,include,entrypoint='rtlDeserializeBufferRow';",
    "   _linkcounted_ row(dummyRecord) createRowFromXml(utf8 _text, boolean xmltransformer, boolean _stripWhitespace) : ctxmethod,pure,entrypoint='fromXml';",

    "   _linkcounted_ dataset appendRowsToRowset(_array_ dataset _in) : pure,eclrtl,include,entrypoint='appendRowsToRowset';",

    "   set of any deserializeSet(boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='deserializeSet',newSet;",
    "   set of any set2SetX(set of any i) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlSetToSetX',newSet;",
    "   set of any appendSetX(set of any l, set of any r) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlAppendSetX',newSet;",

    "   dataset dataset2DatasetX(const dataset src) :   eclrtl,include,pure,library='eclrtl',entrypoint='rtlStrToDataX';",

    "   serializeRaw(const data field, boolean o) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeRaw';",
    "   serializeDataX(const data value, boolean o) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeDataX';",
    "   serializeDatasetX(dataset value, boolean o) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeDataX';",
    "   serializeDictionaryX(linkcounted dictionary value, boolean _ser, boolean o) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeDictionaryX';",
    "   serializeGroupedDatasetX(grouped dataset value, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeDataX';",
    "   serializeRowsetX(_array_ dataset value, boolean _ser, boolean o) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeRowsetX';",
    "   serializeGroupedRowsetX(_array_ grouped dataset value, boolean _ser, boolean o) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeGroupedRowsetX';",
    "   serializeCStringX(const varstring value, boolean o) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeCStringX';",
    "   serializeStringX(const string value, boolean o) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeStringX';",
    "   serializeQStrX(const qstring value, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeQStrX';",
    "   serializeUnicodeX(const unicode value, boolean o) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUnicodeX';",
    "   serializeUtf8X(const utf8 value, boolean o) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUtf8X';",
    "   serializeRow(const row value, boolean _deserializer, boolean _input) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeRow';",

    "   dataset rowset2DatasetX(boolean _ser, _array_ dataset x) : eclrtl,include,library='eclrtl',entrypoint='rtlRowset2DatasetX';",
    "   grouped dataset groupedRowset2DatasetX(boolean _ser, _array_ grouped dataset x) : eclrtl,include,library='eclrtl',entrypoint='rtlGroupedRowset2DatasetX';",
    "   _linkcounted_ dataset dataset2RowsetX(boolean _des, dataset x) : eclrtl,include,library='eclrtl',entrypoint='rtlDataset2RowsetX';",
    "   _linkcounted_ grouped dataset groupedDataset2RowsetX(boolean _des, grouped dataset x) : eclrtl,include,library='eclrtl',entrypoint='rtlGroupedDataset2RowsetX';",

    "   outputXmlBool(boolean value, const varstring name) :    eclrtl,omethod,entrypoint='outputBool';",
    "   outputXmlData(const data value, const varstring nameo) :    eclrtl,omethod,entrypoint='outputData';",
    "   outputXmlDecimal(const data1 value, unsigned4 size, unsigned4 precision, const varstring name) :    eclrtl,omethod,entrypoint='outputDecimal';",
    "   outputXmlInt(integer8 value, const varstring name) :    eclrtl,omethod,entrypoint='outputInt';",
    "   outputXmlQString(const qstring value, const varstring name) :   eclrtl,omethod,entrypoint='outputQString';",
    "   outputXmlReal(real value, const varstring name) :   eclrtl,omethod,entrypoint='outputReal';",
    "   outputXmlString(const string value, const varstring name) : eclrtl,omethod,entrypoint='outputString';",
    "   outputXmlUInt(unsigned8 value, const varstring name) :  eclrtl,omethod,entrypoint='outputUInt';",
    "   outputXmlUnicode(const unicode value, const varstring name) :   eclrtl,omethod,entrypoint='outputUnicode';",
    "   outputXmlUtf8(const utf8 value, const varstring name) : eclrtl,omethod,entrypoint='outputUtf8';",
    "   outputXmlBeginArray(const varstring name) :  eclrtl,omethod,entrypoint='outputBeginArray';",
    "   outputXmlEndArray(const varstring name) :  eclrtl,omethod,entrypoint='outputEndArray';",
    "   outputXmlBeginNested(const varstring name, boolean nestChildren) :  eclrtl,omethod,entrypoint='outputBeginNested';",
    "   outputXmlEndNested(const varstring name) :  eclrtl,omethod,entrypoint='outputEndNested';",
    "   outputXmlSetAll() : eclrtl,omethod,entrypoint='outputSetAll';",

    "   processFieldBool(boolean value, boolean _field) :   eclrtl,omethod,entrypoint='processBool';",
    "   processFieldData(const data value, boolean _fieldo) :   eclrtl,omethod,entrypoint='processData';",
    "   processFieldDecimal(const data1 value, unsigned4 size, unsigned4 precision, boolean _field) :   eclrtl,omethod,entrypoint='processDecimal';",
    "   processFieldInt(integer8 value, boolean _field) :   eclrtl,omethod,entrypoint='processInt';",
    "   processFieldQString(const qstring value, boolean _field) :  eclrtl,omethod,entrypoint='processQString';",
    "   processFieldReal(real value, boolean _field) :  eclrtl,omethod,entrypoint='processReal';",
    "   processFieldString(const string value, boolean _field) :    eclrtl,omethod,entrypoint='processString';",
    "   processFieldUInt(unsigned8 value, boolean _field) : eclrtl,omethod,entrypoint='processUInt';",
    "   processFieldUnicode(const unicode value, boolean _field) :  eclrtl,omethod,entrypoint='processUnicode';",
    "   processFieldUtf8(const utf8 value, boolean _field) :    eclrtl,omethod,entrypoint='processUtf8';",
    "   processFieldSetAll(boolean _field) : eclrtl,omethod,entrypoint='processSetAll';",

    "   boolean processFieldBeginSet(boolean _field) :  eclrtl,omethod,entrypoint='processBeginSet';",
    "   boolean processFieldBeginDataset(boolean _field) :  eclrtl,omethod,entrypoint='processBeginDataset';",
    "   boolean processFieldBeginRow(boolean _field) :  eclrtl,omethod,entrypoint='processBeginRow';",
    "   processFieldEndSet(boolean _field) :    eclrtl,omethod,entrypoint='processEndSet';",
    "   processFieldEndDataset(boolean _field) :    eclrtl,omethod,entrypoint='processEndDataset';",
    "   processFieldEndRow(boolean _field) :    eclrtl,omethod,entrypoint='processEndRow';",


    "   string xmlDecodeStr(const string src)   :   eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='xmlDecodeStrX';",
    "   unicode xmlDecodeUStr(const unicode src)    :   eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='xmlDecodeUStrX';",
    "   string xmlEncodeStr(const string src, unsigned4 flags)  :   eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='xmlEncodeStrX';",
    "   unicode xmlEncodeUStr(const unicode src, unsigned4 flags)   :   eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='xmlEncodeUStrX';",

    "   serializeFixedString(const string field, boolean o) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeFixedString';",
    "   serializeQString(const qstring field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeFixedString';",
    "   serializeLPQString(const qstring field, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeLPString';",
    "   serializeLPString(const string field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeLPString';",
    "   serializeVarString(const varstring field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeVarString';",
    "   serializeBool(boolean field, boolean o) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeBool';",
    "   serializeFixedData(const data field, boolean o) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeFixedData';",
    "   serializeLPData(const data field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeLPData';",
    "   serializeInt1(integer1 field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeInt1';",
    "   serializeInt2(integer2 field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeInt2';",
    "   serializeInt3(integer4 field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeInt3';",
    "   serializeInt4(integer4 field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeInt4';",
    "   serializeInt5(integer8 field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeInt5';",
    "   serializeInt6(integer8 field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeInt6';",
    "   serializeInt7(integer8 field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeInt7';",
    "   serializeInt8(integer8 field, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeInt8';",
    "   serializeUInt1(unsigned1 field, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUInt1';",
    "   serializeUInt2(unsigned2 field, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUInt2';",
    "   serializeUInt3(unsigned4 field, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUInt3';",
    "   serializeUInt4(unsigned4 field, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUInt4';",
    "   serializeUInt5(unsigned8 field, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUInt5';",
    "   serializeUInt6(unsigned8 field, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUInt6';",
    "   serializeUInt7(unsigned8 field, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUInt7';",
    "   serializeUInt8(unsigned8 field, boolean o) :    eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeUInt8';",
    "   serializeReal4(real4 arg, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeReal4';",
    "   serializeReal8(real8 arg, boolean o) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeReal8';",
    "   serializeSet(const set of any arg, boolean o) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='serializeSet',newset;",

    "   string createRangeLow(unsigned4 fieldLen, unsigned4 compareLen, const string src):  eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateRangeLow';",
    "   string createRangeHigh(unsigned4 fieldLen, unsigned4 compareLen, const string src): eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateRangeHigh';",

    "   string createStrRangeLow(unsigned4 fieldLen, unsigned4 compareLen, const string src):   eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateStrRangeLow';",
    "   string createStrRangeHigh(unsigned4 fieldLen, unsigned4 compareLen, const string src): eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateStrRangeHigh';",
    "   data createDataRangeLow(unsigned4 fieldLen, unsigned4 compareLen, const data src):  eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateDataRangeLow';",
    "   data createDataRangeHigh(unsigned4 fieldLen, unsigned4 compareLen, const data src): eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateDataRangeHigh';",
    "   qstring createQStrRangeLow(unsigned4 fieldLen, unsigned4 compareLen, const qstring src):    eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateQStrRangeLow';",
    "   qstring createQStrRangeHigh(unsigned4 fieldLen, unsigned4 compareLen, const qstring src): eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateQStrRangeHigh';",
    "   unicode createUnicodeRangeLow(unsigned4 fieldLen, unsigned4 compareLen, const unicode src): eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateUnicodeRangeLow';",
    "   unicode createUnicodeRangeHigh(unsigned4 fieldLen, unsigned4 compareLen, const unicode src): eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateUnicodeRangeHigh';",

    "   unsigned8 createRegex(const varstring regExpr, boolean isCaseSensitive) :   eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateRegExpr';",
    "   destroyRegex(unsigned8 compiled) :  eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlDestroyRegExpr';",
    "   boolean regexFindX(unsigned8 compiled, const string text)   :   eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlRegExprFind';",
    "   string regexReplaceX(unsigned8 compiled, const string text, const string replace):  eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlRegExprReplace';",
    "   string regexGetFindStr(unsigned8 compiled, unsigned4 idx):  eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlRegExprGetFindStr';",
    "   unsigned8 createWRegex(const varunicode regExpr, boolean isCaseSensitive) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCreateWRegExpr';",
    "   destroyWRegex(unsigned8 compiled) : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlDestroyWRegExpr';",
    "   boolean wregexFindX(unsigned8 compiled, const unicode text) :   eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlWRegExprFind';",
    "   unicode wregexReplaceX(unsigned8 compiled, const unicode text, const unicode replace)   :   eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlWRegExprReplace';",
    "   unicode wregexGetFindStr(unsigned8 compiled, unsigned4 idx):    eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlWRegExprGetFindStr';",

    "   regexNewSetStrPattern(const varstring _pattern, boolean isCaseSensitive) : omethod,entrypoint='setPattern';"
    "   regexNewStrFind(boolean _compiled, const string _search, boolean _cloneSearch) : omethod,entrypoint='find';"
    "   boolean regexNewStrFound() : method,pure,entrypoint='found';"
    "   string regexNewStrFoundX(unsigned4 idx) : method,pure,entrypoint='getMatchX';"
    "   string regexNewStrReplaceX(const string _search, const string _replace) : method,pure,entrypoint='replace';"

    "   regexNewSetUStrPattern(const varunicode _pattern, boolean isCaseSensitive) : omethod,entrypoint='setPattern';"
    "   regexNewUStrFind(boolean _compiled, const unicode _search) : omethod,entrypoint='find';"
    "   boolean regexNewUStrFound() : method,pure,entrypoint='found';"
    "   unicode regexNewUStrFoundX(unsigned4 idx) : method,pure,entrypoint='getMatchX';"
    "   unicode regexNewUStrReplaceX(const unicode _search, const unicode _replace) : method,pure,entrypoint='replace';"
    
    //clibrary functions that are called from the code generation
    "   free(data1 src) : eclrtl,library='eclrtl',entrypoint='rtlFree';",
    "   integer4 memcmp(const data1 target, const data1 src, unsigned4 len) : sys,pure,entrypoint='memcmp';",
    "   data1 memcpy(data1 target, const data1 src, unsigned4 len): sys,entrypoint='memcpy';",
    "   data1 memset(data1 target, integer4 fill, unsigned4 len) :  sys,entrypoint='memset';",
    "   strcpy(const varstring1 target, const varstring1 src) : sys,entrypoint='strcpy';",
    "   unsigned4 strlen(const varstring1 src) :    sys,pure,entrypoint='strlen';",

    "   real8 clibExp(real8 arg) :  sys,pure,entrypoint='exp';",
    "   real8 _LN(real8 arg) :  eclrtl,pure,library='eclrtl',entrypoint='rtlLog';",
    "   real8 _SIN(real8 arg) : sys,pure,entrypoint='sin';",
    "   real8 _COS(real8 arg) : sys,pure,entrypoint='cos';",
    "   real8 _TAN(real8 arg) : sys,pure,entrypoint='tan';",
    "   real8 _SINH(real8 arg) :    sys,pure,entrypoint='sinh';",
    "   real8 _COSH(real8 arg) :    sys,pure,entrypoint='cosh';",
    "   real8 _TANH(real8 arg) :    sys,pure,entrypoint='tanh';",
    "   real8 _ASIN(real8 arg) :    eclrtl,pure,library='eclrtl',entrypoint='rtlASin';",
    "   real8 _ACOS(real8 arg) :    eclrtl,pure,library='eclrtl',entrypoint='rtlACos';",
    "   real8 _ATAN(real8 arg) :    sys,pure,entrypoint='atan';",
    "   real8 _ATAN2(real8 y, real8 x) :    sys,pure,entrypoint='atan2';",
    "   real8 _LOG10(real8 arg) :   eclrtl,pure,library='eclrtl',entrypoint='rtlLog10';",
    "   real8 _POWER(real8 x, real8 y) :    sys,pure,entrypoint='pow';",
    "   real8 _SQRT(real8 x) :  eclrtl,pure,library='eclrtl',entrypoint='rtlSqrt';",

    "   writeEbcdic(const ebcdic string src) : method,include='eclhelper.hpp',entrypoint='writeString';",
    "   writeReal(real8 src) : method,include='eclhelper.hpp',entrypoint='writeReal';",
    "   writeSigned(integer8 src) : method,include='eclhelper.hpp',entrypoint='writeSigned';",
    "   writeString(const string src) : method,include='eclhelper.hpp',entrypoint='writeString';",
    "   writeUnicode(const unicode src) : method,include='eclhelper.hpp',entrypoint='writeUnicode';",
    "   writeUnsigned(unsigned8 src) : method,include='eclhelper.hpp',entrypoint='writeUnsigned';",
    "   writeUtf8(const utf8 src) : method,include='eclhelper.hpp',entrypoint='writeUtf8';",

    "   unsigned8 getFilePosition(boolean _row) :   method,entrypoint='getFilePosition';",
    "   unsigned8 getLocalFilePosition(boolean _row) :  method,entrypoint='getLocalFilePosition';",
    "   const varstring queryLogicalFilename(boolean _row) : method,entrypoint='queryLogicalFilename';",
    
    "   unsigned8 createBlob(boolean _row, const data value) :  method,entrypoint='createBlob';",
    "   boolean lookupBlob(boolean _row, unsigned8 id)  : method,entrypoint='lookupBlob';",

    //Members of the code context
    "   varstring getWuid() : ctxmethod,pure,entrypoint='getWuid';",
    "   executeGraph(const varstring graph, boolean realThor, unsigned4 lenExtract, row parentExtract) : ctxmethod,entrypoint='executeGraph';",
    "   executeChildQueryInstance(unsigned4 lenExtract, row parentExtract)  : method,entrypoint='execute';",
    "   evaluateChildQueryInstance(unsigned4 lenExtract, row parentExtract) : method,entrypoint='evaluate';",       // actually returns something el
    "   _linkcounted_ dataset getChildQueryLinkedResult(unsigned4 id)   : method,allocator(false),pure,entrypoint='getLinkedResult';",
    "   _linkcounted_ dictionary getChildQueryDictionaryResult(unsigned4 id)   : method,allocator(false),pure,entrypoint='getDictionaryResult';",
    
    //MORE: Should this be utf8?
    "   varstring getenv(const varstring name, const varstring defaultValue) : pure,ctxmethod,entrypoint='getEnv';",

    "   integer4 queryFailCode()    : gctxmethod,entrypoint='queryLastFailCode';",
    "   string getFailMessage(const varstring tag)  : gctxmethod,entrypoint='getLastFailMessage';",
    "   integer4 queryLocalFailCode(boolean e)  : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlQueryLocalFailCode';",
    "   string getLocalFailMessage(boolean e, const varstring tag)  : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlGetLocalFailMessage';",
    "   freeException(boolean e)    : eclrtl,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlFreeException';",
    "   string getEventName()   : gctxmethod,entrypoint='getEventName';",
    "   string getEventExtra(const varstring tag)   : gctxmethod,entrypoint='getEventExtra';",

    "   selectCluster(const varstring src)  : gctxmethod,entrypoint='selectCluster';",
    "   restoreCluster()    : gctxmethod,entrypoint='restoreCluster';",

    "   integer4 compareUtf8Utf8(const utf8 l, const utf8 r, const varstring codepage) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareUtf8Utf8';",
    "   integer4 compareUtf8Utf8Strength(const utf8 l, const utf8 r, const varstring loc, unsigned4 str) : eclrtl,pure,library='eclrtl',entrypoint='rtlCompareUtf8Utf8Strength';",
    "   utf8 utf8SubStrFTX(const utf8 src, unsigned4 from, unsigned4 to) : eclrtl,pure,library='eclrtl',entrypoint='rtlUtf8SubStrFTX';",
    "   utf8 utf8SubStrFX(const utf8 src, unsigned4 from) : eclrtl,pure,library='eclrtl',entrypoint='rtlUtf8SubStrFX';",

    "   utf82Codepage(string tgt, const utf8 src, const varstring codepage) :   eclrtl,pure,include,library='eclrtl',entrypoint='rtlUtf8ToCodepage';",
    "   utf82Data(data tgt, const utf8 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUtf8ToData';",
    "   utf82Unicode(unicode tgt, const utf8 src) : eclrtl,pure,library='eclrtl',entrypoint='rtlUtf8ToUnicode';",
    "   utf8ToUtf8(utf8 tgt, const utf8 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlUtf8ToUtf8';",
    "   string utf82CodepageX(const utf8 src, const varstring codepage) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUtf8ToCodepageX';",
    "   data utf82DataX(const utf8 src) :   eclrtl,pure,library='eclrtl',entrypoint='rtlUtf8ToDataX';",
    "   unicode utf82UnicodeX(const utf8 src) : eclrtl,pure,library='eclrtl',entrypoint='rtlUtf8ToUnicodeX';",
    "   utf8 utf8ToUtf8X(const utf8 src) :  eclrtl,pure,library='eclrtl',entrypoint='rtlUtf8ToUtf8X';",
    "   codepageToUtf8(utf8 tgt, const string src, const varstring codepage) :  eclrtl,pure,library='eclrtl',entrypoint='rtlCodepageToUtf8';",
    "   utf8 codepageToUtf8X(const string src, const varstring codepage) :  eclrtl,pure,library='eclrtl',entrypoint='rtlCodepageToUtf8X';",
    "   unicodeToUtf8(utf8 tgt, const unicode src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToUtf8';",
    "   utf8 unicodeToUtf8X(const unicode src) :    eclrtl,pure,library='eclrtl',entrypoint='rtlUnicodeToUtf8X';",
    "   unsigned4 utf8Size(const data src) : eclrtl,include,pure,library='eclrtl',entrypoint='rtlUtf8Size';", 
    "   unsigned4 utf8Length(const data src) : eclrtl,include,pure,library='eclrtl',entrypoint='rtlUtf8Length';", 

    //ecl functions (mainly placeholders for methods)
    "   unsigned8 getDatasetHash(const varstring name, unsigned8 _hash) : ctxmethod,pure,entrypoint='getDatasetHash';",
    "   unsigned4 getResultHash(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultHash';",
    "   integer8 getResultInt(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultInt';",
    "   real8   getResultReal(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultReal';",
    "   boolean getResultBool(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultBool';",
    "   data    getResultData(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultData';",
    "   getResultDecimal(unsigned4 len, unsigned4 precision, boolean isSigned, decimal3_1 value, const varstring stepname, unsigned4 sequence) : ctxmethod,entrypoint='getResultDecimal';",
    "   dataset getResultDataset(const varstring stepname, unsigned4 sequence, boolean xmltransformer, boolean csvtransformer) : ctxmethod,pure,entrypoint='getResultRaw';",    // an alias
    "   qstring getResultQString(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultQString';",
    "   string  getResultString(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultString';",
    "   getResultStringF(string target, const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultStringF';",
    "   unicode getResultUnicode(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultUnicode';",
    "   varstring   getResultVarString(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultVarString';",
    "   varunicode  getResultVarUnicode(const varstring stepname, unsigned4 sequence) : ctxmethod,pure,entrypoint='getResultVarUnicode';",
    "   set of any getResultSet(const varstring stepname, unsigned4 sequence, boolean xmltransformer, boolean csvtransformer) : ctxmethod,pure,entrypoint='getResultSet',newset;",

    "   _linkcounted_ dataset getResultRowset(const varstring stepname, unsigned4 sequence, boolean _allocator, boolean isGrouped, boolean xmltransformer, boolean csvtransformer) : ctxmethod,allocator(false),pure,entrypoint='getResultRowset';",
    "   linkcounted dictionary getResultDictionary(const varstring stepname, unsigned4 sequence, boolean xmltransformer, boolean csvtransformer, boolean hasher) : ctxmethod,pure,entrypoint='getResultDictionary';",

    "   const varstring  cloneVString(const varstring str) : ctxmethod,pure,entrypoint='cloneVString';",
    "   const varstring  cloneVStringX(const string str) : ctxmethod,pure,entrypoint='cloneVString';",

    //Don't make these pure because they may change over time.
    "   boolean isResult(const varstring stepname, unsigned4 sequence) : gctxmethod,entrypoint='isResult';",
    "   boolean fileExists(const varstring lfn) : gctxmethod,entrypoint='fileExists';",
    "   varstring getExpandLogicalName(const varstring lfn) : ctxmethod,entrypoint='getExpandLogicalName';",
    "   deleteFile(const varstring lfn) : gctxmethod,entrypoint='deleteFile';",

    "   setResultInt(const varstring stepname, unsigned4 sequence, integer8 value) : ctxmethod,entrypoint='setResultInt';",
    "   setResultUInt(const varstring stepname, unsigned4 sequence, unsigned8 value) : ctxmethod,entrypoint='setResultUInt';",
    "   setResultReal(const varstring stepname, unsigned4 sequence, real8 value) : ctxmethod,entrypoint='setResultReal';",
    "   setResultBool(const varstring stepname, unsigned4 sequence, boolean value) : ctxmethod,entrypoint='setResultBool';",
    "   setResultData(const varstring stepname, unsigned4 sequence, const data value) : ctxmethod,entrypoint='setResultData';",
    "   setResultDataset(const varstring stepname, unsigned4 sequence, const dataset value, unsigned4 numRows, boolean doExtend) : gctxmethod,entrypoint='setResultDataset';",
    "   setResultDecimal(const varstring stepname, unsigned4 sequence, unsigned4 len, unsigned4 precision, boolean isSigned, const decimal3_1 value) : ctxmethod,entrypoint='setResultDecimal';",
    "   setResultRaw(const varstring stepname, unsigned4 sequence, const data value) : ctxmethod,entrypoint='setResultRaw';",
    "   setResultSet(const varstring stepname, unsigned4 sequence, const set of any value, boolean transformer) : ctxmethod,entrypoint='setResultSet',newset;",
    "   setResultQString(const varstring stepname, unsigned4 sequence, const qstring value) : ctxmethod,entrypoint='setResultQString';",
    "   setResultString(const varstring stepname, unsigned4 sequence, const string value) : ctxmethod,entrypoint='setResultString';",
    "   setResultUnicode(const varstring stepname, unsigned4 sequence, const unicode value) : ctxmethod,entrypoint='setResultUnicode';",
    "   setResultVarString(const varstring stepname, unsigned4 sequence, const varstring value) : ctxmethod,entrypoint='setResultVarString';",
    "   setResultVarUnicode(const varstring stepname, unsigned4 sequence, const varunicode value) : ctxmethod,entrypoint='setResultVarUnicode';",
    "   setConditionCode(integer4 stepname) : ctxmethod,entrypoint='setConditionCode';",
    "   const varstring loadResource(unsigned4 id) : ctxmethod,entrypoint='loadResource';",
    "   unsigned4 getWorkflowId() : gctxmethod,entrypoint='getWorkflowId';",
    "   doNotify(const varstring name, const varstring text) : gctxmethod,entrypoint='doNotify';",
    "   doNotifyTarget(const varstring name, const varstring text, const varstring _target) : gctxmethod,entrypoint='doNotify';",
    "   setWorkflowCondition(boolean value) : gctxmethod,entrypoint='setWorkflowCondition';",
    "   returnPersistVersion(const varstring name, unsigned4 eclCRC, unsigned8 allCRC, boolean isFile) : gctxmethod,entrypoint='returnPersistVersion';",
    "   addWorkunitException(const varstring txt, unsigned code, unsigned severity) : ctxmethod,entrypoint='addWuException'; ",
    "   addWorkunitAssertFailure(unsigned4 errNo, const varstring _msg, const varstring _filename, unsigned4 _lineno, unsigned4 _column, boolean _isAbort) : ctxmethod,entrypoint='addWuAssertFailure'; ",

    //
    "   unsigned4 countRows(const data raw, boolean iRecordSize) : eclrtl,pure,include,entrypoint='rtlCountRows';",
    "   unsigned4 countToSize(unsigned4 numRows, const data1 raw, boolean iRecordSize) : eclrtl,pure,include,entrypoint='rtlCountToSize';",
    
    "   utf8 ctxGetRowXml(boolean _meta, const row _row, unsigned4 flags) : ctxmethod,entrypoint='getRowXML';",

    "   boolean getMatched(unsigned4 idx) : method,pure,include,entrypoint='getMatched';",
    "   unsigned4 getMatchLength(unsigned4 idx) : method,pure,include,entrypoint='getMatchLength';",
    "   unsigned4 getMatchPosition(unsigned4 idx) : method,pure,include,entrypoint='getMatchPosition';",
    "   string getMatchText(unsigned4 idx) : method,pure,include,entrypoint='getMatchText';",
    "   unicode getMatchUnicode(unsigned4 idx) : method,pure,include,entrypoint='getMatchUnicode';",
    "   utf8 getMatchUtf8(unsigned4 idx) : method,pure,include,entrypoint='getMatchUtf8';",
    "   row(dummyRecord) getMatchRow(unsigned4 idx) : method,pure,include,entrypoint='queryMatchRow';",

    "   row(dummyRecord) getRootResult() : method,pure,include,entrypoint='queryRootResult';",

    "   string getProductionText(unsigned4 idx) : method,entrypoint='getText';",
    "   unicode getProductionUnicode(unsigned4 idx) : method,entrypoint='getUnicode';",
    "   utf8 getProductionUtf8(unsigned4 idx) : method,entrypoint='getUtf8';",
    "   row(dummyRecord) getProductionResult(unsigned4 idx) : method,entrypoint='queryResult';",

    "   addAll() : method,include='rtlkey.hpp',entrypoint='addAll';",
    "   addRange(const data1 lo, const data1 hi) : method,include='rtlkey.hpp',entrypoint='addRange';",
    "   killRange(const data1 lo, const data1 hi) : method,include='rtlkey.hpp',entrypoint='killRange';",

    "   boolean columnGetBool(const varstring name) : method,pure,entrypoint='getBool';",
    "   columnGetData(data result, const varstring name) : method,pure,entrypoint='getData';",
    "   data columnGetDataX(const varstring name) : method,pure,entrypoint='getDataX';",
    "   integer columnGetInt(const varstring name) : method,pure,entrypoint='getInt';",
    "   boolean columnGetSetIsAll(const varstring name) : method,pure,entrypoint='getIsSetAll';",
    "   columnGetQString(qstring result, const varstring name) : method,pure,entrypoint='getQString';",
    "   columnGetString(string result, const varstring name) : method,pure,entrypoint='getString';",
    "   string columnGetStringX(const varstring name) : method,pure,entrypoint='getStringX';",
    "   unicode columnGetUnicodeX(const varstring name) : method,pure,entrypoint='getUnicodeX';",
    "   utf8 columnGetUtf8X(const varstring name) : method,pure,entrypoint='getUtf8X';",

    "   boolean columnReadBool(const varstring name, boolean _default) : method,pure,entrypoint='readBool';",
    "   columnReadData(data result, const varstring name, const data _default) : method,pure,entrypoint='readData';",
    "   data columnReadDataX(const varstring name, const data _default) : method,pure,entrypoint='readDataX';",
    "   integer columnReadInt(const varstring name, integer _default) : method,pure,entrypoint='readInt';",
    "   boolean columnReadSetIsAll(const varstring name, boolean _default) : method,pure,entrypoint='readIsSetAll';",
    "   columnReadQString(qstring result, const varstring name, const qstring _default) : method,pure,entrypoint='readQString';",
    "   columnReadString(string result, const varstring name, const string _default) : method,pure,entrypoint='readString';",
    "   string columnReadStringX(const varstring name, const string _default) : method,pure,entrypoint='readStringX';",
    "   unicode columnReadUnicodeX(const varstring name, const unicode _default) : method,pure,entrypoint='readUnicodeX';",
    "   utf8 columnReadUtf8X(const varstring name, const utf8 _default) : method,pure,entrypoint='readUtf8X';",

    "   checkRowOverflow(unsigned4 curSize, unsigned4 maxRowSize) : eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCheckRowOverflow';", 
    "   reportRowOverflow(unsigned4 curSize, unsigned4 maxRowSize) : eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlReportRowOverflow';", 
    "   checkFieldOverflow(unsigned4 curSize, unsigned4 maxRowSize, const varstring _name) : eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlCheckFieldOverflow';", 
    "   reportFieldOverflow(unsigned4 curSize, unsigned4 maxRowSize, const varstring _name) : eclrtl,pure,include='eclrtl.hpp',library='eclrtl',entrypoint='rtlReportFieldOverflow';", 
    "   _linkcounted_ row(dummyRecord) ensureCapacity(unsigned4 curSize, const varstring _fieldName) : omethod,entrypoint='ensureCapacity',allocator=false;",
    "   ensureRowAvailable(unsigned4 curSize) : omethod,entrypoint='ensureAvailable';", 
    "   IIndirectMemberVisitor_visitRowset(_linkcounted_ dataset _x) : omethod,entrypoint='visitRowset';", 
    "   IIndirectMemberVisitor_visitRow(row _x) : omethod,entrypoint='visitRow';", 

    "   addAggregateRow(row extract) : method,entrypoint='processRow';", 
    "   getBytesFromBuilder() : omethod,entrypoint='getbytes';", 
    "   unsigned integer4 getClusterSize() : ctxmethod, entrypoint='getNodes';",

    "   _linkcounted_ dataset getLocalLinkedResult(unsigned4 id) : method,allocator(false),pure,entrypoint='getLinkedResult';",
    "   linkcounted dictionary getLocalDictionaryResult(unsigned4 id) : method,allocator(false),pure,entrypoint='getDictionaryResult';",
    "   unsigned4 getGraphLoopCounter() : ctxmethod,entrypoint='getGraphLoopCounter';",

    "   _linkcounted_ row(dummyRecord) finalizeRowClear(unsigned4 _size) : omethod,entrypoint='finalizeRowClear',allocator=false;",
    "   setMethod(boolean _allocator) : omethod,entrypoint='set';",
    "   setownMethod(boolean _allocator) : omethod,entrypoint='setown';",

    "   boolean newWhenActionArg(boolean _meta) : include, pseudoentrypoint='new CLibraryWhenActionArg';",
    "   boolean newCountAggregateArg(boolean _meta) : include, pseudoentrypoint='new CLibraryCountAggregateArg';",
    "   boolean newDegroupArg(boolean _meta) : include, pseudoentrypoint='new CLibraryDegroupArg';",
    "   boolean newExistsAggregateArg(boolean _meta) : include, pseudoentrypoint='new CLibraryExistsAggregateArg';",
    "   boolean newFunnelArg(boolean _ordered, boolean _sequential, boolean _meta) : include, pseudoentrypoint='new CLibraryFunnelArg';",
    "   boolean newGraphLoopResultWriteArg(boolean _meta) : include, pseudoentrypoint='new CLibraryGraphLoopResultWriteArg';",
    "   boolean newLocalResultReadArg(unsigned4 _sequence, boolean meta) : include, pseudoentrypoint='new CLibraryLocalResultReadArg';",
    "   boolean newLocalResultSpillArg(unsigned4 _sequence, boolean _usedOutside, boolean meta) : include, pseudoentrypoint='new CLibraryLocalResultSpillArg';",
    "   boolean newNullArg(boolean meta) : include, pseudoentrypoint='new CLibraryNullArg';",
    "   boolean newSplitArg(unsigned4 _usageCount, boolean _balanced, boolean meta) : include, pseudoentrypoint='new CLibrarySplitArg';",
    "   boolean newSelectNArg(unsigned8 _index, boolean _clearFunc, boolean meta) : include, pseudoentrypoint='new CLibrarySelectNArg';",
    "   boolean newMemorySpillReadArg(const varstring name, boolean meta) : include, pseudoentrypoint='new CLibraryMemorySpillReadArg';",
    "   boolean newMemorySpillSplitArg(unsigned4 usageCount, const varstring name, boolean meta) : include, pseudoentrypoint='new CLibraryMemorySpillSplitArg';",
    "   boolean newWorkUnitReadArg(const varstring _name, boolean _meta) : include, pseudoentrypoint='new CLibraryWorkUnitReadArg';",
    "   boolean newWorkUnitWriteArg(const varstring _name, unsigned4 _flags, boolean _meta) : include, pseudoentrypoint='new CLibraryWorkUnitWriteArg';",

    "   destructMetaMember(row _x) : omethod,entrypoint='destruct';",
    "   walkIndirectMetaMember(row _x, boolean _visitor) : omethod,entrypoint='walkIndirectMembers';",
    "   _linkcounted_ dataset linkdataset2linkdataset(_linkcounted_ dataset _x) : include,allocator(false),context,entrypoint='linkdataset2linkdataset';",

    "   dummyRecord rtlSerializeToBuilder(boolean _serializer, dummyRecord _in) : eclrtl,include,entrypoint='rtlSerializeToBuilder';",
    "   dummyRecord rtlDeserializeToBuilder(boolean _serializer, dummyRecord _in) : eclrtl,include,entrypoint='rtlDeserializeToBuilder';",
    "   _linkcounted_ row(dummyRecord) rtlDeserializeRow(boolean _deserializer, dummyRecord _in) : eclrtl,include,entrypoint='rtlDeserializeRow';",

    "   releaseRow(row _x) : include,entrypoint='rtlReleaseRow';",
    "   releaseRowset(_linkcounted_ dataset _x) : include,allocator(false),entrypoint='rtlReleaseRowset';",
    "   linkRow(row _x) : include,entrypoint='rtlLinkRow';",
    "   _linkcounted_ dataset linkRowset(_linkcounted_ dataset _x) : include,allocator(false),entrypoint='rtlLinkRowset';",

    "   _linkcounted_ dataset deserializeChildRowsetFromStream(boolean _deserializer, boolean _input) : eclrtl,include,entrypoint='rtlDeserializeChildRowset';",
    "   serializeChildRowsetToStream(boolean _output, boolean _serializer, _linkcounted_ dataset _x) : eclrtl,include,entrypoint='rtlSerializeChildRowset';",

    "   linkcounted dictionary deserializeChildDictionaryFromStream(boolean _deserializer, boolean _input) : eclrtl,include,entrypoint='rtlDeserializeChildDictionary';",
    "   linkcounted dictionary deserializeChildDictionaryFromDatasetFromStream(boolean _deserializer, boolean _hasher, boolean _input) : eclrtl,include,entrypoint='rtlDeserializeChildDictionaryFromDataset';",
    "   serializeChildDictionaryToStream(boolean _output, boolean _serializer, _linkcounted_ dictionary _x) : eclrtl,include,entrypoint='rtlSerializeChildDictionary';",
    "   serializeChildDictionaryToDatasetToStream(boolean _output, boolean _serializer, _linkcounted_ dictionary _x) : eclrtl,include,entrypoint='rtlSerializeChildDictionaryToDataset';",

    "   dictionary rtlSerializeDictionary(IOutputRowSerializer _ser, linkcounted dictionary x) : eclrtl,include,library='eclrtl',entrypoint='rtlSerializeDictionary';",
    "   dataset rtlSerializeDictionaryToDataset(IOutputRowSerializer _ser, linkcounted dictionary x) : eclrtl,include,library='eclrtl',entrypoint='rtlSerializeDictionaryToDataset';",
    "   linkcounted dictionary rtlDeserializeDictionary(IOutputRowDeserializer _ser, dictionary x) : eclrtl,include,library='eclrtl',entrypoint='rtlDeserializeDictionary';",
    "   linkcounted dictionary rtlDeserializeDictionaryFromDataset(IOutputRowDeserializer _ser, IHThorHashLookupInfo _hashInfo, dataset x) : eclrtl,include,library='eclrtl',entrypoint='rtlDeserializeDictionaryFromDataset';",


//Methods of IRowDeserializerSource
    "   row(dummyRecord) deserializerPeek(unsigned4 _maxSize) : omethod,entrypoint='peek';",
    "   unsigned4 deserializerBeginNested() : omethod,entrypoint='beginNested';",
    "   boolean deserializerFinishedNested(unsigned4 pos) : omethod,entrypoint='finishedNested';",
    "   unsigned4 deserializerReadN(data _target) : omethod,entrypoint='read';",
    "   unsigned4 deserializerReadSize() : omethod,entrypoint='readSize';",
    "   unsigned4 deserializerReadPackedInt(data _target) : omethod,entrypoint='readPackedInt';",
    "   unsigned4 deserializerReadUtf8(boolean rowBuilder, unsigned4 offset, unsigned4 fixedSize, unsigned4 len) : omethod,entrypoint='readUtf8';",
    "   unsigned4 deserializerReadVStr(boolean rowBuilder, unsigned4 offset, unsigned4 fixedSize) : omethod,entrypoint='readVStr';",
    "   unsigned4 deserializerReadVUni(boolean rowBuilder, unsigned4 offset, unsigned4 fixedSize) : omethod,entrypoint='readVUni';",
    "   deserializerSkipN(unsigned4 _size) : omethod,entrypoint='skip';",
    "   deserializerSkipPacketInt() : omethod,entrypoint='skipPackedInt';",
    "   deserializerSkipUtf8(unsigned4 _size) : omethod,entrypoint='skipUtf8';",
    "   deserializerSkipVStr() : omethod,entrypoint='skipVStr';",
    "   deserializerSkipVUni() : omethod,entrypoint='skipVUni';",

//Methods of IRowSerializerTarget
    "   serializerPut(const data _target) : omethod,entrypoint='put';",
    "   unsigned4 serializerBeginNested() : omethod,entrypoint='beginNested';",
    "   serializerEndNested(unsigned4 pos) : omethod,entrypoint='endNested';",

    // Dictionary support
    "    integer8 dictionaryCount(_linkcounted_ dictionary dict) : eclrtl,include,pure,entrypoint='rtlDictionaryCount';",
    "    boolean dictionaryExists(_linkcounted_ dictionary dict) : eclrtl,include,pure,entrypoint='rtlDictionaryExists';",
    "   _linkcounted_ row(dummyRecord) dictionaryLookup(IHThorHashLookupInfo meta, _linkcounted_ dictionary dict, row key, _linkcounted_ row defaultrow) : eclrtl,include,pure,entrypoint='rtlDictionaryLookup',allocator=false;",
    "   _linkcounted_ row(dummyRecord) dictionaryLookupString(_linkcounted_ dictionary dict, const string key, _linkcounted_ row defaultrow) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupString',allocator=false;",
    "   _linkcounted_ row(dummyRecord) dictionaryLookupStringN(_linkcounted_ dictionary dict, const unsigned4 size, const string key, _linkcounted_ row defaultrow) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupStringN',allocator=false;",
    "   _linkcounted_ row(dummyRecord) dictionaryLookupSigned(_linkcounted_ dictionary dict, const integer key, _linkcounted_ row defaultrow) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupSigned',allocator=false;",
    "   _linkcounted_ row(dummyRecord) dictionaryLookupUnsigned(_linkcounted_ dictionary dict, const unsigned key, _linkcounted_ row defaultrow) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupUnsigned',allocator=false;",
    "   _linkcounted_ row(dummyRecord) dictionaryLookupSignedN(_linkcounted_ dictionary dict, const unsigned4 size, const integer key, _linkcounted_ row defaultrow) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupSignedN',allocator=false;",
    "   _linkcounted_ row(dummyRecord) dictionaryLookupUnsignedN(_linkcounted_ dictionary dict, const unsigned4 size, const unsigned key, _linkcounted_ row defaultrow) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupUnsignedN',allocator=false;",

    "   boolean dictionaryLookupExists(boolean meta, _linkcounted_ dictionary dict, row key) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupExists';",
    "   boolean dictionaryLookupExistsString(_linkcounted_ dictionary dict, const string key) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupExistsString';",
    "   boolean dictionaryLookupExistsStringN(_linkcounted_ dictionary dict, const unsigned4 size, const string key) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupExistsStringN';",
    "   boolean dictionaryLookupExistsSigned(_linkcounted_ dictionary dict, const integer key) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupExistsSigned';",
    "   boolean dictionaryLookupExistsUnsigned(_linkcounted_ dictionary dict, const unsigned key) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupExistsUnsigned';",
    "   boolean dictionaryLookupExistsSignedN(_linkcounted_ dictionary dict, const unsigned4 size, const integer key) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupExistsSignedN';",
    "   boolean dictionaryLookupExistsUnsignedN(_linkcounted_ dictionary dict, const unsigned4 size, const unsigned key) : eclrtl,include,pure,entrypoint='rtlDictionaryLookupExistsUnsignedN';",

    // Marshalling parameters to external languages
    "   bindBooleanParam(const varstring name, boolean val) : method,entrypoint='bindBooleanParam';",
    "   bindDataParam(const varstring name, data val) : method,entrypoint='bindDataParam';",
    "   bindRealParam(const varstring name, real val) : method,entrypoint='bindRealParam';",
    "   bindRowParam(const varstring name, _linkcounted_ row row) : method,entrypoint='bindRowParam';",
    "   bindSignedParam(const varstring name, integer val) : method,entrypoint='bindSignedParam';",
    "   bindUnsignedParam(const varstring name, unsigned val) : method,entrypoint='bindUnsignedParam';",
    "   bindStringParam(const varstring name, const string val) : method,entrypoint='bindStringParam';",
    "   bindVStringParam(const varstring name, const varstring val) : method,entrypoint='bindVStringParam';",
    "   bindUTF8Param(const varstring name, const utf8 val) : method,entrypoint='bindUTF8Param';",
    "   bindUnicodeParam(const varstring name, const unicode val) : method,entrypoint='bindUnicodeParam';",

    "   bindSetParam(const varstring name, integer4 typeCode, unsigned4 elemSize, const set of any val) : method,entrypoint='bindSetParam';",

    "   boolean getBooleanResult() : method,entrypoint='getBooleanResult';",
    "   data getDataResult() : method,entrypoint='getDataResult';",
    "   streamed dataset getDatasetResult() : method,entrypoint='getDatasetResult';",
    "   real getRealResult() : method,entrypoint='getRealResult';",
    "   _linkcounted_ row(dummyRecord) getRowResult() : method,entrypoint='getRowResult';",
    "   transform(dummyRecord) getTransformResult() : method,entrypoint='getTransformResult';",
    "   integer getSignedResult() : method,entrypoint='getSignedResult';",
    "   string getStringResult() : method,entrypoint='getStringResult';",
    "   unsigned getUnsignedResult() : method,entrypoint='getUnsignedResult';",
    "   utf8 getUTF8Result() : method,entrypoint='getUTF8Result';",
    "   unicode getUnicodeResult() : method,entrypoint='getUnicodeResult';",

    "   set of any getSetResult(integer4 typeCode, unsigned4 elemSize) : method,entrypoint='getSetResult';",

    "   compileEmbeddedScript(const utf8 script) : method,entrypoint='compileEmbeddedScript';",
    "   import(const utf8 script) : method,entrypoint='importFunction';",
    "   END;",
    NULL };


#endif