/**
 * VTF3 - Vampir Trace Format handling 3.<p>
 *
 * Copyright (c) 1999-2004 TU Dresden
 *                         Center for High Performance Computing (ZHR)
 *
 * @name       vtf3showtfwin.c
 *
 * @version    $Revision: 1.2 $ <br>
 *             $Date: 2005/10/22 00:57:03 $ <br>
 *             $Author: sameer $
 *
 * @author     Stephan Seidl (ZHR)
 */


/*****************************************************************************/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>


/* This is for `size_t'. */
#include <stddef.h>


#include "vtf3.h"


/*****************************************************************************/


/* Note for VAMPIR, VPTMERGE and other applications.
   On memory allocation failures, VTF3 executes a statement
   sequence, which is defined by the following macro.
   After that, VTF3 does unconditionally exit with 127. */
#if (1)
#ifndef VTF3_NOMEM_GOOD_BYE_INFO
#define VTF3_NOMEM_GOOD_BYE_INFO                         \
{                                                        \
  (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): " \
                          "No more memory\n");           \
  (void) fflush (stderr);                                \
  }
#endif
#endif

/* Another example could be the following one, but, of course,
   suppress `-Wnested-externs' warning types when using the GCC. */
#if (0)
#ifndef VTF3_NOMEM_GOOD_BYE_INFO
#define VTF3_NOMEM_GOOD_BYE_INFO                 \
{                                                \
  extern void vampir_nomem_good_bye_info (void); \
  (void) vampir_nomem_good_bye_info ();          \
  }
#endif
#endif


/*****************************************************************************/


static const char rcsid[]
  = "@(#) $Id: vtf3showtfwin.c,v 1.2 2005/10/22 00:57:03 sameer Exp $";


/*****************************************************************************/


/* The handler prototypes. */
VTF3_DCL_CLSTRREGVAL      (static, AppendClstrregval     );
VTF3_DCL_COMMENT          (static, AppendComment         );
VTF3_DCL_CPUREGVAL        (static, AppendCpuregval       );
VTF3_DCL_DEFACT           (static, AppendDefact          );
VTF3_DCL_DEFACT_OBSOL     (static, AppendDefact_obsol    );
VTF3_DCL_DEFCLKPERIOD     (static, AppendDefclkperiod    );
VTF3_DCL_DEFCLSTR         (static, AppendDefclstr        );
VTF3_DCL_DEFCLSTRREG      (static, AppendDefclstrreg     );
VTF3_DCL_DEFCLSTRREGCLASS (static, AppendDefclstrregclass);
VTF3_DCL_DEFCOMMUNICATOR  (static, AppendDefcommunicator );
VTF3_DCL_DEFCPUGRP        (static, AppendDefcpugrp       );
VTF3_DCL_DEFCPUNAME       (static, AppendDefcpuname      );
VTF3_DCL_DEFCPUREG        (static, AppendDefcpureg       );
VTF3_DCL_DEFCPUREGCLASS   (static, AppendDefcpuregclass  );
VTF3_DCL_DEFCREATOR       (static, AppendDefcreator      );
VTF3_DCL_DEFGLOBALOP      (static, AppendDefglobalop     );
VTF3_DCL_DEFIOFILE        (static, AppendDefiofile       );
VTF3_DCL_DEFKPARREG       (static, AppendDefkparreg      );
VTF3_DCL_DEFMSGNAME       (static, AppendDefmsgname      );
VTF3_DCL_DEFOPENMPNAME    (static, AppendDefopenmpname   );
VTF3_DCL_DEFOPENMPTYPE    (static, AppendDefopenmptype   );
VTF3_DCL_DEFPATTERN       (static, AppendDefpattern      );
VTF3_DCL_DEFPATTERNSHAPE  (static, AppendDefpatternshape );
VTF3_DCL_DEFREDFUNC_OBSOL (static, AppendDefredfunc_obsol);
VTF3_DCL_DEFSAMP          (static, AppendDefsamp         );
VTF3_DCL_DEFSAMPCLASS     (static, AppendDefsampclass    );
VTF3_DCL_DEFSCL           (static, AppendDefscl          );
VTF3_DCL_DEFSCLFILE       (static, AppendDefsclfile      );
VTF3_DCL_DEFSTATE         (static, AppendDefstate        );
VTF3_DCL_DEFSTATE_OBSOL   (static, AppendDefstate_obsol  );
VTF3_DCL_DEFSYSCPUNAMES   (static, AppendDefsyscpunames  );
VTF3_DCL_DEFSYSCPUNUMS    (static, AppendDefsyscpunums   );
VTF3_DCL_DEFTHREADNUMS    (static, AppendDefthreadnums   );
VTF3_DCL_DEFTIMEOFFSET    (static, AppendDeftimeoffset   );
VTF3_DCL_DEFUNMERGED      (static, AppendDefunmerged     );
VTF3_DCL_DEFVERSION       (static, AppendDefversion      );
VTF3_DCL_DOWNTO           (static, AppendDownto          );
VTF3_DCL_EXCHANGE         (static, AppendExchange        );
VTF3_DCL_EXCHANGE_OBSOL   (static, AppendExchange_obsol  );
VTF3_DCL_FILEIOBEGIN      (static, AppendFileiobegin     );
VTF3_DCL_FILEIOEND        (static, AppendFileioend       );
VTF3_DCL_GLOBALOP         (static, AppendGlobalop        );
VTF3_DCL_KPARREGBARSUM    (static, AppendKparregbarsum   );
VTF3_DCL_KPARREGBEGIN     (static, AppendKparregbegin    );
VTF3_DCL_KPARREGEND       (static, AppendKparregend      );
VTF3_DCL_MUTEXACQUIRE     (static, AppendMutexacquire    );
VTF3_DCL_MUTEXRELEASE     (static, AppendMutexrelease    );
VTF3_DCL_OPENMPENTER      (static, AppendOpenmpenter     );
VTF3_DCL_OPENMPLEAVE      (static, AppendOpenmpleave     );
VTF3_DCL_PARREG           (static, AppendParreg          );
VTF3_DCL_PATTERN          (static, AppendPattern         );
VTF3_DCL_RECVMSG          (static, AppendRecvmsg         );
VTF3_DCL_SAMP             (static, AppendSamp            );
VTF3_DCL_SENDMSG          (static, AppendSendmsg         );
VTF3_DCL_SRCINFO_OBSOL    (static, AppendSrcinfo_obsol   );
VTF3_DCL_UNRECOGNIZABLE   (static, AppendUnrecognizable  );
VTF3_DCL_UPFROM           (static, AppendUpfrom          );
VTF3_DCL_UPTO             (static, AppendUpto            );


/*****************************************************************************/


/* The handler communication control block. */
typedef struct {
  void   *fcboutmemory;
  void   *fcbin;
  char   *outputbufferpos;
  char   *outputbufferbeyond;
  char   **activitynamevector1;
  char   **activitynamevector2;
  int    *activitytokenvector1;
  int    *activitytokenvector2;
  int    activityvectordim1;
  int    activityvectordim2;
  int    numactivities1;
  int    numactivities2;
  double timestampmax;
  double timestampminin;
  double timestampmaxin;
  double timestampminout;
  double timestampmaxout;
  } ccb_t;


/*****************************************************************************/


char *
VTF3_ShowTraceFileWindow (const char *inputfilename, double *timestampmin,
                           double *timestampmax, char *outputbuffer,
                           size_t outputbuffersize)
{
  static const unsigned char stdasciiheader [] = VTF3_HEADER_STD_ASCII;
  ccb_t ccb;
  int nrectypes, *recordtypes, i, numchars;
  VTF3_handler_t *handlers;
  void **firsthandlerargs;
  char *p1, *p2;
  char headbuf [sizeof (stdasciiheader) / sizeof (stdasciiheader[0]) +
                sizeof (rcsid         ) / sizeof (rcsid[0]         ) +
                100];
  size_t l1, bytesread;
  const char *constp1, *constp2;

  (void) memset (&ccb, 0, sizeof (ccb));
  (void) VTF3_InitTables ();
  ccb.fcboutmemory = VTF3_OpenMemoryOutput (VTF3_FILEFORMAT_STD_ASCII);
  if (ccb.fcboutmemory == 0) {
    VTF3_NOMEM_GOOD_BYE_INFO;
    (void) exit (127);
    }
  nrectypes = VTF3_GetRecTypeArrayDim ();
  recordtypes = (int *) malloc ((size_t) nrectypes * sizeof (int));
  if (recordtypes == 0) {
    VTF3_NOMEM_GOOD_BYE_INFO;
    (void) exit (127);
    }
  handlers = (VTF3_handler_t *) malloc ((size_t) nrectypes *
                                         sizeof (VTF3_handler_t));
  if (handlers == 0) {
    VTF3_NOMEM_GOOD_BYE_INFO;
    (void) exit (127);
    }
  firsthandlerargs = (void **) malloc ((size_t) nrectypes * sizeof (void *));
  if (firsthandlerargs == 0) {
    VTF3_NOMEM_GOOD_BYE_INFO;
    (void) exit (127);
    }
  (void) VTF3_GetRecTypeArray (recordtypes);
  for (i = 0; i < nrectypes; i++) {
    *(handlers + i) = 0;
    if (*(recordtypes + i) == VTF3_RECTYPE_CLSTRREGVAL)
      *(handlers + i) = (VTF3_handler_t) AppendClstrregval;
    if (*(recordtypes + i) == VTF3_RECTYPE_COMMENT)
      *(handlers + i) = (VTF3_handler_t) AppendComment;
    if (*(recordtypes + i) == VTF3_RECTYPE_CPUREGVAL)
      *(handlers + i) = (VTF3_handler_t) AppendCpuregval;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFACT)
      *(handlers + i) = (VTF3_handler_t) AppendDefact;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFACT_OBSOL)
      *(handlers + i) = (VTF3_handler_t) AppendDefact_obsol;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCLKPERIOD)
      *(handlers + i) = (VTF3_handler_t) AppendDefclkperiod;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCLSTR)
      *(handlers + i) = (VTF3_handler_t) AppendDefclstr;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCLSTRREG)
      *(handlers + i) = (VTF3_handler_t) AppendDefclstrreg;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCLSTRREGCLASS)
      *(handlers + i) = (VTF3_handler_t) AppendDefclstrregclass;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCOMMUNICATOR)
      *(handlers + i) = (VTF3_handler_t) AppendDefcommunicator;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCPUGRP)
      *(handlers + i) = (VTF3_handler_t) AppendDefcpugrp;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCPUNAME)
      *(handlers + i) = (VTF3_handler_t) AppendDefcpuname;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCPUREG)
      *(handlers + i) = (VTF3_handler_t) AppendDefcpureg;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCPUREGCLASS)
      *(handlers + i) = (VTF3_handler_t) AppendDefcpuregclass;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFCREATOR)
      *(handlers + i) = (VTF3_handler_t) AppendDefcreator;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFGLOBALOP)
      *(handlers + i) = (VTF3_handler_t) AppendDefglobalop;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFIOFILE)
      *(handlers + i) = (VTF3_handler_t) AppendDefiofile;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFKPARREG)
      *(handlers + i) = (VTF3_handler_t) AppendDefkparreg;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFMSGNAME)
      *(handlers + i) = (VTF3_handler_t) AppendDefmsgname;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFOPENMPNAME)
      *(handlers + i) = (VTF3_handler_t) AppendDefopenmpname;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFOPENMPTYPE)
      *(handlers + i) = (VTF3_handler_t) AppendDefopenmptype;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFPATTERN)
      *(handlers + i) = (VTF3_handler_t) AppendDefpattern;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFPATTERNSHAPE)
      *(handlers + i) = (VTF3_handler_t) AppendDefpatternshape;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFREDFUNC_OBSOL)
      *(handlers + i) = (VTF3_handler_t) AppendDefredfunc_obsol;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFSAMP)
      *(handlers + i) = (VTF3_handler_t) AppendDefsamp;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFSAMPCLASS)
      *(handlers + i) = (VTF3_handler_t) AppendDefsampclass;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFSCL)
      *(handlers + i) = (VTF3_handler_t) AppendDefscl;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFSCLFILE)
      *(handlers + i) = (VTF3_handler_t) AppendDefsclfile;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFSTATE)
      *(handlers + i) = (VTF3_handler_t) AppendDefstate;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFSTATE_OBSOL)
      *(handlers + i) = (VTF3_handler_t) AppendDefstate_obsol;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFSYSCPUNAMES)
      *(handlers + i) = (VTF3_handler_t) AppendDefsyscpunames;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFSYSCPUNUMS)
      *(handlers + i) = (VTF3_handler_t) AppendDefsyscpunums;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFTHREADNUMS)
      *(handlers + i) = (VTF3_handler_t) AppendDefthreadnums;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFTIMEOFFSET)
      *(handlers + i) = (VTF3_handler_t) AppendDeftimeoffset;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFUNMERGED)
      *(handlers + i) = (VTF3_handler_t) AppendDefunmerged;
    if (*(recordtypes + i) == VTF3_RECTYPE_DEFVERSION)
      *(handlers + i) = (VTF3_handler_t) AppendDefversion;
    if (*(recordtypes + i) == VTF3_RECTYPE_DOWNTO)
      *(handlers + i) = (VTF3_handler_t) AppendDownto;
    if (*(recordtypes + i) == VTF3_RECTYPE_EXCHANGE)
      *(handlers + i) = (VTF3_handler_t) AppendExchange;
    if (*(recordtypes + i) == VTF3_RECTYPE_EXCHANGE_OBSOL)
      *(handlers + i) = (VTF3_handler_t) AppendExchange_obsol;
    if (*(recordtypes + i) == VTF3_RECTYPE_FILEIOBEGIN)
      *(handlers + i) = (VTF3_handler_t) AppendFileiobegin;
    if (*(recordtypes + i) == VTF3_RECTYPE_FILEIOEND)
      *(handlers + i) = (VTF3_handler_t) AppendFileioend;
    if (*(recordtypes + i) == VTF3_RECTYPE_GLOBALOP)
      *(handlers + i) = (VTF3_handler_t) AppendGlobalop;
    if (*(recordtypes + i) == VTF3_RECTYPE_KPARREGBARSUM)
      *(handlers + i) = (VTF3_handler_t) AppendKparregbarsum;
    if (*(recordtypes + i) == VTF3_RECTYPE_KPARREGBEGIN)
      *(handlers + i) = (VTF3_handler_t) AppendKparregbegin;
    if (*(recordtypes + i) == VTF3_RECTYPE_KPARREGEND)
      *(handlers + i) = (VTF3_handler_t) AppendKparregend;
    if (*(recordtypes + i) == VTF3_RECTYPE_MUTEXACQUIRE)
      *(handlers + i) = (VTF3_handler_t) AppendMutexacquire;
    if (*(recordtypes + i) == VTF3_RECTYPE_MUTEXRELEASE)
      *(handlers + i) = (VTF3_handler_t) AppendMutexrelease;
    if (*(recordtypes + i) == VTF3_RECTYPE_OPENMPENTER)
      *(handlers + i) = (VTF3_handler_t) AppendOpenmpenter;
    if (*(recordtypes + i) == VTF3_RECTYPE_OPENMPLEAVE)
      *(handlers + i) = (VTF3_handler_t) AppendOpenmpleave;
    if (*(recordtypes + i) == VTF3_RECTYPE_PARREG)
      *(handlers + i) = (VTF3_handler_t) AppendParreg;
    if (*(recordtypes + i) == VTF3_RECTYPE_PATTERN)
      *(handlers + i) = (VTF3_handler_t) AppendPattern;
    if (*(recordtypes + i) == VTF3_RECTYPE_RECVMSG)
      *(handlers + i) = (VTF3_handler_t) AppendRecvmsg;
    if (*(recordtypes + i) == VTF3_RECTYPE_SAMP)
      *(handlers + i) = (VTF3_handler_t) AppendSamp;
    if (*(recordtypes + i) == VTF3_RECTYPE_SENDMSG)
      *(handlers + i) = (VTF3_handler_t) AppendSendmsg;
    if (*(recordtypes + i) == VTF3_RECTYPE_SRCINFO_OBSOL)
      *(handlers + i) = (VTF3_handler_t) AppendSrcinfo_obsol;
    if (*(recordtypes + i) == VTF3_RECTYPE_UNRECOGNIZABLE)
      *(handlers + i) = (VTF3_handler_t) AppendUnrecognizable;
    if (*(recordtypes + i) == VTF3_RECTYPE_UPFROM)
      *(handlers + i) = (VTF3_handler_t) AppendUpfrom;
    if (*(recordtypes + i) == VTF3_RECTYPE_UPTO)
      *(handlers + i) = (VTF3_handler_t) AppendUpto;
    *(firsthandlerargs + i) = &ccb;
    }
  if (inputfilename == 0) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "NULL as input file name\n");
    (void) fflush (stderr);
    (void) exit (127);
    }
  ccb.fcbin = VTF3_OpenFileInput (inputfilename, handlers, firsthandlerargs,
                                   0);
  (void) free (firsthandlerargs);
  (void) free (handlers);
  (void) free (recordtypes);
  if (ccb.fcbin == 0) {
    (void) VTF3_Close (ccb.fcboutmemory);
    return (0);
    }
  if (timestampmin == 0) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "NULL as `timestampmin' address\n");
    (void) fflush (stderr);
    (void) exit (127);
    }
  if (timestampmax == 0) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "NULL as `timestampmax' address\n");
    (void) fflush (stderr);
    (void) exit (127);
    }
  if (outputbuffer == 0) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "NULL as output buffer address\n");
    (void) fflush (stderr);
    (void) exit (127);
    }
  ccb.outputbufferpos    = outputbuffer + 0;
  ccb.outputbufferbeyond = outputbuffer + outputbuffersize / sizeof (char);
  *(ccb.outputbufferpos + 0) = '\0';
  ccb.timestampmax    = *timestampmin - 1.0e+0;
  ccb.timestampminin  = *timestampmin;
  ccb.timestampmaxin  = *timestampmax;
  ccb.timestampminout = 1.0e+0;
  ccb.timestampmaxout = 0.0e+0;
  p1  = (char *) &stdasciiheader[0];
  p2  = &headbuf[0];
  (void) memcpy (p2, p1, sizeof (stdasciiheader));
  p1  = (char *) "C TUD/ZHR ";
  l1  = strlen (p1);
  p2 += sizeof (stdasciiheader) / sizeof (stdasciiheader[0]);
  (void) memcpy (p2, p1, l1 * sizeof (char));
  p1  = (char *) &rcsid[0];
  p2 += l1;
  while (*p1 != ':' && *p1 != '\0')
    p1++;
  while (*p1 == ':')
    p1++;
  while (*p1 == ' ')
    p1++;
  while (*p1 != '.' && *p1 != '\0')
    *p2++ = *p1++;
  *p2++ = ' ';
  while (*p1 != ' ' && *p1 != '\0')
    p1++;
  while (*p1 == ' ')
    p1++;
  while (*p1 != ' ' && *p1 != '\0')
    *p2++ = *p1++;
  *p2++ = ' ';
  while (*p1 == ' ')
    p1++;
  while (*p1 != '2' && *p1 != '\0')
    p1++;
  while (*p1 != ' ' && *p1 != '\0')
    *p2++ = *p1++;
  *p2++ = ' ';
  while (*p1 == ' ')
    p1++;
  while (*p1 != ' ' && *p1 != '\0')
    *p2++ = *p1++;
  *p2 = '\0';
  constp1 = " with\nC ";
  constp2 = VTF3_GetVersion ();
  l1 = strlen (&headbuf[0]) + strlen (constp1) + strlen (constp2);
  if (l1 < sizeof (headbuf) / sizeof (headbuf[0])) {
    (void) strcat (&headbuf[0], constp1);
    (void) strcat (&headbuf[0], constp2);
    }
  numchars = (int) strlen (&headbuf[0]) + 1;
  if (ccb.outputbufferpos + numchars + 1 > ccb.outputbufferbeyond) {
    while (ccb.outputbufferpos < ccb.outputbufferbeyond)
      *ccb.outputbufferpos++ = '\0';
    return (outputbuffer);
    }
  for (i = 0; i < numchars - 1; i++)
    *(ccb.outputbufferpos + i) = headbuf[i];
  ccb.outputbufferpos += numchars - 1;
  *ccb.outputbufferpos++ = '\n';
  *ccb.outputbufferpos   = '\0';
  for (;;) {
    bytesread = VTF3_ReadFileInputLtdBytes (ccb.fcbin, 1000000);
    if (bytesread == 0)
      break;
    if (ccb.timestampminout > ccb.timestampmaxout)
      continue;
    if (ccb.timestampmax > ccb.timestampmaxin)
      break;
    }
  (void) VTF3_Close (ccb.fcbin);
  (void) VTF3_Close (ccb.fcboutmemory);
  if (ccb.activitynamevector1 != 0) {
    for (i = 0; i < ccb.numactivities1; i++)
      (void) free (*(ccb.activitynamevector1 + i));
    (void) free (ccb.activitynamevector1);
    }
  if (ccb.activitynamevector2 != 0) {
    for (i = 0; i < ccb.numactivities2; i++)
      (void) free (*(ccb.activitynamevector2 + i));
    (void) free (ccb.activitynamevector2);
    }
  if (ccb.activitytokenvector1 != 0)
    (void) free (ccb.activitytokenvector1);
  if (ccb.activitytokenvector2 != 0)
    (void) free (ccb.activitytokenvector2);
  if (ccb.timestampminout > ccb.timestampmaxout) {
    ccb.timestampminout = *timestampmin;
    ccb.timestampmaxout = *timestampmax;
    }
  *timestampmin = ccb.timestampminout;
  *timestampmax = ccb.timestampmaxout;
  return (outputbuffer);
  }


/*****************************************************************************/


/* Internal prototypes. */
static const char *ActNameByToken (ccb_t *, int, const char *);
static int ActTokenByName (ccb_t *, const char *, int);
static void QuickSortActByName (char **, int *, unsigned int, unsigned int);
static void QuickSortActByToken (int *, char **, unsigned int, unsigned int);
static char *StrDup (const char *);


/*****************************************************************************/


/* Some macro stuff. */

#define VTF3_STRCMP(s1,s2,d)               \
{                                          \
  const char *macro_p1, *macro_p2;         \
  int macro_k1, macro_k2, macro_dk;        \
  macro_p1 = (s1);                         \
  macro_p2 = (s2);                         \
  macro_k1 = (int) (char) *macro_p1++;     \
  macro_k2 = (int) (char) *macro_p2++;     \
  macro_dk = macro_k1 - macro_k2;          \
  while (macro_dk == 0 && macro_k1 != 0) { \
    macro_k1 = (int) (char) *macro_p1++;   \
    macro_k2 = (int) (char) *macro_p2++;   \
    macro_dk = macro_k1 - macro_k2;        \
    }                                      \
  (d) = macro_dk;                          \
  }

#define VTF3_COMPOSER_CALL_DCL_DEFINITION \
  ccb_t *ccb = (ccb_t *) ccbcaller;       \
  VTF3_rec_t *rec;                        \
  int numchars, i

#define VTF3_COMPOSER_CALL_DCL_EVENT \
  ccb_t *ccb = (ccb_t *) ccbcaller;  \
  VTF3_rec_t *rec;                   \
  int numchars, i

#define VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION \
  if (ccb->timestampminin > (-1.5e+0))         \
    return (0)

#define VTF3_COMPOSER_CALL_PROLOGUE_EVENT            \
  if (ccb->timestampmax < time)                      \
    ccb->timestampmax = time;                        \
  if (time < ccb->timestampminin)                    \
    return (0);                                      \
  if (time > ccb->timestampmaxin)                    \
    return (0);                                      \
  if (ccb->timestampminout > ccb->timestampmaxout) { \
    ccb->timestampminout = time;                     \
    ccb->timestampmaxout = time;                     \
    }                                                \
  if (ccb->timestampminout > time)                   \
    ccb->timestampminout = time;                     \
  if (ccb->timestampmaxout < time)                   \
    ccb->timestampmaxout = time

#define VTF3_COMPOSER_CALL_EPILOGUE                                    \
  numchars = rec->numchars;                                            \
  if (ccb->outputbufferpos + numchars + 1 > ccb->outputbufferbeyond) { \
    while (ccb->outputbufferpos < ccb->outputbufferbeyond)             \
      *ccb->outputbufferpos++ = '\0';                                  \
    return (0);                                                        \
    }                                                                  \
  for (i = 0; i < numchars - 1; i++)                                   \
    *(ccb->outputbufferpos + i) = *(rec->record + i);                  \
  ccb->outputbufferpos += numchars - 1;                                \
  *ccb->outputbufferpos++ = '\n';                                      \
  *ccb->outputbufferpos   = '\0'


/*****************************************************************************/


static const char *
ActNameByToken (ccb_t *ccb, int activitytoken, const char *dfltactivityname)
{
  static const char *noact = "NOACT";
  unsigned int isnoact, i, i1, i2;
  size_t size;
  char *activityname;
  int n;

  if (activitytoken == VTF3_NOACT)
    return (noact);
  isnoact = 1;
  for (i = 0; i < 6; i++)
    if (*(dfltactivityname + i) != *(noact + i)) {
      isnoact = 0;
      break;
      }
  if (ccb->activityvectordim1 == 0) {
    if (isnoact != 0)
      return (noact);
    ccb->activityvectordim1 = 10;
    size = (size_t) ccb->activityvectordim1 * sizeof (char *);
    ccb->activitynamevector1 = (char **) malloc (size);
    if (ccb->activitynamevector1 == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    size = (size_t) ccb->activityvectordim1 * sizeof (int);
    ccb->activitytokenvector1 = (int *) malloc (size);
    if (ccb->activitytokenvector1 == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    activityname = StrDup (dfltactivityname);
    if ((*(ccb->activitynamevector1 + 0) = activityname) == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    *(ccb->activitytokenvector1 + 0) = activitytoken;
    ccb->numactivities1 = 1;
    (void) ActTokenByName (ccb, activityname, activitytoken);
    return (activityname);
    }
  i1 = 0;
  i2 = (unsigned int) ccb->numactivities1 - 1;
  while (i1 != i2) {
    i = (i1 + i2) >> 1;
    if (*(ccb->activitytokenvector1 + i) < activitytoken)
        i1 = i + 1;
      else
        i2 = i;
    }
  i = i1;
  if (*(ccb->activitytokenvector1 + i) == activitytoken)
    return (*(ccb->activitynamevector1 + i));
  if (isnoact != 0)
    return (noact);
  if (ccb->numactivities1 == ccb->activityvectordim1) {
    ccb->activityvectordim1 += 10;
    size = (size_t) ccb->activityvectordim1 * sizeof (char *);
    ccb->activitynamevector1 = (char **) realloc (ccb->activitynamevector1,
                                                   size);
    if (ccb->activitynamevector1 == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    size = (size_t) ccb->activityvectordim1 * sizeof (int);
    ccb->activitytokenvector1 = (int *) realloc (ccb->activitytokenvector1,
                                                  size);
    if (ccb->activitytokenvector1 == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    }
  activityname = StrDup (dfltactivityname);
  n = ccb->numactivities1;
  if ((*(ccb->activitynamevector1 + n) = activityname) == 0) {
    VTF3_NOMEM_GOOD_BYE_INFO;
    (void) exit (127);
    }
  *(ccb->activitytokenvector1 + n) = activitytoken;
  ccb->numactivities1++;
  (void) QuickSortActByToken (ccb->activitytokenvector1,
                               ccb->activitynamevector1, 0, (unsigned int) n);
  (void) ActTokenByName (ccb, activityname, activitytoken);
  return (activityname);
  }


static int
ActTokenByName (ccb_t *ccb, const char *activityname, int dfltactivitytoken)
{
  static const char *noact = "NOACT";
  unsigned int isnoact, i, i1, i2, found;
  size_t size;
  int activitytoken, k, n;

  isnoact = 1;
  for (i = 0; i < 6; i++)
    if (*(activityname + i) != *(noact + i)) {
      isnoact = 0;
      break;
      }
  if (isnoact != 0)
    return (VTF3_NOACT);
  if (ccb->activityvectordim2 == 0) {
    ccb->activityvectordim2 = 10;
    size = (size_t) ccb->activityvectordim2 * sizeof (char *);
    ccb->activitynamevector2 = (char **) malloc (size);
    if (ccb->activitynamevector2 == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    size = (size_t) ccb->activityvectordim2 * sizeof (int);
    ccb->activitytokenvector2 = (int *) malloc (size);
    if (ccb->activitytokenvector2 == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    *(ccb->activitynamevector2 + 0) = StrDup (activityname);
    if (*(ccb->activitynamevector2 + 0) == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    activitytoken = dfltactivitytoken != VTF3_NOACT
                  ? dfltactivitytoken
                  : VTF3_NOACT + 1;
    *(ccb->activitytokenvector2 + 0) = activitytoken;
    ccb->numactivities2 = 1;
    (void) ActNameByToken (ccb, activitytoken, activityname);
    return (activitytoken);
    }
  i1 = 0;
  i2 = (unsigned int) ccb->numactivities2 - 1;
  while (i1 != i2) {
    i = (i1 + i2) >> 1;
    VTF3_STRCMP (*(ccb->activitynamevector2 + i), activityname, k);
    if (k < 0)
        i1 = i + 1;
      else
        i2 = i;
    }
  i = i1;
  VTF3_STRCMP (*(ccb->activitynamevector2 + i), activityname, k);
  if (k == 0)
    return (*(ccb->activitytokenvector2 + i));
  activitytoken = dfltactivitytoken;
  if (activitytoken == VTF3_NOACT) {
    found = 1;
    while (found != 0) {
      activitytoken++;
      i1 = 0;
      i2 = (unsigned int) ccb->numactivities1 - 1;
      while (i1 != i2) {
        i = (i1 + i2) >> 1;
        if (*(ccb->activitytokenvector1 + i) < activitytoken)
            i1 = i + 1;
          else
            i2 = i;
        }
      i = i1;
      if (*(ccb->activitytokenvector1 + i) != activitytoken)
        found = 0;
      }
    }
  if (ccb->numactivities2 == ccb->activityvectordim2) {
    ccb->activityvectordim2 += 10;
    size = (size_t) ccb->activityvectordim2 * sizeof (char *);
    ccb->activitynamevector2 = (char **) realloc (ccb->activitynamevector2,
                                                   size);
    if (ccb->activitynamevector2 == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    size = (size_t) ccb->activityvectordim2 * sizeof (int);
    ccb->activitytokenvector2 = (int *) realloc (ccb->activitytokenvector2,
                                                  size);
    if (ccb->activitytokenvector2 == 0) {
      VTF3_NOMEM_GOOD_BYE_INFO;
      (void) exit (127);
      }
    }
  n = ccb->numactivities2;
  *(ccb->activitynamevector2 + n) = StrDup (activityname);
  if (*(ccb->activitynamevector2 + n) == 0) {
    VTF3_NOMEM_GOOD_BYE_INFO;
    (void) exit (127);
    }
  *(ccb->activitytokenvector2 + n) = activitytoken;
  ccb->numactivities2++;
  (void) QuickSortActByName (ccb->activitynamevector2,
                              ccb->activitytokenvector2, 0, (unsigned int) n);
  (void) ActNameByToken (ccb, activitytoken, activityname);
  return (activitytoken);
  }


static void
QuickSortActByName (char **names, int *tokens, unsigned int left,
                     unsigned int right)
{
  unsigned int l1, r1, c1;
  char *nameref, *nameaux;
  int k, tokenaux;

  l1 = left  + 1;
  r1 = right + 1;
  c1 = (l1 + r1) >> 1;
  nameref = *(names + c1 - 1);
  while (l1 <= r1) {
    VTF3_STRCMP (*(names + l1 - 1), nameref, k);
    while (k < 0) {
      l1++;
      VTF3_STRCMP (*(names + l1 - 1), nameref, k);
      }
    VTF3_STRCMP (nameref, *(names + r1 - 1), k);
    while (k < 0) {
      r1--;
      VTF3_STRCMP (nameref, *(names + r1 - 1), k);
      }
    if (l1 < r1) {
      nameaux            = *(names  + l1 - 1);
      *(names  + l1 - 1) = *(names  + r1 - 1);
      *(names  + r1 - 1) = nameaux;
      tokenaux           = *(tokens + l1 - 1);
      *(tokens + l1 - 1) = *(tokens + r1 - 1);
      *(tokens + r1 - 1) = tokenaux;
      }
    if (l1 <= r1) {
      l1++;
      r1--;
      }
    }
  if (left  + 1 < r1)
    (void) QuickSortActByName (names, tokens, left,  r1 - 1);
  if (l1 < right + 1)
    (void) QuickSortActByName (names, tokens, l1 - 1, right);
  return;
  }


static void
QuickSortActByToken (int *tokens, char **names, unsigned int left,
                      unsigned int right)
{
  unsigned int l1, r1, c1;
  int tokenref, tokenaux;
  char *nameaux;

  l1 = left  + 1;
  r1 = right + 1;
  c1 = (l1 + r1) >> 1;
  tokenref = *(tokens + c1 - 1);
  while (l1 <= r1) {
    while (*(tokens + l1 - 1) < tokenref)
      l1++;
    while (tokenref < *(tokens + r1 - 1))
      r1--;
    if (l1 < r1) {
      tokenaux           = *(tokens + l1 - 1);
      *(tokens + l1 - 1) = *(tokens + r1 - 1);
      *(tokens + r1 - 1) = tokenaux;
      nameaux            = *(names  + l1 - 1);
      *(names  + l1 - 1) = *(names  + r1 - 1);
      *(names  + r1 - 1) = nameaux;
      }
    if (l1 <= r1) {
      l1++;
      r1--;
      }
    }
  if (left  + 1 < r1)
    (void) QuickSortActByToken (tokens, names, left,  r1 - 1);
  if (l1 < right + 1)
    (void) QuickSortActByToken (tokens, names, l1 - 1, right);
  return;
  }


static char *
StrDup (const char *si)
{
  const char *pi;
  char *so, *po;

  if (si == 0) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "StrDup(): NULL as argument\n");
    (void) fflush (stderr);
    (void) exit (127);
    }
  pi = si;
  while (*pi != '\0')
    pi++;
  so = (char *) malloc ((size_t) (pi + 1 - si) * sizeof (char));
  if (so == 0) {
    VTF3_NOMEM_GOOD_BYE_INFO;
    (void) exit (127);
    }
  pi = si;
  po = so;
  while (*pi != '\0')
    *po++ = *pi++;
  *po = *pi;
  return (so);
  }


/*****************************************************************************/


static int
AppendClstrregval (void *ccbcaller, double time, int clstrtoken,
                    int clstrregarraydim, const int *clstrregtokenarray,
                    const int *clstrregvaluetypearray,
                    const void *clstrregvaluearray)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeClstrregval (ccb->fcboutmemory, time, clstrtoken,
                                  clstrregarraydim, clstrregtokenarray,
                                  clstrregvaluetypearray, clstrregvaluearray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendComment (void *ccbcaller, double time, const char *comment)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeComment (ccb->fcboutmemory, time, comment);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendCpuregval (void *ccbcaller, double time, unsigned int cpuid,
                  int cpuregarraydim, const int *cpuregtokenarray,
                  const int *cpuregvaluetypearray,
                  const void *cpuregvaluearray)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeCpuregval (ccb->fcboutmemory, time, cpuid, cpuregarraydim,
                                cpuregtokenarray, cpuregvaluetypearray,
                                cpuregvaluearray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefact (void *ccbcaller, int activitytoken, const char *activityname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefact (ccb->fcboutmemory, activitytoken, activityname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefact_obsol (void *ccbcaller, int activitytoken,
                     const char *activityname)
{
  static const char *noact = "NOACT";
  int isnoact;
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  if (activityname == 0) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "AppendDefact_obsol(): "
                            "NULL as activity name\n");
    (void) fflush (stderr);
    (void) exit (127);
    }
  if (activitytoken == VTF3_NOACT)
    return (0);
  isnoact = 1;
  for (i = 0; i < 6; i++)
    if (*(activityname + i) != *(noact + i)) {
      isnoact = 0;
      break;
      }
  if (isnoact != 0)
    return (0);
  (void) ActNameByToken (ccb, activitytoken, activityname);
  (void) ActTokenByName (ccb, activityname, activitytoken);
  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefact_obsol (ccb->fcboutmemory, activitytoken,
                                   activityname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefclkperiod (void *ccbcaller, double clkperiod)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefclkperiod (ccb->fcboutmemory, clkperiod);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefclstr (void *ccbcaller, int clstrtoken, const char *clstrname,
                 int cpuidarraydim, const unsigned int *cpuidarray)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefclstr (ccb->fcboutmemory, clstrtoken, clstrname,
                               cpuidarraydim, cpuidarray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefclstrreg (void *ccbcaller, int clstrregtoken, int clstrregclasstoken,
                    int valuetype, const void *valuebounds,
                    const char *clstrregname, const char *clstrregunit)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefclstrreg (ccb->fcboutmemory, clstrregtoken,
                                  clstrregclasstoken, valuetype, valuebounds,
                                  clstrregname, clstrregunit);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefclstrregclass (void *ccbcaller, int clstrregclasstoken,
                         const char *clstrregclassname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefclstrregclass (ccb->fcboutmemory, clstrregclasstoken,
                                       clstrregclassname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefcommunicator (void *ccbcaller, int communicator,
                        int communicatorsize, int tripletarraydim,
                        const unsigned int *tripletarray)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefcommunicator (ccb->fcboutmemory, communicator,
                                      communicatorsize, tripletarraydim,
                                      tripletarray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefcpugrp (void *ccbcaller, unsigned int cpugrpid,
                  int cpuorcpugrpidarraydim,
                  const unsigned int *cpuorcpugrpidarray,
                  const char *cpugrpname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefcpugrp (ccb->fcboutmemory, cpugrpid,
                                cpuorcpugrpidarraydim, cpuorcpugrpidarray,
                                cpugrpname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefcpuname (void *ccbcaller, unsigned int cpuid, const char *cpuname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefcpuname (ccb->fcboutmemory, cpuid, cpuname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefcpureg (void *ccbcaller, int cpuregtoken, int cpuregclasstoken,
                  int valuetype, const void *valuebounds,
                  const char *cpuregname, const char *cpuregunit)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefcpureg (ccb->fcboutmemory, cpuregtoken,
                                cpuregclasstoken, valuetype, valuebounds,
                                cpuregname, cpuregunit);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefcpuregclass (void *ccbcaller, int cpuregclasstoken,
                       const char *cpuregclassname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefcpuregclass (ccb->fcboutmemory, cpuregclasstoken,
                                     cpuregclassname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefcreator (void *ccbcaller, const char *creator)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefcreator (ccb->fcboutmemory, creator);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefglobalop (void *ccbcaller, int globaloptoken,
                    const char *globalopname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefglobalop (ccb->fcboutmemory, globaloptoken,
                                  globalopname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefiofile (void *ccbcaller, int iofiletoken, int communicator,
                  const char *iofilename)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefiofile (ccb->fcboutmemory, iofiletoken, communicator,
                                iofilename);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefkparreg (void *ccbcaller, int kparregtoken, const char *kparregname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefkparreg (ccb->fcboutmemory, kparregtoken, kparregname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefmsgname (void *ccbcaller, int msgtype, int communicator,
                   const char *msgname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefmsgname (ccb->fcboutmemory, msgtype, communicator,
                                 msgname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefopenmpname (void *ccbcaller, unsigned int nametoken,
                      const char *openmpname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefopenmpname (ccb->fcboutmemory, nametoken, openmpname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefopenmptype (void *ccbcaller, unsigned int constructtypetoken,
                      const char *constructtypename)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefopenmptype (ccb->fcboutmemory, constructtypetoken,
                                    constructtypename);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefpattern (void *ccbcaller, int activitytoken, int pattoken,
                   int patshptoken, double radius, int ratio,
                   int timesteparraydim, const double *timesteparray)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefpattern (ccb->fcboutmemory, activitytoken, pattoken,
                                 patshptoken, radius, ratio, timesteparraydim,
                                 timesteparray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefpatternshape (void *ccbcaller, int activitytoken, int patshptoken,
                        int patterntype, int patshptokenbref1,
                        int patshptokenbref2)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefpatternshape (ccb->fcboutmemory, activitytoken,
                                      patshptoken, patterntype,
                                      patshptokenbref1, patshptokenbref2);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefredfunc_obsol (void *ccbcaller, int redfunctoken,
                         const char *redfuncname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefredfunc_obsol (ccb->fcboutmemory, redfunctoken,
                                       redfuncname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefsamp (void *ccbcaller, int sampletoken, int sampleclasstoken,
                int iscpugrpsamp, unsigned int cpuorcpugrpid, int valuetype,
                const void *valuebounds, int dodifferentiation,
                int datarephint, const char *samplename,
                const char *sampleunit)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefsamp (ccb->fcboutmemory, sampletoken, sampleclasstoken,
                              iscpugrpsamp, cpuorcpugrpid, valuetype,
                              valuebounds, dodifferentiation, datarephint,
                              samplename, sampleunit);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefsampclass (void *ccbcaller, int sampleclasstoken,
                     const char *sampleclassname)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefsampclass (ccb->fcboutmemory, sampleclasstoken,
                                   sampleclassname);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefscl (void *ccbcaller, int scltoken, int sclarraydim,
               const int *sclfiletokenarray, const int *scllinepositionarray)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefscl (ccb->fcboutmemory, scltoken, sclarraydim,
                             sclfiletokenarray, scllinepositionarray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefsclfile (void *ccbcaller, int sclfiletoken, const char *sclfilename)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefsclfile (ccb->fcboutmemory, sclfiletoken, sclfilename);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefstate (void *ccbcaller, int activitytoken, int statetoken,
                 const char *statename, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefstate (ccb->fcboutmemory, activitytoken, statetoken,
                               statename, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefstate_obsol (void *ccbcaller, int activitytoken,
                       const char *activityname,
                       unsigned int activityvalidity, int statetoken,
                       const char *statename)
{
  static const char *noact = "NOACT";
  int isnoact;
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  if ((activityvalidity & VTF3_OLDACT_VALID_TOKEN) != 0 &&
      (activityvalidity & VTF3_OLDACT_VALID_NAME ) != 0) {
      if (activityname == 0) {
        (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                                "AppendDefstate_obsol(): "
                                "NULL as activity name\n");
        (void) fflush (stderr);
        (void) exit (127);
        }
      if (activitytoken == VTF3_NOACT)
        return (0);
      isnoact = 1;
      for (i = 0; i < 6; i++)
        if (*(activityname + i) != *(noact + i)) {
          isnoact = 0;
          break;
          }
      if (isnoact != 0)
        return (0);
      }
    else if ((activityvalidity & VTF3_OLDACT_VALID_TOKEN) != 0) {
      if (activitytoken == VTF3_NOACT)
        return (0);
      activityname = ActNameByToken (ccb, activitytoken, noact);
      if (activityname == 0) {
        (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                                "AppendDefstate_obsol(): "
                                "Unrecoverable error\n");
        (void) fflush (stderr);
        (void) exit (127);
        }
      isnoact = 1;
      for (i = 0; i < 6; i++)
        if (*(activityname + i) != *(noact + i)) {
          isnoact = 0;
          break;
          }
      if (isnoact != 0)
        return (0);
      }
    else if ((activityvalidity & VTF3_OLDACT_VALID_NAME) != 0) {
      if (activityname == 0) {
        (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                                "AppendDefstate_obsol(): "
                                "NULL as activity name\n");
        (void) fflush (stderr);
        (void) exit (127);
        }
      isnoact = 1;
      for (i = 0; i < 6; i++)
        if (*(activityname + i) != *(noact + i)) {
          isnoact = 0;
          break;
          }
      if (isnoact != 0)
        return (0);
      activitytoken = ActTokenByName (ccb, activityname, VTF3_NOACT);
      if (activitytoken == VTF3_NOACT) {
        (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                                "AppendDefstate_obsol(): "
                                "Unrecoverable error\n");
        (void) fflush (stderr);
        (void) exit (127);
        }
      }
    else
      return (0);
  activityvalidity = VTF3_OLDACT_VALID_TOKEN | VTF3_OLDACT_VALID_NAME;
  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefstate_obsol (ccb->fcboutmemory, activitytoken,
                                     activityname, activityvalidity,
                                     statetoken, statename);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefsyscpunames (void *ccbcaller, int systemcpunamearraydim,
                       char * const *systemcpunamearray)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefsyscpunames (ccb->fcboutmemory, systemcpunamearraydim,
                                     systemcpunamearray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefsyscpunums (void *ccbcaller, int systemcpunumberarraydim,
                      const int *systemcpunumberarray)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefsyscpunums (ccb->fcboutmemory, systemcpunumberarraydim,
                                    systemcpunumberarray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefthreadnums (void *ccbcaller, int threadnumarraydim,
                      const int *threadnumarray)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefthreadnums (ccb->fcboutmemory, threadnumarraydim,
                                    threadnumarray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDeftimeoffset (void *ccbcaller, double timeoffset)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDeftimeoffset (ccb->fcboutmemory, timeoffset);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefunmerged (void *ccbcaller)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefunmerged (ccb->fcboutmemory);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDefversion (void *ccbcaller, int versionnumber)
{
  VTF3_COMPOSER_CALL_DCL_DEFINITION;

  VTF3_COMPOSER_CALL_PROLOGUE_DEFINITION;
  rec = VTF3_ComposeDefversion (ccb->fcboutmemory, versionnumber);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendDownto (void *ccbcaller, double time, int statetoken,
               unsigned int cpuid, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeDownto (ccb->fcboutmemory, time, statetoken, cpuid,
                             scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendExchange (void *ccbcaller, double time, unsigned int cpuid,
                 int exchangetype, int statetoken, int job, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeExchange (ccb->fcboutmemory, time, cpuid, exchangetype,
                               statetoken, job, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendExchange_obsol (void *ccbcaller, double time, unsigned int cpuid,
                       int exchangetype, int statetoken, int activitytoken,
                       const char *activityname,
                       unsigned int activityvalidity, int job)
{
  static const char *noact = "NOACT";
  int isnoact;
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  if ((activityvalidity & VTF3_OLDACT_VALID_TOKEN) != 0 &&
      (activityvalidity & VTF3_OLDACT_VALID_NAME ) != 0) {
      if (activityname == 0) {
        (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                                "AppendExchange_obsol(): "
                                "NULL as activity name\n");
        (void) fflush (stderr);
        (void) exit (127);
        }
      isnoact = 1;
      for (i = 0; i < 6; i++)
        if (*(activityname + i) != *(noact + i)) {
          isnoact = 0;
          break;
          }
      if (activitytoken == VTF3_NOACT && isnoact == 0)
        return (0);
      if (activitytoken != VTF3_NOACT && isnoact != 0)
        return (0);
      }
    else if ((activityvalidity & VTF3_OLDACT_VALID_TOKEN) != 0) {
      if (activitytoken == VTF3_NOACT)
          activityname = noact;
        else {
          activityname = ActNameByToken (ccb, activitytoken, noact);
          if (activityname == 0) {
            (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                                    "AppendExchange_obsol(): "
                                    "Unrecoverable error\n");
            (void) fflush (stderr);
            (void) exit (127);
            }
          isnoact = 1;
          for (i = 0; i < 6; i++)
            if (*(activityname + i) != *(noact + i)) {
              isnoact = 0;
              break;
              }
          if (isnoact != 0)
            /* Not found. */
            return (0);
          }
      }
    else if ((activityvalidity & VTF3_OLDACT_VALID_NAME) != 0) {
      if (activityname == 0) {
        (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                                "AppendExchange_obsol(): "
                                "NULL as activity name\n");
        (void) fflush (stderr);
        (void) exit (127);
        }
      isnoact = 1;
      for (i = 0; i < 6; i++)
        if (*(activityname + i) != *(noact + i)) {
          isnoact = 0;
          break;
          }
      if (isnoact != 0)
          activitytoken = VTF3_NOACT;
        else {
          activitytoken = ActTokenByName (ccb, activityname, VTF3_NOACT);
          if (activitytoken == VTF3_NOACT) {
            /* Error in `ActTokenByName()' .*/
            (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                                    "AppendExchange_obsol(): "
                                    "Unrecoverable error\n");
            (void) fflush (stderr);
            (void) exit (127);
            }
          }
      }
    else
      return (0);
  if (exchangetype == VTF3_EXCHANGETYPE_UPFROM)
    return (0);
  if (exchangetype == VTF3_EXCHANGETYPE_DOWNTO && activitytoken == VTF3_NOACT)
    return (0);
  if (statetoken == VTF3_NOSTATE || activitytoken == VTF3_NOACT)
    if (statetoken != VTF3_NOSTATE || activitytoken != VTF3_NOACT)
      return (0);
  activityvalidity = VTF3_OLDACT_VALID_TOKEN | VTF3_OLDACT_VALID_NAME;
  rec = VTF3_ComposeExchange_obsol (ccb->fcboutmemory, time, cpuid,
                                     exchangetype, statetoken, activitytoken,
                                     activityname, activityvalidity, job);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendFileiobegin (void *ccbcaller, double time, unsigned int cpuid,
                    int fileiotype, int iofiletoken, int bytescopied,
                    int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeFileiobegin (ccb->fcboutmemory, time, cpuid, fileiotype,
                                  iofiletoken, bytescopied, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendFileioend (void *ccbcaller, double time, unsigned int cpuid,
                  int fileiotype, int iofiletoken, int bytescopied,
                  int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeFileioend (ccb->fcboutmemory, time, cpuid, fileiotype,
                                iofiletoken, bytescopied, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendGlobalop (void *ccbcaller, double time, int globaloptoken,
                 unsigned int cpuid, int communicator, unsigned int rootcpuid,
                 int bytessent, int bytesreceived, double durationtimesteps,
                 int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeGlobalop (ccb->fcboutmemory, time, globaloptoken, cpuid,
                               communicator, rootcpuid, bytessent,
                               bytesreceived, durationtimesteps, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendKparregbarsum (void *ccbcaller, double time, unsigned int cpuid,
                      int kparregtoken, int seqn, int opasize,
                      const void *opastream, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeKparregbarsum (ccb->fcboutmemory, time, cpuid,
                                    kparregtoken, seqn, opasize, opastream,
                                    scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendKparregbegin (void *ccbcaller, double time, unsigned int cpuid,
                     int kparregtoken, int seqn, int numthreads, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeKparregbegin (ccb->fcboutmemory, time, cpuid,
                                   kparregtoken, seqn, numthreads, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendKparregend (void *ccbcaller, double time, unsigned int cpuid,
                   int kparregtoken, int seqn, int opasize,
                   const void *opastream, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeKparregend (ccb->fcboutmemory, time, cpuid, kparregtoken,
                                 seqn, opasize, opastream, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendMutexacquire (void *ccbcaller, double time, unsigned int cpuid,
                     int enterstatetoken, int leavestatetoken,
                     int leavestatetokenisupfrom, double durationtimesteps,
                     int mutexsize, const void *mutex, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeMutexacquire (ccb->fcboutmemory, time, cpuid,
                                   enterstatetoken, leavestatetoken,
                                   leavestatetokenisupfrom, durationtimesteps,
                                   mutexsize, mutex, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendMutexrelease (void *ccbcaller, double time, unsigned int cpuid,
                     int enterstatetoken, int leavestatetoken,
                     int leavestatetokenisupfrom, double durationtimesteps,
                     int mutexsize, const void *mutex, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeMutexrelease (ccb->fcboutmemory, time, cpuid,
                                   enterstatetoken, leavestatetoken,
                                   leavestatetokenisupfrom, durationtimesteps,
                                   mutexsize, mutex, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendOpenmpenter (void *ccbcaller, double time, unsigned int cpuid,
                    unsigned int constructtypetoken, unsigned int nametoken,
                    int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeOpenmpenter (ccb->fcboutmemory, time, cpuid,
                                  constructtypetoken, nametoken, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendOpenmpleave (void *ccbcaller, double time, unsigned int cpuid,
                    int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeOpenmpleave (ccb->fcboutmemory, time, cpuid, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendParreg (void *ccbcaller, double time, unsigned int cpugrpid,
               unsigned int nametoken, int sclstarttoken, int sclendtoken,
               int timearraydim, const double *timeoffsetanddurationarray)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeParreg (ccb->fcboutmemory, time, cpugrpid, nametoken,
                             sclstarttoken, sclendtoken, timearraydim,
                             timeoffsetanddurationarray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendPattern (void *ccbcaller, double time, unsigned int cpuid,
                int patorpatshptoken, double durationtimesteps,
                int timesteparraydim, const double *timesteparray,
                const int *patchindexarray)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposePattern (ccb->fcboutmemory, time, cpuid, patorpatshptoken,
                              durationtimesteps, timesteparraydim,
                              timesteparray, patchindexarray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendRecvmsg (void *ccbcaller, double time, unsigned int receiver,
                unsigned int sender, int communicator, int msgtype,
                int msglength, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeRecvmsg (ccb->fcboutmemory, time, receiver, sender,
                              communicator, msgtype, msglength, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendSamp (void *ccbcaller, double time, unsigned int cpuorcpugrpid,
             int samplearraydim, const int *sampletokenarray,
             const int *samplevaluetypearray, const void *samplevaluearray)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeSamp (ccb->fcboutmemory, time, cpuorcpugrpid,
                           samplearraydim, sampletokenarray,
                           samplevaluetypearray, samplevaluearray);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendSendmsg (void *ccbcaller, double time, unsigned int sender,
                unsigned int receiver, int communicator, int msgtype,
                int msglength, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeSendmsg (ccb->fcboutmemory, time, sender, receiver,
                              communicator, msgtype, msglength, scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendSrcinfo_obsol (void *ccbcaller, double time, int activitytoken,
                      int statetoken, int scllineposition)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeSrcinfo_obsol (ccb->fcboutmemory, time, activitytoken,
                                    statetoken, scllineposition);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendUnrecognizable (void *ccbcaller, double lastvalidtime,
                       int numberofunrecognizablechars,
                       int typeofunrecognizablerecord,
                       const char *unrecognizablerecord)
{
  double time;
  VTF3_COMPOSER_CALL_DCL_EVENT;

  time = lastvalidtime;
  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeUnrecognizable (ccb->fcboutmemory, lastvalidtime,
                                     numberofunrecognizablechars,
                                     typeofunrecognizablerecord,
                                     unrecognizablerecord);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendUpfrom (void *ccbcaller, double time, int statetoken,
               unsigned int cpuid, int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeUpfrom (ccb->fcboutmemory, time, statetoken, cpuid,
                             scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


static int
AppendUpto (void *ccbcaller, double time, int statetoken, unsigned int cpuid,
             int scltoken)
{
  VTF3_COMPOSER_CALL_DCL_EVENT;

  VTF3_COMPOSER_CALL_PROLOGUE_EVENT;
  rec = VTF3_ComposeUpto (ccb->fcboutmemory, time, statetoken, cpuid,
                           scltoken);
  VTF3_COMPOSER_CALL_EPILOGUE;
  return (0);
  }


/*****************************************************************************/


#if (defined (VTF3_MAIN_SHOWTFWIN))


int
main (void)
{
  const char *inputfilename  = "input.vpt";
  const char *outputfilename = "showlog.vpt";
  double timestampmin = -2.0e+00;
  double timestampmax =  1.1e+30;
  size_t outputbuffersize = 100000000;
  char *outputbuffer;
  FILE *pfile;
  size_t rc;

  (void) VTF3_InitTables ();
  (void) fprintf (stdout, "%s\n", VTF3_GetVersion ());
  (void) fprintf (stdout, "%d\n", VTF3_GetVersionNumber ());
  if ((outputbuffer = (char *) malloc (outputbuffersize)) == 0) {
    VTF3_NOMEM_GOOD_BYE_INFO;
    (void) exit (127);
    }
  if (VTF3_ShowTraceFileWindow (inputfilename, &timestampmin, &timestampmax,
                                 outputbuffer,
                                 outputbuffersize) != outputbuffer) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "Can't open `%s' for input\n", inputfilename);
    (void) fflush (stderr);
    (void) exit (127);
    }
  if ((pfile = fopen (outputfilename, "wb")) == 0) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "Can't open `%s' for output\n", outputfilename);
    (void) fflush (stderr);
    (void) exit (127);
    }
  rc = fwrite (outputbuffer, sizeof (char), (size_t) strlen (outputbuffer),
                pfile);
  if (rc != (size_t) strlen (outputbuffer)) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "I/O error on output\n");
    (void) fflush (stderr);
    (void) exit (127);
    }
  if (fclose (pfile) != 0) {
    (void) fprintf (stderr, "VTF3_ShowTraceFileWindow(): "
                            "Error while closing output\n");
    (void) fflush (stderr);
    (void) exit (127);
    }
  (void) free (outputbuffer);
  return (0);
  }


#endif


/*****************************************************************************/


/* {{{ HISTORY */

/*
 *
 * $Log: vtf3showtfwin.c,v $
 * Revision 1.2  2005/10/22 00:57:03  sameer
 * committing source of vtf3 1.43.
 *
 * Revision 1.16  2004/03/01 22:54:26  seidl
 * Added missing OpenMP stuff.
 *
 * Revision 1.15  2003/11/24 00:16:04  seidl
 * Code should be in "Clean C" now.
 *
 * Revision 1.14  2002/09/09 15:56:53  seidl
 * DEFPATTERN got an additional argument.
 *
 * Revision 1.13  2002/05/03 07:55:35  seidl
 * Tokenization canonicalized.
 *
 * Revision 1.12  2002/05/01 12:45:01  seidl
 * Cosmetic change.
 *
 * Revision 1.11  2002/04/19 01:29:30  seidl
 * Cosmetic changes.
 *
 * Revision 1.10  2002/04/11 12:59:31  seidl
 * Records and interfaces of DEFPATTERN and PATTERN changed.
 *
 * Revision 1.9  2002/03/07 11:10:07  seidl
 * `strdup()' replaced by local code.
 *
 * Revision 1.8  2002/03/06 10:25:32  seidl
 * Work around a problem with respect to the `strdup()' declaration.
 *
 * Revision 1.7  2002/03/02 23:42:03  seidl
 * Improvement in practical speed.
 *
 * Revision 1.6  2002/03/02 23:13:16  seidl
 * Last quick-sort argument casted.
 *
 * Revision 1.5  2002/03/02 22:06:52  seidl
 * Final implementation.
 *
 * Revision 1.4  2002/03/01 19:01:55  seidl
 * Changes to simplify debugging.
 *
 * Revision 1.3  2002/02/28 16:55:41  seidl
 * Prototype went from here to `vtf3.h', not
 * to `vtf3.c', of course.
 *
 * Revision 1.2  2002/02/28 16:52:00  seidl
 * Declaration of VTF3_ShowTraceFileWindow() changed.
 * Prototype went from here to `vtf3.h'.
 * DEFPATTERN, DEFPATTERNSHAPE, PATTERN,
 * MUTEXACQUIRE and MUTEXRELEASE implemented.
 * DOWNTO, UPFROM and UPTO got SCL.
 * Window selection management rewritten.
 * What keeps to do is the (re)tokenization.
 *
 * Revision 1.1  2001/09/25 23:23:42  seidl
 * Initial version.
 *
 * Revision 1.0  2000/00/00 00:00:00  seidl
 * Initial version.
 *
 */

/* }}} */


/*****************************************************************************/