Index: /toppers/tecsgen/trunk/tecsgen/tecs/TECSInfo/TECSInfo.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/TECSInfo/TECSInfo.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/TECSInfo/TECSInfo.cdl (revision 18) @@ -0,0 +1,544 @@ +/* + * Copyright (C) 2008-2017 by TOPPERS Project + * + * 上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * @(#) $Id: TECSInfo.cdl 2663 2017-07-08 23:09:53Z okuma-top $ + */ + +import_C( "t_stddef.h" ); + +/* Constants of Kinds */ +const int8_t TECSTypeKind_BoolType = 1; +const int8_t TECSTypeKind_IntType = 2; +const int8_t TECSTypeKind_FloatType = 3; +const int8_t TECSTypeKind_PtrType = 4; +const int8_t TECSTypeKind_ArrayType = 5; +const int8_t TECSTypeKind_DefinedType = 6; +const int8_t TECSTypeKind_StructType = 7; +const int8_t TECSTypeKind_EnumType = 8; +const int8_t TECSTypeKind_VoidType = 9; +const int8_t TECSTypeKind_DescriptorType = 10; + +/* Parameter Direction */ +const int8_t PARAM_DIR_IN = 1; +const int8_t PARAM_DIR_OUT = 2; +const int8_t PARAM_DIR_INOUT = 3; +const int8_t PARAM_DIR_SEND = 4; +const int8_t PARAM_DIR_RECEIVE = 5; + +/* VarDecl declType */ +const int8_t DECLTYPE_STMEMBER = 1; /* Struct Member */ +const int8_t DECLTYPE_ATTR = 2; +const int8_t DECLTYPE_VAR = 3; + +/* CallInfo location info */ +const int8_t CALL_PLACE_NON = 1; +const int8_t CALL_PLACE_INIB_DES = 2; +const int8_t CALL_PLACE_CB_DES = 3; +const int8_t CALL_PLACE_INIB_IDX = 4; +const int8_t CALL_PLACE_CB_IDX = 5; + +namespace nTECSInfo { + + /******* SIGNATURES *******/ + + /* Type Information of attr, var, param, return */ + signature sTypeInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1] = NULL に末尾 NULL を含む(max_len>0のとき) + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + uint32_t getSize(void); // size of the value in bytes + int8_t getKind(void); // see Constants of Kinds + uint32_t getNType(void); + // kind == ARRAY の場合サイズ、STRUCT の場合メンバー数、POINTER, TYPEDEF の場合1、それ以外は0 + ER getTypeInfo( [in]uint32_t ith, [out]Descriptor(sTypeInfo) *desc ); + // kind == POINTER, TYPEDEF, STRUCT の場合、desc に有効な値を返す + // kind == STRUCT の場合、ith はメンバーの添数 0<=ith<*num、それ以外の場合、ith は無視 + // ith が範囲外の場合 E_NORES を返す +// void getSignatureInfo( [out]Descriptor(sSignatureInfo) *desc ); +// // kind == DESCRIPTOR の場合、desc に有効な値を返す + }; + + /* ATTR, VAR, struct member Information */ + signature sVarDeclInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + uint32_t getOffset(void); // p_cb からのオフセット + void getTypeInfo( [out]Descriptor( sTypeInfo ) *desc ); + void getSizeIsExpr( [out,string(max_len)]char_t *expr_str, [in]int32_t max_len ); + // size_is 計算式を文字列で返す. size_is 未指定の場合 *expr_str = NULL が返される + ER getSizeIs( [out]uint32_t *size, [in]const void *p_cb); + // p_cb を与えると、size を返す (size_is 指定がない場合，E_NOSPT を返す) + }; + + /* PARAM Information */ + signature sParamInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + ER getTypeInfo( [out]Descriptor(sTypeInfo) *desc); + }; + + /* FUNCTION Information */ + signature sFunctionInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + void getReturnTypeInfo( [out]Descriptor( sTypeInfo ) *desc ); + uint32_t getNParam(void); + ER getParamInfo( [in]uint32_t ith, [out]Descriptor(sParamInfo) *param ); + // 0 <= ith < *num + // ith が範囲外の場合 E_NORES を返す + }; + + /* SIGNATURE Information */ + signature sSignatureInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + uint32_t getNFunction(void); + ER getFunctionInfo( [in]uint32_t ith, [out]Descriptor( sFunctionInfo ) *desc ); + // 0 <= ith < *num + // ith が範囲外の場合 E_NORES を返す + }; + + /* CALL Information */ + signature sCallInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + void getSignatureInfo( [out]Descriptor( sSignatureInfo ) *desc ); + uint32_t getArraySize(void); + void getSpecifierInfo( [out]bool_t *b_optional, + [out]bool_t *b_dynamic, + [out]bool_t *b_ref_desc, + [out]bool_t *b_omit ); + void getInternalInfo( [out]bool_t *b_allocator_port, + [out]bool_t *b_require_port ); + void getLocationInfo( [out]uint32_t *offset, // CALL_PLACE_* + [out]int8_t *place ); // CALL_PLACE_* + void getOptimizeInfo( [out]bool_t *b_VMT_useless, // VMT (関数テーブル) 不要最適化 (関数直接呼出し) + [out]bool_t *b_skelton_useless, // スケルトン関数不要 ( + [out]bool_t *b_cell_unique ); // 単一のセル + }; + + /* ENTRY Information */ + signature sEntryInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + void getSignatureInfo( [out]Descriptor( sSignatureInfo ) *desc ); + uint32_t getArraySize(void); + bool_t isInline(void); + }; + + /* CELLTYPE Information */ + signature sCelltypeInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + uint32_t getNAttr(void); + ER getAttrInfo( [in]uint32_t ith, [out]Descriptor(sVarDeclInfo)*desc ); + uint32_t getNVar(void); + ER getVarInfo( [in]uint32_t ith, [out]Descriptor(sVarDeclInfo)*desc ); + // ith が範囲外の場合 E_NORES を返す + uint32_t getNCall(void); + ER getCallInfo( [in]uint32_t ith, [out]Descriptor(sCallInfo)*desc ); + // ith が範囲外の場合 E_NORES を返す + uint32_t getNEntry(void); + ER getEntryInfo( [in]uint32_t ith, [out]Descriptor(sEntryInfo)*desc ); + // ith が範囲外の場合 E_NORES を返す + bool_t isSingleton(void); + bool_t isIDX_is_ID(void); + uint32_t sizeOfCB(void); + uint32_t sizeOfINIB(void); + }; + + /* CELL Information */ + [deviate] + signature sCellInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + void getCelltypeInfo( [out]Descriptor( sCelltypeInfo ) *desc ); + void getCBP( [out]void **cbp ); // out: 逸脱 + void getINIBP( [out]void **inibp ); // out: 逸脱 + }; + + /* NAMESPACE Information */ + signature sNamespaceInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + uint32_t getNNamespace(void); + ER getNamespaceInfo( [in]uint32_t ith, [out]Descriptor(sNamespaceInfo) *des ); + // ith が範囲外の場合 E_NORES を返す + uint32_t getNSignature(void); + ER getSignatureInfo( [in]uint32_t ith, [out]Descriptor(sSignatureInfo) *des ); + // ith が範囲外の場合 E_NORES を返す + uint32_t getNCelltype(void); + ER getCelltypeInfo( [in]uint32_t ith, [out]Descriptor(sCelltypeInfo) *des ); + // ith が範囲外の場合 E_NORES を返す + }; + + /* REGION Information */ + signature sRegionInfo { + ER getName( [out,string(max_len)]char_t *name, [in]int_t max_len ); + // 長さが max_len を超えた場合は E_NOMEM を返す. + // (max_len-1) 文字コピーする。name[max_len-1]は NULL に末尾 NULL を含む + uint16_t getNameLength(void); + // 終端文字 (NULL) を含む長さ (strlen と仕様が異なることに注意) + uint32_t getNCell(void); + ER getCellInfo( [in]uint32_t ith, [out]Descriptor(sCellInfo) *des ); + // ith が範囲外の場合 E_NORES を返す + uint32_t getNRegion(void); + ER getRegionInfo( [in]uint32_t ith, [out]Descriptor(sRegionInfo) *des ); + // ith が範囲外の場合 E_NORES を返す + }; + + /* TECS Information */ + signature sTECSInfo { + ER findNamespace([in,string]const char_t *namespace_path, [out]Descriptor( sNamespaceInfo )*NSdesc); + ER findRegion( [in,string]const char_t *namespace_path, [out]Descriptor( sRegionInfo )*RGNdesc); + ER findSignature([in,string]const char_t *namespace_path, [out]Descriptor( sSignatureInfo )*SIGdesc); + ER findCelltype( [in,string]const char_t *namespace_path, [out]Descriptor( sCelltypeInfo )*CTdesc); + ER findCell( [in,string]const char_t *namespace_path, [out]Descriptor( sCellInfo )*CELLdesc); + }; + + /******* CELLTYPES *******/ + + /* + * このセルタイプのセルは、ユーザーが設置する + * + * このセルから、tTECSInfoSub への結合は、プラグインにより自動的に + * 行われるため、ユーザーは、このセルを設置するだけでよい． + * (プロトタイプを用いていないのは、このセルを任意のリージョンに置 + * くことを想定してのもの) + */ + [singleton, + generate( TECSInfoPlugin, "" )] + celltype tTECSInfo { + [inline] + entry sTECSInfo eTECSInfo; + call sTECSInfo cTECSInfo; + }; + + /* + * 以下のセルタイプは、プラグインにより自動生成される + */ + [singleton] + celltype tTECSInfoSub { + entry sTECSInfo eTECSInfo; + [ref_desc] + call sNamespaceInfo cNamespaceInfo; // root namespace + [dynamic,optional] + call sNamespaceInfo cNamespaceInfoTemp; + [ref_desc] + call sRegionInfo cRegionInfo; // root region + [dynamic,optional] + call sRegionInfo cRegionInfoTemp; + }; + + celltype tNamespaceInfo { + attr { + char *name; + }; + + entry sNamespaceInfo eNamespaceInfo; + [ref_desc,optional] + call sSignatureInfo cSignatureInfo[]; + [ref_desc,optional] + call sCelltypeInfo cCelltypeInfo[]; + [ref_desc,optional] + call sNamespaceInfo cNamespaceInfo[]; + }; + + /* SIGNATURE information */ + celltype tSignatureInfo{ + attr { + char *name; + }; + + entry sSignatureInfo eSignatureInfo; + [ref_desc,optional] + call sFunctionInfo cFunctionInfo[]; + }; + celltype tFunctionInfo { + attr { + char_t *name; + bool_t bOneway; + }; + entry sFunctionInfo eFunctionInfo; + [ref_desc,optional] + call sParamInfo cParamInfo[]; + [ref_desc] + call sTypeInfo cReturnTypeInfo; + }; + celltype tParamInfo { + attr { + char_t *name; + int8_t dir; + char_t *sizeIsExpr; + char_t *countIsExpr; + char_t *stringExpr; + }; + entry sParamInfo eParamInfo; + [ref_desc] + call sTypeInfo cTypeInfo; + }; + + /* CELLTYPE information */ + celltype tCelltypeInfo{ + attr { + char_t *name; + bool_t b_singleton; + bool_t b_IDX_is_ID_act; + uint32_t sizeOfCB; // size in bytes, 0 if not exist + uint32_t sizeOfINIB; // size in bytes, 0 if not exist + uint32_t n_cellInLinkUnit; // CellInLinkUnit == 0 の時 セルタイプコードは、リンクされていない + uint32_t n_cellInSystem; // すべてのリンクユニットを含めたセルの個数． + // この数が 0になるものは、CelltypeInfo は省略される． + }; + [ref_desc,optional] + call sEntryInfo cEntryInfo[]; + [ref_desc,optional] + call sCallInfo cCallInfo[]; + [ref_desc,optional] + call sVarDeclInfo cAttrInfo[]; + [ref_desc,optional] + call sVarDeclInfo cVarInfo[]; + + entry sCelltypeInfo eCelltypeInfo; + }; + celltype tCallInfo { + attr { + char_t *name; + uint32_t offset; + uint32_t array_size; + bool_t b_optional; + bool_t b_omit; + bool_t b_dynamic; + bool_t b_ref_desc; + bool_t b_allocator_port; + bool_t b_require_port; + int8_t place; + bool_t b_VMT_useless; // VMT (関数テーブル) 不要最適化 (関数直接呼出し) + bool_t b_skelton_useless; // スケルトン関数不要 ( + bool_t b_cell_unique; // 単一のセル + }; + entry sCallInfo eCallInfo; + [ref_desc] + call sSignatureInfo cSignatureInfo; + FACTORY { + write( "$ct_global$_factory.h", "#include \"include_all_signature_header.h\"" ); + }; + }; + celltype tEntryInfo { + attr { + char_t *name; + bool_t b_inline; + uint32_t array_size; + }; + entry sEntryInfo eEntryInfo; + [ref_desc] + call sSignatureInfo cSignatureInfo; + FACTORY { + write( "$ct_global$_factory.h", "#include \"include_all_signature_header.h\"" ); + }; + }; + /* Variable Declarator (attr, var, struct member) */ + celltype tVarDeclInfo { + attr { + char_t *name; + char_t *sizeIsExpr; + int8_t declType; /* valid when attr, var */ + uint32_t offset; + }; + entry sVarDeclInfo eVarDeclInfo; + [ref_desc] + call sTypeInfo cTypeInfo; + }; + + /* REGION & CELL information */ + celltype tRegionInfo { + attr { + char *name; + }; + + entry sRegionInfo eRegionInfo; + [ref_desc,optional] + call sCellInfo cCellInfo[]; + [ref_desc,optional] + call sRegionInfo cRegionInfo[]; + }; + celltype tCellInfo { + attr { + char_t *name; + void *cbp; + void *inibp; + }; + [ref_desc] + call sCelltypeInfo cCelltypeInfo; + entry sCellInfo eCellInfo; + }; + + /* celltypes of TYPEs */ + celltype tVoidTypeInfo { + attr { + char_t *name; + int8_t typeKind; + uint32_t size; /* bytes */ + bool_t b_const; + bool_t b_volatile; + }; + entry sTypeInfo eTypeInfo; + }; + celltype tBoolTypeInfo { + attr { + char_t *name; + int8_t typeKind; + uint32_t size; /* bytes */ + bool_t b_const; + bool_t b_volatile; + }; + entry sTypeInfo eTypeInfo; + }; + celltype tIntTypeInfo { + attr { + char_t *name; + int8_t typeKind; + uint32_t size; /* bytes */ + bool_t b_const; + bool_t b_volatile; + }; + entry sTypeInfo eTypeInfo; + }; + celltype tFloatTypeInfo { + attr { + char_t *name; + int8_t typeKind; + uint32_t size; /* bytes */ + bool_t b_const; + bool_t b_volatile; + }; + entry sTypeInfo eTypeInfo; + }; + celltype tStructTypeInfo { + attr { + char_t *name; + int8_t typeKind; + uint32_t size; /* bytes */ + bool_t b_const; + bool_t b_volatile; + }; + entry sTypeInfo eTypeInfo; + [ref_desc] + call sTypeInfo cTypeInfo[]; + }; + celltype tPtrTypeInfo { + attr { + char_t *name; + int8_t typeKind; + uint32_t size; /* bytes */ + bool_t b_const; + bool_t b_volatile; + }; + entry sTypeInfo eTypeInfo; + [ref_desc] + call sTypeInfo cTypeInfo; + FACTORY { + write( "$ct_global$_factory.h", "#include \"include_all_signature_header.h\"" ); + }; + }; + celltype tArrayTypeInfo { + attr { + char_t *name; + int8_t typeKind; + uint32_t size; /* bytes */ + bool_t b_const; + bool_t b_volatile; + }; + entry sTypeInfo eTypeInfo; + [ref_desc] + call sTypeInfo cTypeInfo; + FACTORY { + write( "$ct_global$_factory.h", "#include \"include_all_signature_header.h\"" ); + }; + }; + celltype tDefinedTypeInfo { + attr { + char_t *name; + int8_t typeKind; + uint32_t size; /* bytes */ + bool_t b_const; + bool_t b_volatile; + }; + entry sTypeInfo eTypeInfo; + [ref_desc] + call sTypeInfo cTypeInfo; + }; + celltype tDescriptorTypeInfo { + attr { + char_t *name; + int8_t typeKind; + uint32_t size; /* bytes */ + bool_t b_const; + bool_t b_volatile; + }; + entry sTypeInfo eTypeInfo; + [ref_desc] + call sSignatureInfo cSignatureInfo; + FACTORY { + write( "$ct_global$_factory.h", "#include \"include_all_signature_header.h\"" ); + }; + }; +}; Index: /toppers/tecsgen/trunk/tecsgen/tecs/TLSFMalloc/README-TLSF.txt =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/TLSFMalloc/README-TLSF.txt (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/TLSFMalloc/README-TLSF.txt (revision 18) @@ -0,0 +1,23 @@ +TLSF Malloc アロケータ + 2017.4.15 + 大山 +1.概要 + +TLSF は効率よく、フラグメントが起きにくいアロケータです。 OS 非依存に +実装されているため、組込みシステムへの応用に適しています。この実装では +排他制御を行っていません。複数のタスクで共用するには、排他制御を行う必 +要があります。 + +2. 実装について + +1) TLSF アロケータの本体は、TECS ジェネレータパッケージには含まれていません。 +以下に公開されている TLSF を入手する必要があります。 +これは GPL/LGPL ライセンスで公開されています。 + http://www.gii.upv.es/tlsf/main/docs + +2) TLSF には、別に実装され MIT ライセンスで公開されているものもあります。 +API が若干異なるため、tTLSFMalloc_inline.h を少し修正する必要があります。 + https://github.com/mattconte/tlsf + +3) ETロボコン用パッケージ +mruby-on-ev3rt+tecs_package (ev3rt) には、1) の TLSF が含まれています。 Index: /toppers/tecsgen/trunk/tecsgen/tecs/TLSFMalloc/tTLSFMalloc.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/TLSFMalloc/tTLSFMalloc.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/TLSFMalloc/tTLSFMalloc.cdl (revision 18) @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2008-2017 by TOPPERS Project + * + * 上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * @(#) $Id: tTLSFMalloc.cdl 2640 2017-06-03 11:27:12Z okuma-top $ + */ + +import( ); + +celltype tTLSFMalloc { + [inline] + entry sMalloc eMalloc; + attr { + /* memory pool size in bytes */ + size_t memoryPoolSize; + }; + var { + [size_is( memoryPoolSize/ 8 )] + uint64_t *pool; + }; +}; Index: /toppers/tecsgen/trunk/tecsgen/tecs/posix/posix.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/posix/posix.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/posix/posix.cdl (revision 18) @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2008-2017 by TOPPERS Project + * + * 上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * @(#) $Id: posix.cdl 2640 2017-06-03 11:27:12Z okuma-top $ + */ + + +namespace nPosix { + signature sMain{ + int main( [in]int argc, [in,size_is(argc),string]const char **argv ); + }; +}; + Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/PPAllocator.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/PPAllocator.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/PPAllocator.cdl (revision 18) @@ -0,0 +1,87 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: PPAllocator.cdl 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* + * PPAlloc: Push Pop Allocator + * + * allocate した逆順で deallocate しなくてはならない + * deallocate は、まとめて行うことができる + * 例えば最初に allocate された領域を deallocate すると、すべての allocate された領域を deallocate したことになる + * 排他制御していないため単一のタスクに割付けて使用する + */ + +[deviate] // alloc が逸脱になる +signature sPPAllocator { + /* + * size で指定された大きさのメモリ領域をアロケートする + * メモリ領域が確保された場合 *ptr にメモリ領域のアドレスを格納して E_OK を返す + * 十分な空き領域がない場合 E_NOMEM を返す + */ + ER alloc( [in]uint32_t size, [out]void **ptr ); + /* + * メモリをデアロケートする + * alloc で獲得したポインタを引き数 ptr に指定する + * alloc で獲得したメモリ領域を alloc したのとは逆順に dealloc しなくてはならない + * すべてを dealloc するには、最初に alloc されたメモリ領域を dealloc することで行うことができる + * alloc し獲得したメモリ領域をすべて dealloc する前に、再び alloc することはできる + * その場合でも、dealloc していないメモリ領域を alloc したのとは逆順に dealloc しなくてはならない + * + * ptr の値が buf <= ptr < buf+allocated_size を満たすかどうか検査される + * ptr の値が不正の場合 E_PAR を返す + */ + ER dealloc( [in]const void *ptr ); + + /* + * PPAllocator セルの割付け済みメモリをすべて解放する + * この関数は必ず成功する + */ + ER dealloc_all(void); +}; + +celltype tPPAllocator { + entry sPPAllocator ePPAllocator; + attr { + uint32_t heapSize; + }; + var { + [size_is(heapSize)] + int8_t *buf; + uint32_t allocatedSize; + }; +}; + Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/RPCTask.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/RPCTask.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/RPCTask.cdl (revision 18) @@ -0,0 +1,119 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: RPCTask.cdl 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* + * unmarshaler の main のシグニチャ + */ +signature sUnmarshalerMain { + ER main(void); +}; + +///////////////// 専有チャンネル用の定義 //////////////// +/* + * CELLTYPE: 専有チャンネル用のタスクメイン + */ +celltype tRPCDedicatedTaskMain { // Transparent RPC で用いる + entry sTaskBody eMain; + call sUnmarshalerMain cMain; +}; + +celltype tRPCDedicatedTaskMainWithOpener { // Opaque RPC で用いる + entry sTaskBody eMain; + call sUnmarshalerMain cMain; + call sServerChannelOpener cOpener; + attr { + RELTIM initialDelay = 0; // sec + RELTIM reopenDelay = 1; // sec + }; + require tKernel.eKernel; +}; + +///////////////// 共有チャンネル用の定義 //////////////// +/* + * CONST: 共有チャンネルヘッダのマジック + */ +const uint16_t RPC_CHANNEL_MAN_SOP_MAGIC = (0x3141); // Beginning of using shared channel +const uint16_t RPC_CHANNEL_MAN_EOP_MAGIC = (0x2718); // End of using shared channel + +/* + * CELLTYPE: 共有チャンネルマネージャ + * REM: 呼び元側に置くチャンネルマネージャ + * eSemaphore が呼び出されたときチャンネルをロックするとともに、 + * チャンネル番号を送出する + */ +celltype tRPCSharedChannelMan { + entry sSemaphore eSemaphore[]; + call sSemaphore cSemaphore; + call sTDR cClientSideTDR; +}; + + +/* + * CELLTYPE: 共有チャンネル用のタスクメイン + * REM: 呼び先側に置くタスク + * チャンネル番号を取り出し、チャンネル番号の cTaskBody を呼び出す + */ +celltype tRPCSharedTaskMain { + entry sTaskBody eMain; + + call sUnmarshalerMain cUnmarshalAndCallFunction[]; + call sTDR cServerSideTDR; + + require tSysLog.eSysLog; + + var { + int16_t channelNo; /* 配列添数 + 1 */ + }; +}; + +celltype tRPCSharedTaskMainWithOpener { // Opaque RPC で用いる + entry sTaskBody eMain; + call sUnmarshalerMain cUnmarshalAndCallFunction[]; + call sTDR cServerSideTDR; + call sServerChannelOpener cOpener; + require tSysLog.eSysLog; + require tKernel.eKernel; + + attr { + RELTIM initialDelay = 0; // sec + RELTIM reopenDelay = 1; // sec + }; + var { + int16_t channelNo; /* 配列添数 + 1 */ + }; +}; Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/TDR.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/TDR.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/TDR.cdl (revision 18) @@ -0,0 +1,174 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: TDR.cdl 2640 2017-06-03 11:27:12Z okuma-top $ + */ + +import_C( "tecs_rpc.h" ); + +// Straight Order TDR +const uint32_t TDR_SOP_MAGIC1 = (0x672A); // Client to Server +const uint32_t TDR_SOP_MAGIC2 = (0x561E); // Server to Client +const uint32_t TDR_EOP_MAGIC1 = (0x5A3C); // 返信を待つ (同期呼出し) +const uint32_t TDR_EOP_MAGIC2 = (0x6D5E); // 返信を待たない(非同期呼出しまたはリターン) + +// Straight Order TDR for SharedChannel +const uint32_t TDR_SHSOP_MAGIC1 = (0x98D5); // Client to Server +const uint32_t TDR_SHSOP_MAGIC2 = (0xA9E1); // Server to Client +const uint32_t TDR_SHEOP_MAGIC1 = (0xB5C3); // 返信を待つ (同期呼出し) +const uint32_t TDR_SHEOP_MAGIC2 = (0x92A1); // 返信を待たない(非同期呼出しまたはリターン) + +/* + * TDR: TECS Data Representation layer + */ +[deviate] /* get_intptr が逸脱になる */ +signature sTDR { /* TECS Data Representation */ + + /* 制御関数 */ + + /* チャンネルのリセット */ + ER reset( void ); /* 通信チャンネルのリセット */ + /* 途中でエラーが発生し、送信または受信を続行できなかったときはリセットする */ + /* 一方がリセットをかけると、他方は RESET エラーを返す */ + /* 確認できないときは、このチャネルは放棄するしかない */ + + /* マジックコードの送受信 */ + ER sendSOP( [in]bool_t b_client ); /* StartOfPacket magic を送信 */ + ER receiveSOP( [in]bool_t b_client ); /* StartOfPacket magic を受信 */ + /* b_client: クライアント側なら true, サーバー側なら false */ + + /* マジックコードの送受信 */ + // ER sendSHSOP( [in]bool_t b_client ); /* StartOfPacket magic を送信 */ + // ER receiveSHSOP( [in]bool_t b_client ); /* StartOfPacket magic を受信 */ + /* b_client: クライアント側なら true, サーバー側なら false */ + + ER sendEOP( [in]bool_t b_continue ); /* EndOfPacket magic を送信（パケットの掃きだしも行う） */ + ER receiveEOP( [in]bool_t b_continue );/* EndOfPacket magic を受信 */ + /* b_continue: 同期呼び出しのクライアント側なら true, + 非同期呼び出しのクライアント側またはサーバー側なら false */ + + /* データ送受信関数 */ + + /* 整数型 (推奨) */ + ER putInt8( [in]int8_t in ); + ER putInt16( [in]int16_t in ); + ER putInt32( [in]int32_t in ); + ER putInt64( [in]int64_t in ); + ER putInt128( [in]int128_t in ); + + ER getInt8( [out]int8_t *out ); + ER getInt16( [out]int16_t *out ); + ER getInt32( [out]int32_t *out ); + ER getInt64( [out]int64_t *out ); + ER getInt128( [out]int128_t *out ); + + /* 無符号整数型 (推奨) */ + ER putUInt8( [in]uint8_t in ); + ER putUInt16( [in]uint16_t in ); + ER putUInt32( [in]uint32_t in ); + ER putUInt64( [in]uint64_t in ); + ER putUInt128( [in]uint128_t in ); + + ER getUInt8( [out]uint8_t *out ); + ER getUInt16( [out]uint16_t *out ); + ER getUInt32( [out]uint32_t *out ); + ER getUInt64( [out]uint64_t *out ); + ER getUInt128( [out]uint128_t *out ); + + /* 文字型（推奨、8bit） */ + ER putChar( [in]char_t in ); + ER getChar( [out]char_t *out ); + + /* Bool 型 */ + ER putBool( [in]bool_t in ); + ER getBool( [out]bool_t *out ); + + /* 浮動小数型 */ + ER putFloat32( [in]float32_t in ); + ER putDouble64( [in]double64_t in ); + ER getFloat32( [out]float32_t *out ); + ER getDouble64( [out]double64_t *out ); + + + /* 非推奨の型(有符号) */ + ER putSChar( [in]schar_t in ); + ER putShort( [in]short_t in ); + ER putInt( [in]int_t in ); + ER putLong( [in]long_t in ); + + ER getSChar( [out]schar_t *out ); + ER getShort( [out]short_t *out ); + ER getInt( [out]int_t *out ); + ER getLong( [out]long_t *out ); + + + /* 非推奨の型(無符号) */ + ER putUChar( [in]uchar_t in ); + ER putUShort( [in]ushort_t in ); + ER putUInt( [in]uint_t in ); + ER putULong( [in]ulong_t in ); + + ER getUChar( [out]unsigned char *out ); + ER getUShort( [out]ushort_t *out ); + ER getUInt( [out]uint_t *out ); + ER getULong( [out]ulong_t *out ); + + ER putIntptr( [in]const intptr_t ptr ); + ER getIntptr( [out]intptr_t *ptr ); +}; + +// Straight Order TECS Data Representation (Straight means no endian-conversion is done) +celltype tTDR { + call sChannel cChannel; + [inline] + entry sTDR eTDR; + + var { + TMO tmo = C_EXP( "TMO_FEVR" ); + }; + require tSysLog.eSysLog; +}; + +// Network Byte Order (Big-endian) TECS Data Representation (Data are always sent in big-endian) +celltype tNBOTDR { + call sChannel cChannel; + [inline] + entry sTDR eTDR; + + var { + TMO tmo = C_EXP( "TMO_FEVR" ); + }; + require tSysLog.eSysLog; +}; Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/rpc.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/rpc.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/rpc.cdl (revision 18) @@ -0,0 +1,59 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: rpc.cdl 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* + * TECS RPC に関する定義 + */ + +/* チャンネル シグニチャ */ +import( ); + +/* TDR シグニチャ & セルタイプ */ +import( ); + +/* チャンネルセルタイプ */ +/* チャンネルセルタイプは、必要なものを各アプリケーションで import する */ +// import( ); +// import( ); +// import( ); + +/* タスク セルタイプ */ +import( ); +import( ); + +import( ); Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/rpc_string.h =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/rpc_string.h (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/rpc_string.h (revision 18) @@ -0,0 +1,155 @@ +/* + * + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: rpc_string.h 2027 2014-01-20 08:36:17Z okuma-top $ + */ +#ifndef RPC_STRING_H +#define RPC_STRING_H + +#include + +/* GenParamCopy.rb で生成する STRLEN, STRNLEN 関数の定義 */ +/* 現状では short, int, long, int128_t をサポートしない */ + +#define STRLEN8( str ) strlen( (char *)str ) + +/* + * STRNLEN + * marshaler, unmarshaler は strnlen を使う． + * バッファオーバーランへの耐性を明確にするため． + * しかし、strnlen は ANSI-C 標準のライブラリ関数ではないため、実装されていないケースがある + * GNU (Linux), VC++ では使用できるが、MacOS では使用できない + * （他の組込み用 OS での実装状況も不明） + * 小さな関数ですむので inline 関数として実装しておく + */ + +#ifndef USE_STRNLEN_LIB +#define STRNLEN8( str, n ) strnlen( (char *)str, n ) + +#else + +Inline size_t +#define STRNLEN8( str, n ) STRNLEN8_( (uint8_t *)str, n ) +STRNLEN8_(const uint8_t *s, size_t maxlen) +{ + size_t i; + for( i = 0; i < maxlen; i++ ) + if( *s++ == 0 ) + break; + + return i; +} + +#endif + +#define STRLEN16( s ) STRLEN16_( (uint16_t *)s ) +#define STRLEN32( s ) STRLEN32_( (uint32_t *)s ) +#define STRLEN64( s ) STRLEN64_( (uint64_t *)s ) + +#define STRNLEN16( s, maxlen ) STRLEN16_( (uint16_t *)s, maxlen ) +#define STRNLEN32( s, maxlen ) STRLEN32_( (uint32_t *)s, maxlen ) +#define STRNLEN64( s, maxlen ) STRLEN64_( (uint64_t *)s, maxlen ) + +/** STRLENnn_ nn:16,32,64**/ +Inline size_t +STRLEN16_(const uint16_t *s ) +{ + size_t i; + for( i = 0; ; i++ ) + if( *s++ == 0 ) + break; + + return i; +} + +Inline size_t +STRLEN32_(const uint32_t *s ) +{ + size_t i; + for( i = 0; ; i++ ) + if( *s++ == 0 ) + break; + + return i; +} + +Inline size_t +STRLEN64_(const uint64_t *s ) +{ + size_t i; + for( i = 0; ; i++ ) + if( *s++ == 0 ) + break; + + return i; +} + +/** STRNLENnn_ nn:16,32,64**/ +Inline size_t +STRNLEN16_(const uint16_t *s, size_t maxlen) +{ + size_t i; + for( i = 0; i < maxlen; i++ ) + if( *s++ == 0 ) + break; + + return i; +} + +Inline size_t +STRNLEN32_(const uint32_t *s, size_t maxlen) +{ + size_t i; + for( i = 0; i < maxlen; i++ ) + if( *s++ == 0 ) + break; + + return i; +} + +Inline size_t +STRNLEN64_(const uint64_t *s, size_t maxlen) +{ + size_t i; + for( i = 0; i < maxlen; i++ ) + if( *s++ == 0 ) + break; + + return i; +} + + +#endif /* RPC_STRING_H */ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/sChannel.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/sChannel.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/sChannel.cdl (revision 18) @@ -0,0 +1,59 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: sChannel.cdl 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +signature sServerChannelOpener { + ER open( void ); + ER close( void ); +}; + +signature sChannel { + /* 送る */ + ER send( [in,size_is(size)] const int8_t *buf, [in]int16_t size, [in]TMO tmo ); + /* 送信終わりの掃き出し（パケットの終わりで一回だけ呼出す */ + ER flush( [in]TMO tmo ); /* バッファリングしている場合の掃きだし */ + + /* 受け取る */ + ER_UINT receive( [out,size_is(size)] int8_t *buf, [in]int16_t size, [in]TMO tmo ); + + /* パケットの終わりまで受信した (flush の逆)。終わりに達していない場合 E_ILUSE */ + ER end_receive( void ); + + /* リセット */ + ER reset( void ); /* チャンネルをリセット */ +}; + Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/sRPCErrorHandler.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/sRPCErrorHandler.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/sRPCErrorHandler.cdl (revision 18) @@ -0,0 +1,74 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: sRPCErrorHandler.cdl 2640 2017-06-03 11:27:12Z okuma-top $ + */ + + +/* client side state */ +const int16_t RPCSTATE_CLIENT_GET_SEM = 1; +const int16_t RPCSTATE_CLIENT_SEND_SOP = 2; +const int16_t RPCSTATE_CLIENT_SEND_BODY = 3; +const int16_t RPCSTATE_CLIENT_SEND_EOP = 4; +const int16_t RPCSTATE_CLIENT_EXEC = 5; +const int16_t RPCSTATE_CLIENT_RECV_SOP = 6; +const int16_t RPCSTATE_CLIENT_RECV_BODY = 7; +const int16_t RPCSTATE_CLIENT_RECV_EOP = 8; +const int16_t RPCSTATE_CLIENT_RELEASE_SEM = 9; + +/* server side state */ +const int16_t RPCSTATE_SERVER_GET_SEM = 11; +const int16_t RPCSTATE_SERVER_RECV_SOP = 12; +const int16_t RPCSTATE_SERVER_RECV_BODY = 13; +const int16_t RPCSTATE_SERVER_RECV_EOP = 14; +const int16_t RPCSTATE_SERVER_EXEC = 15; +const int16_t RPCSTATE_SERVER_SEND_SOP = 16; +const int16_t RPCSTATE_SERVER_SEND_BODY = 17; +const int16_t RPCSTATE_SERVER_SEND_EOP = 18; +const int16_t RPCSTATE_SERVER_RELEASE_SEM = 19; + +/* error hadler */ +signature sRPCErrorHandler { + ER errorOccured( [in]int16_t func_id, [in]ER er, [in]int16_t state ); +}; + +/* + * 呼び元側では state が RPCSTATE_CLIENT_EXEC と等しいか大きい場合、 + * 呼び先側では state が RPCSTATE_SERVER_EXEC と等しいか大きい場合、 + * 呼び先関数の呼び出しには成功している。 + * + * RPCErrorHandler が呼び出された時点で、send/receive 引数の解放は終わっている。 + * このため、RPCErrorHandler の中で処理を打ち切っても(タスクの再起動などを行っても)、それらによるメモリリークが起きない。 + */ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tDataqueueAdaptor_inline.h =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tDataqueueAdaptor_inline.h (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tDataqueueAdaptor_inline.h (revision 18) @@ -0,0 +1,221 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tDataqueueAdaptor_inline.h 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * #[]# */ + +/* 受け口関数 #_TEPF_# */ +/* #[]# eChannel + * entry port: eChannel + * signature: sChannel + * context: task + * #[]# */ + +/* #[]# eChannel_open + * name: eChannel_open + * global_name: tDataqueueAdaptor_eChannel_open + * oneway: false + * #[]# */ +Inline ER +eChannel_open(CELLIDX idx, const int8_t* arg, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + + return(ercd); +} + +/* #[]# eChannel_close + * name: eChannel_close + * global_name: tDataqueueAdaptor_eChannel_close + * oneway: false + * #[]# */ +Inline ER +eChannel_close(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + + return(ercd); +} + +/* #[]# eChannel_reset + * name: eChannel_reset + * global_name: tDataqueueAdaptor_eChannel_reset + * oneway: false + * #[]# */ +Inline ER +eChannel_reset(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + cEventflag_clear( 0 ); + + return(ercd); +} + +/* #[]# eChannel_send + * name: eChannel_send + * global_name: tDataqueueAdaptor_eChannel_send + * oneway: false + * #[]# */ +Inline ER +eChannel_send(CELLIDX idx, const int8_t* buf, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + int i; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + ercd = 0; + for( i = 0; i < size; i++ ) + ercd |= cDataqueue_send( (intptr_t)((uint8_t)buf[ i ]) ); + + return(ercd); +} + +/* #[]# eChannel_flush + * name: eChannel_flush + * global_name: tDataqueueAdaptor_eChannel_flush + * oneway: false + * #[]# */ +Inline ER +eChannel_flush(CELLIDX idx, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + + return(ercd); +} + +/* #[]# eChannel_receive + * name: eChannel_receive + * global_name: tDataqueueAdaptor_eChannel_receive + * oneway: false + * #[]# */ +Inline ER_UINT +eChannel_receive(CELLIDX idx, int8_t* buf, int16_t size, TMO tmo) +{ + ER_UINT ercd = E_OK; + CELLCB *p_cellcb; + intptr_t data; + int i; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + /* printf( "DQA: receive(%d) ", size ); */ + for( i = 0; i < size; i++ ){ + ercd = cDataqueue_receive( &data ); + buf[i] = (int8_t)data; + if( ercd != E_OK ) + break; + } + if( ercd != E_OK ) + return(ercd); + else + return i; +} + +/* #[]# eChannel_end_receive + * name: eChannel_end_receive + * global_name: tDataqueueAdaptor_eChannel_end_receive + * oneway: false + * #[]# */ +Inline ER +eChannel_end_receive(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + + return(ercd); +} + Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tDataqueueOWChannel.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tDataqueueOWChannel.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tDataqueueOWChannel.cdl (revision 18) @@ -0,0 +1,80 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tDataqueueOWChannel.cdl 2640 2017-06-03 11:27:12Z okuma-top $ + */ + + +/* + *celltype::tDataqueueAdaptor + */ +celltype tDataqueueAdaptor { + [inline] + entry sChannel eChannel; + call sDataqueue cDataqueue; + call sEventflag cEventflag; +}; + +/* + *composite::tDataqueueOWChannel + */ +composite tDataqueueOWChannel { + entry sTDR eTDR; + entry sDataqueue eDataqueue; + entry sEventflag eEventflag; + attr { + // Queue のデフォルトのサイズ + uint_t queueSize = 64; + }; + + cell tDataqueue Dataqueue{ + count = composite.queueSize; + + }; + cell tEventflag Eventflag{ + flagPattern = 0; + }; + cell tDataqueueAdaptor DataqueueAdaptor{ + cDataqueue = Dataqueue.eDataqueue; + cEventflag = Eventflag.eEventflag; + }; + cell tTDR TDR { + cChannel = DataqueueAdaptor.eChannel; + }; + + composite.eTDR => TDR.eTDR; + composite.eDataqueue => Dataqueue.eDataqueue; + composite.eEventflag => Eventflag.eEventflag; +}; Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tNBOTDR_inline.h =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tNBOTDR_inline.h (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tNBOTDR_inline.h (revision 18) @@ -0,0 +1,1647 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tNBOTDR_inline.h 2569 2016-03-27 12:58:00Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 属性アクセスマクロ #_CAAM_# + * tmo TMO VAR_tmo + * + * 呼び口関数 #_TCPF_# + * call port: cChannel signature: sChannel context:task + * ER cChannel_send( const int8_t* buf, int16_t size, TMO tmo ); + * ER cChannel_flush( TMO tmo ); + * ER_UINT cChannel_receive( int8_t* buf, int16_t size, TMO tmo ); + * ER cChannel_end_receive( ); + * ER cChannel_reset( ); + * require port: signature:sSysLog context:task + * ER write( uint_t prio, const SYSLOG* p_syslog ); + * ER_UINT read( SYSLOG* p_syslog ); + * ER mask( uint_t logmask, uint_t lowmask ); + * ER refer( T_SYSLOG_RLOG* pk_rlog ); + * + * #[]# */ + +/* + * marhaler, unmarshaler が使用する STRLEN 関数を定義する + * marshaler, unmarshaler は必ず TDR は に結合されるため + */ +#include "rpc_string.h" + +/* + * Network Byte Order TECS Data Representation + * + * NBOTDR is one of sTDR implementation and is default TDR for OpaqueRPC. + * NBOTDR always sends and receives data in Big Endian (Network Byte Order). + * So NBOTDR is useful with distributed hybrid systems. + */ + +/* + * Macro Symbols: + * 1) endian + * NBOTDR_BIGENDIAN + * NBOTDR_LITTLEENDIAN + * if these macros are not specified, endian is automatically decided. + * 2) size of each type in bits. + * NBOTDR_LONG_BIT (32) + * NBOTDR_SHORT_BIT (16) + * NBOTDR_INT_BIT (32) + * NBOTDR_INTPTR_BIT (32) + * default value in parenthesises + * normally use default value + */ + +/* + * 無調整型だが、いくらか暫定的な実装になっている + * ・ntohX(), htonX() は int64_t 型に定義されている (32bitならオーバヘッド大) + * ・int128_t, uint128_t は tecs.h で typedef された型である + * ・BIGENDIAN 判定は動的になっている (恐らく最適化で定数判定にされることはない) + */ + +#if defined( NBOTDR_BIGENDIAN ) +#define IS_BIGENDIAN() (1) +# if defined( NBOTDR_LITTLEENDIAN ) +# error "Don't specify both NBOTDR_LITTLEENDIAN and NBOTDR_BIGENDIAN" +# endif +#elif defined( NBOTDR_LITTLEENDIAN ) +#define IS_BIGENDIAN() (0) +#else +/* BIGENDIAN かどうか自動判定 */ +static const uint16_t endian_check = 0xff00; +#define IS_BIGENDIAN() (*(uint8_t *)&endian_check) +#warning "it is better to specify -D NBOTDR_BIGENDIAN or -D NBOTDR_LITTLEENDIAN" +#endif + +#if ! defined( NBOTDR_LONG_BIT ) +#define NBOTDR_LONG_BIT 32 +#endif +#if NBOTDR_LONG_BIT == 32 +# define NTOHL( d, sz ) ntoh32( d ) +# define HTONL( d, sz ) hton32( d ) +typedef int32_t TDR_LONG; +typedef uint32_t TDR_ULONG; +#elif NBOTDR_LONG_BIT == 64 +# define NTOHL( d, sz ) ntoh64( d ) +# define HTONL( d, sz ) hton64( d ) +typedef int64_t TDR_LONG; +typedef uint64_t TDR_ULONG; +#elif NBOTDR_LONG_BIT == 128 +# define NTOHL( d, sz ) ntoh128( d ) +# define HTONL( d, sz ) hton128( d ) +typedef int128_t TDR_LONG; +typedef uint128_t TDR_ULONG; +#elif ! defined( NBOTDR_LONG_BIT ) +# define NTOHL ntohX +# define HTONL htonX +# warning "it is better to specify -D NBOTDR_LONG_BIT=N N: 32, 64, 128" +#else +# error "NBOTDR_LONG_BIT must be 32, 64 or 128" +#endif + +#if ! defined( NBOTDR_SHORT_BIT ) +#define NBOTDR_SHORT_BIT 16 +#endif +#if NBOTDR_SHORT_BIT == 16 +# define NTOHS( d, sz ) ntoh16( d ) +# define HTONS( d, sz ) hton16( d ) +typedef int16_t TDR_SHORT; +typedef uint16_t TDR_USHORT; +#elif NBOTDR_SHORT_BIT == 32 +# define NTOHS( d, sz ) ntoh32( d ) +# define HTONS( d, sz ) hton32( d ) +typedef int32_t TDR_SHORT; +typedef uint32_t TDR_USHORT; +#elif NBOTDR_SHORT_BIT == 64 +# define NTOHS( d, sz ) ntoh64( d ) +# define HTONS( d, sz ) hton64( d ) +typedef int64_t TDR_SHORT; +typedef uint64_t TDR_USHORT; +#elif ! defined( NBOTDR_SHORT_BIT ) +# define NTOHS( d, sz ) ntohX( d, sz ) +# define HTONS( d, sz ) htonX( d, sz ) +# warning "it is better to specify -D NBOTDR_SHORT_BIT=N N: 16, 32, 64" +#else +# error "NBOTDR_SHORT_BIT must be 16, 32 or 64" +#endif + +#if ! defined( NBOTDR_INT_BIT ) +#define NBOTDR_INT_BIT 32 +#endif +#if NBOTDR_INT_BIT == 16 +# define NTOHI( d, sz ) ntoh16( d ) +# define HTONI( d, sz ) hton16( d ) +typedef int16_t TDR_INT; +typedef uint16_t TDR_UINT; +#elif NBOTDR_INT_BIT == 32 +# define NTOHI( d, sz ) ntoh32( d ) +# define HTONI( d, sz ) hton32( d ) +typedef int32_t TDR_INT; +typedef uint32_t TDR_UINT; +#elif NBOTDR_INT_BIT == 64 +# define NTOHI( d, sz ) ntoh64( d ) +# define HTONI( d, sz ) hton64( d ) +typedef int64_t TDR_INT; +typedef uint64_t TDR_UINT; +#elif NBOTDR_INT_BIT == 128 +# define NTOHI( d, sz ) ntoh128( d ) +# define HTONI( d, sz ) hton128( d ) +typedef int128_t TDR_INT; +typedef uint128_t TDR_UINT; +#elif ! defined( NBOTDR_INT_BIT ) +# define NTOHI( d, sz ) ntohX( d, sz ) +# define HTONI( d, sz ) htonX( d, sz ) +# warning "it is better to specify -D NBOTDR_INT_BIT=N N: 16, 32, 64, 128" +#else +# error "NBOTDR_INT_BIT must be 16, 32, 64 or 128" +#endif + +#if ! defined( NBOTDR_INTPTR_BIT ) +#define NBOTDR_INTPTR_BIT 32 +#endif +#if NBOTDR_INTPTR_BIT == 16 +# define NTOHIP( d, sz ) ntoh16( d ) +# define HTONIP( d, sz ) hton16( d ) +typedef int16_t TDR_INTPTR; +#elif NBOTDR_INTPTR_BIT == 32 +# define NTOHIP( d, sz ) ntoh32( d ) +# define HTONIP( d, sz ) hton32( d ) +typedef int32_t TDR_INTPTR; +#elif NBOTDR_INTPTR_BIT == 64 +# define NTOHIP( d, sz ) ntoh64( d ) +# define HTONIP( d, sz ) hton64( d ) +typedef int64_t TDR_INTPTR; +#elif NBOTDR_INTPTR_BIT == 128 +# define NTOHIP( d, sz ) ntoh128( d ) +# define HTONIP( d, sz ) hton128( d ) +typedef int128_t TDR_INTPTR; +#elif ! defined( NBOTDR_INTPTR_BIT ) +# define NTOHIP( d, sz ) ntohX( d, sz ) +# define HTONIP( d, sz ) htonX( d, sz ) +# warning "it is better to specify -D NBOTDR_INTPTR_BIT=N N: 16, 32, 64, 128" +#else +# error "NBOTDR_INTPTR_BIT must be 16, 32, 64 or 128 " +#endif + +Inline int16_t +hton16( int16_t d ) +{ + if( IS_BIGENDIAN() ) + return d; // big endian + else{ + union { + int8_t by[2]; + int16_t d; + } d0, d1; + // syslog( LOG_INFO, "### little endian ###" ); + d0.d = d; + d1.by[0] = d0.by[1]; + d1.by[1] = d0.by[0]; + return d1.d; + } +} + +Inline int32_t +hton32( int32_t d ) +{ + if( IS_BIGENDIAN() ) + return d; + else{ + union { + int8_t by[4]; + int32_t d; + } d0, d1; + d0.d = d; + d1.by[0] = d0.by[3]; + d1.by[1] = d0.by[2]; + d1.by[2] = d0.by[1]; + d1.by[3] = d0.by[0]; + return d1.d; + } +} + +Inline int64_t +hton64( int64_t d ) +{ + if( IS_BIGENDIAN() ) + return d; + else{ + union { + int8_t by[8]; + int64_t d; + } d0, d1; + d0.d = d; + d1.by[0] = d0.by[7]; + d1.by[1] = d0.by[6]; + d1.by[2] = d0.by[5]; + d1.by[3] = d0.by[4]; + d1.by[4] = d0.by[3]; + d1.by[5] = d0.by[2]; + d1.by[6] = d0.by[1]; + d1.by[7] = d0.by[0]; + return d1.d; + } +} + +Inline int128_t +hton128( int128_t d ) +{ + if( IS_BIGENDIAN() ) + return d; + else{ + /* この実装は tecs.h で typedef した int128_t に適合 */ + int128_t d1; + d1.hi = hton64( d.lo ); + d1.lo = hton64( d.hi ); + return d1; + } +} + +Inline int16_t +ntoh16( int16_t d ) +{ + if( IS_BIGENDIAN() ) + return d; + else{ + union { + int8_t by[2]; + int16_t d; + } d0, d1; + d0.d = d; + d1.by[0] = d0.by[1]; + d1.by[1] = d0.by[0]; + return d1.d; + } +} + +Inline int32_t +ntoh32( int32_t d ) +{ + if( IS_BIGENDIAN() ) + return d; + else{ + union { + int8_t by[4]; + int32_t d; + } d0, d1; + d0.d = d; + d1.by[0] = d0.by[3]; + d1.by[1] = d0.by[2]; + d1.by[2] = d0.by[1]; + d1.by[3] = d0.by[0]; + return d1.d; + } +} + +Inline int64_t +ntoh64( int64_t d ) +{ + if( IS_BIGENDIAN() ) + return d; + else{ + union { + int8_t by[8]; + int64_t d; + } d0, d1; + d0.d = d; + d1.by[0] = d0.by[7]; + d1.by[1] = d0.by[6]; + d1.by[2] = d0.by[5]; + d1.by[3] = d0.by[4]; + d1.by[4] = d0.by[3]; + d1.by[5] = d0.by[2]; + d1.by[6] = d0.by[1]; + d1.by[7] = d0.by[0]; + return d1.d; + } +} + +/*** unsigned 用の関数 (128 bit 版のみ用意) ***/ +Inline int128_t +ntoh128( int128_t d ) +{ + if( IS_BIGENDIAN() ) + return d; + else{ + /* この実装は tecs.h で typedef した int128_t に適合 */ + int128_t d1; + d1.hi = ntoh64( d.lo ); + d1.lo = ntoh64( d.hi ); + return d1; + } +} + +Inline uint128_t +hton128u( uint128_t d ) +{ + if( IS_BIGENDIAN() ) + return d; + else{ + /* この実装は tecs.h で typedef した int128_t に適合 */ + uint128_t d1; + d1.hi = hton64( d.lo ); + d1.lo = hton64( d.hi ); + return d1; + } +} + +Inline uint128_t +ntoh128u( uint128_t d ) +{ + if( IS_BIGENDIAN() ) + return d; + else{ + /* この実装は tecs.h で typedef した int128_t に適合 */ + uint128_t d1; + d1.hi = ntoh64( d.lo ); + d1.lo = ntoh64( d.hi ); + return d1; + } +} + +/************************************************ + * htonX, ntohX は 16, 32, 64 にのみ対応できる * + ************************************************/ +Inline int64_t +htonX( int64_t d, int_t sz ) +{ + switch( sz ){ + case 2: return hton16( d ); + case 4: return hton32( d ); + case 8: return hton64( d ); + default: return 0; // # mikan + }; +} + +Inline int64_t +ntohX( int64_t d, int_t sz ) +{ + switch( sz ){ + case 2: return ntoh16( d ); + case 4: return ntoh32( d ); + case 8: return ntoh64( d ); + default: return 0; // # mikan + }; +} + +/* 受け口関数 #_TEPF_# */ +/* #[]# eTDR + * entry port: eTDR + * signature: sTDR + * context: task + * #[]# */ + +/* #[]# eTDR_reset + * name: eTDR_reset + * global_name: tNBOTDR_eTDR_reset + * oneway: false + * #[]# */ +Inline ER +eTDR_reset(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + + syslog( LOG_INFO, "TDR: resetting channel" ); + ercd = cChannel_reset(); + return(ercd); +} + +/* #[]# eTDR_sendSOP + * name: eTDR_sendSOP + * global_name: tNBOTDR_eTDR_sendSOP + * oneway: false + * #[]# */ +Inline ER +eTDR_sendSOP(CELLIDX idx, bool_t b_client ) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + uint16_t sopMagic; + uint8_t val; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "eTDR_sendSOP(b_client=%d)", b_client); +#endif + if( b_client ) + sopMagic = TDR_SOP_MAGIC1; + else + sopMagic = TDR_SOP_MAGIC2; + + /* + * SOP パケットの送信 + * パケットシーケンスが多少崩れても回復できるように、バイト単位で送る + * 上位バイト、下位バイトの順に送る + */ + + val = (uint8_t)(sopMagic>>8); + ercd = eTDR_putUInt8( idx, val ); /* 上位8ビット */ + if( ercd != E_OK ) + return ercd; + + val = (uint8_t)(sopMagic&0xff); /* 下位8ビット */ + ercd = eTDR_putUInt8( idx, val ); + + return ercd; +} + +/* #[]# eTDR_receiveSOP + * name: eTDR_receiveSOP + * global_name: tNBOTDR_eTDR_receiveSOP + * oneway: false + * #[]# */ +Inline ER +eTDR_receiveSOP(CELLIDX idx, bool_t b_client ) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + uint16_t sopMagic; + uint8_t val; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "eTDR_receiveSOP(b_client=%d)", b_client); +#endif + + if( b_client ) + sopMagic = TDR_SOP_MAGIC2; + else + sopMagic = TDR_SOP_MAGIC1; + + if( (ercd=eTDR_getUInt8( idx, &val )) != E_OK ) + ; + else if( val != (uint8_t)(sopMagic>>8) ){ + ercd = E_MAGIC; + } + else if((ercd=eTDR_getUInt8( idx, &val )) != E_OK ) + ; + else if( val != (uint8_t)sopMagic ){ + ercd = E_MAGIC; + } + + if( ercd != E_OK ) + syslog( LOG_INFO, "receiveSOP: ERCD=%d", ercd ); + + return ercd; +} + +/* #[]# eTDR_sendEOP + * name: eTDR_sendEOP + * global_name: tNBOTDR_eTDR_sendEOP + * oneway: false + * #[]# */ +Inline ER +eTDR_sendEOP(CELLIDX idx, bool_t b_continue ) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + uint16_t magic; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "eTDR_sendEOP(b_continue=%d)", b_continue); +#endif + + if( b_continue ) + magic = TDR_EOP_MAGIC1; + else + magic = TDR_EOP_MAGIC2; + + /* EOP magic の送信 */ + if( (ercd = eTDR_putUInt16( idx, magic )) != E_OK ) + return ercd; + + return cChannel_flush(VAR_tmo); +} + +/* #[]# eTDR_receiveEOP + * name: eTDR_receiveEOP + * global_name: tNBOTDR_eTDR_receiveEOP + * oneway: false + * #[]# */ +Inline ER +eTDR_receiveEOP(CELLIDX idx, bool_t b_continue) +{ + ER ercd = E_OK, er2; + CELLCB *p_cellcb; + uint16_t magic; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "eTDR_receiveEOP(b_continue=%d)",b_continue); +#endif +/* mikan cChannel EOF get_* */ +/* mikan magic EOF */ + + if( (ercd=eTDR_getUInt16( idx, &magic )) == E_OK ){ + if( (b_continue && magic == TDR_EOP_MAGIC1) || (!b_continue && magic == TDR_EOP_MAGIC2) ){ + } else { + ercd = E_MAGIC; + } + } + er2 = cChannel_end_receive(); + return ercd != E_OK ? ercd : er2; +} + +/* #[]# eTDR_putInt8 + * name: eTDR_putInt8 + * global_name: tNBOTDR_eTDR_putInt8 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt8(CELLIDX idx, int8_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putInt16 + * name: eTDR_putInt16 + * global_name: tNBOTDR_eTDR_putInt16 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt16(CELLIDX idx, int16_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + in = hton16( in ); + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putInt32 + * name: eTDR_putInt32 + * global_name: tNBOTDR_eTDR_putInt32 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt32(CELLIDX idx, int32_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + in = hton32( in ); + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putInt64 + * name: eTDR_putInt64 + * global_name: tNBOTDR_eTDR_putInt64 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt64(CELLIDX idx, int64_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + in = hton64( in ); + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putInt128 + * name: eTDR_putInt128 + * global_name: tNBOTDR_eTDR_putInt128 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt128(CELLIDX idx, int128_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + in = hton128( in ); + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_getInt8 + * name: eTDR_getInt8 + * global_name: tNBOTDR_eTDR_getInt8 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt8(CELLIDX idx, int8_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt16 + * name: eTDR_getInt16 + * global_name: tNBOTDR_eTDR_getInt16 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt16(CELLIDX idx, int16_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + *out = ntoh16( *out ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt32 + * name: eTDR_getInt32 + * global_name: tNBOTDR_eTDR_getInt32 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt32(CELLIDX idx, int32_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + *out = ntoh32( *out ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt64 + * name: eTDR_getInt64 + * global_name: tNBOTDR_eTDR_getInt64 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt64(CELLIDX idx, int64_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + *out = ntoh64( *out ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt128 + * name: eTDR_getInt128 + * global_name: tNBOTDR_eTDR_getInt128 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt128(CELLIDX idx, int128_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + *out = ntoh128( *out ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putUInt8 + * name: eTDR_putUInt8 + * global_name: tNBOTDR_eTDR_putUInt8 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt8(CELLIDX idx, uint8_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt16 + * name: eTDR_putUInt16 + * global_name: tNBOTDR_eTDR_putUInt16 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt16(CELLIDX idx, uint16_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + in = hton16( in ); + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt32 + * name: eTDR_putUInt32 + * global_name: tNBOTDR_eTDR_putUInt32 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt32(CELLIDX idx, uint32_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + in = hton32( in ); + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt64 + * name: eTDR_putUInt64 + * global_name: tNBOTDR_eTDR_putUInt64 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt64(CELLIDX idx, uint64_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + in = hton64( in ); + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt128 + * name: eTDR_putUInt128 + * global_name: tNBOTDR_eTDR_putUInt128 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt128(CELLIDX idx, uint128_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + in = hton128u( in ); + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_getUInt8 + * name: eTDR_getUInt8 + * global_name: tNBOTDR_eTDR_getUInt8 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt8(CELLIDX idx, uint8_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt16 + * name: eTDR_getUInt16 + * global_name: tNBOTDR_eTDR_getUInt16 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt16(CELLIDX idx, uint16_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + *out = ntoh16( *out ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt32 + * name: eTDR_getUInt32 + * global_name: tNBOTDR_eTDR_getUInt32 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt32(CELLIDX idx, uint32_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + *out = ntoh32( *out ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt64 + * name: eTDR_getUInt64 + * global_name: tNBOTDR_eTDR_getUInt64 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt64(CELLIDX idx, uint64_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + *out = ntoh64( *out ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt128 + * name: eTDR_getUInt128 + * global_name: tNBOTDR_eTDR_getUInt128 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt128(CELLIDX idx, uint128_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + *out = ntoh128u( *out ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putChar + * name: eTDR_putChar + * global_name: tNBOTDR_eTDR_putChar + * oneway: false + * #[]# */ +Inline ER +eTDR_putChar(CELLIDX idx, char_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_getChar + * name: eTDR_getChar + * global_name: tNBOTDR_eTDR_getChar + * oneway: false + * #[]# */ +Inline ER +eTDR_getChar(CELLIDX idx, char_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putBool + * name: eTDR_putBool + * global_name: tNBOTDR_eTDR_putBool + * oneway: false + * #[]# */ +Inline ER +eTDR_putBool(CELLIDX idx, bool_t in) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + eTDR_putUInt8(idx, (uint8_t)(in != 0) ); + + return(ercd); +} + +/* #[]# eTDR_getBool + * name: eTDR_getBool + * global_name: tNBOTDR_eTDR_getBool + * oneway: false + * #[]# */ +Inline ER +eTDR_getBool(CELLIDX idx, bool_t* out) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + uint8_t val; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + ercd = eTDR_getUInt8(idx, &val ); + if( ercd != E_OK ) + return ercd; + *out = (val != 0); + + return(ercd); +} + +/* #[]# eTDR_putFloat32 + * name: eTDR_putFloat32 + * global_name: tNBOTDR_eTDR_putFloat32 + * oneway: false + * #[]# */ +Inline ER +eTDR_putFloat32(CELLIDX idx, float32_t in) +{ + CELLCB *p_cellcb; + int32_t val; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + val = hton32( *(int32_t*)&in ); + return cChannel_send( (int8_t *)&val, (int16_t)sizeof( val ), VAR_tmo ); +} + +/* #[]# eTDR_putDouble64 + * name: eTDR_putDouble64 + * global_name: tNBOTDR_eTDR_putDouble64 + * oneway: false + * #[]# */ +Inline ER +eTDR_putDouble64(CELLIDX idx, double64_t in) +{ + int64_t val; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + val = *(int64_t *)∈ + val = hton64( val ); + return cChannel_send( (int8_t *)&val, (int16_t)sizeof( val ), VAR_tmo ); +} + +/* #[]# eTDR_getFloat32 + * name: eTDR_getFloat32 + * global_name: tNBOTDR_eTDR_getFloat32 + * oneway: false + * #[]# */ +Inline ER +eTDR_getFloat32(CELLIDX idx, float32_t* out) +{ + ER_UINT er_sz = E_OK; + int32_t val; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)&val, (int16_t)sizeof( val ), VAR_tmo ); + val = ntoh32( val ); + *out = *(float32_t *)&val; + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getDouble64 + * name: eTDR_getDouble64 + * global_name: tNBOTDR_eTDR_getDouble64 + * oneway: false + * #[]# */ +Inline ER +eTDR_getDouble64(CELLIDX idx, double64_t* out) +{ + ER_UINT er_sz = E_OK; + int64_t val; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)&val, (int16_t)sizeof( val ), VAR_tmo ); + val = ntoh64( val ); + *out = *(double64_t *)&val; + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putSChar + * name: eTDR_putSChar + * global_name: tNBOTDR_eTDR_putSChar + * oneway: false + * #[]# */ +Inline ER +eTDR_putSChar(CELLIDX idx, signed char in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putShort + * name: eTDR_putShort + * global_name: tNBOTDR_eTDR_putShort + * oneway: false + * #[]# */ +Inline ER +eTDR_putShort(CELLIDX idx, short_t in) +{ + CELLCB *p_cellcb; + TDR_SHORT IN = in; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + IN = HTONS( IN, sizeof IN ); + return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo ); +} + +/* #[]# eTDR_putInt + * name: eTDR_putInt + * global_name: tNBOTDR_eTDR_putInt + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt(CELLIDX idx, int_t in) +{ + CELLCB *p_cellcb; + TDR_INT IN = in; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + IN = HTONI( IN, sizeof IN ); + return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo ); +} + +/* #[]# eTDR_putLong + * name: eTDR_putLong + * global_name: tNBOTDR_eTDR_putLong + * oneway: false + * #[]# */ +Inline ER +eTDR_putLong(CELLIDX idx, long_t in) +{ + CELLCB *p_cellcb; + TDR_LONG IN = in; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + IN = HTONL( IN, sizeof IN ); + return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo ); +} + +/* #[]# eTDR_getSChar + * name: eTDR_getSChar + * global_name: tNBOTDR_eTDR_getSChar + * oneway: false + * #[]# */ +Inline ER +eTDR_getSChar(CELLIDX idx, signed char* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getShort + * name: eTDR_getShort + * global_name: tNBOTDR_eTDR_getShort + * oneway: false + * #[]# */ +Inline ER +eTDR_getShort(CELLIDX idx, short* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + TDR_SHORT OUT; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo ); + *out = NTOHS( OUT, sizeof OUT ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt + * name: eTDR_getInt + * global_name: tNBOTDR_eTDR_getInt + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt(CELLIDX idx, int_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + TDR_INT OUT; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo ); + *out = NTOHI( OUT, sizeof OUT ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getLong + * name: eTDR_getLong + * global_name: tNBOTDR_eTDR_getLong + * oneway: false + * #[]# */ +Inline ER +eTDR_getLong(CELLIDX idx, long_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + TDR_LONG OUT; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo ); + *out = NTOHL( OUT, sizeof OUT ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putUChar + * name: eTDR_putUChar + * global_name: tNBOTDR_eTDR_putUChar + * oneway: false + * #[]# */ +Inline ER +eTDR_putUChar(CELLIDX idx, unsigned char in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUShort + * name: eTDR_putUShort + * global_name: tNBOTDR_eTDR_putUShort + * oneway: false + * #[]# */ +Inline ER +eTDR_putUShort(CELLIDX idx, ushort_t in) +{ + CELLCB *p_cellcb; + TDR_USHORT IN = in; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + IN = HTONS( IN, sizeof IN ); + return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt + * name: eTDR_putUInt + * global_name: tNBOTDR_eTDR_putUInt + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt(CELLIDX idx, uint_t in) +{ + CELLCB *p_cellcb; + TDR_UINT IN = in; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + IN = HTONI( IN, sizeof IN ); + return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo ); +} + +/* #[]# eTDR_putULong + * name: eTDR_putULong + * global_name: tNBOTDR_eTDR_putULong + * oneway: false + * #[]# */ +Inline ER +eTDR_putULong(CELLIDX idx, ulong_t in) +{ + CELLCB *p_cellcb; + TDR_ULONG IN = in; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + IN = HTONL( IN, sizeof IN ); + return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo ); +} + +/* #[]# eTDR_getUChar + * name: eTDR_getUChar + * global_name: tNBOTDR_eTDR_getUChar + * oneway: false + * #[]# */ +Inline ER +eTDR_getUChar(CELLIDX idx, unsigned char* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUShort + * name: eTDR_getUShort + * global_name: tNBOTDR_eTDR_getUShort + * oneway: false + * #[]# */ +Inline ER +eTDR_getUShort(CELLIDX idx, unsigned short* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + TDR_USHORT OUT; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo ); + *out = NTOHS( OUT, sizeof OUT ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt + * name: eTDR_getUInt + * global_name: tNBOTDR_eTDR_getUInt + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt(CELLIDX idx, uint_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + TDR_UINT OUT; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo ); + *out = NTOHI( OUT, sizeof OUT ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getULong + * name: eTDR_getULong + * global_name: tNBOTDR_eTDR_getULong + * oneway: false + * #[]# */ +Inline ER +eTDR_getULong(CELLIDX idx, ulong_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + TDR_ULONG OUT; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo ); + *out = NTOHL( OUT, sizeof OUT ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putIntptr + * name: eTDR_putIntptr + * global_name: tNBOTDR_eTDR_putIntptr + * oneway: false + * #[]# */ +Inline ER +eTDR_putIntptr(CELLIDX idx, const intptr_t ptr) +{ + CELLCB *p_cellcb; + TDR_INTPTR IN = ptr; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + IN = HTONIP( IN, sizeof IN ); + return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo ); +} + +/* #[]# eTDR_getIntptr + * name: eTDR_getIntptr + * global_name: tNBOTDR_eTDR_getIntptr + * oneway: false + * #[]# */ +Inline ER +eTDR_getIntptr(CELLIDX idx, intptr_t* ptr) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + TDR_INTPTR OUT; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo ); + *ptr = NTOHIP( OUT, sizeof OUT ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR ); +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tPPAllocator.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tPPAllocator.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tPPAllocator.c (revision 18) @@ -0,0 +1,146 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tPPAllocator.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 属性アクセスマクロ #_CAAM_# + * heap_size uint32_t ATTR_heap_size + * buf int8_t* VAR_buf + * allocated_size uint32_t VAR_allocated_size + * + * #[]# */ + +#include "tPPAllocator_tecsgen.h" + +#ifndef E_OK +#define E_OK 0 /* success */ +#define E_ID (-18) /* illegal ID */ +#endif + +/* 受け口関数 #_TEPF_# */ +/* #[]# ePPAllocator + * entry port: ePPAllocator + * signature: sPPAllocator + * context: task + * #[]# */ + +/* #[]# ePPAllocator_alloc + * name: ePPAllocator_alloc + * global_name: tPPAllocator_ePPAllocator_alloc + * oneway: false + * #[]# */ +ER +ePPAllocator_alloc(CELLIDX idx, uint32_t size, void** ptr) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + if( size + VAR_allocatedSize > ATTR_heapSize ){ + ercd = E_NOMEM; + } + else { + *ptr = (void *)(VAR_buf+VAR_allocatedSize); + VAR_allocatedSize += size; + } + + return(ercd); +} + +/* #[]# ePPAllocator_dealloc + * name: ePPAllocator_dealloc + * global_name: tPPAllocator_ePPAllocator_dealloc + * oneway: false + * #[]# */ +ER +ePPAllocator_dealloc(CELLIDX idx, const void* ptr) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + if( (uintptr_t)ptr < (uintptr_t)VAR_buf || (uintptr_t)ptr >= (uintptr_t)(VAR_buf+VAR_allocatedSize) ){ + ercd = E_PAR; + } + else { + VAR_allocatedSize = (uintptr_t)ptr - (uintptr_t)VAR_buf; + } + + return(ercd); +} + +/* #[]# ePPAllocator_dealloc_all + * name: ePPAllocator_dealloc_all + * global_name: tPPAllocator_ePPAllocator_dealloc_all + * oneway: false + * #[]# */ +ER +ePPAllocator_dealloc_all(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + VAR_allocatedSize = 0; + + return(ercd); +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCDedicatedTaskMain.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCDedicatedTaskMain.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCDedicatedTaskMain.c (revision 18) @@ -0,0 +1,86 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tRPCDedicatedTaskMain.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 呼び口関数 #_TCPF_# + * call port : cMain signature: sTaskBody context: task + * void cMain_main( ); + * + * #[]# */ + +#include "tRPCDedicatedTaskMain_tecsgen.h" + +#ifndef E_OK +#define E_OK 0 /* success */ +#define E_ID (-18) /* illegal ID */ +#endif + +/* 受け口関数 #_TEPF_# */ +/* #[]# eMain + * entry port: eMain + * signature: sTaskBody + * context: task + * #[]# */ + +/* #[]# eMain_main + * name: eMain_main + * global_name: tRPCDedicatedTaskMain_eMain_main + * oneway: false + * #[]# */ +void +eMain_main(CELLIDX idx) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + /* エラー処理コードをここに記述します */ + } + + /* ここに処理本体を記述します #_TEFB_# */ + while( cMain_main() == E_OK ){ + } +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCDedicatedTaskMainWithOpener.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCDedicatedTaskMainWithOpener.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCDedicatedTaskMainWithOpener.c (revision 18) @@ -0,0 +1,99 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tRPCDedicatedTaskMainWithOpener.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 呼び口関数 #_TCPF_# + * call port : cMain signature: sTaskBody context: task + * void cMain_main( ); + * + * #[]# */ + +#include "tRPCDedicatedTaskMainWithOpener_tecsgen.h" + +#ifndef E_OK +#define E_OK 0 /* success */ +#define E_ID (-18) /* illegal ID */ +#endif + +/* 受け口関数 #_TEPF_# */ +/* #[]# eMain + * entry port: eMain + * signature: sTaskBody + * context: task + * #[]# */ + +/* #[]# eMain_main + * name: eMain_main + * global_name: tRPCDedicatedTaskMain_eMain_main + * oneway: false + * #[]# */ +void +eMain_main(CELLIDX idx) +{ + CELLCB *p_cellcb; + ER er; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + /* エラー処理コードをここに記述します */ + } + + /* ここに処理本体を記述します #_TEFB_# */ + while(1){ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "begin RPC unmarshaler task" ); + syslog(LOG_INFO, "Opening RPC server channel" ); +#endif + delay( ATTR_initialDelay ); + er = cOpener_open(); + syslog(LOG_INFO, "opened" ); + while( cMain_main() == E_OK ){ + } + delay( ATTR_reopenDelay ); + er = cOpener_close(); + } +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCSharedChannelMan.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCSharedChannelMan.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCSharedChannelMan.c (revision 18) @@ -0,0 +1,254 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tRPCSharedChannelMan.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 呼び口関数 #_TCPF_# + * call port : cSemaphore signature: sSemaphore context: task + * ER cSemaphore_signal( ); + * ER cSemaphore_wait( ); + * ER cSemaphore_waitPolling( ); + * ER cSemaphore_waitTimeout( TMO timeout ); + * ER cSemaphore_initialize( ); + * ER cSemaphore_refer( T_RSEM* pk_semaphore_status ); + * call port : cClientSideTDR signature: sTDR context: task + * ER cClientSideTDR_open( const int8_t* arg, int16_t size, TMO tmo ); + * ER cClientSideTDR_close( ); + * ER cClientSideTDR_reset( ); + * ER cClientSideTDR_sop( int_t no ); + * ER cClientSideTDR_is_sop( int_t no ); + * ER cClientSideTDR_eop( int_t no ); + * ER cClientSideTDR_is_eop( int_t no ); + * ER cClientSideTDR_set_tmo( TMO tmo ); + * ER cClientSideTDR_put_int8( int8_t in ); + * ER cClientSideTDR_put_int16( int16_t in ); + * ER cClientSideTDR_put_int32( int32_t in ); + * ER cClientSideTDR_put_int64( int64_t in ); + * ER cClientSideTDR_put_int128( int128_t in ); + * ER cClientSideTDR_get_int8( int8_t* out ); + * ER cClientSideTDR_get_int16( int16_t* out ); + * ER cClientSideTDR_get_int32( int32_t* out ); + * ER cClientSideTDR_get_int64( int64_t* out ); + * ER cClientSideTDR_get_int128( int128_t* out ); + * ER cClientSideTDR_put_char( char_t in ); + * ER cClientSideTDR_put_short( short in ); + * ER cClientSideTDR_put_int( int_t in ); + * ER cClientSideTDR_put_long( long_t in ); + * ER cClientSideTDR_get_char( char_t* out ); + * ER cClientSideTDR_get_short( short* out ); + * ER cClientSideTDR_get_int( int_t* out ); + * ER cClientSideTDR_get_long( long_t* out ); + * ER cClientSideTDR_put_intptr( const void* ptr ); + * ER cClientSideTDR_get_intptr( void** ptr ); + * + * #[]# */ + +#include "tRPCSharedChannelMan_tecsgen.h" + +#ifndef E_OK +#define E_OK 0 /* success */ +#define E_ID (-18) /* illegal ID */ +#endif + + +/* 受け口関数 #_TEPF_# */ +/* #[]# eSemaphore + * entry port: eSemaphore + * signature: sSemaphore + * context: task + * #[]# */ + +/* #[]# eSemaphore_signal + * name: eSemaphore_signal + * global_name: tRPCSharedTaskMain_eSemaphore_signal + * oneway: false + * #[]# */ +ER +eSemaphore_signal(CELLIDX idx, int_t subscript) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + cClientSideTDR_putInt16( RPC_CHANNEL_MAN_EOP_MAGIC ); + ercd = cSemaphore_signal(); + // syslog( LOG_INFO, "tRPCSharedTaskMain: cSemaphore_signal" ); + + return(ercd); +} + +/* #[]# eSemaphore_wait + * name: eSemaphore_wait + * global_name: tRPCSharedTaskMain_eSemaphore_wait + * oneway: false + * #[]# */ +ER +eSemaphore_wait(CELLIDX idx, int_t subscript) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + ercd = cSemaphore_wait(); + if( ercd == E_OK ){ + // syslog( LOG_INFO, "tRPCSharedTaskMain: cSemaphore_wait" ); + + cClientSideTDR_putInt16( RPC_CHANNEL_MAN_SOP_MAGIC ); + cClientSideTDR_putInt16( subscript ); + } + + return(ercd); +} + +/* #[]# eSemaphore_waitPolling + * name: eSemaphore_waitPolling + * global_name: tRPCSharedTaskMain_eSemaphore_waitPolling + * oneway: false + * #[]# */ +ER +eSemaphore_waitPolling(CELLIDX idx, int_t subscript) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + ercd = cSemaphore_waitPolling(); + if( ercd == E_OK ){ + cClientSideTDR_putInt16( RPC_CHANNEL_MAN_SOP_MAGIC ); + cClientSideTDR_putInt16( subscript ); + } + + return(ercd); +} + +/* #[]# eSemaphore_waitTimeout + * name: eSemaphore_waitTimeout + * global_name: tRPCSharedTaskMain_eSemaphore_waitTimeout + * oneway: false + * #[]# */ +ER +eSemaphore_waitTimeout(CELLIDX idx, int_t subscript, TMO timeout) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + ercd = cSemaphore_waitTimeout(timeout); + if( ercd == E_OK ){ + // syslog( LOG_INFO, "tRPCSharedTaskMain: cSemaphore_waitTimeout" ); + + cClientSideTDR_putInt16( RPC_CHANNEL_MAN_SOP_MAGIC ); + cClientSideTDR_putInt16( subscript ); + } + + return(ercd); +} + +/* #[]# eSemaphore_initialize + * name: eSemaphore_initialize + * global_name: tRPCSharedTaskMain_eSemaphore_initialize + * oneway: false + * #[]# */ +ER +eSemaphore_initialize(CELLIDX idx, int_t subscript) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + + return(ercd); +} + +/* #[]# eSemaphore_refer + * name: eSemaphore_refer + * global_name: tRPCSharedTaskMain_eSemaphore_refer + * oneway: false + * #[]# */ +ER +eSemaphore_refer(CELLIDX idx, int_t subscript, T_RSEM* pk_semaphore_status) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + + return(ercd); +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCSharedTaskMain.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCSharedTaskMain.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCSharedTaskMain.c (revision 18) @@ -0,0 +1,160 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tRPCSharedTaskMain.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 属性アクセスマクロ #_CAAM_# + * channelNo int16_t VAR_channelNo + * + * 呼び口関数 #_TCPF_# + * call port : cUnmarshalAndCallFunction signature: sTaskBody context: task + * void cUnmarshalAndCallFunction_main( subscript ); + * call port : cServerSideTDR signature: sTDR context: task + * ER cServerSideTDR_reset( ); + * ER cServerSideTDR_sendSOP( bool_t b_client ); + * ER cServerSideTDR_receiveSOP( bool_t b_client ); + * ER cServerSideTDR_sendEOP( bool_t b_continue ); + * ER cServerSideTDR_receiveEOP( bool_t b_continue ); + * ER cServerSideTDR_putInt8( int8_t in ); + * ER cServerSideTDR_putInt16( int16_t in ); + * ER cServerSideTDR_putInt32( int32_t in ); + * ER cServerSideTDR_putInt64( int64_t in ); + * ER cServerSideTDR_putInt128( int128_t in ); + * ER cServerSideTDR_getInt8( int8_t* out ); + * ER cServerSideTDR_getInt16( int16_t* out ); + * ER cServerSideTDR_getInt32( int32_t* out ); + * ER cServerSideTDR_getInt64( int64_t* out ); + * ER cServerSideTDR_getInt128( int128_t* out ); + * ER cServerSideTDR_putFloat32( float32_t in ); + * ER cServerSideTDR_putDouble64( double64_t in ); + * ER cServerSideTDR_getFloat32( float32_t* out ); + * ER cServerSideTDR_getDouble64( double64_t* out ); + * ER cServerSideTDR_putChar( char_t in ); + * ER cServerSideTDR_putShort( short in ); + * ER cServerSideTDR_putInt( int_t in ); + * ER cServerSideTDR_putLong( long_t in ); + * ER cServerSideTDR_getChar( char_t* out ); + * ER cServerSideTDR_getShort( short* out ); + * ER cServerSideTDR_getInt( int_t* out ); + * ER cServerSideTDR_getLong( long_t* out ); + * ER cServerSideTDR_putIntptr( const intptr_t ptr ); + * ER cServerSideTDR_getIntptr( intptr_t* ptr ); + * require port : signature: sSysLog context: task + * ER write( uint_t prio, const SYSLOG* p_syslog ); + * ER_UINT read( SYSLOG* p_syslog ); + * ER mask( uint_t logmask, uint_t lowmask ); + * ER refer( T_SYSLOG_RLOG* pk_rlog ); + * + * #[]# */ + +#include "tRPCSharedTaskMain_tecsgen.h" +#include "t_syslog.h" + +#ifndef E_OK +#define E_OK 0 /* success */ +#define E_ID (-18) /* illegal ID */ +#endif + +/* 受け口関数 #_TEPF_# */ +/* #[]# eMain + * entry port: eMain + * signature: sTaskBody + * context: task + * #[]# */ + +/* #[]# eMain_main + * name: eMain_main + * global_name: tRPCSharedTaskMain_eMain_main + * oneway: false + * #[]# */ +void +eMain_main(CELLIDX idx) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + /* エラー処理コードをここに記述します */ + } + + /* ここに処理本体を記述します #_TEFB_# */ + syslog( LOG_INFO, "Shared RPC server task started." ); + while(1){ + int16_t magic; + ER er; + + er = cServerSideTDR_getInt16( &magic ); + if( er != E_OK ){ + syslog( LOG_INFO, "err: getInt16 for SOP_MAGIC(%X)", er ); + continue; + } + if( magic != RPC_CHANNEL_MAN_SOP_MAGIC ){ + syslog( LOG_INFO, "illegal SOP magic(%X): retrying", (uint16_t)magic ); + continue; + } + er = cServerSideTDR_getInt16( &VAR_channelNo ); + if( er != E_OK ){ + syslog( LOG_INFO, "err: getInt16 for channelNo(%X)", er ); + continue; + } + if( VAR_channelNo < 0 || VAR_channelNo >= N_CP_cUnmarshalAndCallFunction(p_cellcb) ){ + syslog( LOG_INFO, "illegal channel number(%X): retrying", (uint16_t)VAR_channelNo ); + continue; + } + syslog( LOG_INFO, "Shared Channel: servicing channel No. %d", VAR_channelNo ); + + cUnmarshalAndCallFunction_main( VAR_channelNo ); + + er = cServerSideTDR_getInt16( &magic ); + if( er != E_OK ){ + syslog( LOG_INFO, "err: getInt16 for EOP_MAGIC(%X)", er ); + continue; + } + if( magic != RPC_CHANNEL_MAN_EOP_MAGIC ){ + syslog( LOG_INFO, "illegal EOP magic(%X): retrying", (uint16_t)magic ); + continue; + } + } +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCSharedTaskMainWithOpener.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCSharedTaskMainWithOpener.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tRPCSharedTaskMainWithOpener.c (revision 18) @@ -0,0 +1,190 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tRPCSharedTaskMainWithOpener.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* + * このファイルは tecsgen によりテンプレートとして自動生成されました + * このファイルを編集して使用することが意図されていますが + * tecsgen の再実行により上書きされてしまうため、通常 + * gen/tRPCSharedTaskMainWithOpener_template.c => src/tRPCSharedTaskMainWithOpener.c + * のように名前, フォルダを変更してから修正します + */ +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 属性アクセスマクロ #_CAAM_# + * initialDelay RELTIM ATTR_initialDelay + * reopenDelay RELTIM ATTR_reopenDelay + * channelNo int16_t VAR_channelNo + * + * 呼び口関数 #_TCPF_# + * call port : cUnmarshalAndCallFunction signature: sTaskBody context: task + * void cUnmarshalAndCallFunction_main( subscript ); + * call port : cServerSideTDR signature: sTDR context: task + * ER cServerSideTDR_reset( ); + * ER cServerSideTDR_sendSOP( bool_t b_client ); + * ER cServerSideTDR_receiveSOP( bool_t b_client ); + * ER cServerSideTDR_sendEOP( bool_t b_continue ); + * ER cServerSideTDR_receiveEOP( bool_t b_continue ); + * ER cServerSideTDR_putInt8( int8_t in ); + * ER cServerSideTDR_putInt16( int16_t in ); + * ER cServerSideTDR_putInt32( int32_t in ); + * ER cServerSideTDR_putInt64( int64_t in ); + * ER cServerSideTDR_putInt128( int128_t in ); + * ER cServerSideTDR_getInt8( int8_t* out ); + * ER cServerSideTDR_getInt16( int16_t* out ); + * ER cServerSideTDR_getInt32( int32_t* out ); + * ER cServerSideTDR_getInt64( int64_t* out ); + * ER cServerSideTDR_getInt128( int128_t* out ); + * ER cServerSideTDR_putFloat32( float32_t in ); + * ER cServerSideTDR_putDouble64( double64_t in ); + * ER cServerSideTDR_getFloat32( float32_t* out ); + * ER cServerSideTDR_getDouble64( double64_t* out ); + * ER cServerSideTDR_putChar( char_t in ); + * ER cServerSideTDR_putShort( short in ); + * ER cServerSideTDR_putInt( int_t in ); + * ER cServerSideTDR_putLong( long_t in ); + * ER cServerSideTDR_getChar( char_t* out ); + * ER cServerSideTDR_getShort( short* out ); + * ER cServerSideTDR_getInt( int_t* out ); + * ER cServerSideTDR_getLong( long_t* out ); + * ER cServerSideTDR_putIntptr( const intptr_t ptr ); + * ER cServerSideTDR_getIntptr( intptr_t* ptr ); + * call port : cOpener signature: sServerChannelOpener context: task + * ER cOpener_open( ); + * ER cOpener_close( ); + * require port : signature: sSysLog context: task + * ER write( uint_t prio, const SYSLOG* p_syslog ); + * ER_UINT read( SYSLOG* p_syslog ); + * ER mask( uint_t logmask, uint_t lowmask ); + * ER refer( T_SYSLOG_RLOG* pk_rlog ); + * require port : signature: sKernel context: task + * ER delay( RELTIM delay_time ); + * ER exitTask( ); + * ER getTime( SYSTIM* p_system_time ); + * ER getMicroTime( SYSUTM* p_system_micro_time ); + * ER exitKernel( ); + * + * #[]# */ + +/* プロトタイプ宣言や変数の定義をここに書きます */ +#include "tRPCSharedTaskMainWithOpener_tecsgen.h" + +#ifndef E_OK +#define E_OK 0 /* success */ +#define E_ID (-18) /* illegal ID */ +#endif + +/* 受け口関数 #_TEPF_# */ +/* #[]# eMain + * entry port: eMain + * signature: sTaskBody + * context: task + * #[]# */ + +/* #[]# eMain_main + * name: eMain_main + * global_name: tRPCSharedTaskMainWithOpener_eMain_main + * oneway: false + * #[]# */ +void +eMain_main(CELLIDX idx) +{ + CELLCB *p_cellcb; + ER er; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + /* エラー処理コードをここに記述します */ + } + + /* ここに処理本体を記述します #_TEFB_# */ + delay( ATTR_initialDelay ); + /* ここに処理本体を記述します #_TEFB_# */ + while(1){ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "begin RPC unmarshaler task" ); + syslog(LOG_INFO, "Opening RPC server channel" ); +#endif + + er = cOpener_open(); + syslog(LOG_INFO, "opened" ); + while(1){ + int16_t magic; + + er = cServerSideTDR_getInt16( &magic ); + if( er != E_OK ){ + syslog( LOG_INFO, "err: getInt16 for SOP_MAGIC(%X)", er ); + continue; + } + if( magic != RPC_CHANNEL_MAN_SOP_MAGIC ){ + syslog( LOG_INFO, "illegal SOP magic(%X): retrying", (uint16_t)magic ); + continue; + } + er = cServerSideTDR_getInt16( &VAR_channelNo ); + if( er != E_OK ){ + syslog( LOG_INFO, "err: getInt16 for channelNo(%X)", er ); + continue; + } + if( VAR_channelNo < 0 || VAR_channelNo >= N_CP_cUnmarshalAndCallFunction(p_cellcb) ){ + syslog( LOG_INFO, "illegal channel number(%X): retrying", (uint16_t)VAR_channelNo ); + continue; + } + syslog( LOG_INFO, "Shared Channel: servicing channel No. %d", VAR_channelNo ); + + cUnmarshalAndCallFunction_main( VAR_channelNo ); + + er = cServerSideTDR_getInt16( &magic ); + if( er != E_OK ){ + syslog( LOG_INFO, "err: getInt16 for EOP_MAGIC(%X)", er ); + continue; + } + if( magic != RPC_CHANNEL_MAN_EOP_MAGIC ){ + syslog( LOG_INFO, "illegal EOP magic(%X): retrying", (uint16_t)magic ); + continue; + } + } + er = cOpener_close(); + delay( ATTR_reopenDelay ); + } +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tSocketChannel.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tSocketChannel.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tSocketChannel.cdl (revision 18) @@ -0,0 +1,69 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tSocketChannel.cdl 2640 2017-06-03 11:27:12Z okuma-top $ + */ + +const uint16_t SOCKET_DEFAULT_PORT_NO = 8931; + +signature sSocketClientOpener { + ER open( [in,string]const char_t *serverAddr, [in]uint16_t portNo, [in]TMO tmo ); + ER simpleOpen( [in]TMO tmo ); // attr の設定に従って開く + ER close( [in]TMO tmo ); +}; + +celltype tSocketClient { + entry sChannel eC0; + entry sSocketClientOpener eOpener; + attr { + // simpleOpen で用いられるアドレスおよびポート番号 + int16_t portNo = SOCKET_DEFAULT_PORT_NO; + char_t *serverAddr = "127.0.0.1"; // Loop back address + }; + var { + int_t sd; + }; +}; + +celltype tSocketServer { + entry sChannel eC1; + entry sServerChannelOpener eOpener; + attr { + int16_t portNo = SOCKET_DEFAULT_PORT_NO; + }; + var { + int_t sd; + }; +}; Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tSocketClient.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tSocketClient.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tSocketClient.c (revision 18) @@ -0,0 +1,350 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tSocketClient.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * Don't edit the comments between #[<...>]# and #[]# + * These comment are used by tecsmerege when merging. + * + * attr access macro #_CAAM_# + * portNo int16_t ATTR_portNo + * serverAddr char_t* ATTR_serverAddr + * sd int_t VAR_sd + * + * #[]# */ + +#include "tSocketClient_tecsgen.h" + +#include +#include +#include +#include +#include +#include +#include "errno2ER.h" + +#ifndef E_OK +#define E_OK 0 /* 正常終了 */ +#define E_ID (-18) /* 不正ID番号 */ +#endif + +/* 受け口関数 #_TEPF_# */ +/* #[]# eC0 + * entry port: eC0 + * signature: sChannel + * context: task + * #[]# */ + +/* #[]# eC0_send + * name: eC0_send + * global_name: tSocketClient_eC0_send + * oneway: false + * #[]# */ +ER +eC0_send(CELLIDX idx, const int8_t* buf, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + ssize_t sz; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + // mikan BUG buf の位置を更新していない + while(size>0){ + if((sz=write( VAR_sd, buf, (ssize_t)size )) < 0 ){ +#ifdef RPC_DEBUG + perror( "eC0_send" ); + syslog( LOG_INFO, "eC0_send: sd %d, writing %d bytes, ercd=%d", VAR_sd, size, ercd ); +#endif + ercd = errno2ER( errno ); + break; + } + else{ + size -= sz; + } + } + + return(ercd); +} + +/* #[]# eC0_flush + * name: eC0_flush + * global_name: tSocketClient_eC0_flush + * oneway: false + * #[]# */ +ER +eC0_flush(CELLIDX idx, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + /* write はバッファリングなしなので flush しない */ + + return(ercd); +} + +/* #[]# eC0_receive + * name: eC0_receive + * global_name: tSocketClient_eC0_receive + * oneway: false + * #[]# */ +ER_UINT +eC0_receive(CELLIDX idx, int8_t* buf, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + ssize_t sz; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + sz = read( VAR_sd, buf, (ssize_t)size ); + ercd = errno2ER( errno ); +#ifdef DEBUG + { + int i; + for( i = 0; i < sz; i++ ){ + printf( "%02X ", (unsigned char)buf[i] ); + if( i % 8 == 7 ) + putchar( '\n' ); + } + putchar( '\n' ); + } +#endif + /* mikan 一発で全て読めると仮定 */ + if( sz >= 0 ) + ercd = sz; + + return(ercd); +} + +/* #[]# eC0_end_receive + * name: eC0_end_receive + * global_name: tSocketClient_eC0_end_receive + * oneway: false + * #[]# */ +ER +eC0_end_receive(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + + return(ercd); +} + +/* #[]# eC0_reset + * name: eC0_reset + * global_name: tSocketClient_eC0_reset + * oneway: false + * #[]# */ +ER +eC0_reset(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + + return(ercd); +} + +/* #[]# eOpener + * entry port: eOpener + * signature: sSocketClientOpener + * context: task + * #[]# */ + +/* #[]# eOpener_open + * name: eOpener_open + * global_name: tSocketClient_eOpener_open + * oneway: false + * #[]# */ +ER +eOpener_open(CELLIDX idx, const char_t* serverAddr, uint16_t portNo, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + int soc; + struct sockaddr_in addr={AF_INET}; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + soc=socket(AF_INET, SOCK_STREAM, 0); + if(soc<0){ + ercd = errno2ER( errno ); + syslog( LOG_INFO, "SocketClient: socket failed"); + return ercd; + } + +#if 0 +/* ノンブロックに変更 */ + int flag=fcntl(soc, F_GETFL, 0); + if(flag<0) perror("fcntl(GET) error"); + if(fcntl(soc, F_SETFL, flag|O_NONBLOCK)<0) perror("fcntl(NONBLOCK) error"); +#endif /* 0 */ + + puts( "connecting" ); + inet_aton( serverAddr, &addr.sin_addr ); + addr.sin_port=htons(portNo); + if(connect(soc, (struct sockaddr*)&addr, sizeof(addr))<0){ + ercd = errno2ER( errno ); + close( soc ); + printf( "connect fail errno=%d, ercd=%d\n", errno, ercd ); + syslog( LOG_INFO, "SocketClient: connect" ); + return ercd; + } + VAR_sd = soc; + +#if 0 + if(errno!=EINPROGRESS) + perror("connect error"); + //EINPROGRESS:コネクション要求は始まったが、まだ完了していない + + fd_set rmask,wmask;FD_ZERO(&rmask);FD_SET(soc,&rmask);wmask=rmask; + struct timeval tv={ タイムアウト時間[秒],[μ秒] }; + int rc=select(soc+1, &rmask, &wmask, NULL, &tv); + if(rc<0) perror("connect-select error"); + if(rc==0){ タイムアウト処理 } + if(rc==2){ //読み書きが同時に出来る場合 +#if Solaris + int val; + socklen_t len=sizeof(val); + if(getsockopt(soc,SOL_SOCKET,SO_ERROR, &val,&len)>=0) { +#elif Linux + struct sockaddr_in name; + socklen_t len=sizeof(name); + if(getpeername(soc,(struct sockaddr*)&name,&len)>=0) { +#endif + // 既にデータが来ている + }else{ + // コネクト失敗 + } + } + } +//フラグを元に戻す + if(fcntl(soc, F_SETFL, flag)<0) perror("fcntl(END) error"); +#endif /* 0 */ + + return(ercd); +} + +/* #[]# eOpener_simpleOpen + * name: eOpener_simpleOpen + * global_name: tSocketClient_eOpener_simpleOpen + * oneway: false + * #[]# */ +ER +eOpener_simpleOpen(CELLIDX idx, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* Put statements here #_TEFB_# */ + ercd = eOpener_open(idx, ATTR_serverAddr, ATTR_portNo, tmo); + + return(ercd); +} + +/* #[]# eOpener_close + * name: eOpener_close + * global_name: tSocketClient_eOpener_close + * oneway: false + * #[]# */ +ER +eOpener_close(CELLIDX idx, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + close( VAR_sd ); /* mikan エラー処理 */ + + return(ercd); +} + +/* #[]# + * Put non-entry functions below. + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tSocketServer.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tSocketServer.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tSocketServer.c (revision 18) @@ -0,0 +1,303 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tSocketServer.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 属性アクセスマクロ #_CAAM_# + * portNo int16_t ATTR_portNo + * sd int_t VAR_sd + * + * #[]# */ + +#include "tSocketServer_tecsgen.h" + +#include +#include +#include +#include +#include +#include +#include "errno2ER.h" + +#ifndef E_OK +#define E_OK 0 /* 正常終了 */ +#define E_ID (-18) /* 不正ID番号 */ +#endif + + +/* 受け口関数 #_TEPF_# */ +/* #[]# eC1 + * entry port: eC1 + * signature: sChannel + * context: task + * #[]# */ + +/* #[]# eC1_send + * name: eC1_send + * global_name: tSocketServer_eC1_send + * oneway: false + * #[]# */ +ER +eC1_send(CELLIDX idx, const int8_t* buf, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + int sz; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ +#ifdef DEBUG + syslog( LOG_INFO, "tSocketServer: send" ); + { + int i; + for( i = 0; i < size; i++ ){ + printf( "%02X ", (unsigned char)buf[i] ); + if( i % 8 == 7 ) + putchar( '\n' ); + } + putchar( '\n' ); + } +#endif + while(size>0){ + if((sz=write( VAR_sd, buf, (size_t)size )) < 0 ){ + ercd = errno2ER( errno ); + break; + } + else{ + size -= sz; + } + } + + return(ercd); +} + +/* #[]# eC1_flush + * name: eC1_flush + * global_name: tSocketServer_eC1_flush + * oneway: false + * #[]# */ +ER +eC1_flush(CELLIDX idx, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + + return(ercd); +} + +/* #[]# eC1_receive + * name: eC1_receive + * global_name: tSocketServer_eC1_receive + * oneway: false + * #[]# */ +ER_UINT +eC1_receive(CELLIDX idx, int8_t* buf, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + ER_UINT sz; + CELLCB *p_cellcb; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + if( (sz=read( VAR_sd, buf, (size_t)size )) < 0 ) + ercd = errno2ER( errno ); + else + ercd = sz; + + return(ercd); +} + +/* #[]# eC1_end_receive + * name: eC1_end_receive + * global_name: tSocketServer_eC1_end_receive + * oneway: false + * #[]# */ +ER +eC1_end_receive(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + + return(ercd); +} + +/* #[]# eC1_reset + * name: eC1_reset + * global_name: tSocketServer_eC1_reset + * oneway: false + * #[]# */ +ER +eC1_reset(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + syslog( LOG_INFO, "tSocketServer: reset" ); + + return(ercd); +} + +/* #[]# eOpener + * entry port: eOpener + * signature: sServerChannelOpener + * context: task + * #[]# */ + +/* #[]# eOpener_open + * name: eOpener_open + * global_name: tSocketServer_eOpener_open + * oneway: false + * #[]# */ +ER +eOpener_open(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + int ssoc, soc; + struct sockaddr_in addr={ AF_INET }; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + syslog( LOG_INFO, "tSocketServer: open" ); + + ssoc=socket(AF_INET,SOCK_STREAM,0); + if(ssoc<0){ + ercd = errno2ER( errno ); + syslog( LOG_INFO, "tSocketServer: socket failed" ); + return ercd; + } + + addr.sin_port = htons(ATTR_portNo); + addr.sin_addr.s_addr = INADDR_ANY; + if(bind(ssoc,(struct sockaddr*)&addr,sizeof(addr))<0){ + ercd = errno2ER( errno ); + syslog( LOG_INFO, "tSocketServer: bind failed" ); + return ercd; + } + + if(listen(ssoc, 1 )<0){ + ercd = errno2ER( errno ); + syslog( LOG_INFO, "tSocketServer: listen failed" ); + return ercd; + } + + soc=accept(ssoc, NULL, NULL); + if(soc<0){ + ercd = errno2ER( errno ); + syslog( LOG_INFO, "tSocketServer: accept failed" ); + return ercd; + } + syslog( LOG_INFO, "tSocketServer: accepted" ); + + close( ssoc ); + VAR_sd = soc; + + return(ercd); +} + +/* #[]# eOpener_close + * name: eOpener_close + * global_name: tSocketServer_eOpener_close + * oneway: false + * #[]# */ +ER +eOpener_close(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + syslog( LOG_INFO, "tSocketServer: close" ); + if( close( VAR_sd ) < 0 ) + ercd = errno2ER( errno ); + + return(ercd); +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTDR_inline.h =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTDR_inline.h (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTDR_inline.h (revision 18) @@ -0,0 +1,1228 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tTDR_inline.h 2032 2014-03-16 12:10:58Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 属性アクセスマクロ #_CAAM_# + * tmo TMO VAR_tmo + * + * #[]# */ + +/* + * marhaler, unmarshaler が使用する STRLEN 関数を定義する + * marshaler, unmarshaler は必ず TDR は に結合されるため + */ +#include "rpc_string.h" + +/* 受け口関数 #_TEPF_# */ +/* #[]# eTDR + * entry port: eTDR + * signature: sTDR + * context: task + * #[]# */ + +/* #[]# eTDR_reset + * name: eTDR_reset + * global_name: tTDR_eTDR_reset + * oneway: false + * #[]# */ +Inline ER +eTDR_reset(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + syslog( LOG_INFO, "TDR: resetting channel" ); + ercd = cChannel_reset(); + return(ercd); +} + +/* #[]# eTDR_sendSOP + * name: eTDR_sendSOP + * global_name: tTDR_eTDR_sendSOP + * oneway: false + * #[]# */ +Inline ER +eTDR_sendSOP(CELLIDX idx, bool_t b_client ) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + const uint16_t *p_sopMagic; + const uint16_t SOP_MAGIC1 = TDR_SOP_MAGIC1; + const uint16_t SOP_MAGIC2 = TDR_SOP_MAGIC2; + uint8_t val; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "eTDR_sendSOP(b_client=%d)", b_client); +#endif + if( b_client ) + p_sopMagic = &SOP_MAGIC1; + else + p_sopMagic = &SOP_MAGIC2; + + /* + * SOP パケットの送信 + * パケットシーケンスが多少崩れても回復できるように、バイト単位で送る + * 下位アドレス、上位アドレスの順に送る + */ + + val = (uint8_t)(*((uint8_t *)p_sopMagic)); + ercd = eTDR_putUInt8( idx, val ); + // syslog( LOG_INFO, "sendSOP:1 %02X", val ); + if( ercd != E_OK ) + return ercd; + val = (uint8_t)*(((uint8_t *)p_sopMagic)+1); + ercd = eTDR_putUInt8( idx, val ); + // syslog( LOG_INFO, "sendSOP:2 %02X", val ); + + return ercd; +} + +/* #[]# eTDR_receiveSOP + * name: eTDR_receiveSOP + * global_name: tTDR_eTDR_receiveSOP + * oneway: false + * #[]# */ +Inline ER +eTDR_receiveSOP(CELLIDX idx, bool_t b_client) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + const uint16_t SOP_MAGIC1 = TDR_SOP_MAGIC1; + const uint16_t SOP_MAGIC2 = TDR_SOP_MAGIC2; + const uint16_t *p_sopMagic; + uint16_t magic; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "eTDR_receiveSOP(b_client=%d)", b_client); +#endif + + if( b_client ) + p_sopMagic = &SOP_MAGIC2; + else + p_sopMagic = &SOP_MAGIC1; + + if( (ercd=eTDR_getUInt8( idx, (uint8_t *)&magic )) != E_OK ) + ; + else if( (uint8_t)magic != (uint8_t)(*((uint8_t *)p_sopMagic)) ){ + // syslog( LOG_INFO, "receiveSOP:1 %02X expecting=%02X", (uint8_t)magic, (int8_t)(*((int8_t *)p_sopMagic)) ); + ercd = E_MAGIC; + } + else if((ercd=eTDR_getUInt8( idx, ((uint8_t *)&magic)+1 )) != E_OK ) + ; + else if( magic != *p_sopMagic){ + // syslog( LOG_INFO, "receiveSOP:2 %04X expecting=%04X", magic, *p_sopMagic ); + ercd = E_MAGIC; + } + + if( ercd != E_OK ) + syslog( LOG_INFO, "receiveSOP: ERCD=%d", ercd ); + + return ercd; +} + +/* #[]# eTDR_sendEOP + * name: eTDR_sendEOP + * global_name: tTDR_eTDR_sendEOP + * oneway: false + * #[]# */ +Inline ER +eTDR_sendEOP(CELLIDX idx, bool_t b_continue ) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + uint16_t magic; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "eTDR_sendEOP(b_continue=%d)", b_continue); +#endif + + if( b_continue ) + magic = TDR_EOP_MAGIC1; + else + magic = TDR_EOP_MAGIC2; + + /* EOP magic の送信 */ + if( (ercd = eTDR_putInt16( idx, (int16_t)magic )) != E_OK ) + return ercd; + + return cChannel_flush(VAR_tmo); +} + +/* #[]# eTDR_receiveEOP + * name: eTDR_receiveEOP + * global_name: tTDR_eTDR_receiveEOP + * oneway: false + * #[]# */ +Inline ER +eTDR_receiveEOP(CELLIDX idx, bool_t b_continue) +{ + ER ercd = E_OK, er2; + CELLCB *p_cellcb; + uint16_t magic; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ +#ifdef RPC_DEBUG + syslog(LOG_INFO, "eTDR_receiveEOP(b_continue=%d)",b_continue); +#endif +/* mikan cChannel EOF get_* */ +/* mikan magic EOF */ + + if( (ercd=eTDR_getInt16( idx, (int16_t *)&magic )) == E_OK ){ + if( (b_continue && magic == TDR_EOP_MAGIC1) || (!b_continue && magic == TDR_EOP_MAGIC2) ){ + } else { + ercd = E_MAGIC; + } + } + er2 = cChannel_end_receive(); + return ercd != E_OK ? ercd : er2; +} + +/* #[]# eTDR_putInt8 + * name: eTDR_putInt8 + * global_name: tTDR_eTDR_putInt8 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt8(CELLIDX idx, int8_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putInt16 + * name: eTDR_putInt16 + * global_name: tTDR_eTDR_putInt16 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt16(CELLIDX idx, int16_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putInt32 + * name: eTDR_putInt32 + * global_name: tTDR_eTDR_putInt32 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt32(CELLIDX idx, int32_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putInt64 + * name: eTDR_putInt64 + * global_name: tTDR_eTDR_putInt64 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt64(CELLIDX idx, int64_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putInt128 + * name: eTDR_putInt128 + * global_name: tTDR_eTDR_putInt128 + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt128(CELLIDX idx, int128_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_getInt8 + * name: eTDR_getInt8 + * global_name: tTDR_eTDR_getInt8 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt8(CELLIDX idx, int8_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt16 + * name: eTDR_getInt16 + * global_name: tTDR_eTDR_getInt16 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt16(CELLIDX idx, int16_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt32 + * name: eTDR_getInt32 + * global_name: tTDR_eTDR_getInt32 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt32(CELLIDX idx, int32_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt64 + * name: eTDR_getInt64 + * global_name: tTDR_eTDR_getInt64 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt64(CELLIDX idx, int64_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt128 + * name: eTDR_getInt128 + * global_name: tTDR_eTDR_getInt128 + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt128(CELLIDX idx, int128_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putUInt8 + * name: eTDR_putUInt8 + * global_name: tTDR_eTDR_putUInt8 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt8(CELLIDX idx, uint8_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt16 + * name: eTDR_putUInt16 + * global_name: tTDR_eTDR_putUInt16 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt16(CELLIDX idx, uint16_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt32 + * name: eTDR_putUInt32 + * global_name: tTDR_eTDR_putUInt32 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt32(CELLIDX idx, uint32_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt64 + * name: eTDR_putUInt64 + * global_name: tTDR_eTDR_putUInt64 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt64(CELLIDX idx, uint64_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt128 + * name: eTDR_putUInt128 + * global_name: tTDR_eTDR_putUInt128 + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt128(CELLIDX idx, uint128_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_getUInt8 + * name: eTDR_getUInt8 + * global_name: tTDR_eTDR_getUInt8 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt8(CELLIDX idx, uint8_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt16 + * name: eTDR_getUInt16 + * global_name: tTDR_eTDR_getUInt16 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt16(CELLIDX idx, uint16_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt32 + * name: eTDR_getUInt32 + * global_name: tTDR_eTDR_getUInt32 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt32(CELLIDX idx, uint32_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt64 + * name: eTDR_getUInt64 + * global_name: tTDR_eTDR_getUInt64 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt64(CELLIDX idx, uint64_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt128 + * name: eTDR_getUInt128 + * global_name: tTDR_eTDR_getUInt128 + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt128(CELLIDX idx, uint128_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putBool + * name: eTDR_putBool + * global_name: tNBOTDR_eTDR_putBool + * oneway: false + * #[]# */ +Inline ER +eTDR_putBool(CELLIDX idx, bool_t in) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + eTDR_putUInt8(idx, (uint8_t)(in != 0) ); + + return(ercd); +} + +/* #[]# eTDR_getBool + * name: eTDR_getBool + * global_name: tNBOTDR_eTDR_getBool + * oneway: false + * #[]# */ +Inline ER +eTDR_getBool(CELLIDX idx, bool_t* out) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + uint8_t val; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + ercd = eTDR_getUInt8(idx, &val ); + if( ercd != E_OK ) + return ercd; + *out = (val != 0); + + return(ercd); +} + +/* #[]# eTDR_putFloat32 + * name: eTDR_putFloat32 + * global_name: tTDR_eTDR_putFloat32 + * oneway: false + * #[]# */ +Inline ER +eTDR_putFloat32(CELLIDX idx, float32_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putDouble64 + * name: eTDR_putDouble64 + * global_name: tTDR_eTDR_putDouble64 + * oneway: false + * #[]# */ +Inline ER +eTDR_putDouble64(CELLIDX idx, double64_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_getFloat32 + * name: eTDR_getFloat32 + * global_name: tTDR_eTDR_getFloat32 + * oneway: false + * #[]# */ +Inline ER +eTDR_getFloat32(CELLIDX idx, float32_t* out) +{ + ER_UINT er_sz = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getDouble64 + * name: eTDR_getDouble64 + * global_name: tTDR_eTDR_getDouble64 + * oneway: false + * #[]# */ +Inline ER +eTDR_getDouble64(CELLIDX idx, double64_t* out) +{ + ER_UINT er_sz = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putChar + * name: eTDR_putChar + * global_name: tTDR_eTDR_putChar + * oneway: false + * #[]# */ +Inline ER +eTDR_putChar(CELLIDX idx, char_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_getChar + * name: eTDR_getChar + * global_name: tTDR_eTDR_getChar + * oneway: false + * #[]# */ +Inline ER +eTDR_getChar(CELLIDX idx, char_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putSChar + * name: eTDR_putSChar + * global_name: tTDR_eTDR_putSChar + * oneway: false + * #[]# */ +Inline ER +eTDR_putSChar(CELLIDX idx, signed char in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putShort + * name: eTDR_putShort + * global_name: tTDR_eTDR_putShort + * oneway: false + * #[]# */ +Inline ER +eTDR_putShort(CELLIDX idx, short_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putInt + * name: eTDR_putInt + * global_name: tTDR_eTDR_putInt + * oneway: false + * #[]# */ +Inline ER +eTDR_putInt(CELLIDX idx, int_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putLong + * name: eTDR_putLong + * global_name: tTDR_eTDR_putLong + * oneway: false + * #[]# */ +Inline ER +eTDR_putLong(CELLIDX idx, long_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_getSChar + * name: eTDR_getSChar + * global_name: tTDR_eTDR_getSChar + * oneway: false + * #[]# */ +Inline ER +eTDR_getSChar(CELLIDX idx, signed char* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getShort + * name: eTDR_getShort + * global_name: tTDR_eTDR_getShort + * oneway: false + * #[]# */ +Inline ER +eTDR_getShort(CELLIDX idx, short* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getInt + * name: eTDR_getInt + * global_name: tTDR_eTDR_getInt + * oneway: false + * #[]# */ +Inline ER +eTDR_getInt(CELLIDX idx, int_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getLong + * name: eTDR_getLong + * global_name: tTDR_eTDR_getLong + * oneway: false + * #[]# */ +Inline ER +eTDR_getLong(CELLIDX idx, long_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putUChar + * name: eTDR_putUChar + * global_name: tTDR_eTDR_putUChar + * oneway: false + * #[]# */ +Inline ER +eTDR_putUChar(CELLIDX idx, unsigned char in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUShort + * name: eTDR_putUShort + * global_name: tTDR_eTDR_putUShort + * oneway: false + * #[]# */ +Inline ER +eTDR_putUShort(CELLIDX idx, ushort_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putUInt + * name: eTDR_putUInt + * global_name: tTDR_eTDR_putUInt + * oneway: false + * #[]# */ +Inline ER +eTDR_putUInt(CELLIDX idx, uint_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_putULong + * name: eTDR_putULong + * global_name: tTDR_eTDR_putULong + * oneway: false + * #[]# */ +Inline ER +eTDR_putULong(CELLIDX idx, ulong_t in) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo ); +} + +/* #[]# eTDR_getUChar + * name: eTDR_getUChar + * global_name: tTDR_eTDR_getUChar + * oneway: false + * #[]# */ +Inline ER +eTDR_getUChar(CELLIDX idx, unsigned char* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUShort + * name: eTDR_getUShort + * global_name: tTDR_eTDR_getUShort + * oneway: false + * #[]# */ +Inline ER +eTDR_getUShort(CELLIDX idx, unsigned short* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getUInt + * name: eTDR_getUInt + * global_name: tTDR_eTDR_getUInt + * oneway: false + * #[]# */ +Inline ER +eTDR_getUInt(CELLIDX idx, uint_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_getULong + * name: eTDR_getULong + * global_name: tTDR_eTDR_getULong + * oneway: false + * #[]# */ +Inline ER +eTDR_getULong(CELLIDX idx, ulong_t* out) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } /* end if VALID_IDX(idx) */ + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR ); +} + +/* #[]# eTDR_putIntptr + * name: eTDR_putIntptr + * global_name: tTDR_eTDR_putIntptr + * oneway: false + * #[]# */ +Inline ER +eTDR_putIntptr(CELLIDX idx, const intptr_t ptr) +{ + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + return cChannel_send( (int8_t *)&ptr, (int16_t)sizeof( ptr ), VAR_tmo ); +} + +/* #[]# eTDR_getIntptr + * name: eTDR_getIntptr + * global_name: tTDR_eTDR_getIntptr + * oneway: false + * #[]# */ +Inline ER +eTDR_getIntptr(CELLIDX idx, intptr_t* ptr) +{ + ER_UINT er_sz; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + er_sz = cChannel_receive( (int8_t *)ptr, (int16_t)sizeof( *ptr ), VAR_tmo ); + return er_sz < 0 ? er_sz : ( er_sz == sizeof( *ptr ) ? E_OK : E_BOVR ); +} + + Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTINETChannel.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTINETChannel.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTINETChannel.cdl (revision 18) @@ -0,0 +1,110 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tTINETChannel.cdl 2640 2017-06-03 11:27:12Z okuma-top $ + */ + +import_C( "netinet/in.h" ); + +const uint16_t TINETIPV4_DEFAULT_PORT_NO = 8931; + +signature sTINETClientOpenerIPV4 { + ER open( [in]const T_IPV4EP *clientAddr, [in]TMO tmo ); + ER close( [in]TMO tmo ); +}; + +signature sIPV4AcceptCheck { + bool_t check( [in]const T_IPV4EP *clientAddr ); +}; + +celltype tTINETClient { + entry sChannel eC0; + entry sTINETClientOpenerIPV4 eOpener; + attr { + ID cep_id = C_EXP( "$id$_CEPID" ); + [omit] + uint16_t recv_buf_size = C_EXP( "TCP_MSS" ); + [omit] + uint16_t send_buf_size = C_EXP( "TCP_MSS" ); + }; + FACTORY { + write( "$ct$_factory.h", "#include \"netinet/tcp.h\"\n" ); + write( "$ct$_tecsgen.h", "#include \"tinet_cfg.h\"\n" ); + write( "tinet_tecsgen.cfg", "#include \"$ct$_factory.h\"\n" ); + }; + factory { + write( "$ct$_factory.h", "int8_t $id$_recv_buf[%s];\n", recv_buf_size ); + write( "$ct$_factory.h", "int8_t $id$_send_buf[%s];\n", send_buf_size ); + write( "tinet_tecsgen.cfg", "TCP_CRE_CEP ($id$_CEPID, {\n" + " 0,\n" + " $id$_send_buf,\n" + " %s,\n" + " $id$_recv_buf,\n" + " %s,\n" + " NULL \n" + " } );\n", + send_buf_size, recv_buf_size ); + }; +}; + +celltype tTINETServer { + + entry sChannel eC1; + entry sServerChannelOpener eOpener; + [optional] + call sIPV4AcceptCheck cCheck; + attr { + ID cep_id = C_EXP( "$id$_CEPID" ); + ID rep_id = C_EXP( "$id$_REPID" ); + [omit] + int16_t portNo = TINETIPV4_DEFAULT_PORT_NO; + [omit] + uint16_t recv_buf_size = C_EXP( "TCP_MSS" ); + [omit] + uint16_t send_buf_size = C_EXP( "TCP_MSS" ); + }; + FACTORY { + write( "$ct$_factory.h", "#include \"netinet/tcp.h\"\n" ); + write( "$ct$_tecsgen.h", "#include \"tinet_cfg.h\"\n" ); + write( "tinet_tecsgen.cfg", "#include \"$ct$_factory.h\"\n" ); + }; + factory { + write( "$ct$_factory.h", "int8_t $id$_recv_buf[%s];\n", recv_buf_size ); + write( "$ct$_factory.h", "int8_t $id$_send_buf[%s];\n", send_buf_size ); + write( "tinet_tecsgen.cfg", "TCP_CRE_REP ($id$_REPID, { 0, { IPV4_ADDRANY, %s } } );\n", portNo ); + write( "tinet_tecsgen.cfg", "TCP_CRE_CEP ($id$_CEPID, {0, $id$_send_buf, %s, $id$_recv_buf, %s, NULL } );\n", + send_buf_size, recv_buf_size ); + }; +}; Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTINETClient.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTINETClient.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTINETClient.c (revision 18) @@ -0,0 +1,264 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tTINETClient.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 属性アクセスマクロ #_CAAM_# + * cep_id ID ATTR_cep_id + * + * #[]# */ + +#include "tTINETClient_tecsgen.h" +#include "tTINETClient_factory.h" + +#include + +#include +#include +#include + +#ifndef E_OK +#define E_OK 0 /* 正常終了 */ +#define E_ID (-18) /* 不正ID番号 */ +#endif + +/* 受け口関数 #_TEPF_# */ +/* #[]# eC0 + * entry port: eC0 + * signature: sChannel + * context: task + * #[]# */ + +/* #[]# eC0_send + * name: eC0_send + * global_name: tTINETClient_eC0_send + * oneway: false + * #[]# */ +ER +eC0_send(CELLIDX idx, const int8_t* buf, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + int sz; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ +#ifdef DEBUG + syslog( LOG_INFO, "tTINETServer: send" ); + { + int i; + for( i = 0; i < size; i++ ){ + printf( "%02X ", (unsigned char)buf[i] ); + if( i % 8 == 7 ) + putchar( '\n' ); + } + putchar( '\n' ); + } +#endif + while(size>0){ + if((sz=tcp_snd_dat( ATTR_cep_id, (intptr_t *)buf, (size_t)size, tmo )) < 0 ){ + ercd = sz; + break; + } + else{ + size -= sz; + } + } + + return(ercd); +} + +/* #[]# eC0_flush + * name: eC0_flush + * global_name: tTINETClient_eC0_flush + * oneway: false + * #[]# */ +ER +eC0_flush(CELLIDX idx, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + /* write はバッファリングなしなので flush しない */ + + return(ercd); +} + +/* #[]# eC0_receive + * name: eC0_receive + * global_name: tTINETClient_eC0_receive + * oneway: false + * #[]# */ +ER_UINT +eC0_receive(CELLIDX idx, int8_t* buf, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + ercd = tcp_rcv_dat( ATTR_cep_id, buf, (size_t)size, tmo ); + + return(ercd); +} + +/* #[]# eC0_end_receive + * name: eC0_end_receive + * global_name: tTINETClient_eC0_end_receive + * oneway: false + * #[]# */ +ER +eC0_end_receive(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + + return(ercd); +} + +/* #[]# eC0_reset + * name: eC0_reset + * global_name: tTINETClient_eC0_reset + * oneway: false + * #[]# */ +ER +eC0_reset(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + + return(ercd); +} + +/* #[]# eOpener + * entry port: eOpener + * signature: sTINETClientOpenerIPV4 + * context: task + * #[]# */ + +/* #[]# eOpener_open + * name: eOpener_open + * global_name: tTINETClient_eOpener_open + * oneway: false + * #[]# */ +ER +eOpener_open(CELLIDX idx, const T_IPV4EP* clientAddr, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + puts("opening"); + ercd=tcp_con_cep(ATTR_cep_id, NADR, clientAddr, tmo); + if(ercd<0){ + puts("failed"); + syslog( LOG_INFO, "TINETClient: connect failed"); + } + + return(ercd); +} + +/* #[]# eOpener_close + * name: eOpener_close + * global_name: tTINETClient_eOpener_close + * oneway: false + * #[]# */ +ER +eOpener_close(CELLIDX idx, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + ercd = tcp_cls_cep( ATTR_cep_id, 0 ); /* mikan エラー処理 */ + + return(ercd); +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTINETServer.c =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTINETServer.c (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tTINETServer.c (revision 18) @@ -0,0 +1,275 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tTINETServer.c 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +/* #[]# + * #[<...>]# から #[]# で囲まれたコメントは編集しないでください + * tecsmerge によるマージに使用されます + * + * 属性アクセスマクロ #_CAAM_# + * cep_id ID ATTR_cep_id + * rep_id ID ATTR_rep_id + * + * 呼び口関数 #_TCPF_# + * call port : cCheck signature: sIPV4AcceptCheck context: task + * bool_t cCheck_check( const T_IPV4EP* clientAddr ); + * + * #[]# */ + +#include "tTINETServer_tecsgen.h" +#include "tTINETServer_factory.h" + +#include + +#include +#include +#include + + +#ifndef E_OK +#define E_OK 0 /* 正常終了 */ +#define E_ID (-18) /* 不正ID番号 */ +#endif + +/* 受け口関数 #_TEPF_# */ +/* #[]# eC1 + * entry port: eC1 + * signature: sChannel + * context: task + * #[]# */ + +/* #[]# eC1_send + * name: eC1_send + * global_name: tTINETServer_eC1_send + * oneway: false + * #[]# */ +ER +eC1_send(CELLIDX idx, const int8_t* buf, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + int sz; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ +#ifdef DEBUG + syslog( LOG_INFO, "tTINETServer: send" ); + { + int i; + for( i = 0; i < size; i++ ){ + printf( "%02X ", (unsigned char)buf[i] ); + if( i % 8 == 7 ) + putchar( '\n' ); + } + putchar( '\n' ); + } +#endif + while(size>0){ + if((sz=tcp_snd_dat( ATTR_cep_id, buf, (size_t)size, tmo )) < 0 ){ + ercd = sz; + break; + } + else{ + size -= sz; + } + } + + return(ercd); +} + +/* #[]# eC1_flush + * name: eC1_flush + * global_name: tTINETServer_eC1_flush + * oneway: false + * #[]# */ +ER +eC1_flush(CELLIDX idx, TMO tmo) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + + return(ercd); +} + +/* #[]# eC1_receive + * name: eC1_receive + * global_name: tTINETServer_eC1_receive + * oneway: false + * #[]# */ +ER_UINT +eC1_receive(CELLIDX idx, int8_t* buf, int16_t size, TMO tmo) +{ + ER ercd = E_OK; + ER_UINT sz; + CELLCB *p_cellcb; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + ercd = tcp_rcv_dat( ATTR_cep_id, buf, (size_t)size, tmo ); + + return(ercd); +} + +/* #[]# eC1_end_receive + * name: eC1_end_receive + * global_name: tTINETServer_eC1_end_receive + * oneway: false + * #[]# */ +ER +eC1_end_receive(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + + return(ercd); +} + +/* #[]# eC1_reset + * name: eC1_reset + * global_name: tTINETServer_eC1_reset + * oneway: false + * #[]# */ +ER +eC1_reset(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します */ + syslog( LOG_INFO, "tTINETServer: reset" ); + + return(ercd); +} + +/* #[]# eOpener + * entry port: eOpener + * signature: sServerChannelOpener + * context: task + * #[]# */ + +/* #[]# eOpener_open + * name: eOpener_open + * global_name: tTINETServer_eOpener_open + * oneway: false + * #[]# */ +ER +eOpener_open(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + T_IPV4EP dst; + + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + syslog( LOG_INFO, "tTINETServer: open" ); + if( (ercd=tcp_acp_cep(ATTR_cep_id, ATTR_rep_id, &dst, TMO_FEVR)) != E_OK ){ + syslog( LOG_INFO, "tTINETServer: accept failed" ); + return ercd; + } + + syslog( LOG_INFO, "tTINETServer: accepted" ); + + return(ercd); +} + +/* #[]# eOpener_close + * name: eOpener_close + * global_name: tTINETServer_eOpener_close + * oneway: false + * #[]# */ +ER +eOpener_close(CELLIDX idx) +{ + ER ercd = E_OK; + CELLCB *p_cellcb; + if (VALID_IDX(idx)) { + p_cellcb = GET_CELLCB(idx); + } + else { + return(E_ID); + } + + /* ここに処理本体を記述します #_TEFB_# */ + syslog( LOG_INFO, "tTINETServer: close" ); + ercd = tcp_cls_cep( ATTR_cep_id, TMO_FEVR ); + + return(ercd); +} + +/* #[]# + * これより下に非受け口関数を書きます + * #[]#*/ Index: /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tecs_rpc.h =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tecs_rpc.h (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/rpc/tecs_rpc.h (revision 18) @@ -0,0 +1,65 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tecs_rpc.h 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +#ifndef tecs_rpc_h__ +#define tecs_rpc_h__ + +#include "tecs.h" + +#ifndef E_RPC + +#define E_RPC (-68) + +/* minor error code */ +#define E_RESET (-101) +#define E_MAGIC (-102) + +#endif /* E_RPC */ + + +/* + * marshaler, unmarshaler 内の状態値を設定するマクロ + * val は sRPCErrorHandler.cdl で定義する + */ +#if ! defined( NO_NEED_RPC_STATE ) && ! defined( NO_NEED_RPC_ERROR_HANDLER ) +#define SET_RPC_STATE( state, val ) (state)=(val) +#else +#define SET_RPC_STATE( state, val ) +#endif /* NO_NEED_RPC_STATE */ + +#endif /* tecs_rpc_h__ */ Index: /toppers/tecsgen/trunk/tecsgen/tecs/sMalloc.cdl =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/sMalloc.cdl (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/sMalloc.cdl (revision 18) @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2012 by Ubiquitous Computing and Networking Laboratory + * Ritsumeikan Univ., JAPAN + * 上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * @(#) $Id: sMalloc.cdl 2640 2017-06-03 11:27:12Z okuma-top $ + */ + +import_C( "t_stddef.h" ); + +[deviate] +signature sMalloc { + int initializeMemoryPool(void); + void *calloc( [in]size_t nelem, [in]size_t elem_size ); + void *malloc( [in]size_t size ); + void *realloc( [in]const void *ptr, [in]size_t new_size ); + void free( [in]const void *ptr ); +}; + Index: /toppers/tecsgen/trunk/tecsgen/tecs/tecs.h =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/tecs.h (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/tecs.h (revision 18) @@ -0,0 +1,64 @@ +/* + * TECS Generator + * Generator for TOPPERS Embedded Component System + * + * Copyright (C) 2008-2013 by TOPPERS Project + *-- + * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ + * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改 + * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する． + * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作 + * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー + * スコード中に含まれていること． + * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使 + * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用 + * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記 + * の無保証規定を掲載すること． + * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使 + * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ + * と． + * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著 + * 作権表示，この利用条件および下記の無保証規定を掲載すること． + * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに + * 報告すること． + * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損 + * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること． + * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理 + * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを + * 免責すること． + * + * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お + * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的 + * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ + * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ + * の責任を負わない． + * + * $Id: tecs.h 2027 2014-01-20 08:36:17Z okuma-top $ + */ + +#ifndef tecs_h__ +#define tecs_h__ + +#include "t_stddef.h" + +#ifndef INT128_DEFINED +#define INT128_DEFINED +typedef struct tag_int128_t { int64_t hi; int64_t lo; } int128_t; +typedef struct tag_uint128_t { int64_t hi; int64_t lo; } uint128_t; +#endif /* end INT128_T_DEFINED */ + +#ifndef SHORT_T_DEFINED +#define SHORT_T_DEFINED +typedef short short_t; +typedef unsigned short ushort_t; +#endif /* end SHORT_T_DEFINED */ + +#ifndef CHAR_T_DEFINED /* t_stddef.h ASP 1.7.0 以前では重複する */ +#define CHAR_T_DEFINED +typedef char char_t; /* signed, unsigned 未定 */ +#endif /* end CHAR_T_DEFINED */ + +typedef signed char schar_t; /* signed */ +typedef unsigned char uchar_t; /* unsigned */ + +#endif /* end tecs_h__ */ Index: /toppers/tecsgen/trunk/tecsgen/tecs/tecs.xsd =================================================================== --- /toppers/tecsgen/trunk/tecsgen/tecs/tecs.xsd (revision 18) +++ /toppers/tecsgen/trunk/tecsgen/tecs/tecs.xsd (revision 18) @@ -0,0 +1,191 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +