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 0x20011111

     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 EVENT_MY_EVENT_TRACE1_START 0x8b0001

    73 #define EVENT_MY_EVENT_TRACE1_STOP 0x8b0002

    74 #define EVENT_MY_EVENT_TRACE2_START 0x8b0003

    75 #define EVENT_MY_EVENT_TRACE2_STOP 0x8b0004

    76 

    77 

    78 inline TBool OstTraceGen1( TUint32 aTraceID, TInt8 aParam1 )

    79     {

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

    81     if ( retval )

    82         {

    83         TUint8 data[ 4 ];

    84         TUint8* ptr = data;

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

    86         ptr += sizeof ( TInt8 );

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

    88         ptr += sizeof ( TUint8 );

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

    90         ptr += sizeof ( TUint8 );

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

    92         ptr += sizeof ( TUint8 );

    93         ptr -= 4;

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

    95         }

    96     return retval;

    97     }

    98 

    99 

   100 inline TBool OstTraceGen1( TUint32 aTraceID, TInt16 aParam1 )

   101     {

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

   103     if ( retval )

   104         {

   105         TUint8 data[ 4 ];

   106         TUint8* ptr = data;

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

   108         ptr += sizeof ( TInt16 );

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

   110         ptr += sizeof ( TUint8 );

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

   112         ptr += sizeof ( TUint8 );

   113         ptr -= 4;

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

   115         }

   116     return retval;

   117     }

   118 

   119 

   120 inline TBool OstTraceGen1( TUint32 aTraceID, TInt64 aParam1 )

   121     {

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

   123     if ( retval )

   124         {

   125         TUint8 data[ 8 ];

   126         TUint8* ptr = data;

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

   128         ptr += sizeof ( TInt64 );

   129         ptr -= 8;

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

   131         }

   132     return retval;

   133     }

   134 

   135 

   136 inline TBool OstTraceGen1( TUint32 aTraceID, TUint8 aParam1 )

   137     {

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

   139     if ( retval )

   140         {

   141         TUint8 data[ 4 ];

   142         TUint8* ptr = data;

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

   144         ptr += sizeof ( TUint8 );

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

   146         ptr += sizeof ( TUint8 );

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

   148         ptr += sizeof ( TUint8 );

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

   150         ptr += sizeof ( TUint8 );

   151         ptr -= 4;

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

   153         }

   154     return retval;

   155     }

   156 

   157 

   158 inline TBool OstTraceGen1( TUint32 aTraceID, TUint16 aParam1 )

   159     {

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

   161     if ( retval )

   162         {

   163         TUint8 data[ 4 ];

   164         TUint8* ptr = data;

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

   166         ptr += sizeof ( TUint16 );

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

   168         ptr += sizeof ( TUint8 );

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

   170         ptr += sizeof ( TUint8 );

   171         ptr -= 4;

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

   173         }

   174     return retval;

   175     }

   176 

   177 

   178 inline TBool OstTraceGen1( TUint32 aTraceID, TUint64 aParam1 )

   179     {

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

   181     if ( retval )

   182         {

   183         TUint8 data[ 8 ];

   184         TUint8* ptr = data;

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

   186         ptr += sizeof ( TUint64 );

   187         ptr -= 8;

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

   189         }

   190     return retval;

   191     }

   192 

   193 

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

   195     {

   196     TBool retval;

   197     TInt size = aParam1.Size();

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

   199     if (size % 4 == 0)

   200         {

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

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

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

   204         }

   205     else

   206         {

   207         TUint8 data[ KOstMaxDataLength ];

   208         TUint8* ptr = data;

   209         if (size > KOstMaxDataLength)

   210             {

   211             size = KOstMaxDataLength;

   212             }

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

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

   215         ptr += size;

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

   217         while ( size++ < sizeAligned )

   218             {

   219             *ptr++ = 0;

   220             }

   221         ptr -= sizeAligned;

   222         size = sizeAligned;

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

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

   225         }

   226     return retval;

   227     }

   228 

   229 

   230 #ifndef __KERNEL_MODE__

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

   232     {

   233     TBool retval;

   234     TInt size = aParam1.Size();

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

   236     if (size % 4 == 0)

   237         {

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

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

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

   241         }

   242     else

   243         {

   244         TUint8 data[ KOstMaxDataLength ];

   245         TUint8* ptr = data;

   246         if (size > KOstMaxDataLength)

   247             {

   248             size = KOstMaxDataLength;

   249             }

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

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

   252         ptr += size;

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

   254         while ( size++ < sizeAligned )

   255             {

   256             *ptr++ = 0;

   257             }

   258         ptr -= sizeAligned;

   259         size = sizeAligned;

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

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

   262         }

   263     return retval;

   264     }

   265 #endif

   266 

   267 

   268 inline TBool OstTraceGen1( TUint32 aTraceID, TReal aParam1 )

   269     {

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

   271     if ( retval )

   272         {

   273         TUint8 data[ 8 ];

   274         TUint8* ptr = data;

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

   276         ptr += sizeof ( TReal );

   277         ptr -= 8;

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

   279         }

   280     return retval;

   281     }

   282 

   283 

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

   285     {

   286     TBool retval;

   287     TInt size = aParam1.Size();

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

   289     if (size % 4 == 0)

   290         {

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

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

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

   294         }

   295     else

   296         {

   297         TUint8 data[ KOstMaxDataLength ];

   298         TUint8* ptr = data;

   299         if (size > KOstMaxDataLength)

   300             {

   301             size = KOstMaxDataLength;

   302             }

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

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

   305         ptr += size;

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

   307         while ( size++ < sizeAligned )

   308             {

   309             *ptr++ = 0;

   310             }

   311         ptr -= sizeAligned;

   312         size = sizeAligned;

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

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

   315         }

   316     return retval;

   317     }

   318 

   319 

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

   321     {

   322     TBool retval;

   323     TInt size = aParam1.Size();

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

   325     if (size % 4 == 0)

   326         {

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

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

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

   330         }

   331     else

   332         {

   333         TUint8 data[ KOstMaxDataLength ];

   334         TUint8* ptr = data;

   335         if (size > KOstMaxDataLength)

   336             {

   337             size = KOstMaxDataLength;

   338             }

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

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

   341         ptr += size;

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

   343         while ( size++ < sizeAligned )

   344             {

   345             *ptr++ = 0;

   346             }

   347         ptr -= sizeAligned;

   348         size = sizeAligned;

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

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

   351         }

   352     return retval;

   353     }

   354 

   355 

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

   357     {

   358     TBool retval;

   359     TInt size = aParam1.Size();

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

   361     if (size % 4 == 0)

   362         {

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

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

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

   366         }

   367     else

   368         {

   369         TUint8 data[ KOstMaxDataLength ];

   370         TUint8* ptr = data;

   371         if (size > KOstMaxDataLength)

   372             {

   373             size = KOstMaxDataLength;

   374             }

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

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

   377         ptr += size;

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

   379         while ( size++ < sizeAligned )

   380             {

   381             *ptr++ = 0;

   382             }

   383         ptr -= sizeAligned;

   384         size = sizeAligned;

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

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

   387         }

   388     return retval;

   389     }

   390 

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

   392     {

   393     TBool retval;

   394     TInt size = aParam1.Size();

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

   396     if (size % 4 == 0)

   397         {

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

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

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

   401         }

   402     else

   403         {

   404         TUint8 data[ KOstMaxDataLength ];

   405         TUint8* ptr = data;

   406         if (size > KOstMaxDataLength)

   407             {

   408             size = KOstMaxDataLength;

   409             }

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

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

   412         ptr += size;

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

   414         while ( size++ < sizeAligned )

   415             {

   416             *ptr++ = 0;

   417             }

   418         ptr -= sizeAligned;

   419         size = sizeAligned;

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

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

   422         }

   423     return retval;

   424     }

   425 

   426 

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

   428     {

   429     TBool retval;

   430     TInt size = aParam1.Size();

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

   432     if (size % 4 == 0)

   433         {

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

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

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

   437         }

   438     else

   439         {

   440         TUint8 data[ KOstMaxDataLength ];

   441         TUint8* ptr = data;

   442         if (size > KOstMaxDataLength)

   443             {

   444             size = KOstMaxDataLength;

   445             }

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

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

   448         ptr += size;

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

   450         while ( size++ < sizeAligned )

   451             {

   452             *ptr++ = 0;

   453             }

   454         ptr -= sizeAligned;

   455         size = sizeAligned;

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

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

   458         }

   459     return retval;

   460     }

   461 

   462 

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

   464     {

   465     TBool retval;

   466     TInt size = aParam1.Size();

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

   468     if (size % 4 == 0)

   469         {

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

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

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

   473         }

   474     else

   475         {

   476         TUint8 data[ KOstMaxDataLength ];

   477         TUint8* ptr = data;

   478         if (size > KOstMaxDataLength)

   479             {

   480             size = KOstMaxDataLength;

   481             }

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

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

   484         ptr += size;

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

   486         while ( size++ < sizeAligned )

   487             {

   488             *ptr++ = 0;

   489             }

   490         ptr -= sizeAligned;

   491         size = sizeAligned;

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

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

   494         }

   495     return retval;

   496     }

   497 

   498 

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

   500     {

   501     TBool retval;

   502     TInt size = aParam1.Size();

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

   504     if (size % 4 == 0)

   505         {

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

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

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

   509         }

   510     else

   511         {

   512         TUint8 data[ KOstMaxDataLength ];

   513         TUint8* ptr = data;

   514         if (size > KOstMaxDataLength)

   515             {

   516             size = KOstMaxDataLength;

   517             }

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

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

   520         ptr += size;

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

   522         while ( size++ < sizeAligned )

   523             {

   524             *ptr++ = 0;

   525             }

   526         ptr -= sizeAligned;

   527         size = sizeAligned;

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

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

   530         }

   531     return retval;

   532     }

   533 

   534 

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

   536     {

   537     TBool retval;

   538     TInt size = aParam1.Size();

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

   540     if (size % 4 == 0)

   541         {

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

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

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

   545         }

   546     else

   547         {

   548         TUint8 data[ KOstMaxDataLength ];

   549         TUint8* ptr = data;

   550         if (size > KOstMaxDataLength)

   551             {

   552             size = KOstMaxDataLength;

   553             }

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

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

   556         ptr += size;

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

   558         while ( size++ < sizeAligned )

   559             {

   560             *ptr++ = 0;

   561             }

   562         ptr -= sizeAligned;

   563         size = sizeAligned;

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

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

   566         }

   567     return retval;

   568     }

   569 

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

   571     {

   572     TBool retval;

   573     TInt size = aParam1.Size();

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

   575     if (size % 4 == 0)

   576         {

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

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

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

   580         }

   581     else

   582         {

   583         TUint8 data[ KOstMaxDataLength ];

   584         TUint8* ptr = data;

   585         if (size > KOstMaxDataLength)

   586             {

   587             size = KOstMaxDataLength;

   588             }

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

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

   591         ptr += size;

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

   593         while ( size++ < sizeAligned )

   594             {

   595             *ptr++ = 0;

   596             }

   597         ptr -= sizeAligned;

   598         size = sizeAligned;

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

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

   601         }

   602     return retval;

   603     }

   604 

   605 

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

   607     {

   608     TBool retval;

   609     TInt size = aParam1.Size();

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

   611     if (size % 4 == 0)

   612         {

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

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

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

   616         }

   617     else

   618         {

   619         TUint8 data[ KOstMaxDataLength ];

   620         TUint8* ptr = data;

   621         if (size > KOstMaxDataLength)

   622             {

   623             size = KOstMaxDataLength;

   624             }

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

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

   627         ptr += size;

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

   629         while ( size++ < sizeAligned )

   630             {

   631             *ptr++ = 0;

   632             }

   633         ptr -= sizeAligned;

   634         size = sizeAligned;

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

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

   637         }

   638     return retval;

   639     }

   640 

   641 

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

   643     {

   644     TBool retval;

   645     TInt size = aParam1.Size();

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

   647     if (size % 4 == 0)

   648         {

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

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

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

   652         }

   653     else

   654         {

   655         TUint8 data[ KOstMaxDataLength ];

   656         TUint8* ptr = data;

   657         if (size > KOstMaxDataLength)

   658             {

   659             size = KOstMaxDataLength;

   660             }

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

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

   663         ptr += size;

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

   665         while ( size++ < sizeAligned )

   666             {

   667             *ptr++ = 0;

   668             }

   669         ptr -= sizeAligned;

   670         size = sizeAligned;

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

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

   673         }

   674     return retval;

   675     }

   676 

   677 

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

   679     {

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

   681     if ( retval )

   682         {

   683         TUint8 data[ 4 ];

   684         TUint8* ptr = data;

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

   686         ptr += sizeof ( TInt8 );

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

   688         ptr += sizeof ( TInt8 );

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

   690         ptr += sizeof ( TUint8 );

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

   692         ptr += sizeof ( TUint8 );

   693         ptr -= 4;

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

   695         }

   696     return retval;

   697     }

   698 

   699 

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

   701     {

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

   703     if ( retval )

   704         {

   705         TUint8 data[ 4 ];

   706         TUint8* ptr = data;

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

   708         ptr += sizeof ( TInt16 );

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

   710         ptr += sizeof ( TInt16 );

   711         ptr -= 4;

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

   713         }

   714     return retval;

   715     }

   716 

   717 

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

   719     {

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

   721     if ( retval )

   722         {

   723         TUint8 data[ 8 ];

   724         TUint8* ptr = data;

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

   726         ptr += sizeof ( TInt );

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

   728         ptr += sizeof ( TInt );

   729         ptr -= 8;

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

   731         }

   732     return retval;

   733     }

   734 

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

   736     {

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

   738     if ( retval )

   739         {

   740         TUint8 data[ 8 ];

   741         TUint8* ptr = data;

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

   743         ptr += sizeof ( TInt );

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

   745         ptr += sizeof ( TInt );

   746         ptr -= 8;

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

   748         }

   749     return retval;

   750     }

   751 

   752 

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

   754     {

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

   756     if ( retval )

   757         {

   758         TUint8 data[ 16 ];

   759         TUint8* ptr = data;

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

   761         ptr += sizeof ( TInt64 );

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

   763         ptr += sizeof ( TInt64 );

   764         ptr -= 16;

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

   766         }

   767     return retval;

   768     }

   769 

   770 

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

   772     {

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

   774     if ( retval )

   775         {

   776         TUint8 data[ 4 ];

   777         TUint8* ptr = data;

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

   779         ptr += sizeof ( TUint8 );

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

   781         ptr += sizeof ( TUint8 );

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

   783         ptr += sizeof ( TUint8 );

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

   785         ptr += sizeof ( TUint8 );

   786         ptr -= 4;

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

   788         }

   789     return retval;

   790     }

   791 

   792 

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

   794     {

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

   796     if ( retval )

   797         {

   798         TUint8 data[ 4 ];

   799         TUint8* ptr = data;

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

   801         ptr += sizeof ( TUint16 );

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

   803         ptr += sizeof ( TUint16 );

   804         ptr -= 4;

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

   806         }

   807     return retval;

   808     }

   809 

   810 

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

   812     {

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

   814     if ( retval )

   815         {

   816         TUint8 data[ 8 ];

   817         TUint8* ptr = data;

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

   819         ptr += sizeof ( TUint );

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

   821         ptr += sizeof ( TUint );

   822         ptr -= 8;

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

   824         }

   825     return retval;

   826     }

   827 

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

   829     {

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

   831     if ( retval )

   832         {

   833         TUint8 data[ 8 ];

   834         TUint8* ptr = data;

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

   836         ptr += sizeof ( TUint );

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

   838         ptr += sizeof ( TUint );

   839         ptr -= 8;

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

   841         }

   842     return retval;

   843     }

   844 

   845 

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

   847     {

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

   849     if ( retval )

   850         {

   851         TUint8 data[ 16 ];

   852         TUint8* ptr = data;

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

   854         ptr += sizeof ( TUint64 );

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

   856         ptr += sizeof ( TUint64 );

   857         ptr -= 16;

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

   859         }

   860     return retval;

   861     }

   862 

   863 

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

   865     {

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

   867     if ( retval )

   868         {

   869         TInt length = 0;

   870         // Check that parameter lenght is not too long

   871         TInt length1 = aParam1.Size();

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

   873             {

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

   875             }

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

   877         if (lengthAligned1 > 0)

   878             {

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

   880             }

   881         // Check that parameter lenght is not too long

   882         TInt length2 = aParam2.Size();

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

   884             {

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

   886             }

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

   888         if (lengthAligned2 > 0)

   889             {

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

   891             }

   892         TUint8 data[ KOstMaxDataLength ];

   893         TUint8* ptr = data;

   894         // Set length to zero and calculate it againg

   895         // when adding parameters

   896         length = 0;

   897         if (length1 > 0)

   898             {

   899             // Number of elements is written before data

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

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

   902             ptr += sizeof ( TUint32 );

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

   904             ptr += length1;

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

   906             while ( length1++ < lengthAligned1 )

   907                 {

   908                 *ptr++ = 0;

   909                 }

   910             length += sizeof ( TUint32 ) + lengthAligned1;

   911             }

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

   913             {

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

   915             ptr += sizeof ( TUint32 );

   916             length += sizeof ( TUint32 );

   917             }

   918         if (length2 > 0)

   919             {

   920             // Number of elements is written before data

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

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

   923             ptr += sizeof ( TUint32 );

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

   925             ptr += length2;

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

   927             while ( length2++ < lengthAligned2 )

   928                 {

   929                 *ptr++ = 0;

   930                 }

   931             length += sizeof ( TUint32 ) + lengthAligned2;

   932             }

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

   934             {

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

   936             ptr += sizeof ( TUint32 );

   937             length += sizeof ( TUint32 );

   938             }

   939         ptr -= length;

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

   941         }

   942     return retval;

   943     }

   944 

   945 

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

   947     {

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

   949     if ( retval )

   950         {

   951         TUint8 data[ 16 ];

   952         TUint8* ptr = data;

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

   954         ptr += sizeof ( TReal );

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

   956         ptr += sizeof ( TReal );

   957         ptr -= 16;

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

   959         }

   960     return retval;

   961     }

   962 

   963 

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

   965     {

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

   967     if ( retval )

   968         {

   969         TInt length = 0;

   970         // Check that parameter lenght is not too long

   971         TInt length1 = aParam1.Size();

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

   973             {

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

   975             }

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

   977         if (lengthAligned1 > 0)

   978             {

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

   980             }

   981         // Check that parameter lenght is not too long

   982         TInt length2 = aParam2.Size();

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

   984             {

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

   986             }

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

   988         if (lengthAligned2 > 0)

   989             {

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

   991             }

   992         TUint8 data[ KOstMaxDataLength ];

   993         TUint8* ptr = data;

   994         // Set length to zero and calculate it againg

   995         // when adding parameters

   996         length = 0;

   997         if (length1 > 0)

   998             {

   999             // Number of elements is written before data

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

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

  1002             ptr += sizeof ( TUint32 );

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

  1004             ptr += length1;

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

  1006             while ( length1++ < lengthAligned1 )

  1007                 {

  1008                 *ptr++ = 0;

  1009                 }

  1010             length += sizeof ( TUint32 ) + lengthAligned1;

  1011             }

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

  1013             {

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

  1015             ptr += sizeof ( TUint32 );

  1016             length += sizeof ( TUint32 );

  1017             }

  1018         if (length2 > 0)

  1019             {

  1020             // Number of elements is written before data

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

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

  1023             ptr += sizeof ( TUint32 );

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

  1025             ptr += length2;

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

  1027             while ( length2++ < lengthAligned2 )

  1028                 {

  1029                 *ptr++ = 0;

  1030                 }

  1031             length += sizeof ( TUint32 ) + lengthAligned2;

  1032             }

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

  1034             {

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

  1036             ptr += sizeof ( TUint32 );

  1037             length += sizeof ( TUint32 );

  1038             }

  1039         ptr -= length;

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

  1041         }

  1042     return retval;

  1043     }

  1044 

  1045 

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

  1047     {

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

  1049     if ( retval )

  1050         {

  1051         TInt length = 0;

  1052         // Check that parameter lenght is not too long

  1053         TInt length1 = aParam1.Size();

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

  1055             {

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

  1057             }

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

  1059         if (lengthAligned1 > 0)

  1060             {

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

  1062             }

  1063         // Check that parameter lenght is not too long

  1064         TInt length2 = aParam2.Size();

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

  1066             {

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

  1068             }

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

  1070         if (lengthAligned2 > 0)

  1071             {

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

  1073             }

  1074         TUint8 data[ KOstMaxDataLength ];

  1075         TUint8* ptr = data;

  1076         // Set length to zero and calculate it againg

  1077         // when adding parameters

  1078         length = 0;

  1079         if (length1 > 0)

  1080             {

  1081             // Number of elements is written before data

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

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

  1084             ptr += sizeof ( TUint32 );

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

  1086             ptr += length1;

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

  1088             while ( length1++ < lengthAligned1 )

  1089                 {

  1090                 *ptr++ = 0;

  1091                 }

  1092             length += sizeof ( TUint32 ) + lengthAligned1;

  1093             }

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

  1095             {

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

  1097             ptr += sizeof ( TUint32 );

  1098             length += sizeof ( TUint32 );

  1099             }

  1100         if (length2 > 0)

  1101             {

  1102             // Number of elements is written before data

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

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

  1105             ptr += sizeof ( TUint32 );

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

  1107             ptr += length2;

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

  1109             while ( length2++ < lengthAligned2 )

  1110                 {

  1111                 *ptr++ = 0;

  1112                 }

  1113             length += sizeof ( TUint32 ) + lengthAligned2;

  1114             }

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

  1116             {

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

  1118             ptr += sizeof ( TUint32 );

  1119             length += sizeof ( TUint32 );

  1120             }

  1121         ptr -= length;

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

  1123         }

  1124     return retval;

  1125     }

  1126 

  1127 

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

  1129     {

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

  1131     if ( retval )

  1132         {

  1133         TInt length = 0;

  1134         // Check that parameter lenght is not too long

  1135         TInt length1 = aParam1.Size();