1 // Created by TraceCompiler 2.1.2

     2 // DO NOT EDIT, CHANGES WILL BE LOST

     3 

     4 #ifndef __HELLOWORLDTRACES_H__

     5 #define __HELLOWORLDTRACES_H__

     6 

     7 #define KOstTraceComponentID 0xe9fbe6ee

     8 

     9 #define TRACE0 0xde0001

    10 #define TRACE1 0xde0002

    11 #define TRACE2 0xde0003

    12 #define TRACE3 0xde0004

    13 #define TRACE4 0xde0005

    14 #define TRACE5 0xde0006

    15 #define TRACE7 0xde0007

    16 #define TRACE8 0xde0008

    17 #define TRACE9 0xde0009

    18 #define TRACE10 0xde000a

    19 #define TRACE11 0xde000b

    20 #define TRACE12 0xde000c

    21 #define TRACE13 0xde000d

    22 #define TRACE14 0xde000e

    23 #define TRACE15 0xde000f

    24 #define TRACE16 0xde0010

    25 #define TRACE17 0xde0011

    26 #define TRACE18 0xde0012

    27 #define TRACE19 0xde0013

    28 #define TRACE20 0xde0014

    29 #define TRACE21 0xde0015

    30 #define TRACE22 0xde0016

    31 #define TRACE23 0xde0017

    32 #define TRACE24 0xde0018

    33 #define TRACE25 0xde0019

    34 #define TRACE26 0xde001a

    35 #define TRACE27 0xde001b

    36 #define TRACE28 0xde001c

    37 #define TRACE29 0xde001d

    38 #define TRACE30 0xde001e

    39 #define TRACE31 0xde001f

    40 #define TRACE32 0xde0020

    41 #define TRACE33 0xde0021

    42 #define TRACE34 0xde0022

    43 #define TRACE35 0xde0023

    44 #define TRACE36 0xde0024

    45 

    46 

    47 inline TBool OstTraceGen2( TUint32 aTraceID, const TDesC8& aParam1, const TDesC8& aParam2 )

    48     {

    49     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    50     if ( retval )

    51         {

    52         TInt length = 0;

    53         // Check that parameter lenght is not too long

    54         TInt length1 = aParam1.Size();

    55         if ((length + length1 + sizeof ( TUint32 )) > KOstMaxDataLength)

    56             {

    57             length1 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

    58             }

    59         TInt lengthAligned1 = ( length1 + 3 ) & ~3;

    60         if (lengthAligned1 > 0)

    61             {

    62             length = length + sizeof ( TUint32 ) + lengthAligned1;

    63             }

    64         // Check that parameter lenght is not too long

    65         TInt length2 = aParam2.Size();

    66         if ((length + length2 + sizeof ( TUint32 )) > KOstMaxDataLength)

    67             {

    68             length2 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

    69             }

    70         TInt lengthAligned2 = ( length2 + 3 ) & ~3;

    71         if (lengthAligned2 > 0)

    72             {

    73             length = length + sizeof ( TUint32 ) + lengthAligned2;

    74             }

    75         TUint8 data[ KOstMaxDataLength ];

    76         TUint8* ptr = data;

    77         // Set length to zero and calculate it againg

    78         // when adding parameters

    79         length = 0;

    80         if (length1 > 0)

    81             {

    82             // Number of elements is written before data

    83             // In case of Unicode string, number of elements is half of length

    84             *( ( TUint32* )ptr ) = length1 / (aParam1.Size() / aParam1.Length());

    85             ptr += sizeof ( TUint32 );

    86             memcpy( ptr, aParam1.Ptr(), length1 );

    87             ptr += length1;

    88             // Fillers are written to get 32-bit alignment

    89             while ( length1++ < lengthAligned1 )

    90                 {

    91                 *ptr++ = 0;

    92                 }

    93             length += sizeof ( TUint32 ) + lengthAligned1;

    94             }

    95         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

    96             {

    97             *( ( TUint32* )ptr ) = 0;

    98             ptr += sizeof ( TUint32 );

    99             length += sizeof ( TUint32 );

   100             }

   101         if (length2 > 0)

   102             {

   103             // Number of elements is written before data

   104             // In case of Unicode string, number of elements is half of length

   105             *( ( TUint32* )ptr ) = length2 / (aParam2.Size() / aParam2.Length());

   106             ptr += sizeof ( TUint32 );

   107             memcpy( ptr, aParam2.Ptr(), length2 );

   108             ptr += length2;

   109             // Fillers are written to get 32-bit alignment

   110             while ( length2++ < lengthAligned2 )

   111                 {

   112                 *ptr++ = 0;

   113                 }

   114             length += sizeof ( TUint32 ) + lengthAligned2;

   115             }

   116         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   117             {

   118             *( ( TUint32* )ptr ) = 0;

   119             ptr += sizeof ( TUint32 );

   120             length += sizeof ( TUint32 );

   121             }

   122         ptr -= length;

   123         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, length );

   124         }

   125     return retval;

   126     }

   127 

   128 

   129 #ifndef __KERNEL_MODE__

   130 inline TBool OstTraceGen2( TUint32 aTraceID, const TDesC16& aParam1, const TDesC16& aParam2 )

   131     {

   132     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

   133     if ( retval )

   134         {

   135         TInt length = 0;

   136         // Check that parameter lenght is not too long

   137         TInt length1 = aParam1.Size();

   138         if ((length + length1 + sizeof ( TUint32 )) > KOstMaxDataLength)

   139             {

   140             length1 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   141             }

   142         TInt lengthAligned1 = ( length1 + 3 ) & ~3;

   143         if (lengthAligned1 > 0)

   144             {

   145             length = length + sizeof ( TUint32 ) + lengthAligned1;

   146             }

   147         // Check that parameter lenght is not too long

   148         TInt length2 = aParam2.Size();

   149         if ((length + length2 + sizeof ( TUint32 )) > KOstMaxDataLength)

   150             {

   151             length2 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   152             }

   153         TInt lengthAligned2 = ( length2 + 3 ) & ~3;

   154         if (lengthAligned2 > 0)

   155             {

   156             length = length + sizeof ( TUint32 ) + lengthAligned2;

   157             }

   158         TUint8 data[ KOstMaxDataLength ];

   159         TUint8* ptr = data;

   160         // Set length to zero and calculate it againg

   161         // when adding parameters

   162         length = 0;

   163         if (length1 > 0)

   164             {

   165             // Number of elements is written before data

   166             // In case of Unicode string, number of elements is half of length

   167             *( ( TUint32* )ptr ) = length1 / (aParam1.Size() / aParam1.Length());

   168             ptr += sizeof ( TUint32 );

   169             memcpy( ptr, aParam1.Ptr(), length1 );

   170             ptr += length1;

   171             // Fillers are written to get 32-bit alignment

   172             while ( length1++ < lengthAligned1 )

   173                 {

   174                 *ptr++ = 0;

   175                 }

   176             length += sizeof ( TUint32 ) + lengthAligned1;

   177             }

   178         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   179             {

   180             *( ( TUint32* )ptr ) = 0;

   181             ptr += sizeof ( TUint32 );

   182             length += sizeof ( TUint32 );

   183             }

   184         if (length2 > 0)

   185             {

   186             // Number of elements is written before data

   187             // In case of Unicode string, number of elements is half of length

   188             *( ( TUint32* )ptr ) = length2 / (aParam2.Size() / aParam2.Length());

   189             ptr += sizeof ( TUint32 );

   190             memcpy( ptr, aParam2.Ptr(), length2 );

   191             ptr += length2;

   192             // Fillers are written to get 32-bit alignment

   193             while ( length2++ < lengthAligned2 )

   194                 {

   195                 *ptr++ = 0;

   196                 }

   197             length += sizeof ( TUint32 ) + lengthAligned2;

   198             }

   199         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   200             {

   201             *( ( TUint32* )ptr ) = 0;

   202             ptr += sizeof ( TUint32 );

   203             length += sizeof ( TUint32 );

   204             }

   205         ptr -= length;

   206         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, length );

   207         }

   208     return retval;

   209     }

   210 #endif

   211 

   212 

   213 #ifndef __KERNEL_MODE__

   214 inline TBool OstTraceGen2( TUint32 aTraceID, const TDesC8& aParam1, const TDesC16& aParam2 )

   215     {

   216     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

   217     if ( retval )

   218         {

   219         TInt length = 0;

   220         // Check that parameter lenght is not too long

   221         TInt length1 = aParam1.Size();

   222         if ((length + length1 + sizeof ( TUint32 )) > KOstMaxDataLength)

   223             {

   224             length1 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   225             }

   226         TInt lengthAligned1 = ( length1 + 3 ) & ~3;

   227         if (lengthAligned1 > 0)

   228             {

   229             length = length + sizeof ( TUint32 ) + lengthAligned1;

   230             }

   231         // Check that parameter lenght is not too long

   232         TInt length2 = aParam2.Size();

   233         if ((length + length2 + sizeof ( TUint32 )) > KOstMaxDataLength)

   234             {

   235             length2 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   236             }

   237         TInt lengthAligned2 = ( length2 + 3 ) & ~3;

   238         if (lengthAligned2 > 0)

   239             {

   240             length = length + sizeof ( TUint32 ) + lengthAligned2;

   241             }

   242         TUint8 data[ KOstMaxDataLength ];

   243         TUint8* ptr = data;

   244         // Set length to zero and calculate it againg

   245         // when adding parameters

   246         length = 0;

   247         if (length1 > 0)

   248             {

   249             // Number of elements is written before data

   250             // In case of Unicode string, number of elements is half of length

   251             *( ( TUint32* )ptr ) = length1 / (aParam1.Size() / aParam1.Length());

   252             ptr += sizeof ( TUint32 );

   253             memcpy( ptr, aParam1.Ptr(), length1 );

   254             ptr += length1;

   255             // Fillers are written to get 32-bit alignment

   256             while ( length1++ < lengthAligned1 )

   257                 {

   258                 *ptr++ = 0;

   259                 }

   260             length += sizeof ( TUint32 ) + lengthAligned1;

   261             }

   262         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   263             {

   264             *( ( TUint32* )ptr ) = 0;

   265             ptr += sizeof ( TUint32 );

   266             length += sizeof ( TUint32 );

   267             }

   268         if (length2 > 0)

   269             {

   270             // Number of elements is written before data

   271             // In case of Unicode string, number of elements is half of length

   272             *( ( TUint32* )ptr ) = length2 / (aParam2.Size() / aParam2.Length());

   273             ptr += sizeof ( TUint32 );

   274             memcpy( ptr, aParam2.Ptr(), length2 );

   275             ptr += length2;

   276             // Fillers are written to get 32-bit alignment

   277             while ( length2++ < lengthAligned2 )

   278                 {

   279                 *ptr++ = 0;

   280                 }

   281             length += sizeof ( TUint32 ) + lengthAligned2;

   282             }

   283         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   284             {

   285             *( ( TUint32* )ptr ) = 0;

   286             ptr += sizeof ( TUint32 );

   287             length += sizeof ( TUint32 );

   288             }

   289         ptr -= length;

   290         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, length );

   291         }

   292     return retval;

   293     }

   294 #endif

   295 

   296 

   297 #ifndef __KERNEL_MODE__

   298 inline TBool OstTraceGen2( TUint32 aTraceID, const TDesC16& aParam1, const TDesC8& aParam2 )

   299     {

   300     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

   301     if ( retval )

   302         {

   303         TInt length = 0;

   304         // Check that parameter lenght is not too long

   305         TInt length1 = aParam1.Size();

   306         if ((length + length1 + sizeof ( TUint32 )) > KOstMaxDataLength)

   307             {

   308             length1 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   309             }

   310         TInt lengthAligned1 = ( length1 + 3 ) & ~3;

   311         if (lengthAligned1 > 0)

   312             {

   313             length = length + sizeof ( TUint32 ) + lengthAligned1;

   314             }

   315         // Check that parameter lenght is not too long

   316         TInt length2 = aParam2.Size();

   317         if ((length + length2 + sizeof ( TUint32 )) > KOstMaxDataLength)

   318             {

   319             length2 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   320             }

   321         TInt lengthAligned2 = ( length2 + 3 ) & ~3;

   322         if (lengthAligned2 > 0)

   323             {

   324             length = length + sizeof ( TUint32 ) + lengthAligned2;

   325             }

   326         TUint8 data[ KOstMaxDataLength ];

   327         TUint8* ptr = data;

   328         // Set length to zero and calculate it againg

   329         // when adding parameters

   330         length = 0;

   331         if (length1 > 0)

   332             {

   333             // Number of elements is written before data

   334             // In case of Unicode string, number of elements is half of length

   335             *( ( TUint32* )ptr ) = length1 / (aParam1.Size() / aParam1.Length());

   336             ptr += sizeof ( TUint32 );

   337             memcpy( ptr, aParam1.Ptr(), length1 );

   338             ptr += length1;

   339             // Fillers are written to get 32-bit alignment

   340             while ( length1++ < lengthAligned1 )

   341                 {

   342                 *ptr++ = 0;

   343                 }

   344             length += sizeof ( TUint32 ) + lengthAligned1;

   345             }

   346         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   347             {

   348             *( ( TUint32* )ptr ) = 0;

   349             ptr += sizeof ( TUint32 );

   350             length += sizeof ( TUint32 );

   351             }

   352         if (length2 > 0)

   353             {

   354             // Number of elements is written before data

   355             // In case of Unicode string, number of elements is half of length

   356             *( ( TUint32* )ptr ) = length2 / (aParam2.Size() / aParam2.Length());

   357             ptr += sizeof ( TUint32 );

   358             memcpy( ptr, aParam2.Ptr(), length2 );

   359             ptr += length2;

   360             // Fillers are written to get 32-bit alignment

   361             while ( length2++ < lengthAligned2 )

   362                 {

   363                 *ptr++ = 0;

   364                 }

   365             length += sizeof ( TUint32 ) + lengthAligned2;

   366             }

   367         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   368             {

   369             *( ( TUint32* )ptr ) = 0;

   370             ptr += sizeof ( TUint32 );

   371             length += sizeof ( TUint32 );

   372             }

   373         ptr -= length;

   374         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, length );

   375         }

   376     return retval;

   377     }

   378 #endif

   379 

   380 

   381 inline TBool OstTraceGen1( TUint32 aTraceID, const TDesC8& aParam1 )

   382     {

   383     TBool retval;

   384     TInt size = aParam1.Size();

   385     // BTrace assumes that parameter size is atleast 4 bytes

   386     if (size % 4 == 0)

   387         {

   388         TUint8* ptr = ( TUint8* )aParam1.Ptr();

   389         // Data is written directly and length is determined from trace message length

   390         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

   391         }

   392     else

   393         {

   394         TUint8 data[ KOstMaxDataLength ];

   395         TUint8* ptr = data;

   396         if (size > KOstMaxDataLength)

   397             {

   398             size = KOstMaxDataLength;

   399             }

   400         TInt sizeAligned = ( size + 3 ) & ~3;

   401         memcpy( ptr, aParam1.Ptr(), size );

   402         ptr += size;

   403         // Fillers are written to get 32-bit alignment

   404         while ( size++ < sizeAligned )

   405             {

   406             *ptr++ = 0;

   407             }

   408         ptr -= sizeAligned;

   409         size = sizeAligned;

   410         // Data is written directly and length is determined from trace message length

   411         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

   412         }

   413     return retval;

   414     }

   415 

   416 

   417 #ifndef __KERNEL_MODE__

   418 inline TBool OstTraceGen1( TUint32 aTraceID, const TDesC16& aParam1 )

   419     {

   420     TBool retval;

   421     TInt size = aParam1.Size();

   422     // BTrace assumes that parameter size is atleast 4 bytes

   423     if (size % 4 == 0)

   424         {

   425         TUint8* ptr = ( TUint8* )aParam1.Ptr();

   426         // Data is written directly and length is determined from trace message length

   427         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

   428         }

   429     else

   430         {

   431         TUint8 data[ KOstMaxDataLength ];

   432         TUint8* ptr = data;

   433         if (size > KOstMaxDataLength)

   434             {

   435             size = KOstMaxDataLength;

   436             }

   437         TInt sizeAligned = ( size + 3 ) & ~3;

   438         memcpy( ptr, aParam1.Ptr(), size );

   439         ptr += size;

   440         // Fillers are written to get 32-bit alignment

   441         while ( size++ < sizeAligned )

   442             {

   443             *ptr++ = 0;

   444             }

   445         ptr -= sizeAligned;

   446         size = sizeAligned;

   447         // Data is written directly and length is determined from trace message length

   448         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

   449         }

   450     return retval;

   451     }

   452 #endif

   453 

   454 

   455 #ifndef __KERNEL_MODE__

   456 inline TBool OstTraceGen3( TUint32 aTraceID, const TDesC16& aParam1, const TDesC8& aParam2, TInt aParam3 )

   457     {

   458     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

   459     if ( retval )

   460         {

   461         TInt length = 0;

   462         // Check that parameter lenght is not too long

   463         TInt length1 = aParam1.Size();

   464         if ((length + length1 + sizeof ( TUint32 )) > KOstMaxDataLength)

   465             {

   466             length1 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   467             }

   468         TInt lengthAligned1 = ( length1 + 3 ) & ~3;

   469         if (lengthAligned1 > 0)

   470             {

   471             length = length + sizeof ( TUint32 ) + lengthAligned1;

   472             }

   473         // Check that parameter lenght is not too long

   474         TInt length2 = aParam2.Size();

   475         if ((length + length2 + sizeof ( TUint32 )) > KOstMaxDataLength)

   476             {

   477             length2 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   478             }

   479         TInt lengthAligned2 = ( length2 + 3 ) & ~3;

   480         if (lengthAligned2 > 0)

   481             {

   482             length = length + sizeof ( TUint32 ) + lengthAligned2;

   483             }

   484         TUint8 data[ KOstMaxDataLength ];

   485         TUint8* ptr = data;

   486         // Set length to zero and calculate it againg

   487         // when adding parameters

   488         length = 0;

   489         if (length1 > 0)

   490             {

   491             // Number of elements is written before data

   492             // In case of Unicode string, number of elements is half of length

   493             *( ( TUint32* )ptr ) = length1 / (aParam1.Size() / aParam1.Length());

   494             ptr += sizeof ( TUint32 );

   495             memcpy( ptr, aParam1.Ptr(), length1 );

   496             ptr += length1;

   497             // Fillers are written to get 32-bit alignment

   498             while ( length1++ < lengthAligned1 )

   499                 {

   500                 *ptr++ = 0;

   501                 }

   502             length += sizeof ( TUint32 ) + lengthAligned1;

   503             }

   504         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   505             {

   506             *( ( TUint32* )ptr ) = 0;

   507             ptr += sizeof ( TUint32 );

   508             length += sizeof ( TUint32 );

   509             }

   510         if (length2 > 0)

   511             {

   512             // Number of elements is written before data

   513             // In case of Unicode string, number of elements is half of length

   514             *( ( TUint32* )ptr ) = length2 / (aParam2.Size() / aParam2.Length());

   515             ptr += sizeof ( TUint32 );

   516             memcpy( ptr, aParam2.Ptr(), length2 );

   517             ptr += length2;

   518             // Fillers are written to get 32-bit alignment

   519             while ( length2++ < lengthAligned2 )

   520                 {

   521                 *ptr++ = 0;

   522                 }

   523             length += sizeof ( TUint32 ) + lengthAligned2;

   524             }

   525         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   526             {

   527             *( ( TUint32* )ptr ) = 0;

   528             ptr += sizeof ( TUint32 );

   529             length += sizeof ( TUint32 );

   530             }

   531         // Check that there are enough space to next parameter

   532         if ((length + sizeof ( TInt )) <= KOstMaxDataLength)

   533             {

   534             *( ( TInt* )ptr ) = aParam3;

   535             ptr += sizeof ( TInt );

   536             length += sizeof ( TInt );

   537             }

   538         ptr -= length;

   539         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, length );

   540         }

   541     return retval;

   542     }

   543 

   544 inline TBool OstTraceGen3( TUint32 aTraceID, const TDesC16& aParam1, const TDesC8& aParam2, TInt32 aParam3 )

   545     {

   546     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

   547     if ( retval )

   548         {

   549         TInt length = 0;

   550         // Check that parameter lenght is not too long

   551         TInt length1 = aParam1.Size();

   552         if ((length + length1 + sizeof ( TUint32 )) > KOstMaxDataLength)

   553             {

   554             length1 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   555             }

   556         TInt lengthAligned1 = ( length1 + 3 ) & ~3;

   557         if (lengthAligned1 > 0)

   558             {

   559             length = length + sizeof ( TUint32 ) + lengthAligned1;

   560             }

   561         // Check that parameter lenght is not too long

   562         TInt length2 = aParam2.Size();

   563         if ((length + length2 + sizeof ( TUint32 )) > KOstMaxDataLength)

   564             {

   565             length2 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   566             }

   567         TInt lengthAligned2 = ( length2 + 3 ) & ~3;

   568         if (lengthAligned2 > 0)

   569             {

   570             length = length + sizeof ( TUint32 ) + lengthAligned2;

   571             }

   572         TUint8 data[ KOstMaxDataLength ];

   573         TUint8* ptr = data;

   574         // Set length to zero and calculate it againg

   575         // when adding parameters

   576         length = 0;

   577         if (length1 > 0)

   578             {

   579             // Number of elements is written before data

   580             // In case of Unicode string, number of elements is half of length

   581             *( ( TUint32* )ptr ) = length1 / (aParam1.Size() / aParam1.Length());

   582             ptr += sizeof ( TUint32 );

   583             memcpy( ptr, aParam1.Ptr(), length1 );

   584             ptr += length1;

   585             // Fillers are written to get 32-bit alignment

   586             while ( length1++ < lengthAligned1 )

   587                 {

   588                 *ptr++ = 0;

   589                 }

   590             length += sizeof ( TUint32 ) + lengthAligned1;

   591             }

   592         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   593             {

   594             *( ( TUint32* )ptr ) = 0;

   595             ptr += sizeof ( TUint32 );

   596             length += sizeof ( TUint32 );

   597             }

   598         if (length2 > 0)

   599             {

   600             // Number of elements is written before data

   601             // In case of Unicode string, number of elements is half of length

   602             *( ( TUint32* )ptr ) = length2 / (aParam2.Size() / aParam2.Length());

   603             ptr += sizeof ( TUint32 );

   604             memcpy( ptr, aParam2.Ptr(), length2 );

   605             ptr += length2;

   606             // Fillers are written to get 32-bit alignment

   607             while ( length2++ < lengthAligned2 )

   608                 {

   609                 *ptr++ = 0;

   610                 }

   611             length += sizeof ( TUint32 ) + lengthAligned2;

   612             }

   613         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   614             {

   615             *( ( TUint32* )ptr ) = 0;

   616             ptr += sizeof ( TUint32 );

   617             length += sizeof ( TUint32 );

   618             }

   619         // Check that there are enough space to next parameter

   620         if ((length + sizeof ( TInt )) <= KOstMaxDataLength)

   621             {

   622             *( ( TInt* )ptr ) = aParam3;

   623             ptr += sizeof ( TInt );

   624             length += sizeof ( TInt );

   625             }

   626         ptr -= length;

   627         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, length );

   628         }

   629     return retval;

   630     }

   631 #endif

   632 

   633 

   634 #endif

   635 

   636 // End of file

   637