wrapper/xim/IMdkit/FrameMgr.c

   1 /******************************************************************
   2 Copyright 1993, 1994 by Digital Equipment Corporation, Maynard, Massachusetts,
   3
   4                         All Rights Reserved
   5
   6 Permission to use, copy, modify, and distribute this software and its
   7 documentation for any purpose and without fee is hereby granted,
   8 provided that the above copyright notice appear in all copies and that
   9 both that copyright notice and this permission notice appear in
  10 supporting documentation, and that the names of Digital or MIT not be
  11 used in advertising or publicity pertaining to distribution of the
  12 software without specific, written prior permission.
  13
  14 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  15 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  16 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  17 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  18 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  19 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  20 SOFTWARE.
  21
  22   Author: Hiroyuki Miyamoto  Digital Equipment Corporation
  23                              miyamoto@jrd.dec.com
  24
  25     This version tidied and debugged by Steve Underwood May 1999
  26
  27 ******************************************************************/
  28
  29 #include <X11/Xlibint.h>
  30 #include <stdlib.h>
  31 #include "FrameMgr.h"
  32
  33 /* Convenient macro */
  34
  35 #define _UNIT(n)   ((int)(n) & 0xFF)
  36 #define _NUMBER(n) (((int)(n) >> 8) & 0xFF)
  37
  38 /* For byte swapping */
  39
  40 #define Swap16(p, n) ((p)->byte_swap ?       \
  41 (((n) << 8 & 0xFF00) | \
  42  ((n) >> 8 & 0xFF)     \
  43 ) : n)
  44 #define Swap32(p, n) ((p)->byte_swap ?            \
  45         (((n) << 24 & 0xFF000000) | \
  46          ((n) <<  8 & 0xFF0000) |   \
  47          ((n) >>  8 & 0xFF00) |     \
  48          ((n) >> 24 & 0xFF)         \
  49         ) : n)
  50 #define Swap64(p, n) ((p)->byte_swap ?            \
  51         (((n) << 56 & 0xFF00000000000000) | \
  52          ((n) << 40 & 0xFF000000000000) |   \
  53          ((n) << 24 & 0xFF0000000000) |     \
  54          ((n) <<  8 & 0xFF00000000) |       \
  55          ((n) >>  8 & 0xFF000000) |         \
  56          ((n) >> 24 & 0xFF0000) |           \
  57          ((n) >> 40 & 0xFF00) |             \
  58          ((n) >> 56 & 0xFF)                 \
  59         ) : n)
  60
  61 /* Type definition */
  62
  63 typedef struct _Iter *Iter;
  64
  65 typedef struct _FrameInst *FrameInst;
  66
  67 typedef union
  68 {
  69     int num;            /* For BARRAY */
  70     FrameInst fi;       /* For POINTER */
  71     Iter iter;          /* For ITER */
  72 } ExtraDataRec, *ExtraData;
  73
  74 typedef struct _Chain
  75 {
  76     ExtraDataRec d;
  77     int frame_no;
  78     struct _Chain *next;
  79 } ChainRec, *Chain;
  80
  81 typedef struct _ChainMgr
  82 {
  83     Chain top;
  84     Chain tail;
  85 } ChainMgrRec, *ChainMgr;
  86
  87 typedef struct _ChainIter
  88 {
  89     Chain cur;
  90 } ChainIterRec, *ChainIter;
  91
  92 typedef struct _FrameIter
  93 {
  94     Iter iter;
  95     Bool counting;
  96     unsigned int counter;
  97     int end;
  98     struct _FrameIter* next;
  99 } FrameIterRec, *FrameIter;
 100
 101 typedef struct _FrameInst
 102 {
 103     XimFrame template;
 104     ChainMgrRec cm;
 105     int cur_no;
 106 } FrameInstRec;
 107
 108 typedef void (*IterStartWatchProc) (Iter it, void *client_data);
 109
 110 typedef struct _Iter
 111 {
 112     XimFrame template;
 113     int max_count;
 114     Bool allow_expansion;
 115     ChainMgrRec cm;
 116     int cur_no;
 117     IterStartWatchProc start_watch_proc;
 118     void *client_data;
 119     Bool start_counter;
 120 } IterRec;
 121
 122 typedef struct _FrameMgr
 123 {
 124     XimFrame frame;
 125     FrameInst fi;
 126     char *area;
 127     int idx;
 128     Bool byte_swap;
 129     int total_size;
 130     FrameIter iters;
 131 } FrameMgrRec;
 132
 133 typedef union
 134 {
 135     int num;           /* For BARRAY and PAD */
 136     struct
 137     {          /* For COUNTER_* */
 138         Iter iter;
 139         Bool is_byte_len;
 140     } counter;
 141 } XimFrameTypeInfoRec, *XimFrameTypeInfo;
 142
 143 /* Special values */
 144 #define NO_VALUE -1
 145 #define NO_VALID_FIELD -2
 146
 147 static FrameInst FrameInstInit(XimFrame frame);
 148 static void FrameInstFree(FrameInst fi);
 149 static XimFrameType FrameInstGetNextType(FrameInst fi, XimFrameTypeInfo info);
 150 static XimFrameType FrameInstPeekNextType(FrameInst fi, XimFrameTypeInfo info);
 151 static FmStatus FrameInstSetSize(FrameInst fi, int num);
 152 static FmStatus FrameInstSetIterCount(FrameInst fi, int num);
 153 static int FrameInstGetTotalSize(FrameInst fi);
 154 static void FrameInstReset(FrameInst fi);
 155
 156 static Iter IterInit(XimFrame frame, int count);
 157 static void IterFree(Iter it);
 158 static int FrameInstGetSize(FrameInst fi);
 159 static int IterGetSize(Iter it);
 160 static XimFrameType IterGetNextType(Iter it, XimFrameTypeInfo info);
 161 static XimFrameType IterPeekNextType(Iter it, XimFrameTypeInfo info);
 162 static FmStatus IterSetSize(Iter it, int num);
 163 static FmStatus IterSetIterCount(Iter it, int num);
 164 static int IterGetTotalSize(Iter it);
 165 static void IterReset(Iter it);
 166 static Bool IterIsLoopEnd(Iter it, Bool* myself);
 167 static void IterSetStartWatch(Iter it, IterStartWatchProc proc, void* client_data);
 168 static void _IterStartWatch(Iter it, void* client_data);
 169
 170 static ExtraData ChainMgrGetExtraData(ChainMgr cm, int frame_no);
 171 static ExtraData ChainMgrSetData(ChainMgr cm, int frame_no,
 172                                  ExtraDataRec data);
 173 static Bool ChainIterGetNext(ChainIter ci, int* frame_no, ExtraData d);
 174 static int _FrameInstIncrement(XimFrame frame, int count);
 175 static int _FrameInstDecrement(XimFrame frame, int count);
 176 static int _FrameInstGetItemSize(FrameInst fi, int cur_no);
 177 static Bool FrameInstIsIterLoopEnd(FrameInst fi);
 178
 179 static FrameIter _FrameMgrAppendIter(FrameMgr fm, Iter it, int end);
 180 static FrameIter _FrameIterCounterIncr(FrameIter fitr, int i);
 181 static void _FrameMgrRemoveIter(FrameMgr fm, FrameIter it);
 182 static Bool _FrameMgrIsIterLoopEnd(FrameMgr fm);
 183 static Bool _FrameMgrProcessPadding(FrameMgr fm, FmStatus* status);
 184
 185 #define IterGetIterCount(it) ((it)->allow_expansion ? \
 186 NO_VALUE : (it)->max_count)
 187
 188 #define IterFixIteration(it) ((it)->allow_expansion = False)
 189
 190 #define IterSetStarter(it) ((it)->start_counter = True)
 191
 192 #define ChainMgrInit(cm) (cm)->top = (cm)->tail = NULL
 193 #define ChainMgrFree(cm)                \
 194 {                                       \
 195     Chain tmp;                          \
 196     Chain cur = (cm)->top;              \
 197                                         \
 198     while (cur)                         \
 199     {                                   \
 200         tmp = cur->next;                \
 201         Xfree (cur);                    \
 202         cur = tmp;                      \
 203     }                                   \
 204 }
 205
 206 #define ChainIterInit(ci, cm)           \
 207 {                                       \
 208     (ci)->cur = (cm)->top;              \
 209 }
 210
 211 /* ChainIterFree has nothing to do. */
 212 #define ChainIterFree(ci)
 213
 214 #define FrameInstIsEnd(fi) ((fi)->template[(fi)->cur_no].type == EOL)
 215
 216 FrameMgr FrameMgrInit (XimFrame frame, char* area, Bool byte_swap)
 217 {
 218     FrameMgr fm;
 219
 220     fm = (FrameMgr) Xmalloc (sizeof (FrameMgrRec));
 221
 222     fm->frame = frame;
 223     fm->fi = FrameInstInit (frame);
 224     fm->area = (char *) area;
 225     fm->idx = 0;
 226     fm->byte_swap = byte_swap;
 227     fm->total_size = NO_VALUE;
 228     fm->iters = NULL;
 229
 230     return fm;
 231 }
 232
 233 void FrameMgrInitWithData (FrameMgr fm,
 234                            XimFrame frame,
 235                            void * area,
 236                            Bool byte_swap)
 237 {
 238     fm->frame = frame;
 239     fm->fi = FrameInstInit (frame);
 240     fm->area = (char *) area;
 241     fm->idx = 0;
 242     fm->byte_swap = byte_swap;
 243     fm->total_size = NO_VALUE;
 244 }
 245
 246 void FrameMgrFree (FrameMgr fm)
 247 {
 248     FrameIter p, cur;
 249
 250     p = fm->iters;
 251     cur = p;
 252
 253     while (p)
 254     {
 255         p = p->next;
 256         Xfree (cur);
 257         cur = p;
 258     }
 259     /*endwhile*/
 260
 261     FrameInstFree (fm->fi);
 262     Xfree (fm);
 263 }
 264
 265 FmStatus FrameMgrSetBuffer (FrameMgr fm, void* area)
 266 {
 267     if (fm->area)
 268         return FmBufExist;
 269     fm->area = (char *) area;
 270     return FmSuccess;
 271 }
 272
 273 FmStatus _FrameMgrPutToken (FrameMgr fm, void *data, int data_size)
 274 {
 275     XimFrameType type;
 276     XimFrameTypeInfoRec info;
 277
 278     if (fm->total_size != NO_VALUE  &&  fm->idx >= fm->total_size)
 279         return FmNoMoreData;
 280     /*endif*/
 281
 282     type = FrameInstGetNextType(fm->fi, &info);
 283
 284     if (type & COUNTER_MASK)
 285     {
 286         unsigned long input_length;
 287
 288         if (info.counter.is_byte_len)
 289         {
 290             if ((input_length = IterGetTotalSize (info.counter.iter))
 291                     == NO_VALUE)
 292             {
 293                 return FmCannotCalc;
 294             }
 295             /*endif*/
 296         }
 297         else
 298         {
 299             if ((input_length = IterGetIterCount (info.counter.iter))
 300                 == NO_VALUE)
 301             {
 302                 return FmCannotCalc;
 303             }
 304             /*endif*/
 305         }
 306         /*endif*/
 307         switch (type)
 308         {
 309         case COUNTER_BIT8:
 310             *(CARD8 *) (fm->area + fm->idx) = input_length;
 311             fm->idx++;
 312             break;
 313
 314         case COUNTER_BIT16:
 315             *(CARD16 *) (fm->area + fm->idx) = Swap16 (fm, input_length);
 316             fm->idx += 2;
 317             break;
 318
 319         case COUNTER_BIT32:
 320             *(CARD32 *) (fm->area + fm->idx) = Swap32 (fm, input_length);
 321             fm->idx += 4;
 322             break;
 323
 324 #if defined(_NEED64BIT)
 325         case COUNTER_BIT64:
 326             *(CARD64 *) (fm->area + fm->idx) = Swap64 (fm, input_length);
 327             fm->idx += 8;
 328             break;
 329 #endif
 330         default:
 331             break;
 332         }
 333         /*endswitch*/
 334         _FrameMgrPutToken(fm, data, data_size);
 335         return FmSuccess;
 336     }
 337     /*endif*/
 338
 339     switch (type)
 340     {
 341     case BIT8:
 342         if (data_size == sizeof (unsigned char))
 343         {
 344             unsigned long num = *(unsigned char *) data;
 345             *(CARD8 *) (fm->area + fm->idx) = num;
 346         }
 347         else if (data_size == sizeof (unsigned short))
 348         {
 349             unsigned long num = *(unsigned short *) data;
 350             *(CARD8 *) (fm->area + fm->idx) = num;
 351         }
 352         else if (data_size == sizeof (unsigned int))
 353         {
 354             unsigned long num = *(unsigned int *) data;
 355             *(CARD8 *) (fm->area + fm->idx) = num;
 356         }
 357         else if (data_size == sizeof (unsigned long))
 358         {
 359             unsigned long num = *(unsigned long *) data;
 360             *(CARD8 *) (fm->area + fm->idx) = num;
 361         }
 362         else
 363         {
 364             ; /* Should never be reached */
 365         }
 366         /*endif*/
 367         fm->idx++;
 368         return FmSuccess;
 369
 370     case BIT16:
 371         if (data_size == sizeof (unsigned char))
 372         {
 373             unsigned long num = *(unsigned char *) data;
 374             *(CARD16*)(fm->area + fm->idx) = Swap16 (fm, num);
 375         }
 376         else if (data_size == sizeof (unsigned short))
 377         {
 378             unsigned long num = *(unsigned short *) data;
 379             *(CARD16 *) (fm->area + fm->idx) = Swap16 (fm, num);
 380         }
 381         else if (data_size == sizeof (unsigned int))
 382         {
 383             unsigned long num = *(unsigned int *) data;
 384             *(CARD16 *) (fm->area + fm->idx) = Swap16 (fm, num);
 385         }
 386         else if (data_size == sizeof (unsigned long))
 387         {
 388             unsigned long num = *(unsigned long *) data;
 389             *(CARD16 *) (fm->area + fm->idx) = Swap16 (fm, num);
 390         }
 391         else
 392         {
 393             ; /* Should never reached */
 394         }
 395         /*endif*/
 396         fm->idx += 2;
 397         return FmSuccess;
 398
 399     case BIT32:
 400         if (data_size == sizeof (unsigned char))
 401         {
 402             unsigned long num = *(unsigned char *) data;
 403             *(CARD32 *) (fm->area + fm->idx) = Swap32 (fm, num);
 404         }
 405         else if (data_size == sizeof (unsigned short))
 406         {
 407             unsigned long num = *(unsigned short *) data;
 408             *(CARD32 *) (fm->area + fm->idx) = Swap32 (fm, num);
 409         }
 410         else if (data_size == sizeof (unsigned int))
 411         {
 412             unsigned long num = *(unsigned int *) data;
 413             *(CARD32 *) (fm->area + fm->idx) = Swap32 (fm, num);
 414         }
 415         else if (data_size == sizeof (unsigned long))
 416         {
 417             unsigned long num = *(unsigned long *) data;
 418             *(CARD32 *) (fm->area + fm->idx) = Swap32 (fm, num);
 419         }
 420         else
 421         {
 422             ; /* Should never reached */
 423         }
 424         /*endif*/
 425         fm->idx += 4;
 426         return FmSuccess;
 427
 428 #if defined(_NEED64BIT)
 429     case BIT64:
 430         if (data_size == sizeof (unsigned char))
 431         {
 432             unsigned long num = *(unsigned char *) data;
 433             *(CARD64 *) (fm->area + fm->idx) = Swap64 (fm, num);
 434         }
 435         else if (data_size == sizeof (unsigned short))
 436         {
 437             unsigned long num = *(unsigned short *) data;
 438             *(CARD64 *) (fm->area + fm->idx) = Swap64 (fm, num);
 439         }
 440         else if (data_size == sizeof (unsigned int))
 441         {
 442             unsigned long num = *(unsigned int *) data;
 443             *(CARD64 *) (fm->area + fm->idx) = Swap64 (fm, num);
 444         }
 445         else if (data_size == sizeof (unsigned long))
 446         {
 447             unsigned long num = *(unsigned long *) data;
 448             *(CARD64 *) (fm->area + fm->idx) = Swap64 (fm, num);
 449         }
 450         else
 451         {
 452             ; /* Should never reached */
 453         }
 454         /*endif*/
 455         fm->idx += 4;
 456         return FmSuccess;
 457 #endif
 458
 459     case BARRAY:
 460         if (info.num == NO_VALUE)
 461             return FmInvalidCall;
 462         /*endif*/
 463         if (info.num > 0)
 464         {
 465             bcopy (*(char **) data, fm->area + fm->idx, info.num);
 466             fm->idx += info.num;
 467         }
 468         /*endif*/
 469         return FmSuccess;
 470
 471     case PADDING:
 472         if (info.num == NO_VALUE)
 473             return FmInvalidCall;
 474         /*endif*/
 475         fm->idx += info.num;
 476         return _FrameMgrPutToken(fm, data, data_size);
 477
 478     case ITER:
 479         return FmInvalidCall;
 480
 481     case EOL:
 482         return FmEOD;
 483     default:
 484         break;
 485     }
 486     /*endswitch*/
 487     return (FmStatus) NULL;  /* Should never be reached */
 488 }
 489
 490 FmStatus _FrameMgrGetToken (FrameMgr fm , void* data, int data_size)
 491 {
 492     XimFrameType type;
 493     static XimFrameTypeInfoRec info;  /* memory */
 494     FrameIter fitr;
 495
 496     if (fm->total_size != NO_VALUE  &&  fm->idx >= fm->total_size)
 497         return FmNoMoreData;
 498     /*endif*/
 499
 500     type = FrameInstGetNextType(fm->fi, &info);
 501
 502     if (type & COUNTER_MASK)
 503     {
 504         int end=0;
 505         FrameIter client_data;
 506
 507         type &= ~COUNTER_MASK;
 508         switch (type)
 509         {
 510         case BIT8:
 511             end = *(CARD8 *) (fm->area + fm->idx);
 512             break;
 513
 514         case BIT16:
 515             end = Swap16 (fm, *(CARD16 *) (fm->area + fm->idx));
 516             break;
 517
 518         case BIT32:
 519             end = Swap32 (fm, *(CARD32 *) (fm->area + fm->idx));
 520             break;
 521
 522 #if defined(_NEED64BIT)
 523         case BIT64:
 524             end = Swap64 (fm, *(CARD64 *) (fm->area + fm->idx));
 525             break;
 526 #endif
 527         default:
 528             break;
 529         }
 530         /*endswitch*/
 531
 532         if ((client_data = _FrameMgrAppendIter (fm, info.counter.iter, end)))
 533         {
 534             IterSetStarter (info.counter.iter);
 535             IterSetStartWatch (info.counter.iter,
 536                                _IterStartWatch,
 537                                (void *) client_data);
 538         }
 539         /*endif*/
 540     }
 541     /*endif*/
 542
 543     type &= ~COUNTER_MASK;
 544     switch (type)
 545     {
 546     case BIT8:
 547         if (data_size == sizeof (unsigned char))
 548         {
 549             *(unsigned char*) data = *(CARD8 *) (fm->area + fm->idx);
 550         }
 551         else if (data_size == sizeof (unsigned short))
 552         {
 553             *(unsigned short *) data = *(CARD8 *) (fm->area + fm->idx);
 554         }
 555         else if (data_size == sizeof (unsigned int))
 556         {
 557             *(unsigned int *) data = *(CARD8 *) (fm->area + fm->idx);
 558         }
 559         else if (data_size == sizeof (unsigned long))
 560         {
 561             *(unsigned long *) data = *(CARD8 *) (fm->area + fm->idx);
 562         }
 563         else
 564         {
 565             ; /* Should never reached */
 566         }
 567         /*endif*/
 568         fm->idx++;
 569         if ((fitr = _FrameIterCounterIncr (fm->iters, 1/*BIT8*/)))
 570             _FrameMgrRemoveIter (fm, fitr);
 571         /*endif*/
 572         return FmSuccess;
 573
 574     case BIT16:
 575         if (data_size == sizeof (unsigned char))
 576         {
 577             *(unsigned char *) data =
 578                 Swap16 (fm, *(CARD16 *) (fm->area + fm->idx));
 579         }
 580         else if (data_size == sizeof (unsigned short))
 581         {
 582             *(unsigned short *) data =
 583                 Swap16 (fm, *(CARD16 *) (fm->area + fm->idx));
 584         }
 585         else if (data_size == sizeof (unsigned int))
 586         {
 587             *(unsigned int *) data =
 588                 Swap16 (fm, *(CARD16 *) (fm->area + fm->idx));
 589         }
 590         else if (data_size == sizeof (unsigned long))
 591         {
 592             *(unsigned long *) data =
 593                 Swap16 (fm, *(CARD16 *) (fm->area + fm->idx));
 594         }
 595         else
 596         {
 597             ; /* Should never reached */
 598         }
 599         /*endif*/
 600         fm->idx += 2;
 601         if ((fitr = _FrameIterCounterIncr (fm->iters, 2/*BIT16*/)))
 602             _FrameMgrRemoveIter(fm, fitr);
 603         /*endif*/
 604         return FmSuccess;
 605
 606     case BIT32:
 607         if (data_size == sizeof (unsigned char))
 608         {
 609             *(unsigned char *) data =
 610                 Swap32 (fm, *(CARD32 *) (fm->area + fm->idx));
 611         }
 612         else if (data_size == sizeof (unsigned short))
 613         {
 614             *(unsigned short *) data =
 615                 Swap32 (fm, *(CARD32 *) (fm->area + fm->idx));
 616         }
 617         else if (data_size == sizeof (unsigned int))
 618         {
 619             *(unsigned int *) data =
 620                 Swap32 (fm, *(CARD32 *) (fm->area + fm->idx));
 621         }
 622         else if (data_size == sizeof (unsigned long))
 623         {
 624             *(unsigned long *) data =
 625                 Swap32 (fm, *(CARD32 *) (fm->area + fm->idx));
 626         }
 627         else
 628         {
 629             ; /* Should never reached */
 630         }
 631         /*endif*/
 632         fm->idx += 4;
 633         if ((fitr = _FrameIterCounterIncr (fm->iters, 4/*BIT32*/)))
 634             _FrameMgrRemoveIter (fm, fitr);
 635         /*endif*/
 636         return FmSuccess;
 637
 638 #if defined(_NEED64BIT)
 639     case BIT64:
 640         if (data_size == sizeof (unsigned char))
 641         {
 642             *(unsigned char *) data =
 643                 Swap64 (fm, *(CARD64 *) (fm->area + fm->idx));
 644         }
 645         else if (data_size == sizeof (unsigned short))
 646         {
 647             *(unsigned short *) data =
 648                 Swap64 (fm, *(CARD64 *) (fm->area + fm->idx));
 649         }
 650         else if (data_size == sizeof (unsigned int))
 651         {
 652             *(unsigned int *) data =
 653                 Swap64 (fm, *(CARD64 *) (fm->area + fm->idx));
 654         }
 655         else if (data_size == sizeof (unsigned long))
 656         {
 657             *(unsigned long *) data =
 658                 Swap64 (fm, *(CARD64 *) (fm->area + fm->idx));
 659         }
 660         else
 661         {
 662             ; /* Should never reached */
 663         }
 664         /*endif*/
 665         fm->idx += 8;
 666         if ((fitr = _FrameIterCounterIncr (fm->iters, 8/*BIT64*/)))
 667             _FrameMgrRemoveIter (fm, fitr);
 668         /*endif*/
 669         return FmSuccess;
 670 #endif
 671
 672     case BARRAY:
 673         if (info.num == NO_VALUE)
 674             return FmInvalidCall;
 675         /*endif*/
 676         if (info.num > 0)
 677         {
 678             *(char **) data = fm->area + fm->idx;
 679
 680             fm->idx += info.num;
 681             if ((fitr = _FrameIterCounterIncr (fm->iters, info.num)))
 682                 _FrameMgrRemoveIter (fm, fitr);
 683             /*endif*/
 684         }
 685         else
 686         {
 687             *(char **) data = NULL;
 688         }
 689         /*endif*/
 690         return FmSuccess;
 691
 692     case PADDING:
 693         if (info.num == NO_VALUE)
 694             return FmInvalidCall;
 695         /*endif*/
 696         fm->idx += info.num;
 697         if ((fitr = _FrameIterCounterIncr (fm->iters, info.num)))
 698             _FrameMgrRemoveIter (fm, fitr);
 699         /*endif*/
 700         return _FrameMgrGetToken (fm, data, data_size);
 701
 702     case ITER:
 703         return FmInvalidCall;   /* if comes here, it's a bug! */
 704
 705     case EOL:
 706         return FmEOD;
 707     default:
 708         break;
 709     }
 710     /*endswitch*/
 711     return (FmStatus) NULL;  /* Should never be reached */
 712 }
 713
 714 FmStatus FrameMgrSetSize (FrameMgr fm, int barray_size)
 715 {
 716     if (FrameInstSetSize (fm->fi, barray_size) == FmSuccess)
 717         return FmSuccess;
 718     /*endif*/
 719     return FmNoMoreData;
 720 }
 721
 722 FmStatus FrameMgrSetIterCount (FrameMgr fm, int count)
 723 {
 724     if (FrameInstSetIterCount (fm->fi, count) == FmSuccess)
 725         return FmSuccess;
 726     /*endif*/
 727     return FmNoMoreData;
 728 }
 729
 730 FmStatus FrameMgrSetTotalSize (FrameMgr fm, int total_size)
 731 {
 732     fm->total_size = total_size;
 733     return FmSuccess;
 734 }
 735
 736 int FrameMgrGetTotalSize (FrameMgr fm)
 737 {
 738     return FrameInstGetTotalSize (fm->fi);
 739 }
 740
 741 int FrameMgrGetSize (FrameMgr fm)
 742 {
 743     register int ret_size;
 744
 745     ret_size = FrameInstGetSize (fm->fi);
 746     if (ret_size == NO_VALID_FIELD)
 747         return NO_VALUE;
 748     /*endif*/
 749     return ret_size;
 750 }
 751
 752 FmStatus FrameMgrSkipToken (FrameMgr fm, int skip_count)
 753 {
 754     XimFrameType type;
 755     XimFrameTypeInfoRec info;
 756     register int i;
 757
 758     if (fm->total_size != NO_VALUE  &&  fm->idx >= fm->total_size)
 759         return FmNoMoreData;
 760     /*endif*/
 761     for (i = 0;  i < skip_count;  i++)
 762     {
 763         type = FrameInstGetNextType (fm->fi, &info);
 764         type &= ~COUNTER_MASK;
 765
 766         switch (type)
 767         {
 768         case BIT8:
 769             fm->idx++;
 770             break;
 771
 772         case BIT16:
 773             fm->idx += 2;
 774             break;
 775
 776         case BIT32:
 777             fm->idx += 4;
 778             break;
 779
 780         case BIT64:
 781             fm->idx += 8;
 782             break;
 783
 784         case BARRAY:
 785             if (info.num == NO_VALUE)
 786                 return FmInvalidCall;
 787             /*endif*/
 788             fm->idx += info.num;
 789             break;
 790
 791         case PADDING:
 792             if (info.num == NO_VALUE)
 793                 return FmInvalidCall;
 794             /*endif*/
 795             fm->idx += info.num;
 796             return FrameMgrSkipToken (fm, skip_count);
 797
 798         case ITER:
 799             return FmInvalidCall;
 800
 801         case EOL:
 802             return FmEOD;
 803         default:
 804             break;
 805         }
 806         /*endswitch*/
 807     }
 808     /*endfor*/
 809     return FmSuccess;
 810 }
 811
 812 void FrameMgrReset (FrameMgr fm)
 813 {
 814     fm->idx = 0;
 815     FrameInstReset (fm->fi);
 816 }
 817
 818 Bool FrameMgrIsIterLoopEnd (FrameMgr fm, FmStatus* status)
 819 {
 820     do
 821     {
 822         if (_FrameMgrIsIterLoopEnd (fm))
 823             return  True;
 824         /*endif*/
 825     }
 826     while (_FrameMgrProcessPadding (fm, status));
 827
 828     return False;
 829 }
 830
 831
 832 /* Internal routines */
 833
 834 static Bool _FrameMgrIsIterLoopEnd (FrameMgr fm)
 835 {
 836     return FrameInstIsIterLoopEnd (fm->fi);
 837 }
 838
 839 static Bool _FrameMgrProcessPadding (FrameMgr fm, FmStatus* status)
 840 {
 841     XimFrameTypeInfoRec info;
 842     XimFrameType next_type = FrameInstPeekNextType (fm->fi, &info);
 843     FrameIter fitr;
 844
 845     if (next_type == PADDING)
 846     {
 847         if (info.num == NO_VALUE)
 848         {
 849             *status = FmInvalidCall;
 850             return True;
 851         }
 852         /*endif*/
 853         next_type = FrameInstGetNextType (fm->fi, &info);
 854         fm->idx += info.num;
 855         if ((fitr = _FrameIterCounterIncr (fm->iters, info.num)))
 856             _FrameMgrRemoveIter (fm, fitr);
 857         /*endif*/
 858         *status = FmSuccess;
 859         return True;
 860     }
 861     /*endif*/
 862     *status = FmSuccess;
 863     return False;
 864 }
 865
 866 static FrameInst FrameInstInit (XimFrame frame)
 867 {
 868     FrameInst fi;
 869
 870     fi = (FrameInst) Xmalloc (sizeof (FrameInstRec));
 871
 872     fi->template = frame;
 873     fi->cur_no = 0;
 874     ChainMgrInit (&fi->cm);
 875     return fi;
 876 }
 877
 878 static void FrameInstFree (FrameInst fi)
 879 {
 880     ChainIterRec ci;
 881     int frame_no;
 882     ExtraDataRec d;
 883
 884     ChainIterInit (&ci, &fi->cm);
 885
 886     while (ChainIterGetNext (&ci, &frame_no, &d))
 887     {
 888         register XimFrameType type;
 889         type = fi->template[frame_no].type;
 890         if (type == ITER)
 891         {
 892             if (d.iter)
 893                 IterFree (d.iter);
 894             /*endif*/
 895         }
 896         else if (type == POINTER)
 897         {
 898             if (d.fi)
 899                 FrameInstFree (d.fi);
 900             /*endif*/
 901         }
 902         /*endif*/
 903     }
 904     /*endwhile*/
 905     ChainIterFree (&ci);
 906     ChainMgrFree (&fi->cm);
 907     Xfree (fi);
 908 }
 909
 910 static XimFrameType FrameInstGetNextType(FrameInst fi, XimFrameTypeInfo info)
 911 {
 912     XimFrameType ret_type;
 913
 914     ret_type = fi->template[fi->cur_no].type;
 915
 916     switch (ret_type)
 917     {
 918     case BIT8:
 919     case BIT16:
 920     case BIT32:
 921     case BIT64:
 922     case EOL:
 923         fi->cur_no = _FrameInstIncrement(fi->template, fi->cur_no);
 924         break;
 925
 926     case COUNTER_BIT8:
 927     case COUNTER_BIT16:
 928     case COUNTER_BIT32:
 929     case COUNTER_BIT64:
 930         if (info)
 931         {
 932             register int offset, iter_idx;
 933
 934             info->counter.is_byte_len =
 935                 (((long) fi->template[fi->cur_no].data & 0xFF)) == FmCounterByte;
 936             offset = ((long) fi->template[fi->cur_no].data) >> 8;
 937             iter_idx = fi->cur_no + offset;
 938             if (fi->template[iter_idx].type == ITER)
 939             {
 940                 ExtraData d;
 941                 ExtraDataRec dr;
 942
 943                 if ((d = ChainMgrGetExtraData (&fi->cm, iter_idx)) == NULL)
 944                 {
 945                     dr.iter = IterInit (&fi->template[iter_idx + 1], NO_VALUE);
 946                     d = ChainMgrSetData (&fi->cm, iter_idx, dr);
 947                 }
 948                 /*endif*/
 949                 info->counter.iter = d->iter;
 950             }
 951             else
 952             {
 953                 /* Should never reach here */
 954             }
 955             /*endif*/
 956         }
 957         /*endif*/
 958         fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
 959         break;
 960
 961     case BARRAY:
 962         if (info)
 963         {
 964             ExtraData d;
 965
 966             if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
 967                 info->num = NO_VALUE;
 968             else
 969                 info->num = d->num;
 970             /*endif*/
 971         }
 972         /*endif*/
 973         fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
 974         break;
 975
 976     case PADDING:
 977         if (info)
 978         {
 979             register int unit;
 980             register int number;
 981             register int size;
 982             register int i;
 983
 984             unit = _UNIT ((long) fi->template[fi->cur_no].data);
 985             number = _NUMBER ((long) fi->template[fi->cur_no].data);
 986
 987             i = fi->cur_no;
 988             size = 0;
 989             while (number > 0)
 990             {
 991                 i = _FrameInstDecrement (fi->template, i);
 992                 size += _FrameInstGetItemSize (fi, i);
 993                 number--;
 994             }
 995             /*endwhile*/
 996             info->num = (unit - (size%unit))%unit;
 997         }
 998         /*endif*/
 999         fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
1000         break;
1001
1002     case ITER:
1003         {
1004             ExtraData d;
1005             ExtraDataRec dr;
1006             XimFrameType sub_type;
1007
1008
1009             if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
1010             {
1011                 dr.iter = IterInit (&fi->template[fi->cur_no + 1], NO_VALUE);
1012                 d = ChainMgrSetData (&fi->cm, fi->cur_no, dr);
1013             }
1014             /*endif*/
1015             sub_type = IterGetNextType (d->iter, info);
1016             if (sub_type == EOL)
1017             {
1018                 fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
1019                 ret_type = FrameInstGetNextType (fi, info);
1020             }
1021             else
1022             {
1023                 ret_type = sub_type;
1024             }
1025             /*endif*/
1026         }
1027         break;
1028
1029     case POINTER:
1030         {
1031             ExtraData d;
1032             ExtraDataRec dr;
1033             XimFrameType sub_type;
1034
1035             if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
1036             {
1037                 dr.fi = FrameInstInit (fi->template[fi->cur_no + 1].data);
1038                 d = ChainMgrSetData (&fi->cm, fi->cur_no, dr);
1039             }
1040             /*endif*/
1041             sub_type = FrameInstGetNextType (d->fi, info);
1042             if (sub_type == EOL)
1043             {
1044                 fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
1045                 ret_type = FrameInstGetNextType (fi, info);
1046             }
1047             else
1048             {
1049                 ret_type = sub_type;
1050             }
1051             /*endif*/
1052         }
1053         break;
1054     default:
1055         break;
1056     }
1057     /*endswitch*/
1058     return ret_type;
1059 }
1060
1061 static XimFrameType FrameInstPeekNextType (FrameInst fi, XimFrameTypeInfo info)
1062 {
1063     XimFrameType ret_type;
1064
1065     ret_type = fi->template[fi->cur_no].type;
1066
1067     switch (ret_type)
1068     {
1069     case BIT8:
1070     case BIT16:
1071     case BIT32:
1072     case BIT64:
1073     case EOL:
1074         break;
1075
1076     case COUNTER_BIT8:
1077     case COUNTER_BIT16:
1078     case COUNTER_BIT32:
1079     case COUNTER_BIT64:
1080         if (info)
1081         {
1082             register int offset;
1083             register int iter_idx;
1084
1085             info->counter.is_byte_len =
1086                 (((long) fi->template[fi->cur_no].data) & 0xFF) == FmCounterByte;
1087             offset = ((long)fi->template[fi->cur_no].data) >> 8;
1088             iter_idx = fi->cur_no + offset;
1089             if (fi->template[iter_idx].type == ITER)
1090             {
1091                 ExtraData d;
1092                 ExtraDataRec dr;
1093
1094                 if ((d = ChainMgrGetExtraData (&fi->cm, iter_idx)) == NULL)
1095                 {
1096                     dr.iter = IterInit (&fi->template[iter_idx + 1], NO_VALUE);
1097                     d = ChainMgrSetData (&fi->cm, iter_idx, dr);
1098                 }
1099                 /*endif*/
1100                 info->counter.iter = d->iter;
1101             }
1102             else
1103             {
1104                 /* Should not be reached here */
1105             }
1106             /*endif*/
1107         }
1108         /*endif*/
1109         break;
1110
1111     case BARRAY:
1112         if (info)
1113         {
1114             ExtraData d;
1115
1116             if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
1117                 info->num = NO_VALUE;
1118             else
1119                 info->num = d->num;
1120             /*endif*/
1121         }
1122         /*endif*/
1123         break;
1124
1125     case PADDING:
1126         if (info)
1127         {
1128             register int unit;
1129             register int number;
1130             register int size;
1131             register int i;
1132
1133             unit = _UNIT ((long) fi->template[fi->cur_no].data);
1134             number = _NUMBER ((long) fi->template[fi->cur_no].data);
1135
1136             i = fi->cur_no;
1137             size = 0;
1138             while (number > 0)
1139             {
1140                 i = _FrameInstDecrement (fi->template, i);
1141                 size += _FrameInstGetItemSize (fi, i);
1142                 number--;
1143             }
1144             /*endwhile*/
1145             info->num = (unit - (size%unit))%unit;
1146         }
1147         /*endif*/
1148         break;
1149
1150     case ITER:
1151         {
1152             ExtraData d;
1153             ExtraDataRec dr;
1154             XimFrameType sub_type;
1155
1156             if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
1157             {
1158                 dr.iter = IterInit (&fi->template[fi->cur_no + 1], NO_VALUE);
1159                 d = ChainMgrSetData (&fi->cm, fi->cur_no, dr);
1160             }
1161             /*endif*/
1162             sub_type = IterPeekNextType (d->iter, info);
1163             if (sub_type == EOL)
1164                 ret_type = FrameInstPeekNextType (fi, info);
1165             else
1166                 ret_type = sub_type;
1167             /*endif*/
1168         }
1169         break;
1170
1171     case POINTER:
1172         {
1173             ExtraData d;
1174             ExtraDataRec dr;
1175             XimFrameType sub_type;
1176
1177             if ((d = ChainMgrGetExtraData (&fi->cm, fi->cur_no)) == NULL)
1178             {
1179                 dr.fi = FrameInstInit (fi->template[fi->cur_no + 1].data);
1180                 d = ChainMgrSetData (&fi->cm, fi->cur_no, dr);
1181             }
1182             /*endif*/
1183             sub_type = FrameInstPeekNextType (d->fi, info);
1184             if (sub_type == EOL)
1185                 ret_type = FrameInstPeekNextType (fi, info);
1186             else
1187                 ret_type = sub_type;
1188             /*endif*/
1189         default:
1190             break;
1191         }
1192         break;
1193     }
1194     /*endswitch*/
1195     return ret_type;
1196 }
1197
1198 static Bool FrameInstIsIterLoopEnd (FrameInst fi)
1199 {
1200     Bool ret = False;
1201
1202     if (fi->template[fi->cur_no].type == ITER)
1203     {
1204         ExtraData d = ChainMgrGetExtraData (&fi->cm, fi->cur_no);
1205         Bool yourself;
1206
1207         if (d)
1208         {
1209             ret = IterIsLoopEnd (d->iter, &yourself);
1210             if (ret  &&  yourself)
1211                 fi->cur_no = _FrameInstIncrement (fi->template, fi->cur_no);
1212             /*endif*/
1213         }
1214         /*endif*/
1215     }
1216     /*endif*/
1217     return (ret);
1218 }
1219
1220 static FrameIter _FrameMgrAppendIter (FrameMgr fm, Iter it, int end)
1221 {
1222     FrameIter p = fm->iters;
1223
1224     while (p  &&  p->next)
1225         p = p->next;
1226     /*endwhile*/
1227
1228     if (!p)
1229     {
1230         fm->iters =
1231         p = (FrameIter) Xmalloc (sizeof (FrameIterRec));
1232     }
1233     else
1234     {
1235         p->next = (FrameIter) Xmalloc (sizeof (FrameIterRec));
1236         p = p->next;
1237     }
1238     /*endif*/
1239     if (p)
1240     {
1241         p->iter = it;
1242         p->counting = False;
1243         p->counter = 0;
1244         p->end = end;
1245         p->next = NULL;
1246     }
1247     /*endif*/
1248     return (p);
1249 }
1250
1251 static void _FrameMgrRemoveIter (FrameMgr fm, FrameIter it)
1252 {
1253     FrameIter prev;
1254     FrameIter p;
1255
1256     prev = NULL;
1257     p = fm->iters;
1258     while (p)
1259     {
1260         if (p == it)
1261         {
1262             if (prev)
1263                 prev->next = p->next;
1264             else
1265                 fm->iters = p->next;
1266             /*endif*/
1267             Xfree (p);
1268             break;
1269         }
1270         /*endif*/
1271         prev = p;
1272         p = p->next;
1273     }
1274     /*endwhile*/
1275 }
1276
1277 static FrameIter _FrameIterCounterIncr (FrameIter fitr, int i)
1278 {
1279     FrameIter p = fitr;
1280
1281     while (p)
1282     {
1283         if (p->counting)
1284         {
1285             p->counter += i;
1286             if (p->counter >= p->end)
1287             {
1288                 IterFixIteration (p->iter);
1289                 return (p);
1290             }
1291             /*endif*/
1292         }
1293         /*endif*/
1294         p = p->next;
1295     }
1296     /*endwhile*/
1297     return (NULL);
1298 }
1299
1300 static void _IterStartWatch (Iter it, void *client_data)
1301 {
1302     FrameIter p = (FrameIter) client_data;
1303     p->counting = True;
1304 }
1305
1306 static FmStatus FrameInstSetSize (FrameInst fi, int num)
1307 {
1308     ExtraData d;
1309     ExtraDataRec dr;
1310     XimFrameType type;
1311     register int i;
1312
1313     i = 0;
1314     while ((type = fi->template[i].type) != EOL)
1315     {
1316         switch (type)
1317         {
1318         case BARRAY:
1319             if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
1320             {
1321                 dr.num = -1;
1322                 d = ChainMgrSetData (&fi->cm, i, dr);
1323             }
1324             /*endif*/
1325             if (d->num == NO_VALUE)
1326             {
1327                 d->num = num;
1328                 return FmSuccess;
1329             }
1330             /*endif*/
1331             break;
1332         case ITER:
1333             if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
1334             {
1335                 dr.iter = IterInit (&fi->template[i + 1], NO_VALUE);
1336                 d = ChainMgrSetData (&fi->cm, i, dr);
1337             }
1338             /*endif*/
1339             if (IterSetSize (d->iter, num) == FmSuccess)
1340                 return FmSuccess;
1341             /*endif*/
1342             break;
1343
1344         case POINTER:
1345             if ((d = ChainMgrGetExtraData(&fi->cm, i)) == NULL)
1346             {
1347                 dr.fi = FrameInstInit(fi->template[i + 1].data);
1348                 d = ChainMgrSetData(&fi->cm, i, dr);
1349             }
1350             /*endif*/
1351             if (FrameInstSetSize(d->fi, num) == FmSuccess)
1352                 return FmSuccess;
1353             /*endif*/
1354             break;
1355         default:
1356             break;
1357         }
1358         /*endswitch*/
1359         i = _FrameInstIncrement(fi->template, i);
1360     }
1361     /*endwhile*/
1362     return FmNoMoreData;
1363 }
1364
1365 static int FrameInstGetSize (FrameInst fi)
1366 {
1367     XimFrameType type;
1368     register int i;
1369     ExtraData d;
1370     ExtraDataRec dr;
1371     int ret_size;
1372
1373     i = fi->cur_no;
1374     while ((type = fi->template[i].type) != EOL)
1375     {
1376         switch (type)
1377         {
1378         case BARRAY:
1379             if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
1380                 return NO_VALUE;
1381             /*endif*/
1382             return d->num;
1383
1384         case ITER:
1385             if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
1386             {
1387                 dr.iter = IterInit (&fi->template[i + 1], NO_VALUE);
1388                 d = ChainMgrSetData (&fi->cm, i, dr);
1389             }
1390             /*endif*/
1391             ret_size = IterGetSize(d->iter);
1392             if (ret_size != NO_VALID_FIELD)
1393                 return ret_size;
1394             /*endif*/
1395             break;
1396
1397         case POINTER:
1398             if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
1399             {
1400                 dr.fi = FrameInstInit (fi->template[i + 1].data);
1401                 d = ChainMgrSetData (&fi->cm, i, dr);
1402             }
1403             /*endif*/
1404             ret_size = FrameInstGetSize (d->fi);
1405             if (ret_size != NO_VALID_FIELD)
1406                 return ret_size;
1407             /*endif*/
1408             break;
1409         default:
1410             break;
1411         }
1412         /*endswitch*/
1413         i = _FrameInstIncrement (fi->template, i);
1414     }
1415     /*endwhile*/
1416     return NO_VALID_FIELD;
1417 }
1418
1419 static FmStatus FrameInstSetIterCount (FrameInst fi, int num)
1420 {
1421     ExtraData d;
1422     ExtraDataRec dr;
1423     register int i;
1424     XimFrameType type;
1425
1426     i = 0;
1427     while ((type = fi->template[i].type) != EOL)
1428     {
1429         switch (type)
1430         {
1431         case ITER:
1432             if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
1433             {
1434                 dr.iter = IterInit (&fi->template[i + 1], num);
1435                 (void)ChainMgrSetData (&fi->cm, i, dr);
1436                 return FmSuccess;
1437             }
1438             /*endif*/
1439             if (IterSetIterCount (d->iter, num) == FmSuccess)
1440                 return FmSuccess;
1441             /*endif*/
1442             break;
1443
1444         case POINTER:
1445             if ((d = ChainMgrGetExtraData (&fi->cm, i)) == NULL)
1446             {
1447                 dr.fi = FrameInstInit (fi->template[i + 1].data);
1448                 d = ChainMgrSetData (&fi->cm, i, dr);
1449             }
1450             /*endif*/
1451             if (FrameInstSetIterCount (d->fi, num) == FmSuccess)
1452                 return FmSuccess;
1453             /*endif*/
1454             break;
1455
1456         default:
1457             break;
1458         }
1459         /*endswitch*/
1460         i = _FrameInstIncrement (fi->template, i);
1461     }
1462     /*endwhile*/
1463     return FmNoMoreData;
1464 }
1465
1466 static int FrameInstGetTotalSize (FrameInst fi)
1467 {
1468     register int size;
1469     register int i;
1470
1471     size = 0;
1472     i = 0;
1473
1474     while (fi->template[i].type != EOL)
1475     {
1476         size += _FrameInstGetItemSize (fi, i);
1477         i = _FrameInstIncrement (fi->template, i);
1478     }
1479     /*endwhile*/
1480     return size;
1481 }
1482
1483 static void FrameInstReset (FrameInst fi)
1484 {
1485     ChainIterRec ci;
1486     int frame_no;
1487     ExtraDataRec d;
1488
1489     ChainIterInit (&ci, &fi->cm);
1490
1491     while (ChainIterGetNext (&ci, &frame_no, &d))
1492     {
1493         register XimFrameType type;
1494         type = fi->template[frame_no].type;
1495         if (type == ITER)
1496         {
1497             if (d.iter)
1498                 IterReset (d.iter);
1499             /*endif*/
1500         }
1501         else if (type == POINTER)
1502         {
1503             if (d.fi)
1504                 FrameInstReset (d.fi);
1505             /*endif*/
1506         }
1507         /*endif*/
1508     }
1509     /*endwhile*/
1510     ChainIterFree (&ci);
1511
1512     fi->cur_no = 0;
1513 }
1514
1515 static Iter IterInit (XimFrame frame, int count)
1516 {
1517     Iter it;
1518     register XimFrameType type;
1519
1520     it = (Iter) Xmalloc (sizeof (IterRec));
1521     it->template = frame;
1522     it->max_count = (count == NO_VALUE)  ?  0  :  count;
1523     it->allow_expansion = (count == NO_VALUE);
1524     it->cur_no = 0;
1525     it->start_watch_proc = NULL;
1526     it->client_data = NULL;
1527     it->start_counter = False;
1528
1529     type = frame->type;
1530     if (type & COUNTER_MASK)
1531     {
1532         /* COUNTER_XXX cannot be an item of a ITER */
1533         Xfree (it);
1534         return NULL;
1535     }
1536     /*endif*/
1537
1538     switch (type)
1539     {
1540     case BIT8:
1541     case BIT16:
1542     case BIT32:
1543     case BIT64:
1544         /* Do nothing */
1545         break;
1546
1547     case BARRAY:
1548     case ITER:
1549     case POINTER:
1550         ChainMgrInit (&it->cm);
1551         break;
1552
1553     default:
1554         Xfree (it);
1555         return NULL; /* This should never occur */
1556     }
1557     /*endswitch*/
1558     return it;
1559 }
1560
1561 static void IterFree (Iter it)
1562 {
1563     switch (it->template->type)
1564     {
1565     case BARRAY:
1566         ChainMgrFree (&it->cm);
1567         break;
1568
1569     case ITER:
1570         {
1571             ChainIterRec ci;
1572             int count;
1573             ExtraDataRec d;
1574
1575             ChainIterInit (&ci, &it->cm);
1576             while (ChainIterGetNext (&ci, &count, &d))
1577                 IterFree (d.iter);
1578             /*endwhile*/
1579             ChainIterFree (&ci);
1580             ChainMgrFree (&it->cm);
1581         }
1582         break;
1583
1584     case POINTER:
1585         {
1586             ChainIterRec ci;
1587             int count;
1588             ExtraDataRec dr;
1589
1590             ChainIterInit (&ci, &it->cm);
1591             while (ChainIterGetNext (&ci, &count, &dr))
1592                 FrameInstFree (dr.fi);
1593             /*endwhile*/
1594             ChainIterFree (&ci);
1595             ChainMgrFree (&it->cm);
1596         }
1597         break;
1598
1599     default:
1600         break;
1601     }
1602     /*endswitch*/
1603     Xfree (it);
1604 }
1605
1606 static Bool IterIsLoopEnd (Iter it, Bool *myself)
1607 {
1608     Bool ret = False;
1609     *myself = False;
1610
1611     if (!it->allow_expansion  &&  (it->cur_no == it->max_count))
1612     {
1613         *myself = True;
1614         return True;
1615     }
1616     /*endif*/
1617
1618     if (it->template->type == POINTER)
1619     {
1620         ExtraData d = ChainMgrGetExtraData (&it->cm, it->cur_no);
1621         if (d)
1622         {
1623             if (FrameInstIsIterLoopEnd (d->fi))
1624             {
1625                 ret = True;
1626             }
1627             else
1628             {
1629                 if (FrameInstIsEnd (d->fi))
1630                 {
1631                     it->cur_no++;
1632                     if (!it->allow_expansion  &&  it->cur_no == it->max_count)
1633                     {
1634                         *myself = True;
1635                         ret = True;
1636                     }
1637                     /*endif*/
1638                 }
1639                 /*endif*/
1640             }
1641             /*endif*/
1642         }
1643         /*endif*/
1644     }
1645     else if (it->template->type == ITER)
1646     {
1647         ExtraData d = ChainMgrGetExtraData (&it->cm, it->cur_no);
1648         if (d)
1649         {
1650             Bool yourself;
1651
1652             if (IterIsLoopEnd (d->iter, &yourself))
1653                 ret = True;
1654             /*endif*/
1655         }
1656         /*endif*/
1657     }
1658     /*endif*/
1659
1660     return ret;
1661 }
1662
1663 static XimFrameType IterGetNextType (Iter it, XimFrameTypeInfo info)
1664 {
1665     XimFrameType type = it->template->type;
1666
1667     if (it->start_counter)
1668     {
1669         (*it->start_watch_proc) (it, it->client_data);
1670         it->start_counter = False;
1671     }
1672     /*endif*/
1673     if (it->cur_no >= it->max_count)
1674     {
1675         if (it->allow_expansion)
1676             it->max_count = it->cur_no + 1;
1677         else
1678             return EOL;
1679         /*endif*/
1680     }
1681     /*endif*/
1682
1683     switch (type)
1684     {
1685     case BIT8:
1686     case BIT16:
1687     case BIT32:
1688     case BIT64:
1689         it->cur_no++;
1690         return type;
1691
1692     case BARRAY:
1693         if (info)
1694         {
1695             ExtraData d;
1696
1697             if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
1698                 info->num = NO_VALUE;
1699             else
1700                 info->num = d->num;
1701             /*endif*/
1702         }
1703         /*endif*/
1704         it->cur_no++;
1705         return BARRAY;
1706
1707     case ITER:
1708         {
1709             XimFrameType ret_type;
1710             ExtraData d;
1711             ExtraDataRec dr;
1712
1713             if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
1714             {
1715                 dr.iter = IterInit (it->template + 1, NO_VALUE);
1716                 d = ChainMgrSetData (&it->cm, it->cur_no, dr);
1717             }
1718             /*endif*/
1719
1720             ret_type = IterGetNextType (d->iter, info);
1721             if (ret_type == EOL)
1722             {
1723                 it->cur_no++;
1724                 ret_type = IterGetNextType (it, info);
1725             }
1726             /*endif*/
1727             return ret_type;
1728         }
1729
1730     case POINTER:
1731         {
1732             XimFrameType ret_type;
1733             ExtraData d;
1734             ExtraDataRec dr;
1735
1736             if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
1737             {
1738                 dr.fi = FrameInstInit (it->template[1].data);
1739                 d = ChainMgrSetData (&it->cm, it->cur_no, dr);
1740             }
1741             /*endif*/
1742
1743             ret_type = FrameInstGetNextType (d->fi, info);
1744             if (ret_type == EOL)
1745             {
1746                 it->cur_no++;
1747                 ret_type = IterGetNextType (it, info);
1748             }
1749             /*endif*/
1750             return ret_type;
1751         }
1752
1753     default:
1754         return (XimFrameType) NULL;
1755     }
1756     /*endswitch*/
1757     return (XimFrameType) NULL;  /* This should never occur */
1758 }
1759
1760 static XimFrameType IterPeekNextType (Iter it, XimFrameTypeInfo info)
1761 {
1762     XimFrameType type = it->template->type;
1763
1764     if (!it->allow_expansion  &&  it->cur_no >= it->max_count)
1765         return (EOL);
1766     /*endif*/
1767
1768     switch (type)
1769     {
1770     case BIT8:
1771     case BIT16:
1772     case BIT32:
1773     case BIT64:
1774         return type;
1775
1776     case BARRAY:
1777         if (info)
1778         {
1779             ExtraData d;
1780
1781             if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
1782                 info->num = NO_VALUE;
1783             else
1784                 info->num = d->num;
1785             /*endif*/
1786         }
1787         /*endif*/
1788         return BARRAY;
1789
1790     case ITER:
1791         {
1792             XimFrameType ret_type;
1793             ExtraData d;
1794             ExtraDataRec dr;
1795
1796             if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
1797             {
1798                 dr.iter = IterInit (it->template + 1, NO_VALUE);
1799                 d = ChainMgrSetData (&it->cm, it->cur_no, dr);
1800             }
1801             /*endif*/
1802
1803             ret_type = IterPeekNextType (d->iter, info);
1804             if (ret_type == EOL)
1805                 ret_type = IterPeekNextType (it, info);
1806             /*endif*/
1807             return ret_type;
1808         }
1809
1810     case POINTER:
1811         {
1812             XimFrameType ret_type;
1813             ExtraData d;
1814             ExtraDataRec dr;
1815
1816             if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
1817             {
1818                 dr.fi = FrameInstInit (it->template[1].data);
1819                 d = ChainMgrSetData (&it->cm, it->cur_no, dr);
1820             }
1821             /*endif*/
1822
1823             ret_type = FrameInstPeekNextType (d->fi, info);
1824             if (ret_type == EOL)
1825                 ret_type = IterPeekNextType (it, info);
1826             /*endif*/
1827             return (ret_type);
1828         }
1829
1830     default:
1831         break;
1832     }
1833     /*endswitch*/
1834     /* Reaching here is a bug! */
1835     return (XimFrameType) NULL;
1836 }
1837
1838 static FmStatus IterSetSize (Iter it, int num)
1839 {
1840     XimFrameType type;
1841     register int i;
1842
1843     if (!it->allow_expansion  &&  it->max_count == 0)
1844         return FmNoMoreData;
1845     /*endif*/
1846
1847     type = it->template->type;
1848     switch (type)
1849     {
1850     case BARRAY:
1851         {
1852             ExtraData d;
1853             ExtraDataRec dr;
1854
1855             for (i = 0;  i < it->max_count;  i++)
1856             {
1857                 if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
1858                 {
1859                     dr.num = NO_VALUE;
1860                     d = ChainMgrSetData (&it->cm, i, dr);
1861                 }
1862                 /*endif*/
1863                 if (d->num == NO_VALUE)
1864                 {
1865                     d->num = num;
1866                     return FmSuccess;
1867                 }
1868                 /*endif*/
1869             }
1870             /*endfor*/
1871             if (it->allow_expansion)
1872             {
1873                 ExtraDataRec dr;
1874
1875                 dr.num = num;
1876                 ChainMgrSetData (&it->cm, it->max_count, dr);
1877                 it->max_count++;
1878
1879                 return FmSuccess;
1880             }
1881             /*endif*/
1882         }
1883         return FmNoMoreData;
1884
1885     case ITER:
1886         {
1887             ExtraData d;
1888             ExtraDataRec dr;
1889
1890             for (i = 0;  i < it->max_count;  i++)
1891             {
1892                 if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
1893                 {
1894                     dr.iter = IterInit (it->template + 1, NO_VALUE);
1895                     d = ChainMgrSetData (&it->cm, i, dr);
1896                 }
1897                 /*endif*/
1898                 if (IterSetSize (d->iter, num) == FmSuccess)
1899                     return FmSuccess;
1900                 /*endif*/
1901             }
1902             /*endfor*/
1903             if (it->allow_expansion)
1904             {
1905                 ExtraDataRec dr;
1906
1907                 dr.iter = IterInit (it->template + 1, NO_VALUE);
1908                 ChainMgrSetData (&it->cm, it->max_count, dr);
1909                 it->max_count++;
1910
1911                 if (IterSetSize(dr.iter, num) == FmSuccess)
1912                     return FmSuccess;
1913                 /*endif*/
1914             }
1915             /*endif*/
1916         }
1917         return FmNoMoreData;
1918
1919     case POINTER:
1920         {
1921             ExtraData d;
1922             ExtraDataRec dr;
1923
1924             for (i = 0;  i < it->max_count;  i++)
1925             {
1926                 if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
1927                 {
1928                     dr.fi = FrameInstInit (it->template[1].data);
1929                     d = ChainMgrSetData (&it->cm, i, dr);
1930                 }
1931                 /*endif*/
1932                 if (FrameInstSetSize (d->fi, num) == FmSuccess)
1933                     return FmSuccess;
1934                 /*endif*/
1935             }
1936             /*endfor*/
1937             if (it->allow_expansion)
1938             {
1939                 ExtraDataRec dr;
1940
1941                 dr.fi = FrameInstInit (it->template[1].data);
1942                 ChainMgrSetData (&it->cm, it->max_count, dr);
1943                 it->max_count++;
1944
1945                 if (FrameInstSetSize (dr.fi, num) == FmSuccess)
1946                     return FmSuccess;
1947                 /*endif*/
1948             }
1949             /*endif*/
1950         }
1951         return FmNoMoreData;
1952
1953     default:
1954         break;
1955     }
1956     /*endswitch*/
1957     return FmNoMoreData;
1958 }
1959
1960 static int IterGetSize (Iter it)
1961 {
1962     register int i;
1963     ExtraData d;
1964     ExtraDataRec dr;
1965
1966     if (it->cur_no >= it->max_count)
1967         return NO_VALID_FIELD;
1968     /*endif*/
1969
1970     switch (it->template->type)
1971     {
1972     case BARRAY:
1973         if ((d = ChainMgrGetExtraData (&it->cm, it->cur_no)) == NULL)
1974             return NO_VALUE;
1975         /*endif*/
1976         return d->num;
1977
1978     case ITER:
1979         for (i = it->cur_no; i < it->max_count; i++)
1980         {
1981             int ret_size;
1982
1983             if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
1984             {
1985                 dr.iter = IterInit (it->template + 1, NO_VALUE);
1986                 d = ChainMgrSetData (&it->cm, i, dr);
1987             }
1988             /*endif*/
1989             ret_size = IterGetSize (d->iter);
1990             if (ret_size != NO_VALID_FIELD)
1991                 return ret_size;
1992             /*endif*/
1993         }
1994         /*endfor*/
1995         return NO_VALID_FIELD;
1996
1997     case POINTER:
1998         for (i = it->cur_no;  i < it->max_count;  i++)
1999         {
2000             int ret_size;
2001
2002             if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
2003             {
2004                 dr.fi = FrameInstInit (it->template[1].data);
2005                 d = ChainMgrSetData (&it->cm, i, dr);
2006             }
2007             /*endif*/
2008             ret_size = FrameInstGetSize (d->fi);
2009             if (ret_size != NO_VALID_FIELD)
2010                 return ret_size;
2011             /*endif*/
2012         }
2013         /*endfor*/
2014         return NO_VALID_FIELD;
2015
2016     default:
2017         break;
2018     }
2019     /*endswitch*/
2020     return NO_VALID_FIELD;
2021 }
2022
2023 static FmStatus IterSetIterCount (Iter it, int num)
2024 {
2025     register int i;
2026
2027     if (it->allow_expansion)
2028     {
2029         it->max_count = num;
2030         it->allow_expansion = False;
2031         return FmSuccess;
2032     }
2033     /*endif*/
2034
2035     if (it->max_count == 0)
2036         return FmNoMoreData;
2037     /*endif*/
2038
2039     switch (it->template->type)
2040     {
2041     case ITER:
2042         for (i = 0;  i < it->max_count;  i++)
2043         {
2044             ExtraData d;
2045             ExtraDataRec dr;
2046
2047             if ((d = ChainMgrGetExtraData(&it->cm, i)) == NULL)
2048             {
2049                 dr.iter = IterInit(it->template + 1, num);
2050                 (void)ChainMgrSetData(&it->cm, i, dr);
2051                 return FmSuccess;
2052             }
2053             /*endif*/
2054             if (IterSetIterCount(d->iter, num) == FmSuccess)
2055                 return FmSuccess;
2056             /*endif*/
2057         }
2058         /*endfor*/
2059         if (it->allow_expansion)
2060         {
2061             ExtraDataRec dr;
2062
2063             dr.iter = IterInit (it->template + 1, num);
2064             ChainMgrSetData (&it->cm, it->max_count, dr);
2065             it->max_count++;
2066
2067             return FmSuccess;
2068         }
2069         /*endif*/
2070         break;
2071
2072     case POINTER:
2073         for (i = 0;  i < it->max_count;  i++)
2074         {
2075             ExtraData d;
2076             ExtraDataRec dr;
2077
2078             if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
2079             {
2080                 dr.fi = FrameInstInit (it->template[1].data);
2081                 d = ChainMgrSetData (&it->cm, i, dr);
2082             }
2083             /*endif*/
2084             if (FrameInstSetIterCount (d->fi, num) == FmSuccess)
2085                 return FmSuccess;
2086             /*endif*/
2087         }
2088         /*endfor*/
2089         if (it->allow_expansion)
2090         {
2091             ExtraDataRec dr;
2092
2093             dr.fi = FrameInstInit (it->template[1].data);
2094             ChainMgrSetData (&it->cm, it->max_count, dr);
2095             it->max_count++;
2096
2097             if (FrameInstSetIterCount (dr.fi, num) == FmSuccess)
2098                 return FmSuccess;
2099             /*endif*/
2100         }
2101         /*endif*/
2102         break;
2103
2104     default:
2105         break;
2106     }
2107     /*endswitch*/
2108     return FmNoMoreData;
2109 }
2110
2111 static int IterGetTotalSize (Iter it)
2112 {
2113     register int size, i;
2114     XimFrameType type;
2115
2116     if (it->allow_expansion)
2117         return NO_VALUE;
2118     /*endif*/
2119     if (it->max_count == 0)
2120         return 0;
2121     /*endif*/
2122
2123     size = 0;
2124     type = it->template->type;
2125
2126     switch (type)
2127     {
2128     case BIT8:
2129         size = it->max_count;
2130         break;
2131
2132     case BIT16:
2133         size = it->max_count*2;
2134         break;
2135
2136     case BIT32:
2137         size = it->max_count*4;
2138         break;
2139
2140     case BIT64:
2141         size = it->max_count*8;
2142         break;
2143
2144     case BARRAY:
2145         for (i = 0;  i < it->max_count;  i++)
2146         {
2147             register int num;
2148             ExtraData d;
2149
2150             if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
2151                 return  NO_VALUE;
2152             /*endif*/
2153             if ((num = d->num) == NO_VALUE)
2154                 return  NO_VALUE;
2155             /*endif*/
2156             size += num;
2157         }
2158         /*endfor*/
2159         break;
2160
2161     case ITER:
2162         for (i = 0;  i < it->max_count;  i++)
2163         {
2164             register int num;
2165             ExtraData d;
2166
2167             if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
2168                 return  NO_VALUE;
2169             /*endif*/
2170             if ((num = IterGetTotalSize (d->iter)) == NO_VALUE)
2171                 return  NO_VALUE;
2172             /*endif*/
2173             size += num;
2174         }
2175         /*endfor*/
2176         break;
2177
2178     case POINTER:
2179         for (i = 0;  i < it->max_count;  i++)
2180         {
2181             register int num;
2182             ExtraData d;
2183             ExtraDataRec dr;
2184
2185             if ((d = ChainMgrGetExtraData (&it->cm, i)) == NULL)
2186             {
2187                 dr.fi = FrameInstInit (it->template[1].data);
2188                 d = ChainMgrSetData (&it->cm, i, dr);
2189             }
2190             /*endif*/
2191             if ((num = FrameInstGetTotalSize (d->fi)) == NO_VALUE)
2192                 return NO_VALUE;
2193             /*endif*/
2194             size += num;
2195         }
2196         /*endfor*/
2197         break;
2198
2199     default:
2200         break;
2201     }
2202     /*endswitch*/
2203     return  size;
2204 }
2205
2206 static void IterReset (Iter it)
2207 {
2208     ChainIterRec ci;
2209     int count;
2210     ExtraDataRec d;
2211
2212     switch (it->template->type)
2213     {
2214     case ITER:
2215         ChainIterInit (&ci, &it->cm);
2216         while (ChainIterGetNext (&ci, &count, &d))
2217             IterReset (d.iter);
2218         /*endwhile*/
2219         ChainIterFree (&ci);
2220         break;
2221
2222     case POINTER:
2223         ChainIterInit (&ci, &it->cm);
2224         while (ChainIterGetNext (&ci, &count, &d))
2225             FrameInstReset (d.fi);
2226         /*endwhile*/
2227         ChainIterFree (&ci);
2228         break;
2229
2230     default:
2231         break;
2232     }
2233     /*endswitch*/
2234     it->cur_no = 0;
2235 }
2236
2237 static void IterSetStartWatch (Iter it,
2238                                IterStartWatchProc proc,
2239                                void *client_data)
2240 {
2241     it->start_watch_proc = proc;
2242     it->client_data = client_data;
2243 }
2244
2245 static ExtraData ChainMgrSetData (ChainMgr cm,
2246                                   int frame_no,
2247                                   ExtraDataRec data)
2248 {
2249     Chain cur = (Chain) Xmalloc (sizeof (ChainRec));
2250
2251     cur->frame_no = frame_no;
2252     cur->d = data;
2253     cur->next = NULL;
2254
2255     if (cm->top == NULL)
2256     {
2257         cm->top = cm->tail = cur;
2258     }
2259     else
2260     {
2261         cm->tail->next = cur;
2262         cm->tail = cur;
2263     }
2264     /*endif*/
2265     return &cur->d;
2266 }
2267
2268 static ExtraData ChainMgrGetExtraData (ChainMgr cm, int frame_no)
2269 {
2270     Chain cur;
2271
2272     cur = cm->top;
2273
2274     while (cur)
2275     {
2276         if (cur->frame_no == frame_no)
2277             return &cur->d;
2278         /*endif*/
2279         cur = cur->next;
2280     }
2281     /*endwhile*/
2282     return NULL;
2283 }
2284
2285 static Bool ChainIterGetNext (ChainIter ci, int *frame_no, ExtraData d)
2286 {
2287     if (ci->cur == NULL)
2288         return False;
2289     /*endif*/
2290
2291     *frame_no = ci->cur->frame_no;
2292     *d = ci->cur->d;
2293
2294     ci->cur = ci->cur->next;
2295
2296     return True;
2297 }
2298
2299 static int _FrameInstIncrement (XimFrame frame, int count)
2300 {
2301     XimFrameType type;
2302
2303     type = frame[count].type;
2304     type &= ~COUNTER_MASK;
2305
2306     switch (type)
2307     {
2308     case BIT8:
2309     case BIT16:
2310     case BIT32:
2311     case BIT64:
2312     case BARRAY:
2313     case PADDING:
2314         return count + 1;
2315
2316     case POINTER:
2317         return count + 2;
2318
2319     case ITER:
2320         return _FrameInstIncrement (frame, count + 1);
2321     default:
2322         break;
2323     }
2324     /*endswitch*/
2325     return - 1;    /* Error */
2326 }
2327
2328 static int _FrameInstDecrement (XimFrame frame, int count)
2329 {
2330     register int i;
2331     XimFrameType type;
2332
2333     if (count == 0)
2334         return - 1;    /* cannot decrement */
2335     /*endif*/
2336
2337     if (count == 1)
2338         return 0;     /* BOGUS - It should check the contents of data */
2339     /*endif*/
2340
2341     type = frame[count - 2].type;
2342     type &= ~COUNTER_MASK;
2343
2344     switch (type)
2345     {
2346     case BIT8:
2347     case BIT16:
2348     case BIT32:
2349     case BIT64:
2350     case BARRAY:
2351     case PADDING:
2352     case PTR_ITEM:
2353         return count - 1;
2354
2355     case POINTER:
2356     case ITER:
2357         i = count - 3;
2358         while (i >= 0)
2359         {
2360             if (frame[i].type != ITER)
2361                 return i + 1;
2362             /*endif*/
2363             i--;
2364         }
2365         /*endwhile*/
2366         return 0;
2367     default:
2368         break;
2369     }
2370     /*enswitch*/
2371     return - 1;    /* Error */
2372 }
2373
2374 static int _FrameInstGetItemSize (FrameInst fi, int cur_no)
2375 {
2376     XimFrameType type;
2377
2378     type = fi->template[cur_no].type;
2379     type &= ~COUNTER_MASK;
2380
2381     switch (type)
2382     {
2383     case BIT8:
2384         return 1;
2385
2386     case BIT16:
2387         return 2;
2388
2389     case BIT32:
2390         return 4;
2391
2392     case BIT64:
2393         return 8;
2394
2395     case BARRAY:
2396         {
2397             ExtraData d;
2398
2399             if ((d = ChainMgrGetExtraData (&fi->cm, cur_no)) == NULL)
2400                 return NO_VALUE;
2401             /*endif*/
2402             if (d->num == NO_VALUE)
2403                 return NO_VALUE;
2404             /*endif*/
2405             return d->num;
2406         }
2407
2408     case PADDING:
2409         {
2410             register int unit;
2411             register int number;
2412             register int size;
2413             register int i;
2414
2415             unit = _UNIT ((long) fi->template[cur_no].data);
2416             number = _NUMBER ((long) fi->template[cur_no].data);
2417
2418             i = cur_no;
2419             size = 0;
2420             while (number > 0)
2421             {
2422                 i = _FrameInstDecrement (fi->template, i);
2423                 size += _FrameInstGetItemSize (fi, i);
2424                 number--;
2425             }
2426             /*endwhile*/
2427             size = (unit - (size%unit))%unit;
2428             return size;
2429         }
2430
2431     case ITER:
2432         {
2433             ExtraData d;
2434             int sub_size;
2435
2436             if ((d = ChainMgrGetExtraData (&fi->cm, cur_no)) == NULL)
2437                 return NO_VALUE;
2438             /*endif*/
2439             sub_size = IterGetTotalSize (d->iter);
2440             if (sub_size == NO_VALUE)
2441                 return NO_VALUE;
2442             /*endif*/
2443             return sub_size;
2444         }
2445
2446     case POINTER:
2447         {
2448             ExtraData d;
2449             int sub_size;
2450
2451             if ((d = ChainMgrGetExtraData (&fi->cm, cur_no)) == NULL)
2452                 return NO_VALUE;
2453             /*endif*/
2454             sub_size = FrameInstGetTotalSize (d->fi);
2455             if (sub_size == NO_VALUE)
2456                 return NO_VALUE;
2457             /*endif*/
2458             return sub_size;
2459         }
2460
2461     default:
2462         break;
2463     }
2464     /*endswitch*/
2465     return NO_VALUE;
2466 }