source: asp3_tinet_ecnl_rx/trunk/asp3_dcre/tecsgen/tecs/rpc/tNBOTDR_inline.h@ 337

Last change on this file since 337 was 337, checked in by coas-nagasima, 6 years ago

ASP3版ECNLを追加
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-chdr;charset=UTF-8
File size: 39.3 KB
Line 
1/*
2 * TECS Generator
3 * Generator for TOPPERS Embedded Component System
4 *
5 * Copyright (C) 2008-2013 by TOPPERS Project
6 *--
7 * 上記著作権者は，以下の(1)(4)の条件を満たす場合に限り，本ソフトウェ
8 * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
9 * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
10 * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
11 * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー
12 * スコード中に含まれていること．
13 * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
14 * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用
15 * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記
16 * の無保証規定を掲載すること．
17 * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
18 * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ
19 * と．
20 * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
21 * 作権表示，この利用条件および下記の無保証規定を掲載すること．
22 * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
23 * 報告すること．
24 * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
25 * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
26 * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
27 * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
28 * 免責すること．
29 *
30 * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お
31 * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
32 * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
33 * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
34 * の責任を負わない．
35 *
36 * $Id$
37 */
38
39/* #[<PREAMBLE>]#
40 * #[<...>]# から #[</...>]# で囲まれたコメントは編集しないでください
41 * tecsmerge によるマージに使用されます
42 *
43 * 属性アクセスマクロ #_CAAM_#
44 * tmo TMO VAR_tmo
45 *
46 * 呼び口関数 #_TCPF_#
47 * call port: cChannel signature: sChannel context:task
48 * ER cChannel_send( const int8_t* buf, int16_t size, TMO tmo );
49 * ER cChannel_flush( TMO tmo );
50 * ER_UINT cChannel_receive( int8_t* buf, int16_t size, TMO tmo );
51 * ER cChannel_end_receive( );
52 * ER cChannel_reset( );
53 * require port: signature:sSysLog context:task
54 * ER write( uint_t prio, const SYSLOG* p_syslog );
55 * ER_UINT read( SYSLOG* p_syslog );
56 * ER mask( uint_t logmask, uint_t lowmask );
57 * ER refer( T_SYSLOG_RLOG* pk_rlog );
58 *
59 * #[</PREAMBLE>]# */
60
61/*
62 * marhaler, unmarshaler が使用する STRLEN 関数を定義する
63 * marshaler, unmarshaler は必ず TDR は に結合されるため
64 */
65#include "rpc_string.h"
66
67/*
68 * Network Byte Order TECS Data Representation
69 *
70 * NBOTDR is one of sTDR implementation and is default TDR for OpaqueRPC.
71 * NBOTDR always sends and receives data in Big Endian (Network Byte Order).
72 * So NBOTDR is useful with distributed hybrid systems.
73 */
74
75/*
76 * Macro Symbols:
77 * 1) endian
78 * NBOTDR_BIGENDIAN
79 * NBOTDR_LITTLEENDIAN
80 * if these macros are not specified, endian is automatically decided.
81 * 2) size of each type in bits.
82 * NBOTDR_LONG_BIT (32)
83 * NBOTDR_SHORT_BIT (16)
84 * NBOTDR_INT_BIT (32)
85 * NBOTDR_INTPTR_BIT (32)
86 * default value in parenthesises
87 * normally use default value
88 */
89
90/*
91 * 無調整型だが、いくらか暫定的な実装になっている
92 * ・ntohX(), htonX() は int64_t 型に定義されている (32bitならオーバヘッド大)
93 * ・int128_t, uint128_t は tecs.h で typedef された型である
94 * ・BIGENDIAN 判定は動的になっている (恐らく最適化で定数判定にされることはない)
95 */
96
97#if defined( NBOTDR_BIGENDIAN )
98#define IS_BIGENDIAN() (1)
99# if defined( NBOTDR_LITTLEENDIAN )
100# error "Don't specify both NBOTDR_LITTLEENDIAN and NBOTDR_BIGENDIAN"
101# endif
102#elif defined( NBOTDR_LITTLEENDIAN )
103#define IS_BIGENDIAN() (0)
104#else
105/* BIGENDIAN かどうか自動判定 */
106static const uint16_t endian_check = 0xff00;
107#define IS_BIGENDIAN() (*(uint8_t *)&endian_check)
108#warning "it is better to specify -D NBOTDR_BIGENDIAN or -D NBOTDR_LITTLEENDIAN"
109#endif
110
111#if ! defined( NBOTDR_LONG_BIT )
112#define NBOTDR_LONG_BIT 32
113#endif
114#if NBOTDR_LONG_BIT == 32
115# define NTOHL( d, sz ) ntoh32( d )
116# define HTONL( d, sz ) hton32( d )
117typedef int32_t TDR_LONG;
118typedef uint32_t TDR_ULONG;
119#elif NBOTDR_LONG_BIT == 64
120# define NTOHL( d, sz ) ntoh64( d )
121# define HTONL( d, sz ) hton64( d )
122typedef int64_t TDR_LONG;
123typedef uint64_t TDR_ULONG;
124#elif NBOTDR_LONG_BIT == 128
125# define NTOHL( d, sz ) ntoh128( d )
126# define HTONL( d, sz ) hton128( d )
127typedef int128_t TDR_LONG;
128typedef uint128_t TDR_ULONG;
129#elif ! defined( NBOTDR_LONG_BIT )
130# define NTOHL ntohX
131# define HTONL htonX
132# warning "it is better to specify -D NBOTDR_LONG_BIT=N N: 32, 64, 128"
133#else
134# error "NBOTDR_LONG_BIT must be 32, 64 or 128"
135#endif
136
137#if ! defined( NBOTDR_SHORT_BIT )
138#define NBOTDR_SHORT_BIT 16
139#endif
140#if NBOTDR_SHORT_BIT == 16
141# define NTOHS( d, sz ) ntoh16( d )
142# define HTONS( d, sz ) hton16( d )
143typedef int16_t TDR_SHORT;
144typedef uint16_t TDR_USHORT;
145#elif NBOTDR_SHORT_BIT == 32
146# define NTOHS( d, sz ) ntoh32( d )
147# define HTONS( d, sz ) hton32( d )
148typedef int32_t TDR_SHORT;
149typedef uint32_t TDR_USHORT;
150#elif NBOTDR_SHORT_BIT == 64
151# define NTOHS( d, sz ) ntoh64( d )
152# define HTONS( d, sz ) hton64( d )
153typedef int64_t TDR_SHORT;
154typedef uint64_t TDR_USHORT;
155#elif ! defined( NBOTDR_SHORT_BIT )
156# define NTOHS( d, sz ) ntohX( d, sz )
157# define HTONS( d, sz ) htonX( d, sz )
158# warning "it is better to specify -D NBOTDR_SHORT_BIT=N N: 16, 32, 64"
159#else
160# error "NBOTDR_SHORT_BIT must be 16, 32 or 64"
161#endif
162
163#if ! defined( NBOTDR_INT_BIT )
164#define NBOTDR_INT_BIT 32
165#endif
166#if NBOTDR_INT_BIT == 16
167# define NTOHI( d, sz ) ntoh16( d )
168# define HTONI( d, sz ) hton16( d )
169typedef int16_t TDR_INT;
170typedef uint16_t TDR_UINT;
171#elif NBOTDR_INT_BIT == 32
172# define NTOHI( d, sz ) ntoh32( d )
173# define HTONI( d, sz ) hton32( d )
174typedef int32_t TDR_INT;
175typedef uint32_t TDR_UINT;
176#elif NBOTDR_INT_BIT == 64
177# define NTOHI( d, sz ) ntoh64( d )
178# define HTONI( d, sz ) hton64( d )
179typedef int64_t TDR_INT;
180typedef uint64_t TDR_UINT;
181#elif NBOTDR_INT_BIT == 128
182# define NTOHI( d, sz ) ntoh128( d )
183# define HTONI( d, sz ) hton128( d )
184typedef int128_t TDR_INT;
185typedef uint128_t TDR_UINT;
186#elif ! defined( NBOTDR_INT_BIT )
187# define NTOHI( d, sz ) ntohX( d, sz )
188# define HTONI( d, sz ) htonX( d, sz )
189# warning "it is better to specify -D NBOTDR_INT_BIT=N N: 16, 32, 64, 128"
190#else
191# error "NBOTDR_INT_BIT must be 16, 32, 64 or 128"
192#endif
193
194#if ! defined( NBOTDR_INTPTR_BIT )
195#define NBOTDR_INTPTR_BIT 32
196#endif
197#if NBOTDR_INTPTR_BIT == 16
198# define NTOHIP( d, sz ) ntoh16( d )
199# define HTONIP( d, sz ) hton16( d )
200typedef int16_t TDR_INTPTR;
201#elif NBOTDR_INTPTR_BIT == 32
202# define NTOHIP( d, sz ) ntoh32( d )
203# define HTONIP( d, sz ) hton32( d )
204typedef int32_t TDR_INTPTR;
205#elif NBOTDR_INTPTR_BIT == 64
206# define NTOHIP( d, sz ) ntoh64( d )
207# define HTONIP( d, sz ) hton64( d )
208typedef int64_t TDR_INTPTR;
209#elif NBOTDR_INTPTR_BIT == 128
210# define NTOHIP( d, sz ) ntoh128( d )
211# define HTONIP( d, sz ) hton128( d )
212typedef int128_t TDR_INTPTR;
213#elif ! defined( NBOTDR_INTPTR_BIT )
214# define NTOHIP( d, sz ) ntohX( d, sz )
215# define HTONIP( d, sz ) htonX( d, sz )
216# warning "it is better to specify -D NBOTDR_INTPTR_BIT=N N: 16, 32, 64, 128"
217#else
218# error "NBOTDR_INTPTR_BIT must be 16, 32, 64 or 128 "
219#endif
220
221Inline int16_t
222hton16( int16_t d )
223{
224 if( IS_BIGENDIAN() )
225 return d; // big endian
226 else{
227 union {
228 int8_t by[2];
229 int16_t d;
230 } d0, d1;
231 // syslog( LOG_INFO, "### little endian ###" );
232 d0.d = d;
233 d1.by[0] = d0.by[1];
234 d1.by[1] = d0.by[0];
235 return d1.d;
236 }
237}
238
239Inline int32_t
240hton32( int32_t d )
241{
242 if( IS_BIGENDIAN() )
243 return d;
244 else{
245 union {
246 int8_t by[4];
247 int32_t d;
248 } d0, d1;
249 d0.d = d;
250 d1.by[0] = d0.by[3];
251 d1.by[1] = d0.by[2];
252 d1.by[2] = d0.by[1];
253 d1.by[3] = d0.by[0];
254 return d1.d;
255 }
256}
257
258Inline int64_t
259hton64( int64_t d )
260{
261 if( IS_BIGENDIAN() )
262 return d;
263 else{
264 union {
265 int8_t by[8];
266 int64_t d;
267 } d0, d1;
268 d0.d = d;
269 d1.by[0] = d0.by[7];
270 d1.by[1] = d0.by[6];
271 d1.by[2] = d0.by[5];
272 d1.by[3] = d0.by[4];
273 d1.by[4] = d0.by[3];
274 d1.by[5] = d0.by[2];
275 d1.by[6] = d0.by[1];
276 d1.by[7] = d0.by[0];
277 return d1.d;
278 }
279}
280
281Inline int128_t
282hton128( int128_t d )
283{
284 if( IS_BIGENDIAN() )
285 return d;
286 else{
287 /* この実装は tecs.h で typedef した int128_t に適合 */
288 int128_t d1;
289 d1.hi = hton64( d.lo );
290 d1.lo = hton64( d.hi );
291 return d1;
292 }
293}
294
295Inline int16_t
296ntoh16( int16_t d )
297{
298 if( IS_BIGENDIAN() )
299 return d;
300 else{
301 union {
302 int8_t by[2];
303 int16_t d;
304 } d0, d1;
305 d0.d = d;
306 d1.by[0] = d0.by[1];
307 d1.by[1] = d0.by[0];
308 return d1.d;
309 }
310}
311
312Inline int32_t
313ntoh32( int32_t d )
314{
315 if( IS_BIGENDIAN() )
316 return d;
317 else{
318 union {
319 int8_t by[4];
320 int32_t d;
321 } d0, d1;
322 d0.d = d;
323 d1.by[0] = d0.by[3];
324 d1.by[1] = d0.by[2];
325 d1.by[2] = d0.by[1];
326 d1.by[3] = d0.by[0];
327 return d1.d;
328 }
329}
330
331Inline int64_t
332ntoh64( int64_t d )
333{
334 if( IS_BIGENDIAN() )
335 return d;
336 else{
337 union {
338 int8_t by[8];
339 int64_t d;
340 } d0, d1;
341 d0.d = d;
342 d1.by[0] = d0.by[7];
343 d1.by[1] = d0.by[6];
344 d1.by[2] = d0.by[5];
345 d1.by[3] = d0.by[4];
346 d1.by[4] = d0.by[3];
347 d1.by[5] = d0.by[2];
348 d1.by[6] = d0.by[1];
349 d1.by[7] = d0.by[0];
350 return d1.d;
351 }
352}
353
354/*** unsigned 用の関数 (128 bit 版のみ用意) ***/
355Inline int128_t
356ntoh128( int128_t d )
357{
358 if( IS_BIGENDIAN() )
359 return d;
360 else{
361 /* この実装は tecs.h で typedef した int128_t に適合 */
362 int128_t d1;
363 d1.hi = ntoh64( d.lo );
364 d1.lo = ntoh64( d.hi );
365 return d1;
366 }
367}
368
369Inline uint128_t
370hton128u( uint128_t d )
371{
372 if( IS_BIGENDIAN() )
373 return d;
374 else{
375 /* この実装は tecs.h で typedef した int128_t に適合 */
376 uint128_t d1;
377 d1.hi = hton64( d.lo );
378 d1.lo = hton64( d.hi );
379 return d1;
380 }
381}
382
383Inline uint128_t
384ntoh128u( uint128_t d )
385{
386 if( IS_BIGENDIAN() )
387 return d;
388 else{
389 /* この実装は tecs.h で typedef した int128_t に適合 */
390 uint128_t d1;
391 d1.hi = ntoh64( d.lo );
392 d1.lo = ntoh64( d.hi );
393 return d1;
394 }
395}
396
397/************************************************
398 * htonX, ntohX は 16, 32, 64 にのみ対応できる *
399 ************************************************/
400Inline int64_t
401htonX( int64_t d, int_t sz )
402{
403 switch( sz ){
404 case 2: return hton16( d );
405 case 4: return hton32( d );
406 case 8: return hton64( d );
407 default: return 0; // # mikan
408 };
409}
410
411Inline int64_t
412ntohX( int64_t d, int_t sz )
413{
414 switch( sz ){
415 case 2: return ntoh16( d );
416 case 4: return ntoh32( d );
417 case 8: return ntoh64( d );
418 default: return 0; // # mikan
419 };
420}
421
422/* 受け口関数 #_TEPF_# */
423/* #[<ENTRY_PORT>]# eTDR
424 * entry port: eTDR
425 * signature: sTDR
426 * context: task
427 * #[</ENTRY_PORT>]# */
428
429/* #[<ENTRY_FUNC>]# eTDR_reset
430 * name: eTDR_reset
431 * global_name: tNBOTDR_eTDR_reset
432 * oneway: false
433 * #[</ENTRY_FUNC>]# */
434Inline ER
435eTDR_reset(CELLIDX idx)
436{
437 ER ercd = E_OK;
438 CELLCB *p_cellcb;
439 if (VALID_IDX(idx)) {
440 p_cellcb = GET_CELLCB(idx);
441 }
442 else {
443 return(E_ID);
444 }
445
446 /* ここに処理本体を記述します #_TEFB_# */
447
448 syslog( LOG_INFO, "TDR: resetting channel" );
449 ercd = cChannel_reset();
450 return(ercd);
451}
452
453/* #[<ENTRY_FUNC>]# eTDR_sendSOP
454 * name: eTDR_sendSOP
455 * global_name: tNBOTDR_eTDR_sendSOP
456 * oneway: false
457 * #[</ENTRY_FUNC>]# */
458Inline ER
459eTDR_sendSOP(CELLIDX idx, bool_t b_client )
460{
461 ER ercd = E_OK;
462 CELLCB *p_cellcb;
463 uint16_t sopMagic;
464 uint8_t val;
465 if (VALID_IDX(idx)) {
466 p_cellcb = GET_CELLCB(idx);
467 }
468 else {
469 return(E_ID);
470 }
471
472 /* ここに処理本体を記述します #_TEFB_# */
473#ifdef RPC_DEBUG
474 syslog(LOG_INFO, "eTDR_sendSOP(b_client=%d)", b_client);
475#endif
476 if( b_client )
477 sopMagic = TDR_SOP_MAGIC1;
478 else
479 sopMagic = TDR_SOP_MAGIC2;
480
481 /*
482 * SOP パケットの送信
483 * パケットシーケンスが多少崩れても回復できるように、バイト単位で送る
484 * 上位バイト、下位バイトの順に送る
485 */
486
487 val = (uint8_t)(sopMagic>>8);
488 ercd = eTDR_putUInt8( idx, val ); /* 上位8ビット */
489 if( ercd != E_OK )
490 return ercd;
491
492 val = (uint8_t)(sopMagic&0xff); /* 下位8ビット */
493 ercd = eTDR_putUInt8( idx, val );
494
495 return ercd;
496}
497
498/* #[<ENTRY_FUNC>]# eTDR_receiveSOP
499 * name: eTDR_receiveSOP
500 * global_name: tNBOTDR_eTDR_receiveSOP
501 * oneway: false
502 * #[</ENTRY_FUNC>]# */
503Inline ER
504eTDR_receiveSOP(CELLIDX idx, bool_t b_client )
505{
506 ER ercd = E_OK;
507 CELLCB *p_cellcb;
508 uint16_t sopMagic;
509 uint8_t val;
510
511 if (VALID_IDX(idx)) {
512 p_cellcb = GET_CELLCB(idx);
513 }
514 else {
515 return(E_ID);
516 }
517
518 /* ここに処理本体を記述します #_TEFB_# */
519#ifdef RPC_DEBUG
520 syslog(LOG_INFO, "eTDR_receiveSOP(b_client=%d)", b_client);
521#endif
522
523 if( b_client )
524 sopMagic = TDR_SOP_MAGIC2;
525 else
526 sopMagic = TDR_SOP_MAGIC1;
527
528 if( (ercd=eTDR_getUInt8( idx, &val )) != E_OK )
529 ;
530 else if( val != (uint8_t)(sopMagic>>8) ){
531 ercd = E_MAGIC;
532 }
533 else if((ercd=eTDR_getUInt8( idx, &val )) != E_OK )
534 ;
535 else if( val != (uint8_t)sopMagic ){
536 ercd = E_MAGIC;
537 }
538
539 if( ercd != E_OK )
540 syslog( LOG_INFO, "receiveSOP: ERCD=%d", ercd );
541
542 return ercd;
543}
544
545/* #[<ENTRY_FUNC>]# eTDR_sendEOP
546 * name: eTDR_sendEOP
547 * global_name: tNBOTDR_eTDR_sendEOP
548 * oneway: false
549 * #[</ENTRY_FUNC>]# */
550Inline ER
551eTDR_sendEOP(CELLIDX idx, bool_t b_continue )
552{
553 ER ercd = E_OK;
554 CELLCB *p_cellcb;
555 uint16_t magic;
556 if (VALID_IDX(idx)) {
557 p_cellcb = GET_CELLCB(idx);
558 }
559 else {
560 return(E_ID);
561 }
562
563 /* ここに処理本体を記述します #_TEFB_# */
564#ifdef RPC_DEBUG
565 syslog(LOG_INFO, "eTDR_sendEOP(b_continue=%d)", b_continue);
566#endif
567
568 if( b_continue )
569 magic = TDR_EOP_MAGIC1;
570 else
571 magic = TDR_EOP_MAGIC2;
572
573 /* EOP magic の送信 */
574 if( (ercd = eTDR_putUInt16( idx, magic )) != E_OK )
575 return ercd;
576
577 return cChannel_flush(VAR_tmo);
578}
579
580/* #[<ENTRY_FUNC>]# eTDR_receiveEOP
581 * name: eTDR_receiveEOP
582 * global_name: tNBOTDR_eTDR_receiveEOP
583 * oneway: false
584 * #[</ENTRY_FUNC>]# */
585Inline ER
586eTDR_receiveEOP(CELLIDX idx, bool_t b_continue)
587{
588 ER ercd = E_OK, er2;
589 CELLCB *p_cellcb;
590 uint16_t magic;
591
592 if (VALID_IDX(idx)) {
593 p_cellcb = GET_CELLCB(idx);
594 }
595 else {
596 return(E_ID);
597 }
598
599 /* ここに処理本体を記述します #_TEFB_# */
600#ifdef RPC_DEBUG
601 syslog(LOG_INFO, "eTDR_receiveEOP(b_continue=%d)",b_continue);
602#endif
603/* mikan cChannel EOF get_* */
604/* mikan magic EOF */
605
606 if( (ercd=eTDR_getUInt16( idx, &magic )) == E_OK ){
607 if( (b_continue && magic == TDR_EOP_MAGIC1) || (!b_continue && magic == TDR_EOP_MAGIC2) ){
608 } else {
609 ercd = E_MAGIC;
610 }
611 }
612 er2 = cChannel_end_receive();
613 return ercd != E_OK ? ercd : er2;
614}
615
616/* #[<ENTRY_FUNC>]# eTDR_putInt8
617 * name: eTDR_putInt8
618 * global_name: tNBOTDR_eTDR_putInt8
619 * oneway: false
620 * #[</ENTRY_FUNC>]# */
621Inline ER
622eTDR_putInt8(CELLIDX idx, int8_t in)
623{
624 CELLCB *p_cellcb;
625 if (VALID_IDX(idx)) {
626 p_cellcb = GET_CELLCB(idx);
627 }
628 else {
629 return(E_ID);
630 }
631
632 /* ここに処理本体を記述します #_TEFB_# */
633 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
634}
635
636/* #[<ENTRY_FUNC>]# eTDR_putInt16
637 * name: eTDR_putInt16
638 * global_name: tNBOTDR_eTDR_putInt16
639 * oneway: false
640 * #[</ENTRY_FUNC>]# */
641Inline ER
642eTDR_putInt16(CELLIDX idx, int16_t in)
643{
644 CELLCB *p_cellcb;
645 if (VALID_IDX(idx)) {
646 p_cellcb = GET_CELLCB(idx);
647 }
648 else {
649 return(E_ID);
650 }
651
652 /* ここに処理本体を記述します #_TEFB_# */
653 in = hton16( in );
654 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
655}
656
657/* #[<ENTRY_FUNC>]# eTDR_putInt32
658 * name: eTDR_putInt32
659 * global_name: tNBOTDR_eTDR_putInt32
660 * oneway: false
661 * #[</ENTRY_FUNC>]# */
662Inline ER
663eTDR_putInt32(CELLIDX idx, int32_t in)
664{
665 CELLCB *p_cellcb;
666 if (VALID_IDX(idx)) {
667 p_cellcb = GET_CELLCB(idx);
668 }
669 else {
670 return(E_ID);
671 }
672
673 /* ここに処理本体を記述します #_TEFB_# */
674 in = hton32( in );
675 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
676}
677
678/* #[<ENTRY_FUNC>]# eTDR_putInt64
679 * name: eTDR_putInt64
680 * global_name: tNBOTDR_eTDR_putInt64
681 * oneway: false
682 * #[</ENTRY_FUNC>]# */
683Inline ER
684eTDR_putInt64(CELLIDX idx, int64_t in)
685{
686 CELLCB *p_cellcb;
687 if (VALID_IDX(idx)) {
688 p_cellcb = GET_CELLCB(idx);
689 }
690 else {
691 return(E_ID);
692 }
693
694 /* ここに処理本体を記述します #_TEFB_# */
695 in = hton64( in );
696 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
697}
698
699/* #[<ENTRY_FUNC>]# eTDR_putInt128
700 * name: eTDR_putInt128
701 * global_name: tNBOTDR_eTDR_putInt128
702 * oneway: false
703 * #[</ENTRY_FUNC>]# */
704Inline ER
705eTDR_putInt128(CELLIDX idx, int128_t in)
706{
707 CELLCB *p_cellcb;
708 if (VALID_IDX(idx)) {
709 p_cellcb = GET_CELLCB(idx);
710 }
711 else {
712 return(E_ID);
713 }
714
715 /* ここに処理本体を記述します #_TEFB_# */
716 in = hton128( in );
717 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
718}
719
720/* #[<ENTRY_FUNC>]# eTDR_getInt8
721 * name: eTDR_getInt8
722 * global_name: tNBOTDR_eTDR_getInt8
723 * oneway: false
724 * #[</ENTRY_FUNC>]# */
725Inline ER
726eTDR_getInt8(CELLIDX idx, int8_t* out)
727{
728 ER_UINT er_sz;
729 CELLCB *p_cellcb;
730 if (VALID_IDX(idx)) {
731 p_cellcb = GET_CELLCB(idx);
732 }
733 else {
734 return(E_ID);
735 }
736
737 /* ここに処理本体を記述します #_TEFB_# */
738 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
739 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
740}
741
742/* #[<ENTRY_FUNC>]# eTDR_getInt16
743 * name: eTDR_getInt16
744 * global_name: tNBOTDR_eTDR_getInt16
745 * oneway: false
746 * #[</ENTRY_FUNC>]# */
747Inline ER
748eTDR_getInt16(CELLIDX idx, int16_t* out)
749{
750 ER_UINT er_sz;
751 CELLCB *p_cellcb;
752 if (VALID_IDX(idx)) {
753 p_cellcb = GET_CELLCB(idx);
754 }
755 else {
756 return(E_ID);
757 }
758
759 /* ここに処理本体を記述します #_TEFB_# */
760 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
761 *out = ntoh16( *out );
762 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
763}
764
765/* #[<ENTRY_FUNC>]# eTDR_getInt32
766 * name: eTDR_getInt32
767 * global_name: tNBOTDR_eTDR_getInt32
768 * oneway: false
769 * #[</ENTRY_FUNC>]# */
770Inline ER
771eTDR_getInt32(CELLIDX idx, int32_t* out)
772{
773 ER_UINT er_sz;
774 CELLCB *p_cellcb;
775 if (VALID_IDX(idx)) {
776 p_cellcb = GET_CELLCB(idx);
777 }
778 else {
779 return(E_ID);
780 }
781
782 /* ここに処理本体を記述します #_TEFB_# */
783 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
784 *out = ntoh32( *out );
785 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
786}
787
788/* #[<ENTRY_FUNC>]# eTDR_getInt64
789 * name: eTDR_getInt64
790 * global_name: tNBOTDR_eTDR_getInt64
791 * oneway: false
792 * #[</ENTRY_FUNC>]# */
793Inline ER
794eTDR_getInt64(CELLIDX idx, int64_t* out)
795{
796 ER_UINT er_sz;
797 CELLCB *p_cellcb;
798 if (VALID_IDX(idx)) {
799 p_cellcb = GET_CELLCB(idx);
800 }
801 else {
802 return(E_ID);
803 }
804
805 /* ここに処理本体を記述します #_TEFB_# */
806 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
807 *out = ntoh64( *out );
808 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
809}
810
811/* #[<ENTRY_FUNC>]# eTDR_getInt128
812 * name: eTDR_getInt128
813 * global_name: tNBOTDR_eTDR_getInt128
814 * oneway: false
815 * #[</ENTRY_FUNC>]# */
816Inline ER
817eTDR_getInt128(CELLIDX idx, int128_t* out)
818{
819 ER_UINT er_sz;
820 CELLCB *p_cellcb;
821 if (VALID_IDX(idx)) {
822 p_cellcb = GET_CELLCB(idx);
823 }
824 else {
825 return(E_ID);
826 }
827
828 /* ここに処理本体を記述します #_TEFB_# */
829 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
830 *out = ntoh128( *out );
831 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
832}
833
834/* #[<ENTRY_FUNC>]# eTDR_putUInt8
835 * name: eTDR_putUInt8
836 * global_name: tNBOTDR_eTDR_putUInt8
837 * oneway: false
838 * #[</ENTRY_FUNC>]# */
839Inline ER
840eTDR_putUInt8(CELLIDX idx, uint8_t in)
841{
842 CELLCB *p_cellcb;
843 if (VALID_IDX(idx)) {
844 p_cellcb = GET_CELLCB(idx);
845 }
846 else {
847 return(E_ID);
848 } /* end if VALID_IDX(idx) */
849
850 /* ここに処理本体を記述します #_TEFB_# */
851 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
852}
853
854/* #[<ENTRY_FUNC>]# eTDR_putUInt16
855 * name: eTDR_putUInt16
856 * global_name: tNBOTDR_eTDR_putUInt16
857 * oneway: false
858 * #[</ENTRY_FUNC>]# */
859Inline ER
860eTDR_putUInt16(CELLIDX idx, uint16_t in)
861{
862 CELLCB *p_cellcb;
863 if (VALID_IDX(idx)) {
864 p_cellcb = GET_CELLCB(idx);
865 }
866 else {
867 return(E_ID);
868 } /* end if VALID_IDX(idx) */
869
870 /* ここに処理本体を記述します #_TEFB_# */
871 in = hton16( in );
872 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
873}
874
875/* #[<ENTRY_FUNC>]# eTDR_putUInt32
876 * name: eTDR_putUInt32
877 * global_name: tNBOTDR_eTDR_putUInt32
878 * oneway: false
879 * #[</ENTRY_FUNC>]# */
880Inline ER
881eTDR_putUInt32(CELLIDX idx, uint32_t in)
882{
883 CELLCB *p_cellcb;
884 if (VALID_IDX(idx)) {
885 p_cellcb = GET_CELLCB(idx);
886 }
887 else {
888 return(E_ID);
889 } /* end if VALID_IDX(idx) */
890
891 /* ここに処理本体を記述します #_TEFB_# */
892 in = hton32( in );
893 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
894}
895
896/* #[<ENTRY_FUNC>]# eTDR_putUInt64
897 * name: eTDR_putUInt64
898 * global_name: tNBOTDR_eTDR_putUInt64
899 * oneway: false
900 * #[</ENTRY_FUNC>]# */
901Inline ER
902eTDR_putUInt64(CELLIDX idx, uint64_t in)
903{
904 CELLCB *p_cellcb;
905 if (VALID_IDX(idx)) {
906 p_cellcb = GET_CELLCB(idx);
907 }
908 else {
909 return(E_ID);
910 } /* end if VALID_IDX(idx) */
911
912 /* ここに処理本体を記述します #_TEFB_# */
913 in = hton64( in );
914 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
915}
916
917/* #[<ENTRY_FUNC>]# eTDR_putUInt128
918 * name: eTDR_putUInt128
919 * global_name: tNBOTDR_eTDR_putUInt128
920 * oneway: false
921 * #[</ENTRY_FUNC>]# */
922Inline ER
923eTDR_putUInt128(CELLIDX idx, uint128_t in)
924{
925 CELLCB *p_cellcb;
926 if (VALID_IDX(idx)) {
927 p_cellcb = GET_CELLCB(idx);
928 }
929 else {
930 return(E_ID);
931 } /* end if VALID_IDX(idx) */
932
933 /* ここに処理本体を記述します #_TEFB_# */
934 in = hton128u( in );
935 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
936}
937
938/* #[<ENTRY_FUNC>]# eTDR_getUInt8
939 * name: eTDR_getUInt8
940 * global_name: tNBOTDR_eTDR_getUInt8
941 * oneway: false
942 * #[</ENTRY_FUNC>]# */
943Inline ER
944eTDR_getUInt8(CELLIDX idx, uint8_t* out)
945{
946 ER_UINT er_sz;
947 CELLCB *p_cellcb;
948 if (VALID_IDX(idx)) {
949 p_cellcb = GET_CELLCB(idx);
950 }
951 else {
952 return(E_ID);
953 } /* end if VALID_IDX(idx) */
954
955 /* ここに処理本体を記述します #_TEFB_# */
956 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
957 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
958}
959
960/* #[<ENTRY_FUNC>]# eTDR_getUInt16
961 * name: eTDR_getUInt16
962 * global_name: tNBOTDR_eTDR_getUInt16
963 * oneway: false
964 * #[</ENTRY_FUNC>]# */
965Inline ER
966eTDR_getUInt16(CELLIDX idx, uint16_t* out)
967{
968 ER_UINT er_sz;
969 CELLCB *p_cellcb;
970 if (VALID_IDX(idx)) {
971 p_cellcb = GET_CELLCB(idx);
972 }
973 else {
974 return(E_ID);
975 } /* end if VALID_IDX(idx) */
976
977 /* ここに処理本体を記述します #_TEFB_# */
978 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
979 *out = ntoh16( *out );
980 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
981}
982
983/* #[<ENTRY_FUNC>]# eTDR_getUInt32
984 * name: eTDR_getUInt32
985 * global_name: tNBOTDR_eTDR_getUInt32
986 * oneway: false
987 * #[</ENTRY_FUNC>]# */
988Inline ER
989eTDR_getUInt32(CELLIDX idx, uint32_t* out)
990{
991 ER_UINT er_sz;
992 CELLCB *p_cellcb;
993 if (VALID_IDX(idx)) {
994 p_cellcb = GET_CELLCB(idx);
995 }
996 else {
997 return(E_ID);
998 } /* end if VALID_IDX(idx) */
999
1000 /* ここに処理本体を記述します #_TEFB_# */
1001 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1002 *out = ntoh32( *out );
1003 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1004}
1005
1006/* #[<ENTRY_FUNC>]# eTDR_getUInt64
1007 * name: eTDR_getUInt64
1008 * global_name: tNBOTDR_eTDR_getUInt64
1009 * oneway: false
1010 * #[</ENTRY_FUNC>]# */
1011Inline ER
1012eTDR_getUInt64(CELLIDX idx, uint64_t* out)
1013{
1014 ER_UINT er_sz;
1015 CELLCB *p_cellcb;
1016 if (VALID_IDX(idx)) {
1017 p_cellcb = GET_CELLCB(idx);
1018 }
1019 else {
1020 return(E_ID);
1021 } /* end if VALID_IDX(idx) */
1022
1023 /* ここに処理本体を記述します #_TEFB_# */
1024 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1025 *out = ntoh64( *out );
1026 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1027}
1028
1029/* #[<ENTRY_FUNC>]# eTDR_getUInt128
1030 * name: eTDR_getUInt128
1031 * global_name: tNBOTDR_eTDR_getUInt128
1032 * oneway: false
1033 * #[</ENTRY_FUNC>]# */
1034Inline ER
1035eTDR_getUInt128(CELLIDX idx, uint128_t* out)
1036{
1037 ER_UINT er_sz;
1038 CELLCB *p_cellcb;
1039 if (VALID_IDX(idx)) {
1040 p_cellcb = GET_CELLCB(idx);
1041 }
1042 else {
1043 return(E_ID);
1044 } /* end if VALID_IDX(idx) */
1045
1046 /* ここに処理本体を記述します #_TEFB_# */
1047 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1048 *out = ntoh128u( *out );
1049 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1050}
1051
1052/* #[<ENTRY_FUNC>]# eTDR_putChar
1053 * name: eTDR_putChar
1054 * global_name: tNBOTDR_eTDR_putChar
1055 * oneway: false
1056 * #[</ENTRY_FUNC>]# */
1057Inline ER
1058eTDR_putChar(CELLIDX idx, char_t in)
1059{
1060 CELLCB *p_cellcb;
1061 if (VALID_IDX(idx)) {
1062 p_cellcb = GET_CELLCB(idx);
1063 }
1064 else {
1065 return(E_ID);
1066 }
1067
1068 /* ここに処理本体を記述します #_TEFB_# */
1069 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1070}
1071
1072/* #[<ENTRY_FUNC>]# eTDR_getChar
1073 * name: eTDR_getChar
1074 * global_name: tNBOTDR_eTDR_getChar
1075 * oneway: false
1076 * #[</ENTRY_FUNC>]# */
1077Inline ER
1078eTDR_getChar(CELLIDX idx, char_t* out)
1079{
1080 ER_UINT er_sz;
1081 CELLCB *p_cellcb;
1082 if (VALID_IDX(idx)) {
1083 p_cellcb = GET_CELLCB(idx);
1084 }
1085 else {
1086 return(E_ID);
1087 }
1088
1089 /* ここに処理本体を記述します #_TEFB_# */
1090 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1091 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1092}
1093
1094/* #[<ENTRY_FUNC>]# eTDR_putBool
1095 * name: eTDR_putBool
1096 * global_name: tNBOTDR_eTDR_putBool
1097 * oneway: false
1098 * #[</ENTRY_FUNC>]# */
1099Inline ER
1100eTDR_putBool(CELLIDX idx, bool_t in)
1101{
1102 ER ercd = E_OK;
1103 CELLCB *p_cellcb;
1104 if (VALID_IDX(idx)) {
1105 p_cellcb = GET_CELLCB(idx);
1106 }
1107 else {
1108 return(E_ID);
1109 } /* end if VALID_IDX(idx) */
1110
1111 /* ここに処理本体を記述します #_TEFB_# */
1112 eTDR_putUInt8(idx, (uint8_t)(in != 0) );
1113
1114 return(ercd);
1115}
1116
1117/* #[<ENTRY_FUNC>]# eTDR_getBool
1118 * name: eTDR_getBool
1119 * global_name: tNBOTDR_eTDR_getBool
1120 * oneway: false
1121 * #[</ENTRY_FUNC>]# */
1122Inline ER
1123eTDR_getBool(CELLIDX idx, bool_t* out)
1124{
1125 ER ercd = E_OK;
1126 CELLCB *p_cellcb;
1127 uint8_t val;
1128 if (VALID_IDX(idx)) {
1129 p_cellcb = GET_CELLCB(idx);
1130 }
1131 else {
1132 return(E_ID);
1133 } /* end if VALID_IDX(idx) */
1134
1135 /* ここに処理本体を記述します #_TEFB_# */
1136 ercd = eTDR_getUInt8(idx, &val );
1137 if( ercd != E_OK )
1138 return ercd;
1139 *out = (val != 0);
1140
1141 return(ercd);
1142}
1143
1144/* #[<ENTRY_FUNC>]# eTDR_putFloat32
1145 * name: eTDR_putFloat32
1146 * global_name: tNBOTDR_eTDR_putFloat32
1147 * oneway: false
1148 * #[</ENTRY_FUNC>]# */
1149Inline ER
1150eTDR_putFloat32(CELLIDX idx, float32_t in)
1151{
1152 CELLCB *p_cellcb;
1153 int32_t val;
1154 if (VALID_IDX(idx)) {
1155 p_cellcb = GET_CELLCB(idx);
1156 }
1157 else {
1158 return(E_ID);
1159 }
1160
1161 /* ここに処理本体を記述します #_TEFB_# */
1162 val = hton32( *(int32_t*)&in );
1163 return cChannel_send( (int8_t *)&val, (int16_t)sizeof( val ), VAR_tmo );
1164}
1165
1166/* #[<ENTRY_FUNC>]# eTDR_putDouble64
1167 * name: eTDR_putDouble64
1168 * global_name: tNBOTDR_eTDR_putDouble64
1169 * oneway: false
1170 * #[</ENTRY_FUNC>]# */
1171Inline ER
1172eTDR_putDouble64(CELLIDX idx, double64_t in)
1173{
1174 int64_t val;
1175 CELLCB *p_cellcb;
1176 if (VALID_IDX(idx)) {
1177 p_cellcb = GET_CELLCB(idx);
1178 }
1179 else {
1180 return(E_ID);
1181 }
1182
1183 /* ここに処理本体を記述します #_TEFB_# */
1184 val = *(int64_t *)&in;
1185 val = hton64( val );
1186 return cChannel_send( (int8_t *)&val, (int16_t)sizeof( val ), VAR_tmo );
1187}
1188
1189/* #[<ENTRY_FUNC>]# eTDR_getFloat32
1190 * name: eTDR_getFloat32
1191 * global_name: tNBOTDR_eTDR_getFloat32
1192 * oneway: false
1193 * #[</ENTRY_FUNC>]# */
1194Inline ER
1195eTDR_getFloat32(CELLIDX idx, float32_t* out)
1196{
1197 ER_UINT er_sz = E_OK;
1198 int32_t val;
1199 CELLCB *p_cellcb;
1200 if (VALID_IDX(idx)) {
1201 p_cellcb = GET_CELLCB(idx);
1202 }
1203 else {
1204 return(E_ID);
1205 }
1206
1207 /* ここに処理本体を記述します #_TEFB_# */
1208 er_sz = cChannel_receive( (int8_t *)&val, (int16_t)sizeof( val ), VAR_tmo );
1209 val = ntoh32( val );
1210 *out = *(float32_t *)&val;
1211 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1212}
1213
1214/* #[<ENTRY_FUNC>]# eTDR_getDouble64
1215 * name: eTDR_getDouble64
1216 * global_name: tNBOTDR_eTDR_getDouble64
1217 * oneway: false
1218 * #[</ENTRY_FUNC>]# */
1219Inline ER
1220eTDR_getDouble64(CELLIDX idx, double64_t* out)
1221{
1222 ER_UINT er_sz = E_OK;
1223 int64_t val;
1224 CELLCB *p_cellcb;
1225 if (VALID_IDX(idx)) {
1226 p_cellcb = GET_CELLCB(idx);
1227 }
1228 else {
1229 return(E_ID);
1230 }
1231
1232 /* ここに処理本体を記述します #_TEFB_# */
1233 er_sz = cChannel_receive( (int8_t *)&val, (int16_t)sizeof( val ), VAR_tmo );
1234 val = ntoh64( val );
1235 *out = *(double64_t *)&val;
1236 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1237}
1238
1239/* #[<ENTRY_FUNC>]# eTDR_putSChar
1240 * name: eTDR_putSChar
1241 * global_name: tNBOTDR_eTDR_putSChar
1242 * oneway: false
1243 * #[</ENTRY_FUNC>]# */
1244Inline ER
1245eTDR_putSChar(CELLIDX idx, signed char in)
1246{
1247 CELLCB *p_cellcb;
1248 if (VALID_IDX(idx)) {
1249 p_cellcb = GET_CELLCB(idx);
1250 }
1251 else {
1252 return(E_ID);
1253 } /* end if VALID_IDX(idx) */
1254
1255 /* ここに処理本体を記述します #_TEFB_# */
1256 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1257}
1258
1259/* #[<ENTRY_FUNC>]# eTDR_putShort
1260 * name: eTDR_putShort
1261 * global_name: tNBOTDR_eTDR_putShort
1262 * oneway: false
1263 * #[</ENTRY_FUNC>]# */
1264Inline ER
1265eTDR_putShort(CELLIDX idx, short_t in)
1266{
1267 CELLCB *p_cellcb;
1268 TDR_SHORT IN = in;
1269 if (VALID_IDX(idx)) {
1270 p_cellcb = GET_CELLCB(idx);
1271 }
1272 else {
1273 return(E_ID);
1274 }
1275
1276 /* ここに処理本体を記述します #_TEFB_# */
1277 IN = HTONS( IN, sizeof IN );
1278 return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo );
1279}
1280
1281/* #[<ENTRY_FUNC>]# eTDR_putInt
1282 * name: eTDR_putInt
1283 * global_name: tNBOTDR_eTDR_putInt
1284 * oneway: false
1285 * #[</ENTRY_FUNC>]# */
1286Inline ER
1287eTDR_putInt(CELLIDX idx, int_t in)
1288{
1289 CELLCB *p_cellcb;
1290 TDR_INT IN = in;
1291 if (VALID_IDX(idx)) {
1292 p_cellcb = GET_CELLCB(idx);
1293 }
1294 else {
1295 return(E_ID);
1296 }
1297
1298 /* ここに処理本体を記述します #_TEFB_# */
1299 IN = HTONI( IN, sizeof IN );
1300 return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo );
1301}
1302
1303/* #[<ENTRY_FUNC>]# eTDR_putLong
1304 * name: eTDR_putLong
1305 * global_name: tNBOTDR_eTDR_putLong
1306 * oneway: false
1307 * #[</ENTRY_FUNC>]# */
1308Inline ER
1309eTDR_putLong(CELLIDX idx, long_t in)
1310{
1311 CELLCB *p_cellcb;
1312 TDR_LONG IN = in;
1313 if (VALID_IDX(idx)) {
1314 p_cellcb = GET_CELLCB(idx);
1315 }
1316 else {
1317 return(E_ID);
1318 }
1319
1320 /* ここに処理本体を記述します #_TEFB_# */
1321 IN = HTONL( IN, sizeof IN );
1322 return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo );
1323}
1324
1325/* #[<ENTRY_FUNC>]# eTDR_getSChar
1326 * name: eTDR_getSChar
1327 * global_name: tNBOTDR_eTDR_getSChar
1328 * oneway: false
1329 * #[</ENTRY_FUNC>]# */
1330Inline ER
1331eTDR_getSChar(CELLIDX idx, signed char* out)
1332{
1333 ER_UINT er_sz;
1334 CELLCB *p_cellcb;
1335 if (VALID_IDX(idx)) {
1336 p_cellcb = GET_CELLCB(idx);
1337 }
1338 else {
1339 return(E_ID);
1340 } /* end if VALID_IDX(idx) */
1341
1342 /* ここに処理本体を記述します #_TEFB_# */
1343 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1344 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1345}
1346
1347/* #[<ENTRY_FUNC>]# eTDR_getShort
1348 * name: eTDR_getShort
1349 * global_name: tNBOTDR_eTDR_getShort
1350 * oneway: false
1351 * #[</ENTRY_FUNC>]# */
1352Inline ER
1353eTDR_getShort(CELLIDX idx, short* out)
1354{
1355 ER_UINT er_sz;
1356 CELLCB *p_cellcb;
1357 TDR_SHORT OUT;
1358 if (VALID_IDX(idx)) {
1359 p_cellcb = GET_CELLCB(idx);
1360 }
1361 else {
1362 return(E_ID);
1363 }
1364
1365 /* ここに処理本体を記述します #_TEFB_# */
1366 er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo );
1367 *out = NTOHS( OUT, sizeof OUT );
1368 return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR );
1369}
1370
1371/* #[<ENTRY_FUNC>]# eTDR_getInt
1372 * name: eTDR_getInt
1373 * global_name: tNBOTDR_eTDR_getInt
1374 * oneway: false
1375 * #[</ENTRY_FUNC>]# */
1376Inline ER
1377eTDR_getInt(CELLIDX idx, int_t* out)
1378{
1379 ER_UINT er_sz;
1380 CELLCB *p_cellcb;
1381 TDR_INT OUT;
1382 if (VALID_IDX(idx)) {
1383 p_cellcb = GET_CELLCB(idx);
1384 }
1385 else {
1386 return(E_ID);
1387 }
1388
1389 /* ここに処理本体を記述します #_TEFB_# */
1390 er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo );
1391 *out = NTOHI( OUT, sizeof OUT );
1392 return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR );
1393}
1394
1395/* #[<ENTRY_FUNC>]# eTDR_getLong
1396 * name: eTDR_getLong
1397 * global_name: tNBOTDR_eTDR_getLong
1398 * oneway: false
1399 * #[</ENTRY_FUNC>]# */
1400Inline ER
1401eTDR_getLong(CELLIDX idx, long_t* out)
1402{
1403 ER_UINT er_sz;
1404 CELLCB *p_cellcb;
1405 TDR_LONG OUT;
1406 if (VALID_IDX(idx)) {
1407 p_cellcb = GET_CELLCB(idx);
1408 }
1409 else {
1410 return(E_ID);
1411 }
1412
1413 /* ここに処理本体を記述します #_TEFB_# */
1414 er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo );
1415 *out = NTOHL( OUT, sizeof OUT );
1416 return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR );
1417}
1418
1419/* #[<ENTRY_FUNC>]# eTDR_putUChar
1420 * name: eTDR_putUChar
1421 * global_name: tNBOTDR_eTDR_putUChar
1422 * oneway: false
1423 * #[</ENTRY_FUNC>]# */
1424Inline ER
1425eTDR_putUChar(CELLIDX idx, unsigned char in)
1426{
1427 CELLCB *p_cellcb;
1428 if (VALID_IDX(idx)) {
1429 p_cellcb = GET_CELLCB(idx);
1430 }
1431 else {
1432 return(E_ID);
1433 } /* end if VALID_IDX(idx) */
1434
1435 /* ここに処理本体を記述します #_TEFB_# */
1436 return cChannel_send( (int8_t *)&in, (int16_t)sizeof( in ), VAR_tmo );
1437}
1438
1439/* #[<ENTRY_FUNC>]# eTDR_putUShort
1440 * name: eTDR_putUShort
1441 * global_name: tNBOTDR_eTDR_putUShort
1442 * oneway: false
1443 * #[</ENTRY_FUNC>]# */
1444Inline ER
1445eTDR_putUShort(CELLIDX idx, ushort_t in)
1446{
1447 CELLCB *p_cellcb;
1448 TDR_USHORT IN = in;
1449 if (VALID_IDX(idx)) {
1450 p_cellcb = GET_CELLCB(idx);
1451 }
1452 else {
1453 return(E_ID);
1454 } /* end if VALID_IDX(idx) */
1455
1456 /* ここに処理本体を記述します #_TEFB_# */
1457 IN = HTONS( IN, sizeof IN );
1458 return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo );
1459}
1460
1461/* #[<ENTRY_FUNC>]# eTDR_putUInt
1462 * name: eTDR_putUInt
1463 * global_name: tNBOTDR_eTDR_putUInt
1464 * oneway: false
1465 * #[</ENTRY_FUNC>]# */
1466Inline ER
1467eTDR_putUInt(CELLIDX idx, uint_t in)
1468{
1469 CELLCB *p_cellcb;
1470 TDR_UINT IN = in;
1471 if (VALID_IDX(idx)) {
1472 p_cellcb = GET_CELLCB(idx);
1473 }
1474 else {
1475 return(E_ID);
1476 } /* end if VALID_IDX(idx) */
1477
1478 /* ここに処理本体を記述します #_TEFB_# */
1479 IN = HTONI( IN, sizeof IN );
1480 return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo );
1481}
1482
1483/* #[<ENTRY_FUNC>]# eTDR_putULong
1484 * name: eTDR_putULong
1485 * global_name: tNBOTDR_eTDR_putULong
1486 * oneway: false
1487 * #[</ENTRY_FUNC>]# */
1488Inline ER
1489eTDR_putULong(CELLIDX idx, ulong_t in)
1490{
1491 CELLCB *p_cellcb;
1492 TDR_ULONG IN = in;
1493 if (VALID_IDX(idx)) {
1494 p_cellcb = GET_CELLCB(idx);
1495 }
1496 else {
1497 return(E_ID);
1498 } /* end if VALID_IDX(idx) */
1499
1500 /* ここに処理本体を記述します #_TEFB_# */
1501 IN = HTONL( IN, sizeof IN );
1502 return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo );
1503}
1504
1505/* #[<ENTRY_FUNC>]# eTDR_getUChar
1506 * name: eTDR_getUChar
1507 * global_name: tNBOTDR_eTDR_getUChar
1508 * oneway: false
1509 * #[</ENTRY_FUNC>]# */
1510Inline ER
1511eTDR_getUChar(CELLIDX idx, unsigned char* out)
1512{
1513 ER_UINT er_sz;
1514 CELLCB *p_cellcb;
1515 if (VALID_IDX(idx)) {
1516 p_cellcb = GET_CELLCB(idx);
1517 }
1518 else {
1519 return(E_ID);
1520 } /* end if VALID_IDX(idx) */
1521
1522 /* ここに処理本体を記述します #_TEFB_# */
1523 er_sz = cChannel_receive( (int8_t *)out, (int16_t)sizeof( *out ), VAR_tmo );
1524 return er_sz < 0 ? er_sz : ( er_sz == sizeof( *out ) ? E_OK : E_BOVR );
1525}
1526
1527/* #[<ENTRY_FUNC>]# eTDR_getUShort
1528 * name: eTDR_getUShort
1529 * global_name: tNBOTDR_eTDR_getUShort
1530 * oneway: false
1531 * #[</ENTRY_FUNC>]# */
1532Inline ER
1533eTDR_getUShort(CELLIDX idx, unsigned short* out)
1534{
1535 ER_UINT er_sz;
1536 CELLCB *p_cellcb;
1537 TDR_USHORT OUT;
1538 if (VALID_IDX(idx)) {
1539 p_cellcb = GET_CELLCB(idx);
1540 }
1541 else {
1542 return(E_ID);
1543 } /* end if VALID_IDX(idx) */
1544
1545 /* ここに処理本体を記述します #_TEFB_# */
1546 er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo );
1547 *out = NTOHS( OUT, sizeof OUT );
1548 return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR );
1549}
1550
1551/* #[<ENTRY_FUNC>]# eTDR_getUInt
1552 * name: eTDR_getUInt
1553 * global_name: tNBOTDR_eTDR_getUInt
1554 * oneway: false
1555 * #[</ENTRY_FUNC>]# */
1556Inline ER
1557eTDR_getUInt(CELLIDX idx, uint_t* out)
1558{
1559 ER_UINT er_sz;
1560 CELLCB *p_cellcb;
1561 TDR_UINT OUT;
1562 if (VALID_IDX(idx)) {
1563 p_cellcb = GET_CELLCB(idx);
1564 }
1565 else {
1566 return(E_ID);
1567 } /* end if VALID_IDX(idx) */
1568
1569 /* ここに処理本体を記述します #_TEFB_# */
1570 er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo );
1571 *out = NTOHI( OUT, sizeof OUT );
1572 return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR );
1573}
1574
1575/* #[<ENTRY_FUNC>]# eTDR_getULong
1576 * name: eTDR_getULong
1577 * global_name: tNBOTDR_eTDR_getULong
1578 * oneway: false
1579 * #[</ENTRY_FUNC>]# */
1580Inline ER
1581eTDR_getULong(CELLIDX idx, ulong_t* out)
1582{
1583 ER_UINT er_sz;
1584 CELLCB *p_cellcb;
1585 TDR_ULONG OUT;
1586 if (VALID_IDX(idx)) {
1587 p_cellcb = GET_CELLCB(idx);
1588 }
1589 else {
1590 return(E_ID);
1591 } /* end if VALID_IDX(idx) */
1592
1593 /* ここに処理本体を記述します #_TEFB_# */
1594 er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo );
1595 *out = NTOHL( OUT, sizeof OUT );
1596 return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR );
1597}
1598
1599/* #[<ENTRY_FUNC>]# eTDR_putIntptr
1600 * name: eTDR_putIntptr
1601 * global_name: tNBOTDR_eTDR_putIntptr
1602 * oneway: false
1603 * #[</ENTRY_FUNC>]# */
1604Inline ER
1605eTDR_putIntptr(CELLIDX idx, const intptr_t ptr)
1606{
1607 CELLCB *p_cellcb;
1608 TDR_INTPTR IN = ptr;
1609 if (VALID_IDX(idx)) {
1610 p_cellcb = GET_CELLCB(idx);
1611 }
1612 else {
1613 return(E_ID);
1614 }
1615
1616 /* ここに処理本体を記述します #_TEFB_# */
1617 IN = HTONIP( IN, sizeof IN );
1618 return cChannel_send( (int8_t *)&IN, (int16_t)sizeof( IN ), VAR_tmo );
1619}
1620
1621/* #[<ENTRY_FUNC>]# eTDR_getIntptr
1622 * name: eTDR_getIntptr
1623 * global_name: tNBOTDR_eTDR_getIntptr
1624 * oneway: false
1625 * #[</ENTRY_FUNC>]# */
1626Inline ER
1627eTDR_getIntptr(CELLIDX idx, intptr_t* ptr)
1628{
1629 ER_UINT er_sz;
1630 CELLCB *p_cellcb;
1631 TDR_INTPTR OUT;
1632 if (VALID_IDX(idx)) {
1633 p_cellcb = GET_CELLCB(idx);
1634 }
1635 else {
1636 return(E_ID);
1637 }
1638
1639 /* ここに処理本体を記述します #_TEFB_# */
1640 er_sz = cChannel_receive( (int8_t *)&OUT, (int16_t)sizeof( OUT ), VAR_tmo );
1641 *ptr = NTOHIP( OUT, sizeof OUT );
1642 return er_sz < 0 ? er_sz : ( er_sz == sizeof( OUT ) ? E_OK : E_BOVR );
1643}
1644
1645/* #[<POSTAMBLE>]#
1646 * これより下に非受け口関数を書きます
1647 * #[</POSTAMBLE>]#*/
Note: See TracBrowser for help on using the repository browser.