1 : //==============================================================================
2 : // File <$/src/cpp/prod/protocol/cdr/cdr.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, 2006, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //==============================================================================
21 :
22 : // Portability
23 : #include "yaorb/config.h"
24 : #include "src/cpp/prod/port/port_stdc.h"
25 :
26 : #include <endian.h>
27 :
28 : #include <yaorb/CORBA.h>
29 : #include <yaorb/YAORB.h>
30 :
31 : #include "src/cpp/prod/protocol/cdr/msg.h"
32 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
33 : #include "src/cpp/prod/tool/Assert.h"
34 :
35 : // Native byte ordering of this platform :
36 :
37 : #if __BYTE_ORDER == __BIG_ENDIAN
38 : static const YAORB::CDR_Ordering NativeOrder = YAORB::CDR_BIG_ENDIAN ;
39 : #endif
40 :
41 : #if __BYTE_ORDER == __LITTLE_ENDIAN
42 : static const YAORB::CDR_Ordering NativeOrder = YAORB::CDR_LITTLE_ENDIAN ;
43 : #endif
44 :
45 94 : YAORB::CDR::CDR(YAORB::CDR_Op op)
46 94 : : _op(op), _order(NativeOrder), _position(0)
47 : {
48 : }
49 :
50 94 : YAORB::CDR::~CDR()
51 0 : {}
52 :
53 26 : void YAORB::CDR::SetBigEndian(void)
54 : {
55 26 : _order = CDR_BIG_ENDIAN ;
56 : }
57 :
58 28 : void YAORB::CDR::SetLittleEndian(void)
59 : {
60 28 : _order = CDR_LITTLE_ENDIAN ;
61 : }
62 :
63 0 : void YAORB::CDR::SetNative(void)
64 : {
65 0 : _order = NativeOrder ;
66 : }
67 :
68 73 : YAORB::CDR_Op YAORB::CDR::Op(void)
69 : {
70 : return _op ;
71 : }
72 :
73 : void YAORB::CDR::cdr_ByteOrder(void)
74 33 : throw (CORBA::SystemException)
75 : {
76 : CORBA::Octet octet ;
77 :
78 : // No alignment constraints
79 :
80 : // CDR_LITTLE_ENDIAN and CDR_BIG_ENDIAN are values in the process space.
81 : // 0 and 1 are values in the CDR space.
82 : // Anything else is junk, stop right here.
83 :
84 33 : switch (_op)
85 : {
86 : case YAORB::CDR_READ :
87 : {
88 32 : GetBytes(& octet, 1) ;
89 :
90 32 : if (octet == 0)
91 : {
92 23 : _order = CDR_BIG_ENDIAN ;
93 : }
94 9 : else if (octet == 1)
95 : {
96 9 : _order = CDR_LITTLE_ENDIAN ;
97 : }
98 : else
99 : {
100 0 : ThrowMarshal(this) ;
101 : }
102 :
103 : break ;
104 : }
105 : case YAORB::CDR_WRITE :
106 : {
107 1 : octet = (_order == CDR_BIG_ENDIAN ? 0 : 1) ;
108 1 : PutBytes(& octet, 1) ;
109 : break ;
110 : }
111 : }
112 : }
113 :
114 : void YAORB::CDR::cdr_Boolean(CORBA::Boolean *data)
115 8 : throw (CORBA::SystemException)
116 : {
117 : CORBA::Octet octet ;
118 :
119 : // No alignment constraints
120 :
121 : // true and false are values in the process space.
122 : // 1 and 0 are values in the CDR space.
123 : // Anything else is junk, stop right here.
124 :
125 8 : switch (_op)
126 : {
127 : case YAORB::CDR_READ :
128 : {
129 4 : GetBytes(& octet, 1) ;
130 :
131 4 : if (octet == 0)
132 : {
133 2 : *data = false ;
134 : }
135 2 : else if (octet == 1)
136 : {
137 2 : *data = true ;
138 : }
139 : else
140 : {
141 0 : ThrowMarshal(this) ;
142 : }
143 : break ;
144 : }
145 : case YAORB::CDR_WRITE :
146 : {
147 4 : if (*data == false)
148 : {
149 2 : octet = 0 ;
150 : }
151 : else if (*data == true)
152 : {
153 2 : octet = 1 ;
154 : }
155 : else
156 : {
157 : ThrowMarshal(this) ;
158 : }
159 :
160 4 : PutBytes(& octet, 1) ;
161 : break ;
162 : }
163 : }
164 : }
165 :
166 : void YAORB::CDR::cdr_Char(CORBA::Char *data)
167 8 : throw (CORBA::SystemException)
168 : {
169 : // FIXME : Transmission Character Code Set
170 :
171 8 : CORBA::Octet * data2 = (CORBA::Octet*) data ;
172 :
173 8 : switch (_op)
174 : {
175 : case YAORB::CDR_READ :
176 : {
177 4 : GetBytes(data2, 1) ;
178 : break ;
179 : }
180 : case YAORB::CDR_WRITE :
181 : {
182 4 : PutBytes(data2, 1) ;
183 : break ;
184 : }
185 : }
186 : }
187 :
188 : void YAORB::CDR::cdr_WChar(CORBA::WChar *data)
189 0 : throw (CORBA::SystemException)
190 : {
191 0 : NON_DEV("cdr_WChar") ;
192 : }
193 :
194 : void YAORB::CDR::cdr_Octet(CORBA::Octet *data)
195 200 : throw (CORBA::SystemException)
196 : {
197 : // No alignement constraints
198 :
199 200 : switch (_op)
200 : {
201 : case YAORB::CDR_READ :
202 : {
203 148 : GetBytes(data, 1) ;
204 : break ;
205 : }
206 : case YAORB::CDR_WRITE :
207 : {
208 52 : PutBytes(data, 1) ;
209 : break ;
210 : }
211 : }
212 : }
213 :
214 : void YAORB::CDR::cdr_Short(CORBA::Short *data)
215 25 : throw (CORBA::SystemException)
216 : {
217 25 : Align(2) ;
218 25 : cdr_2bytes((CORBA::Octet*) data) ;
219 : }
220 :
221 : void YAORB::CDR::cdr_UShort(CORBA::UShort *data)
222 18 : throw (CORBA::SystemException)
223 : {
224 18 : Align(2) ;
225 18 : cdr_2bytes((CORBA::Octet*) data) ;
226 : }
227 :
228 : void YAORB::CDR::cdr_Long(CORBA::Long *data)
229 14 : throw (CORBA::SystemException)
230 : {
231 14 : Align(4) ;
232 14 : cdr_4bytes((CORBA::Octet*) data) ;
233 : }
234 :
235 : void YAORB::CDR::cdr_ULong(CORBA::ULong *data)
236 132 : throw (CORBA::SystemException)
237 : {
238 132 : Align(4) ;
239 132 : cdr_4bytes((CORBA::Octet*) data) ;
240 : }
241 :
242 : void YAORB::CDR::cdr_LongLong(CORBA::LongLong *data)
243 14 : throw (CORBA::SystemException)
244 : {
245 14 : Align(8) ;
246 14 : cdr_8bytes((CORBA::Octet*) data) ;
247 : }
248 :
249 : void YAORB::CDR::cdr_ULongLong(CORBA::ULongLong *data)
250 14 : throw (CORBA::SystemException)
251 : {
252 14 : Align(8) ;
253 14 : cdr_8bytes((CORBA::Octet*) data) ;
254 : }
255 :
256 : void YAORB::CDR::cdr_Float(CORBA::Float *data)
257 7 : throw (CORBA::SystemException)
258 : {
259 7 : Align(4) ;
260 7 : cdr_4bytes((CORBA::Octet*) data) ;
261 : }
262 :
263 : void YAORB::CDR::cdr_Double(CORBA::Double *data)
264 7 : throw (CORBA::SystemException)
265 : {
266 7 : Align(8) ;
267 7 : cdr_8bytes((CORBA::Octet*) data) ;
268 : }
269 :
270 : void YAORB::CDR::cdr_LongDouble(CORBA::LongDouble *data)
271 7 : throw (CORBA::SystemException)
272 : {
273 7 : Align(8) ; // Yes, 8 bytes not 16
274 7 : cdr_16bytes((CORBA::Octet*) data) ;
275 : }
276 :
277 : void YAORB::CDR::cdr_String_var(CORBA::String_var *data)
278 24 : throw (CORBA::SystemException)
279 : {
280 : CORBA::ULong len ;
281 : CORBA::Char *ptr ;
282 :
283 24 : switch(_op)
284 : {
285 : case YAORB::CDR_READ:
286 : {
287 18 : cdr_ULong(& len) ;
288 18 : ptr = CORBA::string_alloc(len) ;
289 18 : cdr_CharArray(ptr, len) ;
290 18 : *data = ptr ;
291 : break ;
292 : }
293 : case YAORB::CDR_WRITE:
294 : {
295 6 : ptr = *data ;
296 6 : len = strlen(ptr) + 1 ;
297 6 : cdr_ULong(& len) ;
298 6 : cdr_CharArray(ptr, len) ;
299 : break ;
300 : }
301 : }
302 : }
303 :
304 : void YAORB::CDR::cdr_Array(void *data,
305 : int elemNb,
306 : int elemSize,
307 : cdr_proc_t proc)
308 0 : throw (CORBA::SystemException)
309 : {
310 0 : char *dataElement = (char*) data ;
311 :
312 0 : for (int i=0 ;
313 : i < elemNb ;
314 : i++)
315 : {
316 0 : (this->*proc) (dataElement) ;
317 0 : dataElement += elemSize ;
318 : }
319 : }
320 :
321 : void YAORB::CDR::cdr_BooleanArray(CORBA::Boolean *data, int size)
322 4 : throw (CORBA::SystemException)
323 : {
324 4 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
325 :
326 4 : switch (_op)
327 : {
328 : case YAORB::CDR_READ :
329 : {
330 2 : GetBytes(data2, size) ;
331 : break ;
332 : }
333 : case YAORB::CDR_WRITE :
334 : {
335 2 : PutBytes(data2, size) ;
336 : break ;
337 : }
338 : }
339 : }
340 :
341 : void YAORB::CDR::cdr_CharArray(CORBA::Char *data, int size)
342 46 : throw (CORBA::SystemException)
343 : {
344 : // FIXME : Transmition Character Set !
345 :
346 46 : CORBA::Octet * data2 = (CORBA::Octet *) data ;
347 :
348 46 : switch (_op)
349 : {
350 : case YAORB::CDR_READ :
351 : {
352 38 : GetBytes(data2, size) ;
353 : break ;
354 : }
355 : case YAORB::CDR_WRITE :
356 : {
357 8 : PutBytes(data2, size) ;
358 : break ;
359 : }
360 : }
361 : }
362 :
363 : void YAORB::CDR::cdr_WCharArray(CORBA::WChar *data, int size)
364 0 : throw (CORBA::SystemException)
365 : {
366 : // FIXME : ineficient.
367 : CORBA::WChar *ptr = data ;
368 :
369 0 : for (int i=0 ;
370 : i < size ;
371 : i++ )
372 : {
373 0 : cdr_WChar(ptr) ;
374 0 : ptr++ ;
375 : }
376 : }
377 :
378 : void YAORB::CDR::cdr_OctetArray(CORBA::Octet *data, int size)
379 74 : throw (CORBA::SystemException)
380 : {
381 74 : switch (_op)
382 : {
383 : case YAORB::CDR_READ :
384 : {
385 56 : GetBytes(data, size) ;
386 : break ;
387 : }
388 : case YAORB::CDR_WRITE :
389 : {
390 18 : PutBytes(data, size) ;
391 : break ;
392 : }
393 : }
394 : }
395 :
396 : void YAORB::CDR::cdr_ShortArray(CORBA::Short *data, int size)
397 4 : throw (CORBA::SystemException)
398 : {
399 :
400 4 : if (_order == NativeOrder)
401 : {
402 2 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
403 2 : int size2 = size * sizeof(CORBA::Short) ;
404 :
405 2 : Align(2) ;
406 :
407 2 : switch (_op)
408 : {
409 : case YAORB::CDR_READ :
410 : {
411 1 : GetBytes(data2, size2) ;
412 : break ;
413 : }
414 : case YAORB::CDR_WRITE :
415 : {
416 1 : PutBytes(data2, size2) ;
417 : break ;
418 : }
419 : }
420 : }
421 : else
422 : {
423 : CORBA::Short *ptr = data ;
424 :
425 8 : for (int i=0 ;
426 : i < size ;
427 : i++ )
428 : {
429 6 : cdr_Short(ptr) ;
430 6 : ptr++ ;
431 : }
432 : }
433 2 : }
434 :
435 : void YAORB::CDR::cdr_UShortArray(CORBA::UShort *data, int size)
436 4 : throw (CORBA::SystemException)
437 : {
438 :
439 4 : if (_order == NativeOrder)
440 : {
441 2 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
442 2 : int size2 = size * sizeof(CORBA::UShort) ;
443 :
444 2 : Align(2) ;
445 :
446 2 : switch (_op)
447 : {
448 : case YAORB::CDR_READ :
449 : {
450 1 : GetBytes(data2, size2) ;
451 : break ;
452 : }
453 : case YAORB::CDR_WRITE :
454 : {
455 1 : PutBytes(data2, size2) ;
456 : break ;
457 : }
458 : }
459 : }
460 : else
461 : {
462 : CORBA::UShort *ptr = data ;
463 :
464 8 : for (int i=0 ;
465 : i < size ;
466 : i++ )
467 : {
468 6 : cdr_UShort(ptr) ;
469 6 : ptr++ ;
470 : }
471 : }
472 2 : }
473 :
474 : void YAORB::CDR::cdr_LongArray(CORBA::Long *data, int size)
475 4 : throw (CORBA::SystemException)
476 : {
477 :
478 4 : if (_order == NativeOrder)
479 : {
480 2 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
481 2 : int size2 = size * sizeof(CORBA::Long) ;
482 :
483 2 : Align(4) ;
484 :
485 2 : switch (_op)
486 : {
487 : case YAORB::CDR_READ :
488 : {
489 1 : GetBytes(data2, size2) ;
490 : break ;
491 : }
492 : case YAORB::CDR_WRITE :
493 : {
494 1 : PutBytes(data2, size2) ;
495 : break ;
496 : }
497 : }
498 : }
499 : else
500 : {
501 : CORBA::Long *ptr = data ;
502 :
503 8 : for (int i=0 ;
504 : i < size ;
505 : i++ )
506 : {
507 6 : cdr_Long(ptr) ;
508 6 : ptr++ ;
509 : }
510 : }
511 2 : }
512 :
513 : void YAORB::CDR::cdr_ULongArray(CORBA::ULong *data, int size)
514 4 : throw (CORBA::SystemException)
515 : {
516 :
517 4 : if (_order == NativeOrder)
518 : {
519 2 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
520 2 : int size2 = size * sizeof(CORBA::ULong) ;
521 :
522 2 : Align(4) ;
523 :
524 2 : switch (_op)
525 : {
526 : case YAORB::CDR_READ :
527 : {
528 1 : GetBytes(data2, size2) ;
529 : break ;
530 : }
531 : case YAORB::CDR_WRITE :
532 : {
533 1 : PutBytes(data2, size2) ;
534 : break ;
535 : }
536 : }
537 : }
538 : else
539 : {
540 : CORBA::ULong *ptr = data ;
541 :
542 8 : for (int i=0 ;
543 : i < size ;
544 : i++ )
545 : {
546 6 : cdr_ULong(ptr) ;
547 6 : ptr++ ;
548 : }
549 : }
550 2 : }
551 :
552 : void YAORB::CDR::cdr_LongLongArray(CORBA::LongLong *data, int size)
553 4 : throw (CORBA::SystemException)
554 : {
555 :
556 4 : if (_order == NativeOrder)
557 : {
558 2 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
559 2 : int size2 = size * sizeof(CORBA::LongLong) ;
560 :
561 2 : Align(8) ;
562 :
563 2 : switch (_op)
564 : {
565 : case YAORB::CDR_READ :
566 : {
567 1 : GetBytes(data2, size2) ;
568 : break ;
569 : }
570 : case YAORB::CDR_WRITE :
571 : {
572 1 : PutBytes(data2, size2) ;
573 : break ;
574 : }
575 : }
576 : }
577 : else
578 : {
579 : CORBA::LongLong *ptr = data ;
580 :
581 8 : for (int i=0 ;
582 : i < size ;
583 : i++ )
584 : {
585 6 : cdr_LongLong(ptr) ;
586 6 : ptr++ ;
587 : }
588 : }
589 2 : }
590 :
591 : void YAORB::CDR::cdr_ULongLongArray(CORBA::ULongLong *data, int size)
592 4 : throw (CORBA::SystemException)
593 : {
594 :
595 4 : if (_order == NativeOrder)
596 : {
597 2 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
598 2 : int size2 = size * sizeof(CORBA::ULongLong) ;
599 :
600 2 : Align(8) ;
601 :
602 2 : switch (_op)
603 : {
604 : case YAORB::CDR_READ :
605 : {
606 1 : GetBytes(data2, size2) ;
607 : break ;
608 : }
609 : case YAORB::CDR_WRITE :
610 : {
611 1 : PutBytes(data2, size2) ;
612 : break ;
613 : }
614 : }
615 : }
616 : else
617 : {
618 : CORBA::ULongLong *ptr = data ;
619 :
620 8 : for (int i=0 ;
621 : i < size ;
622 : i++ )
623 : {
624 6 : cdr_ULongLong(ptr) ;
625 6 : ptr++ ;
626 : }
627 : }
628 2 : }
629 :
630 : void YAORB::CDR::cdr_FloatArray(CORBA::Float *data, int size)
631 2 : throw (CORBA::SystemException)
632 : {
633 :
634 2 : if (_order == NativeOrder)
635 : {
636 1 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
637 1 : int size2 = size * sizeof(CORBA::Float) ;
638 :
639 1 : Align(4) ;
640 :
641 1 : switch (_op)
642 : {
643 : case YAORB::CDR_READ :
644 : {
645 0 : GetBytes(data2, size2) ;
646 : break ;
647 : }
648 : case YAORB::CDR_WRITE :
649 : {
650 1 : PutBytes(data2, size2) ;
651 : break ;
652 : }
653 : }
654 : }
655 : else
656 : {
657 : CORBA::Float *ptr = data ;
658 :
659 4 : for (int i=0 ;
660 : i < size ;
661 : i++ )
662 : {
663 3 : cdr_Float(ptr) ;
664 3 : ptr++ ;
665 : }
666 : }
667 1 : }
668 :
669 : void YAORB::CDR::cdr_DoubleArray(CORBA::Double *data, int size)
670 2 : throw (CORBA::SystemException)
671 : {
672 :
673 2 : if (_order == NativeOrder)
674 : {
675 1 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
676 1 : int size2 = size * sizeof(CORBA::Double) ;
677 :
678 1 : Align(8) ;
679 :
680 1 : switch (_op)
681 : {
682 : case YAORB::CDR_READ :
683 : {
684 0 : GetBytes(data2, size2) ;
685 : break ;
686 : }
687 : case YAORB::CDR_WRITE :
688 : {
689 1 : PutBytes(data2, size2) ;
690 : break ;
691 : }
692 : }
693 : }
694 : else
695 : {
696 : CORBA::Double *ptr = data ;
697 :
698 4 : for (int i=0 ;
699 : i < size ;
700 : i++ )
701 : {
702 3 : cdr_Double(ptr) ;
703 3 : ptr++ ;
704 : }
705 : }
706 1 : }
707 :
708 : void YAORB::CDR::cdr_LongDoubleArray(CORBA::LongDouble *data, int size)
709 2 : throw (CORBA::SystemException)
710 : {
711 :
712 2 : if (_order == NativeOrder)
713 : {
714 1 : CORBA::Octet *data2 = (CORBA::Octet*) data ;
715 1 : int size2 = size * sizeof(CORBA::LongDouble) ;
716 :
717 1 : Align(8) ; // Yes, 8 bytes not 16
718 :
719 1 : switch (_op)
720 : {
721 : case YAORB::CDR_READ :
722 : {
723 0 : GetBytes(data2, size2) ;
724 : break ;
725 : }
726 : case YAORB::CDR_WRITE :
727 : {
728 1 : PutBytes(data2, size2) ;
729 : break ;
730 : }
731 : }
732 : }
733 : else
734 : {
735 : CORBA::LongDouble *ptr = data ;
736 :
737 4 : for (int i=0 ;
738 : i < size ;
739 : i++ )
740 : {
741 3 : cdr_LongDouble(ptr) ;
742 3 : ptr++ ;
743 : }
744 : }
745 1 : }
746 :
747 43 : int YAORB::CDR::GetPosition(void) const
748 : {
749 : return _position ;
750 : }
751 :
752 : void YAORB::CDR::Align(int boundary)
753 253 : throw (CORBA::SystemException)
754 : {
755 : ASSERT(boundary <= 8) ;
756 :
757 : // MT-Safe : values are garbage anyway.
758 : static CORBA::Octet dummyRead[8] ;
759 :
760 : // MT-Safe : read-only data.
761 : static CORBA::Octet dummyWrite[8] =
762 : {
763 : 0xDE, 0xAD, 0xBE, 0xEF, // 0xDeadBeef
764 : 0xDE, 0xAD, 0xBE, 0xEF // 0xDeadBeef
765 : } ;
766 :
767 253 : int len = boundary - (_position % boundary) ;
768 :
769 253 : if (len != boundary)
770 : {
771 44 : switch (_op)
772 : {
773 : case YAORB::CDR_READ :
774 : {
775 38 : GetBytes( dummyRead, len) ;
776 : break ;
777 : }
778 : case YAORB::CDR_WRITE :
779 : {
780 6 : PutBytes( dummyWrite, len) ;
781 : break ;
782 : }
783 : }
784 : }
785 : }
786 :
787 : void YAORB::CDR::cdr_2bytes(CORBA::Octet *data)
788 43 : throw (CORBA::SystemException)
789 : {
790 : const int length = 2 ;
791 : CORBA::Octet buf[length] ;
792 :
793 43 : switch (_op)
794 : {
795 : case YAORB::CDR_READ :
796 : {
797 25 : if (_order == NativeOrder)
798 : {
799 9 : GetBytes(data, length) ;
800 : }
801 : else
802 : {
803 16 : GetBytes(buf, length) ;
804 16 : data[0] = buf[1] ;
805 16 : data[1] = buf[0] ;
806 : }
807 : break ;
808 : }
809 : case YAORB::CDR_WRITE :
810 : {
811 18 : if (_order == NativeOrder)
812 : {
813 4 : PutBytes(data, length) ;
814 : }
815 : else
816 : {
817 14 : buf[0] = data[1] ;
818 14 : buf[1] = data[0] ;
819 14 : PutBytes(buf, length) ;
820 : }
821 : break ;
822 : }
823 : }
824 : }
825 :
826 : void YAORB::CDR::cdr_4bytes(CORBA::Octet *data)
827 153 : throw (CORBA::SystemException)
828 : {
829 : const int length = 4 ;
830 : CORBA::Octet buf[length] ;
831 :
832 153 : switch (_op)
833 : {
834 : case YAORB::CDR_READ :
835 : {
836 106 : if (_order == NativeOrder)
837 : {
838 46 : GetBytes(data, length) ;
839 : }
840 : else
841 : {
842 60 : GetBytes(buf, length) ;
843 60 : data[0] = buf[3] ;
844 60 : data[1] = buf[2] ;
845 60 : data[2] = buf[1] ;
846 60 : data[3] = buf[0] ;
847 : }
848 : break ;
849 : }
850 : case YAORB::CDR_WRITE :
851 : {
852 47 : if (_order == NativeOrder)
853 : {
854 8 : PutBytes(data, length) ;
855 : }
856 : else
857 : {
858 39 : buf[0] = data[3] ;
859 39 : buf[1] = data[2] ;
860 39 : buf[2] = data[1] ;
861 39 : buf[3] = data[0] ;
862 39 : PutBytes(buf, length) ;
863 : }
864 : break ;
865 : }
866 : }
867 : }
868 :
869 : void YAORB::CDR::cdr_8bytes(CORBA::Octet *data)
870 35 : throw (CORBA::SystemException)
871 : {
872 : const int length = 8 ;
873 : CORBA::Octet buf[length] ;
874 :
875 35 : switch (_op)
876 : {
877 : case YAORB::CDR_READ :
878 : {
879 14 : if (_order == NativeOrder)
880 : {
881 4 : GetBytes(data, length) ;
882 : }
883 : else
884 : {
885 10 : GetBytes(buf, length) ;
886 10 : data[0] = buf[7] ;
887 10 : data[1] = buf[6] ;
888 10 : data[2] = buf[5] ;
889 10 : data[3] = buf[4] ;
890 10 : data[4] = buf[3] ;
891 10 : data[5] = buf[2] ;
892 10 : data[6] = buf[1] ;
893 10 : data[7] = buf[0] ;
894 : }
895 : break ;
896 : }
897 : case YAORB::CDR_WRITE :
898 : {
899 21 : if (_order == NativeOrder)
900 : {
901 6 : PutBytes(data, length) ;
902 : }
903 : else
904 : {
905 15 : buf[0] = data[7] ;
906 15 : buf[1] = data[6] ;
907 15 : buf[2] = data[5] ;
908 15 : buf[3] = data[4] ;
909 15 : buf[4] = data[3] ;
910 15 : buf[5] = data[2] ;
911 15 : buf[6] = data[1] ;
912 15 : buf[7] = data[0] ;
913 15 : PutBytes(buf, length) ;
914 : }
915 : break ;
916 : }
917 : }
918 : }
919 :
920 : void YAORB::CDR::cdr_16bytes(CORBA::Octet *data)
921 7 : throw (CORBA::SystemException)
922 : {
923 : const int length = 16 ;
924 : CORBA::Octet buf[length] ;
925 :
926 7 : switch (_op)
927 : {
928 : case YAORB::CDR_READ :
929 : {
930 0 : if (_order == NativeOrder)
931 : {
932 0 : GetBytes(data, length) ;
933 : }
934 : else
935 : {
936 0 : GetBytes(buf, length) ;
937 0 : data[ 0] = buf[15] ;
938 0 : data[ 1] = buf[14] ;
939 0 : data[ 2] = buf[13] ;
940 0 : data[ 3] = buf[12] ;
941 0 : data[ 4] = buf[11] ;
942 0 : data[ 5] = buf[10] ;
943 0 : data[ 6] = buf[ 9] ;
944 0 : data[ 7] = buf[ 8] ;
945 0 : data[ 8] = buf[ 7] ;
946 0 : data[ 9] = buf[ 6] ;
947 0 : data[10] = buf[ 5] ;
948 0 : data[11] = buf[ 4] ;
949 0 : data[12] = buf[ 3] ;
950 0 : data[13] = buf[ 2] ;
951 0 : data[14] = buf[ 1] ;
952 0 : data[15] = buf[ 0] ;
953 : }
954 : break ;
955 : }
956 : case YAORB::CDR_WRITE :
957 : {
958 7 : if (_order == NativeOrder)
959 : {
960 2 : PutBytes(data, length) ;
961 : }
962 : else
963 : {
964 5 : buf[ 0] = data[15] ;
965 5 : buf[ 1] = data[14] ;
966 5 : buf[ 2] = data[13] ;
967 5 : buf[ 3] = data[12] ;
968 5 : buf[ 4] = data[11] ;
969 5 : buf[ 5] = data[10] ;
970 5 : buf[ 6] = data[ 9] ;
971 5 : buf[ 7] = data[ 8] ;
972 5 : buf[ 8] = data[ 7] ;
973 5 : buf[ 9] = data[ 6] ;
974 5 : buf[10] = data[ 5] ;
975 5 : buf[11] = data[ 4] ;
976 5 : buf[12] = data[ 3] ;
977 5 : buf[13] = data[ 2] ;
978 5 : buf[14] = data[ 1] ;
979 5 : buf[15] = data[ 0] ;
980 5 : PutBytes(buf, length) ;
981 : }
982 : break ;
983 : }
984 : }
985 : }
986 :
|
