1 // Created by TraceCompiler 2.1.2

     2 // DO NOT EDIT, CHANGES WILL BE LOST

     3 

     4 #ifndef __TRACECOMPILERTESTERBASICTRACES_H__

     5 #define __TRACECOMPILERTESTERBASICTRACES_H__

     6 

     7 #define KOstTraceComponentID 0x20011112

     8 

     9 #define TEST_BASIC_INT8 0xdf0001

    10 #define TEST_BASIC_INT16 0xdf0002

    11 #define TEST_BASIC_INT32 0xdf0003

    12 #define TEST_BASIC_INT64 0xdf0004

    13 #define TEST_BASIC_UINT8 0xdf0005

    14 #define TEST_BASIC_UINT16 0xdf0006

    15 #define TEST_BASIC_UINT32 0xdf0007

    16 #define TEST_BASIC_UINT64 0xdf0008

    17 #define TEST_BASIC_HEX8 0xdf0009

    18 #define TEST_BASIC_HEX16 0xdf000a

    19 #define TEST_BASIC_HEX32 0xdf000b

    20 #define TEST_BASIC_HEX64 0xdf000c

    21 #define TEST_BASIC_STRING8 0xdf000d

    22 #define TEST_BASIC_STRING16 0xdf000e

    23 #define TEST_BASIC_FFIX 0xdf000f

    24 #define TEST_BASIC_FEXP 0xdf0010

    25 #define TEST_BASIC_FOPT 0xdf0011

    26 #define TEST_ARRAY_INT8 0xe00001

    27 #define TEST_ARRAY_INT16 0xe00002

    28 #define TEST_ARRAY_INT32 0xe00003

    29 #define TEST_ARRAY_INT64 0xe00004

    30 #define TEST_ARRAY_UINT8 0xe00005

    31 #define TEST_ARRAY_UINT16 0xe00006

    32 #define TEST_ARRAY_UINT32 0xe00007

    33 #define TEST_ARRAY_UINT64 0xe00008

    34 #define TEST_ARRAY_HEX8 0xe00009

    35 #define TEST_ARRAY_HEX16 0xe0000a

    36 #define TEST_ARRAY_HEX32 0xe0000b

    37 #define TEST_ARRAY_HEX64 0xe0000c

    38 #define TEST_ARRAY_FFIX 0xe0000d

    39 #define TEST_ARRAY_FEXP 0xe0000e

    40 #define TEST_ARRAY_FOPT 0xe0000f

    41 #define TEST_BASIC_SIMILAR2_INT8 0xe10001

    42 #define TEST_BASIC_SIMILAR2_INT16 0xe10002

    43 #define TEST_BASIC_SIMILAR2_INT32 0xe10003

    44 #define TEST_BASIC_SIMILAR2_INT64 0xe10004

    45 #define TEST_BASIC_SIMILAR2_UINT8 0xe10005

    46 #define TEST_BASIC_SIMILAR2_UINT16 0xe10006

    47 #define TEST_BASIC_SIMILAR2_UINT32 0xe10007

    48 #define TEST_BASIC_SIMILAR2_UINT64 0xe10008

    49 #define TEST_BASIC_SIMILAR2_HEX8 0xe10009

    50 #define TEST_BASIC_SIMILAR2_HEX16 0xe1000a

    51 #define TEST_BASIC_SIMILAR2_HEX32 0xe1000b

    52 #define TEST_BASIC_SIMILAR2_HEX64 0xe1000c

    53 #define TEST_BASIC_SIMILAR2_STRING8 0xe1000d

    54 #define TEST_BASIC_SIMILAR2_FFIX 0xe1000e

    55 #define TEST_BASIC_SIMILAR2_FEXP 0xe1000f

    56 #define TEST_BASIC_SIMILAR2_FOPT 0xe10010

    57 #define TEST_ARRAY_SIMILAR2_INT8 0xe20001

    58 #define TEST_ARRAY_SIMILAR2_INT16 0xe20002

    59 #define TEST_ARRAY_SIMILAR2_INT32 0xe20003

    60 #define TEST_ARRAY_SIMILAR2_INT64 0xe20004

    61 #define TEST_ARRAY_SIMILAR2_UINT8 0xe20005

    62 #define TEST_ARRAY_SIMILAR2_UINT16 0xe20006

    63 #define TEST_ARRAY_SIMILAR2_UINT32 0xe20007

    64 #define TEST_ARRAY_SIMILAR2_UINT64 0xe20008

    65 #define TEST_ARRAY_SIMILAR2_HEX8 0xe20009

    66 #define TEST_ARRAY_SIMILAR2_HEX16 0xe2000a

    67 #define TEST_ARRAY_SIMILAR2_HEX32 0xe2000b

    68 #define TEST_ARRAY_SIMILAR2_HEX64 0xe2000c

    69 #define TEST_ARRAY_SIMILAR2_FFIX 0xe2000d

    70 #define TEST_ARRAY_SIMILAR2_FEXP 0xe2000e

    71 #define TEST_ARRAY_SIMILAR2_FOPT 0xe2000f

    72 #define TEST_ENUM_OK 0xe30001

    73 #define TEST_ENUM_ARRAY_OK 0xe30002

    74 #define EVENT_MY_EVENT_TRACE1_START 0x8b0001

    75 #define EVENT_MY_EVENT_TRACE1_STOP 0x8b0002

    76 #define EVENT_MY_EVENT_TRACE2_START 0x8b0003

    77 #define EVENT_MY_EVENT_TRACE2_STOP 0x8b0004

    78 

    79 

    80 inline TBool OstTraceGen1( TUint32 aTraceID, TInt8 aParam1 )

    81     {

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

    83     if ( retval )

    84         {

    85         TUint8 data[ 4 ];

    86         TUint8* ptr = data;

    87         *( ( TInt8* )ptr ) = aParam1;

    88         ptr += sizeof ( TInt8 );

    89         *( ( TUint8* )ptr ) = 0;

    90         ptr += sizeof ( TUint8 );

    91         *( ( TUint8* )ptr ) = 0;

    92         ptr += sizeof ( TUint8 );

    93         *( ( TUint8* )ptr ) = 0;

    94         ptr += sizeof ( TUint8 );

    95         ptr -= 4;

    96         retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

    97         }

    98     return retval;

    99     }

   100 

   101 

   102 inline TBool OstTraceGen1( TUint32 aTraceID, TInt16 aParam1 )

   103     {

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

   105     if ( retval )

   106         {

   107         TUint8 data[ 4 ];

   108         TUint8* ptr = data;

   109         *( ( TInt16* )ptr ) = aParam1;

   110         ptr += sizeof ( TInt16 );

   111         *( ( TUint8* )ptr ) = 0;

   112         ptr += sizeof ( TUint8 );

   113         *( ( TUint8* )ptr ) = 0;

   114         ptr += sizeof ( TUint8 );

   115         ptr -= 4;

   116         retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

   117         }

   118     return retval;

   119     }

   120 

   121 

   122 inline TBool OstTraceGen1( TUint32 aTraceID, TInt64 aParam1 )

   123     {

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

   125     if ( retval )

   126         {

   127         TUint8 data[ 8 ];

   128         TUint8* ptr = data;

   129         *( ( TInt64* )ptr ) = aParam1;

   130         ptr += sizeof ( TInt64 );

   131         ptr -= 8;

   132         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

   133         }

   134     return retval;

   135     }

   136 

   137 

   138 inline TBool OstTraceGen1( TUint32 aTraceID, TUint8 aParam1 )

   139     {

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

   141     if ( retval )

   142         {

   143         TUint8 data[ 4 ];

   144         TUint8* ptr = data;

   145         *( ( TUint8* )ptr ) = aParam1;

   146         ptr += sizeof ( TUint8 );

   147         *( ( TUint8* )ptr ) = 0;

   148         ptr += sizeof ( TUint8 );

   149         *( ( TUint8* )ptr ) = 0;

   150         ptr += sizeof ( TUint8 );

   151         *( ( TUint8* )ptr ) = 0;

   152         ptr += sizeof ( TUint8 );

   153         ptr -= 4;

   154         retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

   155         }

   156     return retval;

   157     }

   158 

   159 

   160 inline TBool OstTraceGen1( TUint32 aTraceID, TUint16 aParam1 )

   161     {

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

   163     if ( retval )

   164         {

   165         TUint8 data[ 4 ];

   166         TUint8* ptr = data;

   167         *( ( TUint16* )ptr ) = aParam1;

   168         ptr += sizeof ( TUint16 );

   169         *( ( TUint8* )ptr ) = 0;

   170         ptr += sizeof ( TUint8 );

   171         *( ( TUint8* )ptr ) = 0;

   172         ptr += sizeof ( TUint8 );

   173         ptr -= 4;

   174         retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

   175         }

   176     return retval;

   177     }

   178 

   179 

   180 inline TBool OstTraceGen1( TUint32 aTraceID, TUint64 aParam1 )

   181     {

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

   183     if ( retval )

   184         {

   185         TUint8 data[ 8 ];

   186         TUint8* ptr = data;

   187         *( ( TUint64* )ptr ) = aParam1;

   188         ptr += sizeof ( TUint64 );

   189         ptr -= 8;

   190         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

   191         }

   192     return retval;

   193     }

   194 

   195 

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

   197     {

   198     TBool retval;

   199     TInt size = aParam1.Size();

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

   201     if (size % 4 == 0)

   202         {

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

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

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

   206         }

   207     else

   208         {

   209         TUint8 data[ KOstMaxDataLength ];

   210         TUint8* ptr = data;

   211         if (size > KOstMaxDataLength)

   212             {

   213             size = KOstMaxDataLength;

   214             }

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

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

   217         ptr += size;

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

   219         while ( size++ < sizeAligned )

   220             {

   221             *ptr++ = 0;

   222             }

   223         ptr -= sizeAligned;

   224         size = sizeAligned;

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

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

   227         }

   228     return retval;

   229     }

   230 

   231 

   232 #ifndef __KERNEL_MODE__

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

   234     {

   235     TBool retval;

   236     TInt size = aParam1.Size();

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

   238     if (size % 4 == 0)

   239         {

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

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

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

   243         }

   244     else

   245         {

   246         TUint8 data[ KOstMaxDataLength ];

   247         TUint8* ptr = data;

   248         if (size > KOstMaxDataLength)

   249             {

   250             size = KOstMaxDataLength;

   251             }

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

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

   254         ptr += size;

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

   256         while ( size++ < sizeAligned )

   257             {

   258             *ptr++ = 0;

   259             }

   260         ptr -= sizeAligned;

   261         size = sizeAligned;

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

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

   264         }

   265     return retval;

   266     }

   267 #endif

   268 

   269 

   270 inline TBool OstTraceGen1( TUint32 aTraceID, TReal aParam1 )

   271     {

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

   273     if ( retval )

   274         {

   275         TUint8 data[ 8 ];

   276         TUint8* ptr = data;

   277         *( ( TReal* )ptr ) = aParam1;

   278         ptr += sizeof ( TReal );

   279         ptr -= 8;

   280         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

   281         }

   282     return retval;

   283     }

   284 

   285 

   286 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt8 >& aParam1 )

   287     {

   288     TBool retval;

   289     TInt size = aParam1.Size();

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

   291     if (size % 4 == 0)

   292         {

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

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

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

   296         }

   297     else

   298         {

   299         TUint8 data[ KOstMaxDataLength ];

   300         TUint8* ptr = data;

   301         if (size > KOstMaxDataLength)

   302             {

   303             size = KOstMaxDataLength;

   304             }

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

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

   307         ptr += size;

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

   309         while ( size++ < sizeAligned )

   310             {

   311             *ptr++ = 0;

   312             }

   313         ptr -= sizeAligned;

   314         size = sizeAligned;

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

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

   317         }

   318     return retval;

   319     }

   320 

   321 

   322 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt16 >& aParam1 )

   323     {

   324     TBool retval;

   325     TInt size = aParam1.Size();

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

   327     if (size % 4 == 0)

   328         {

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

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

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

   332         }

   333     else

   334         {

   335         TUint8 data[ KOstMaxDataLength ];

   336         TUint8* ptr = data;

   337         if (size > KOstMaxDataLength)

   338             {

   339             size = KOstMaxDataLength;

   340             }

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

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

   343         ptr += size;

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

   345         while ( size++ < sizeAligned )

   346             {

   347             *ptr++ = 0;

   348             }

   349         ptr -= sizeAligned;

   350         size = sizeAligned;

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

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

   353         }

   354     return retval;

   355     }

   356 

   357 

   358 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt >& aParam1 )

   359     {

   360     TBool retval;

   361     TInt size = aParam1.Size();

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

   363     if (size % 4 == 0)

   364         {

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

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

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

   368         }

   369     else

   370         {

   371         TUint8 data[ KOstMaxDataLength ];

   372         TUint8* ptr = data;

   373         if (size > KOstMaxDataLength)

   374             {

   375             size = KOstMaxDataLength;

   376             }

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

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

   379         ptr += size;

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

   381         while ( size++ < sizeAligned )

   382             {

   383             *ptr++ = 0;

   384             }

   385         ptr -= sizeAligned;

   386         size = sizeAligned;

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

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

   389         }

   390     return retval;

   391     }

   392 

   393 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt32 >& aParam1 )

   394     {

   395     TBool retval;

   396     TInt size = aParam1.Size();

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

   398     if (size % 4 == 0)

   399         {

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

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

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

   403         }

   404     else

   405         {

   406         TUint8 data[ KOstMaxDataLength ];

   407         TUint8* ptr = data;

   408         if (size > KOstMaxDataLength)

   409             {

   410             size = KOstMaxDataLength;

   411             }

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

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

   414         ptr += size;

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

   416         while ( size++ < sizeAligned )

   417             {

   418             *ptr++ = 0;

   419             }

   420         ptr -= sizeAligned;

   421         size = sizeAligned;

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

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

   424         }

   425     return retval;

   426     }

   427 

   428 

   429 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TInt64 >& aParam1 )

   430     {

   431     TBool retval;

   432     TInt size = aParam1.Size();

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

   434     if (size % 4 == 0)

   435         {

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

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

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

   439         }

   440     else

   441         {

   442         TUint8 data[ KOstMaxDataLength ];

   443         TUint8* ptr = data;

   444         if (size > KOstMaxDataLength)

   445             {

   446             size = KOstMaxDataLength;

   447             }

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

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

   450         ptr += size;

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

   452         while ( size++ < sizeAligned )

   453             {

   454             *ptr++ = 0;

   455             }

   456         ptr -= sizeAligned;

   457         size = sizeAligned;

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

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

   460         }

   461     return retval;

   462     }

   463 

   464 

   465 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TUint8 >& aParam1 )

   466     {

   467     TBool retval;

   468     TInt size = aParam1.Size();

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

   470     if (size % 4 == 0)

   471         {

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

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

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

   475         }

   476     else

   477         {

   478         TUint8 data[ KOstMaxDataLength ];

   479         TUint8* ptr = data;

   480         if (size > KOstMaxDataLength)

   481             {

   482             size = KOstMaxDataLength;

   483             }

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

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

   486         ptr += size;

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

   488         while ( size++ < sizeAligned )

   489             {

   490             *ptr++ = 0;

   491             }

   492         ptr -= sizeAligned;

   493         size = sizeAligned;

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

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

   496         }

   497     return retval;

   498     }

   499 

   500 

   501 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TUint16 >& aParam1 )

   502     {

   503     TBool retval;

   504     TInt size = aParam1.Size();

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

   506     if (size % 4 == 0)

   507         {

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

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

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

   511         }

   512     else

   513         {

   514         TUint8 data[ KOstMaxDataLength ];

   515         TUint8* ptr = data;

   516         if (size > KOstMaxDataLength)

   517             {

   518             size = KOstMaxDataLength;

   519             }

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

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

   522         ptr += size;

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

   524         while ( size++ < sizeAligned )

   525             {

   526             *ptr++ = 0;

   527             }

   528         ptr -= sizeAligned;

   529         size = sizeAligned;

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

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

   532         }

   533     return retval;

   534     }

   535 

   536 

   537 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TUint >& aParam1 )

   538     {

   539     TBool retval;

   540     TInt size = aParam1.Size();

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

   542     if (size % 4 == 0)

   543         {

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

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

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

   547         }

   548     else

   549         {

   550         TUint8 data[ KOstMaxDataLength ];

   551         TUint8* ptr = data;

   552         if (size > KOstMaxDataLength)

   553             {

   554             size = KOstMaxDataLength;

   555             }

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

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

   558         ptr += size;

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

   560         while ( size++ < sizeAligned )

   561             {

   562             *ptr++ = 0;

   563             }

   564         ptr -= sizeAligned;

   565         size = sizeAligned;

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

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

   568         }

   569     return retval;

   570     }

   571 

   572 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TUint32 >& aParam1 )

   573     {

   574     TBool retval;

   575     TInt size = aParam1.Size();

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

   577     if (size % 4 == 0)

   578         {

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

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

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

   582         }

   583     else

   584         {

   585         TUint8 data[ KOstMaxDataLength ];

   586         TUint8* ptr = data;

   587         if (size > KOstMaxDataLength)

   588             {

   589             size = KOstMaxDataLength;

   590             }

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

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

   593         ptr += size;

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

   595         while ( size++ < sizeAligned )

   596             {

   597             *ptr++ = 0;

   598             }

   599         ptr -= sizeAligned;

   600         size = sizeAligned;

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

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

   603         }

   604     return retval;

   605     }

   606 

   607 

   608 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TUint64 >& aParam1 )

   609     {

   610     TBool retval;

   611     TInt size = aParam1.Size();

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

   613     if (size % 4 == 0)

   614         {

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

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

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

   618         }

   619     else

   620         {

   621         TUint8 data[ KOstMaxDataLength ];

   622         TUint8* ptr = data;

   623         if (size > KOstMaxDataLength)

   624             {

   625             size = KOstMaxDataLength;

   626             }

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

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

   629         ptr += size;

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

   631         while ( size++ < sizeAligned )

   632             {

   633             *ptr++ = 0;

   634             }

   635         ptr -= sizeAligned;

   636         size = sizeAligned;

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

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

   639         }

   640     return retval;

   641     }

   642 

   643 

   644 inline TBool OstTraceGen1( TUint32 aTraceID, const TOstArray< TReal >& aParam1 )

   645     {

   646     TBool retval;

   647     TInt size = aParam1.Size();

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

   649     if (size % 4 == 0)

   650         {

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

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

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

   654         }

   655     else

   656         {

   657         TUint8 data[ KOstMaxDataLength ];

   658         TUint8* ptr = data;

   659         if (size > KOstMaxDataLength)

   660             {

   661             size = KOstMaxDataLength;

   662             }

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

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

   665         ptr += size;

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

   667         while ( size++ < sizeAligned )

   668             {

   669             *ptr++ = 0;

   670             }

   671         ptr -= sizeAligned;

   672         size = sizeAligned;

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

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

   675         }

   676     return retval;

   677     }

   678 

   679 

   680 inline TBool OstTraceGen2( TUint32 aTraceID, TInt8 aParam1, TInt8 aParam2 )

   681     {

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

   683     if ( retval )

   684         {

   685         TUint8 data[ 4 ];

   686         TUint8* ptr = data;

   687         *( ( TInt8* )ptr ) = aParam1;

   688         ptr += sizeof ( TInt8 );

   689         *( ( TInt8* )ptr ) = aParam2;

   690         ptr += sizeof ( TInt8 );

   691         *( ( TUint8* )ptr ) = 0;

   692         ptr += sizeof ( TUint8 );

   693         *( ( TUint8* )ptr ) = 0;

   694         ptr += sizeof ( TUint8 );

   695         ptr -= 4;

   696         retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

   697         }

   698     return retval;

   699     }

   700 

   701 

   702 inline TBool OstTraceGen2( TUint32 aTraceID, TInt16 aParam1, TInt16 aParam2 )

   703     {

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

   705     if ( retval )

   706         {

   707         TUint8 data[ 4 ];

   708         TUint8* ptr = data;

   709         *( ( TInt16* )ptr ) = aParam1;

   710         ptr += sizeof ( TInt16 );

   711         *( ( TInt16* )ptr ) = aParam2;

   712         ptr += sizeof ( TInt16 );

   713         ptr -= 4;

   714         retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

   715         }

   716     return retval;

   717     }

   718 

   719 

   720 inline TBool OstTraceGen2( TUint32 aTraceID, TInt aParam1, TInt aParam2 )

   721     {

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

   723     if ( retval )

   724         {

   725         TUint8 data[ 8 ];

   726         TUint8* ptr = data;

   727         *( ( TInt* )ptr ) = aParam1;

   728         ptr += sizeof ( TInt );

   729         *( ( TInt* )ptr ) = aParam2;

   730         ptr += sizeof ( TInt );

   731         ptr -= 8;

   732         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

   733         }

   734     return retval;

   735     }

   736 

   737 inline TBool OstTraceGen2( TUint32 aTraceID, TInt32 aParam1, TInt32 aParam2 )

   738     {

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

   740     if ( retval )

   741         {

   742         TUint8 data[ 8 ];

   743         TUint8* ptr = data;

   744         *( ( TInt* )ptr ) = aParam1;

   745         ptr += sizeof ( TInt );

   746         *( ( TInt* )ptr ) = aParam2;

   747         ptr += sizeof ( TInt );

   748         ptr -= 8;

   749         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

   750         }

   751     return retval;

   752     }

   753 

   754 

   755 inline TBool OstTraceGen2( TUint32 aTraceID, TInt64 aParam1, TInt64 aParam2 )

   756     {

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

   758     if ( retval )

   759         {

   760         TUint8 data[ 16 ];

   761         TUint8* ptr = data;

   762         *( ( TInt64* )ptr ) = aParam1;

   763         ptr += sizeof ( TInt64 );

   764         *( ( TInt64* )ptr ) = aParam2;

   765         ptr += sizeof ( TInt64 );

   766         ptr -= 16;

   767         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 16 );

   768         }

   769     return retval;

   770     }

   771 

   772 

   773 inline TBool OstTraceGen2( TUint32 aTraceID, TUint8 aParam1, TUint8 aParam2 )

   774     {

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

   776     if ( retval )

   777         {

   778         TUint8 data[ 4 ];

   779         TUint8* ptr = data;

   780         *( ( TUint8* )ptr ) = aParam1;

   781         ptr += sizeof ( TUint8 );

   782         *( ( TUint8* )ptr ) = aParam2;

   783         ptr += sizeof ( TUint8 );

   784         *( ( TUint8* )ptr ) = 0;

   785         ptr += sizeof ( TUint8 );

   786         *( ( TUint8* )ptr ) = 0;

   787         ptr += sizeof ( TUint8 );

   788         ptr -= 4;

   789         retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

   790         }

   791     return retval;

   792     }

   793 

   794 

   795 inline TBool OstTraceGen2( TUint32 aTraceID, TUint16 aParam1, TUint16 aParam2 )

   796     {

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

   798     if ( retval )

   799         {

   800         TUint8 data[ 4 ];

   801         TUint8* ptr = data;

   802         *( ( TUint16* )ptr ) = aParam1;

   803         ptr += sizeof ( TUint16 );

   804         *( ( TUint16* )ptr ) = aParam2;

   805         ptr += sizeof ( TUint16 );

   806         ptr -= 4;

   807         retval = BTraceFilteredContext12( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, *( ( TUint32* )ptr ) );

   808         }

   809     return retval;

   810     }

   811 

   812 

   813 inline TBool OstTraceGen2( TUint32 aTraceID, TUint aParam1, TUint aParam2 )

   814     {

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

   816     if ( retval )

   817         {

   818         TUint8 data[ 8 ];

   819         TUint8* ptr = data;

   820         *( ( TUint* )ptr ) = aParam1;

   821         ptr += sizeof ( TUint );

   822         *( ( TUint* )ptr ) = aParam2;

   823         ptr += sizeof ( TUint );

   824         ptr -= 8;

   825         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

   826         }

   827     return retval;

   828     }

   829 

   830 inline TBool OstTraceGen2( TUint32 aTraceID, TUint32 aParam1, TUint32 aParam2 )

   831     {

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

   833     if ( retval )

   834         {

   835         TUint8 data[ 8 ];

   836         TUint8* ptr = data;

   837         *( ( TUint* )ptr ) = aParam1;

   838         ptr += sizeof ( TUint );

   839         *( ( TUint* )ptr ) = aParam2;

   840         ptr += sizeof ( TUint );

   841         ptr -= 8;

   842         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 8 );

   843         }

   844     return retval;

   845     }

   846 

   847 

   848 inline TBool OstTraceGen2( TUint32 aTraceID, TUint64 aParam1, TUint64 aParam2 )

   849     {

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

   851     if ( retval )

   852         {

   853         TUint8 data[ 16 ];

   854         TUint8* ptr = data;

   855         *( ( TUint64* )ptr ) = aParam1;

   856         ptr += sizeof ( TUint64 );

   857         *( ( TUint64* )ptr ) = aParam2;

   858         ptr += sizeof ( TUint64 );

   859         ptr -= 16;

   860         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 16 );

   861         }

   862     return retval;

   863     }

   864 

   865 

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

   867     {

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

   869     if ( retval )

   870         {

   871         TInt length = 0;

   872         // Check that parameter lenght is not too long

   873         TInt length1 = aParam1.Size();

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

   875             {

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

   877             }

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

   879         if (lengthAligned1 > 0)

   880             {

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

   882             }

   883         // Check that parameter lenght is not too long

   884         TInt length2 = aParam2.Size();

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

   886             {

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

   888             }

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

   890         if (lengthAligned2 > 0)

   891             {

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

   893             }

   894         TUint8 data[ KOstMaxDataLength ];

   895         TUint8* ptr = data;

   896         // Set length to zero and calculate it againg

   897         // when adding parameters

   898         length = 0;

   899         if (length1 > 0)

   900             {

   901             // Number of elements is written before data

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

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

   904             ptr += sizeof ( TUint32 );

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

   906             ptr += length1;

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

   908             while ( length1++ < lengthAligned1 )

   909                 {

   910                 *ptr++ = 0;

   911                 }

   912             length += sizeof ( TUint32 ) + lengthAligned1;

   913             }

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

   915             {

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

   917             ptr += sizeof ( TUint32 );

   918             length += sizeof ( TUint32 );

   919             }

   920         if (length2 > 0)

   921             {

   922             // Number of elements is written before data

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

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

   925             ptr += sizeof ( TUint32 );

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

   927             ptr += length2;

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

   929             while ( length2++ < lengthAligned2 )

   930                 {

   931                 *ptr++ = 0;

   932                 }

   933             length += sizeof ( TUint32 ) + lengthAligned2;

   934             }

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

   936             {

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

   938             ptr += sizeof ( TUint32 );

   939             length += sizeof ( TUint32 );

   940             }

   941         ptr -= length;

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

   943         }

   944     return retval;

   945     }

   946 

   947 

   948 inline TBool OstTraceGen2( TUint32 aTraceID, TReal aParam1, TReal aParam2 )

   949     {

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

   951     if ( retval )

   952         {

   953         TUint8 data[ 16 ];

   954         TUint8* ptr = data;

   955         *( ( TReal* )ptr ) = aParam1;

   956         ptr += sizeof ( TReal );

   957         *( ( TReal* )ptr ) = aParam2;

   958         ptr += sizeof ( TReal );

   959         ptr -= 16;

   960         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 16 );

   961         }

   962     return retval;

   963     }

   964 

   965 

   966 inline TBool OstTraceGen2( TUint32 aTraceID, const TOstArray< TInt8 >& aParam1, const TOstArray< TInt8 >& aParam2 )

   967     {

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

   969     if ( retval )

   970         {

   971         TInt length = 0;

   972         // Check that parameter lenght is not too long

   973         TInt length1 = aParam1.Size();

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

   975             {

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

   977             }

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

   979         if (lengthAligned1 > 0)

   980             {

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

   982             }

   983         // Check that parameter lenght is not too long

   984         TInt length2 = aParam2.Size();

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

   986             {

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

   988             }

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

   990         if (lengthAligned2 > 0)

   991             {

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

   993             }

   994         TUint8 data[ KOstMaxDataLength ];

   995         TUint8* ptr = data;

   996         // Set length to zero and calculate it againg

   997         // when adding parameters

   998         length = 0;

   999         if (length1 > 0)

  1000             {

  1001             // Number of elements is written before data

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

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

  1004             ptr += sizeof ( TUint32 );

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

  1006             ptr += length1;

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

  1008             while ( length1++ < lengthAligned1 )

  1009                 {

  1010                 *ptr++ = 0;

  1011                 }

  1012             length += sizeof ( TUint32 ) + lengthAligned1;

  1013             }

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

  1015             {

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

  1017             ptr += sizeof ( TUint32 );

  1018             length += sizeof ( TUint32 );

  1019             }

  1020         if (length2 > 0)

  1021             {

  1022             // Number of elements is written before data

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

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

  1025             ptr += sizeof ( TUint32 );

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

  1027             ptr += length2;

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

  1029             while ( length2++ < lengthAligned2 )

  1030                 {

  1031                 *ptr++ = 0;

  1032                 }

  1033             length += sizeof ( TUint32 ) + lengthAligned2;

  1034             }

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

  1036             {

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

  1038             ptr += sizeof ( TUint32 );

  1039             length += sizeof ( TUint32 );

  1040             }

  1041         ptr -= length;

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

  1043         }

  1044     return retval;

  1045     }

  1046 

  1047 

  1048 inline TBool OstTraceGen2( TUint32 aTraceID, const TOstArray< TInt16 >& aParam1, const TOstArray< TInt16 >& aParam2 )

  1049     {

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

  1051     if ( retval )

  1052         {

  1053         TInt length = 0;

  1054         // Check that parameter lenght is not too long

  1055         TInt length1 = aParam1.Size();

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

  1057             {

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

  1059             }

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

  1061         if (lengthAligned1 > 0)

  1062             {

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

  1064             }

  1065         // Check that parameter lenght is not too long

  1066         TInt length2 = aParam2.Size();

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

  1068             {

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

  1070             }

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

  1072         if (lengthAligned2 > 0)

  1073             {

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

  1075             }

  1076         TUint8 data[ KOstMaxDataLength ];

  1077         TUint8* ptr = data;

  1078         // Set length to zero and calculate it againg

  1079         // when adding parameters

  1080         length = 0;

  1081         if (length1 > 0)

  1082             {

  1083             // Number of elements is written before data

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

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

  1086             ptr += sizeof ( TUint32 );

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

  1088             ptr += length1;

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

  1090             while ( length1++ < lengthAligned1 )

  1091                 {

  1092                 *ptr++ = 0;

  1093                 }

  1094             length += sizeof ( TUint32 ) + lengthAligned1;

  1095             }

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

  1097             {

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

  1099             ptr += sizeof ( TUint32 );

  1100             length += sizeof ( TUint32 );

  1101             }

  1102         if (length2 > 0)

  1103             {

  1104             // Number of elements is written before data

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

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

  1107             ptr += sizeof ( TUint32 );

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

  1109             ptr += length2;

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

  1111             while ( length2++ < lengthAligned2 )

  1112                 {

  1113                 *ptr++ = 0;

  1114                 }

  1115             length += sizeof ( TUint32 ) + lengthAligned2;

  1116             }

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

  1118             {

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

  1120             ptr += sizeof ( TUint32 );

  1121             length += sizeof ( TUint32 );

  1122             }

  1123         ptr -= length;

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

  1125         }

  1126     return retval;

  1127     }

  1128 

  1129 

  1130 inline TBool OstTraceGen2( TUint32 aTraceID, const TOstArray< TInt >& aParam1, const TOstArray< TInt >& aParam2 )

  1131     {

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

  1133     if ( retval )

  1134         {

  1135         TInt length = 0;