1 // Created by TraceCompiler 2.1.2

     2 // DO NOT EDIT, CHANGES WILL BE LOST

     3 

     4 #ifndef __TRACECOMPILERTESTERADVANCEDTRACES_H__

     5 #define __TRACECOMPILERTESTERADVANCEDTRACES_H__

     6 

     7 #define KOstTraceComponentID 0x20011111

     8 

     9 #define HELLO_WORLD 0xde0001

    10 #define HELLO_MOON 0x8a0001

    11 #define TEST_TRACE_2 0x8a0002

    12 #define POINTER_PARAMETER_TRACE1 0xdf0001

    13 #define POINTER_PARAMETER_TRACE2 0xdf0002

    14 #define ASCII60 0xe00001

    15 #define ASCII300 0xe00002

    16 #define ASCII512 0xe00003

    17 #define ASCII600 0xe00004

    18 #define ASCII300_ASCII512 0xe00005

    19 #define ASCII600_ASCII300 0xe00006

    20 #define ASCII333_ASCII333 0xe00007

    21 #define ASCII1 0xe10001

    22 #define ASCII2 0xe10002

    23 #define ASCII3 0xe10003

    24 #define ASCII4 0xe10004

    25 #define ASCII5 0xe10005

    26 #define STATE_TRACE_0 0x870001

    27 #define STATE_TRACE_1 0x870002

    28 #define TRACE_DATA_TRACE 0xe20001

    29 #define POST1 0xe30001

    30 

    31 

    32 inline TBool OstTraceGen2( TUint32 aTraceID, const TAny* aParam1, const TAny* aParam2 )

    33     {

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

    35     if ( retval )

    36         {

    37         TUint8 data[ 8 ];

    38         TUint8* ptr = data;

    39         *( ( const TAny** )ptr ) = aParam1;

    40         ptr += sizeof ( const TAny* );

    41         *( ( const TAny** )ptr ) = aParam2;

    42         ptr += sizeof ( const TAny* );

    43         ptr -= 8;

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

    45         }

    46     return retval;

    47     }

    48 

    49 

    50 inline TBool OstTraceGen1( TUint32 aTraceID, const TAny* aParam1 )

    51     {

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

    53     if ( retval )

    54         {

    55         TUint8 data[ 4 ];

    56         TUint8* ptr = data;

    57         *( ( const TAny** )ptr ) = aParam1;

    58         ptr += sizeof ( const TAny* );

    59         ptr -= 4;

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

    61         }

    62     return retval;

    63     }

    64 

    65 

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

    67     {

    68     TBool retval;

    69     TInt size = aParam1.Size();

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

    71     if (size % 4 == 0)

    72         {

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

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

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

    76         }

    77     else

    78         {

    79         TUint8 data[ KOstMaxDataLength ];

    80         TUint8* ptr = data;

    81         if (size > KOstMaxDataLength)

    82             {

    83             size = KOstMaxDataLength;

    84             }

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

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

    87         ptr += size;

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

    89         while ( size++ < sizeAligned )

    90             {

    91             *ptr++ = 0;

    92             }

    93         ptr -= sizeAligned;

    94         size = sizeAligned;

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

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

    97         }

    98     return retval;

    99     }

   100 

   101 

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

   103     {

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

   105     if ( retval )

   106         {

   107         TInt length = 0;

   108         // Check that parameter lenght is not too long

   109         TInt length1 = aParam1.Size();

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

   111             {

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

   113             }

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

   115         if (lengthAligned1 > 0)

   116             {

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

   118             }

   119         // Check that parameter lenght is not too long

   120         TInt length2 = aParam2.Size();

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

   122             {

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

   124             }

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

   126         if (lengthAligned2 > 0)

   127             {

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

   129             }

   130         TUint8 data[ KOstMaxDataLength ];

   131         TUint8* ptr = data;

   132         // Set length to zero and calculate it againg

   133         // when adding parameters

   134         length = 0;

   135         if (length1 > 0)

   136             {

   137             // Number of elements is written before data

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

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

   140             ptr += sizeof ( TUint32 );

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

   142             ptr += length1;

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

   144             while ( length1++ < lengthAligned1 )

   145                 {

   146                 *ptr++ = 0;

   147                 }

   148             length += sizeof ( TUint32 ) + lengthAligned1;

   149             }

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

   151             {

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

   153             ptr += sizeof ( TUint32 );

   154             length += sizeof ( TUint32 );

   155             }

   156         if (length2 > 0)

   157             {

   158             // Number of elements is written before data

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

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

   161             ptr += sizeof ( TUint32 );

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

   163             ptr += length2;

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

   165             while ( length2++ < lengthAligned2 )

   166                 {

   167                 *ptr++ = 0;

   168                 }

   169             length += sizeof ( TUint32 ) + lengthAligned2;

   170             }

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

   172             {

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

   174             ptr += sizeof ( TUint32 );

   175             length += sizeof ( TUint32 );

   176             }

   177         ptr -= length;

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

   179         }

   180     return retval;

   181     }

   182 

   183 

   184 inline TBool OstTraceGen3( TUint32 aTraceID, const TDesC8& aParam1, const TDesC8& aParam2, TUint aParam3 )

   185     {

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

   187     if ( retval )

   188         {

   189         TInt length = 0;

   190         // Check that parameter lenght is not too long

   191         TInt length1 = aParam1.Size();

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

   193             {

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

   195             }

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

   197         if (lengthAligned1 > 0)

   198             {

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

   200             }

   201         // Check that parameter lenght is not too long

   202         TInt length2 = aParam2.Size();

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

   204             {

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

   206             }

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

   208         if (lengthAligned2 > 0)

   209             {

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

   211             }

   212         TUint8 data[ KOstMaxDataLength ];

   213         TUint8* ptr = data;

   214         // Set length to zero and calculate it againg

   215         // when adding parameters

   216         length = 0;

   217         if (length1 > 0)

   218             {

   219             // Number of elements is written before data

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

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

   222             ptr += sizeof ( TUint32 );

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

   224             ptr += length1;

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

   226             while ( length1++ < lengthAligned1 )

   227                 {

   228                 *ptr++ = 0;

   229                 }

   230             length += sizeof ( TUint32 ) + lengthAligned1;

   231             }

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

   233             {

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

   235             ptr += sizeof ( TUint32 );

   236             length += sizeof ( TUint32 );

   237             }

   238         if (length2 > 0)

   239             {

   240             // Number of elements is written before data

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

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

   243             ptr += sizeof ( TUint32 );

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

   245             ptr += length2;

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

   247             while ( length2++ < lengthAligned2 )

   248                 {

   249                 *ptr++ = 0;

   250                 }

   251             length += sizeof ( TUint32 ) + lengthAligned2;

   252             }

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

   254             {

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

   256             ptr += sizeof ( TUint32 );

   257             length += sizeof ( TUint32 );

   258             }

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

   260         if ((length + sizeof ( TUint )) <= KOstMaxDataLength)

   261             {

   262             *( ( TUint* )ptr ) = aParam3;

   263             ptr += sizeof ( TUint );

   264             length += sizeof ( TUint );

   265             }

   266         ptr -= length;

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

   268         }

   269     return retval;

   270     }

   271 

   272 inline TBool OstTraceGen3( TUint32 aTraceID, const TDesC8& aParam1, const TDesC8& aParam2, TUint32 aParam3 )

   273     {

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

   275     if ( retval )

   276         {

   277         TInt length = 0;

   278         // Check that parameter lenght is not too long

   279         TInt length1 = aParam1.Size();

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

   281             {

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

   283             }

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

   285         if (lengthAligned1 > 0)

   286             {

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

   288             }

   289         // Check that parameter lenght is not too long

   290         TInt length2 = aParam2.Size();

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

   292             {

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

   294             }

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

   296         if (lengthAligned2 > 0)

   297             {

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

   299             }

   300         TUint8 data[ KOstMaxDataLength ];

   301         TUint8* ptr = data;

   302         // Set length to zero and calculate it againg

   303         // when adding parameters

   304         length = 0;

   305         if (length1 > 0)

   306             {

   307             // Number of elements is written before data

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

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

   310             ptr += sizeof ( TUint32 );

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

   312             ptr += length1;

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

   314             while ( length1++ < lengthAligned1 )

   315                 {

   316                 *ptr++ = 0;

   317                 }

   318             length += sizeof ( TUint32 ) + lengthAligned1;

   319             }

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

   321             {

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

   323             ptr += sizeof ( TUint32 );

   324             length += sizeof ( TUint32 );

   325             }

   326         if (length2 > 0)

   327             {

   328             // Number of elements is written before data

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

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

   331             ptr += sizeof ( TUint32 );

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

   333             ptr += length2;

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

   335             while ( length2++ < lengthAligned2 )

   336                 {

   337                 *ptr++ = 0;

   338                 }

   339             length += sizeof ( TUint32 ) + lengthAligned2;

   340             }

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

   342             {

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

   344             ptr += sizeof ( TUint32 );

   345             length += sizeof ( TUint32 );

   346             }

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

   348         if ((length + sizeof ( TUint )) <= KOstMaxDataLength)

   349             {

   350             *( ( TUint* )ptr ) = aParam3;

   351             ptr += sizeof ( TUint );

   352             length += sizeof ( TUint );

   353             }

   354         ptr -= length;

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

   356         }

   357     return retval;

   358     }

   359 

   360 

   361 #endif

   362 

   363 // End of file

   364