buildframework/helium/tools/compile/sbs/sbs.ant.xml
changeset 628 7c4a911dc066
parent 588 c7c26511138f
child 645 b8d81fa19e7d
equal deleted inserted replaced
588:c7c26511138f 628:7c4a911dc066
    25     <description>
    25     <description>
    26     Executes compilation of a System Model of System Definition file using Symbian SBS (Raptor) tools. 
    26     Executes compilation of a System Model of System Definition file using Symbian SBS (Raptor) tools. 
    27     </description>
    27     </description>
    28 
    28 
    29 
    29 
    30 
       
    31     <!--
    30     <!--
    32         Executes compilation  of a System Model of System Definition file using Symbian SBS (Raptor) tools. 
    31         Executes compilation  of a System Model of System Definition file using Symbian SBS (Raptor) tools. 
    33         Should not be called directly but through compile-main by setting ${build.system.sbs} property.
    32         Should not be called directly but through compile-main by setting ${build.system.sbs} property.
    34     -->
    33     -->
    35 
    34 
       
    35     <!--* @property sbs.ctc.enabled
       
    36     This property enables Raptor compilation using ctc. 
       
    37     @type boolean
       
    38     @editable required
       
    39     @scope public
       
    40     -->
       
    41      
    36     <!--* @property sbs.build.ctc
    42     <!--* @property sbs.build.ctc
    37      This property enables Raptor compilation using ctc. 
    43     This property enables Raptor compilation using ctc. - deprecated: Start using sbs.ctc.enabled property.
    38      @type boolean
    44     @type boolean
    39      @scope public
    45     @editable required
    40      -->
    46     @scope public
    41     
    47     @deprecated since 11.0
    42     <!--* @property schema.new
    48     -->
    43      This property enables sbs compilation based on system definition schema 3.0.0. 
    49 
    44      @type boolean
    50     <!--* @property sbs.checksource.enabled
    45      @scope public
    51     This property enables Raptor checksource analysis. 
    46      -->
    52     @type boolean
       
    53     @editable required
       
    54     @scope public
       
    55     -->
       
    56 
    47     
    57     
    48     <!-- This property enables sbs layer filtering of the canonical system definition file 
    58     <!-- This property enables sbs layer filtering of the canonical system definition file 
    49          for system definition schema 1.4.0 using ${sysdef.configuration}. 
    59          for system definition schema 1.4.0 using ${sysdef.configuration}. 
    50      @type boolean
    60      @type boolean
    51     -->
    61     -->
    52     <property name="sbs.layer.generation.enabled" value="true" />
    62     <property name="sbs.layer.generation.enabled" value="true" />
    53 
    63 
       
    64     <!-- This property enables the downgrading of the canonical system
       
    65          definition v3 model into 2.0 before passing the file to sbs.  
       
    66      @type boolean
       
    67     -->
       
    68     <property name="sbs.downgrade.sysdef.enabled" value="true" />
       
    69         
       
    70     
    54     <!-- Default CTC command line option, override it to customize it. -->
    71     <!-- Default CTC command line option, override it to customize it. -->
    55     <hlm:argSet id="ctc.build.options" />
    72     <hlm:argSet id="ctc.build.options" />
    56 
    73 
    57     <!-- This property define what instrumentation CTC should create.
    74     <!-- This property define what instrumentation CTC should create.
    58     @type string
    75     @type string
    61     
    78     
    62     
    79     
    63     <!-- This target filters the canonical system definition file compare to the "raptor_${sysdef.configuration}" filter. -->
    80     <!-- This target filters the canonical system definition file compare to the "raptor_${sysdef.configuration}" filter. -->
    64     <macrodef name="generate-layers" uri="http://www.nokia.com/helium">
    81     <macrodef name="generate-layers" uri="http://www.nokia.com/helium">
    65         <sequential>
    82         <sequential>
    66             <echo message="canno-file:${canonical.sysdef.file}" />
    83             <echo message="cannonical sysdef file: ${canonical.sysdef.file}" />
    67             <echo message="raptor-filters:raptor_${sysdef.configuration}" />
    84             <echo message="raptor-filters: raptor_${sysdef.configuration}" />
    68             <if>
    85             <if>
    69                 <isfalse value="${sbs.layer.generation.enabled}" />
    86                 <isfalse value="${sbs.layer.generation.enabled}" />
    70                 <then>
    87                 <then>
    71                     <if>
    88                     <if>
    72                         <isreference refid="sysdef.layers.${sysdef.configuration}" />
    89                         <isreference refid="sysdef.layers.${sysdef.configuration}" />
    73                         <then>
    90                         <then>
    74                             <property name="sbs.patternset" value="sysdef.filters.${sysdef.configuration}" />
    91                             <property name="sbs.patternset" value="sysdef.layers.${sysdef.configuration}" />
    75                             <echo message="sbs.patternset: ${sbs.patternset}" />
    92                             <echo message="sbs.patternset: ${sbs.patternset}" />
    76                         </then>
    93                         </then>
    77                         <else>
    94                         <else>
    78                             <echo message="The sysdef.layers.${sysdef.configuration} pattern set is not defined." />
    95                             <echo message="The sysdef.layers.${sysdef.configuration} pattern set is not defined." />
    79                         </else>
    96                         </else>
    95             </copy>
   112             </copy>
    96             <delete file="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}_temp.xml"/>
   113             <delete file="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}_temp.xml"/>
    97         </sequential>
   114         </sequential>
    98     </macrodef>
   115     </macrodef>
    99 
   116 
   100     <!-- SBS build with gmake as engine type. Default is using sbs macro, to use old implementation to
   117     
   101     use using exec task, then sbs.using.exec needs to be set. -->
   118     <condition property="build.system.sbs-any">
   102     <target name="compile-sbs" description="This is the main build that gets built for ARMV5 and WINSCW platforms">
   119         <or>
   103         <!-- only temporary once config file option starts to work, then no 
   120             <equals arg1="${build.system}" arg2="sbs" />
   104         need to copy the plugin file -->
   121             <equals arg1="${build.system}" arg2="sbs-ec" />
   105 
   122         </or>
       
   123     </condition>
       
   124     
       
   125     
       
   126     <!-- SBS build with gmake as engine type.
       
   127         
       
   128     Default is using sbs macro, to use old implementation to
       
   129     use using exec task, then sbs.using.exec needs to be set.
       
   130     -->
       
   131     <target name="compile-sbs" if="build.system.sbs-any">
       
   132         <echo message="Copying Helium filter plugin to sbs home" />
       
   133         <var name="sbs.internal.inputs.list" unset="true"/>
   106         <if>
   134         <if>
   107             <or>
   135             <istrue value="${sysdef3.enabled}" />
   108                 <equals arg1="${build.system}" arg2="sbs" />
       
   109                 <equals arg1="${build.system}" arg2="sbs-ec" />
       
   110             </or>
       
   111             <then>
   136             <then>
   112                 <echo message="Copying helium filter plugin to sbs home" />
   137                 <if>
   113                 <copy file="${helium.dir}/tools/common/python/scripts/filter_metadatalog.py" todir="${env.SBS_HOME}/python/plugins/" failonerror="true" />
   138                     <isreference refid="sysdef.filters.${sysdef.configuration}" />
   114                 <copy file="${helium.dir}/tools/common/python/scripts/sbsscanlogmetadata.py" todir="${env.SBS_HOME}/python/plugins/" failonerror="true" />
   139                     <then>
   115                 <var name="sbs.internal.inputs.list" value="" unset="true"/>
   140                         <hlm:filterSysdef epocroot="${build.drive}/" srcfile="${canonical.sysdef.file}" 
   116                 <if>
   141                             destfile="${build.drive}/output/build/canonical_system_definition_filtered_${sysdef.configuration}.xml">
   117                     <istrue value="${schema.new}" />
   142                             <filterSet refid="sysdef.filters.${sysdef.configuration}" />
   118                     <then>
   143                         </hlm:filterSysdef>
   119                         <hlm:downgradeSysdef epocroot="${build.drive}/" srcfile="${canonical.sysdef.file}" 
   144                     </then>
       
   145                     <else>
       
   146                         <echo message="The sysdef.filters.${sysdef.configuration} sysdefFilterSet is not defined." />
       
   147                         <copy file="${canonical.sysdef.file}"
       
   148                             tofile="${build.drive}/output/build/canonical_system_definition_filtered_${sysdef.configuration}.xml" />
       
   149                     </else>
       
   150                 </if>
       
   151                 <if>
       
   152                     <istrue value="${sbs.downgrade.sysdef.enabled}" />
       
   153                     <then>
       
   154                         <hlm:downgradeSysdef epocroot="${build.drive}/" srcfile="${build.drive}/output/build/canonical_system_definition_filtered_${sysdef.configuration}.xml" 
   120                             destfile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml"/>
   155                             destfile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml"/>
   121                         <var name="sbs.patternset" unset="true"/>
   156                     </then>
   122                         <if>
   157                     <else>
   123                             <isreference refid="sysdef.filters.${sysdef.configuration}" />
   158                         <echo message="Downgrading to 2.0 model disabled." />
   124                             <then>
   159                         <copy file="${build.drive}/output/build/canonical_system_definition_filtered_${sysdef.configuration}.xml"
   125                                 <property name="sbs.patternset" value="sysdef.filters.${sysdef.configuration}" />
   160                             tofile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" />
   126                                 <echo message="sbs.patternset: ${sbs.patternset}" />
   161                     </else>
   127                             </then>
   162                 </if>
   128                             <else>
   163                 <var name="sbs.patternset" unset="true"/>
   129                                 <echo message="The sysdef.filters.${sysdef.configuration} patternset is not defined." />
   164                 <if>
   130                             </else>
   165                     <isreference refid="sysdef.layers.${sysdef.configuration}" />
   131                         </if>
   166                     <then>
   132                     </then>
   167                         <property name="sbs.patternset" value="sysdef.layers.${sysdef.configuration}" />
   133                     <else>
   168                         <echo message="sbs.patternset: ${sbs.patternset}" />
   134                         <var name="sbs.patternset" unset="true"/>
   169                     </then>
   135                         <if>
   170                     <else>
   136                             <isreference refid="sysdef.layers.${sysdef.configuration}" />
   171                         <echo message="The sysdef.layers.${sysdef.configuration} patternset is not defined." />
   137                             <then>
   172                     </else>
   138                                 <property name="sbs.patternset" value="sysdef.filters.${sysdef.configuration}" />
   173                 </if>
   139                                 <echo message="sbs.patternset: ${sbs.patternset}" />
       
   140                                 <copy file="${canonical.sysdef.file}" tofile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" />
       
   141                             </then>
       
   142                             <else>
       
   143                                 <echo message="The sysdef.layers.${sysdef.configuration} patternset is not defined." />
       
   144                                 <hlm:generate-layers />
       
   145                             </else>
       
   146                         </if>
       
   147                     </else>
       
   148                 </if>              
       
   149                 <hlm:getsbsinputs config="sbs.${sysdef.configuration}" outputProperty="sbs.internal.inputs.list"/>
       
   150                 <for list="${sbs.internal.inputs.list}" delimiter="," param="sbs.input">
       
   151                     <sequential>
       
   152                         <echo message="building raptor input: @{sbs.input}" />
       
   153                         <var name="sbs.log.file" unset="true" />
       
   154                         <property name="sbs.log.file" location="${compile.log.dir}/${build.id}_${sysdef.configuration}_@{sbs.input}_compile.log" />
       
   155                         <!-- run arm license checking / setting arm version only for arm config -->
       
   156                         <hlm:getVariableValue name="-c" property="compilevalue.var" failOnerror="false">
       
   157                             <hlm:sbsinput refid="@{sbs.input}" />
       
   158                         </hlm:getVariableValue>
       
   159                         <echo message="config parameter -c : ${compilevalue.var}" />
       
   160                         <if>
       
   161                             <and>
       
   162                                 <isset property="compilevalue.var"/>
       
   163                                 <matches string="${compilevalue.var}" pattern="arm.*"/>
       
   164                             </and>
       
   165                             <then>
       
   166                                 <runtarget target="set-arm-version"/>
       
   167                             </then>
       
   168                         </if>
       
   169                         <!-- Generate the filtered layers -->
       
   170                         <if>
       
   171                             <isset property="run.coverity"/>
       
   172                             <then>
       
   173                                 <hlm:coveritybuild  sbsinput="@{sbs.input}" 
       
   174                                                     sysdeffile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml"
       
   175                                                     layerpatternsetref="${sbs.patternset}" 
       
   176                                                     workingdir="${build.drive}/" 
       
   177                                                     execute="true"
       
   178                                                     failonerror="false"
       
   179                                                     outputlog="${sbs.log.file}" 
       
   180                                                     erroroutput="${sbs.log.file}.sbs_error.log">
       
   181                                     <hlm:coverityoptions refid="coverity.build.options"/>
       
   182                                 </hlm:coveritybuild>
       
   183                             </then>
       
   184                             <elseif>
       
   185                                 <istrue value="${sbs.build.ctc}"/>
       
   186                                 <then>
       
   187                                     <hlm:ctctask sbsinput="@{sbs.input}" 
       
   188                                                     sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 
       
   189                                                     layerPatternSetRef="${sbs.patternset}" 
       
   190                                                     errorOutput="${sbs.log.file}.sbs_error.log" 
       
   191                                                     workingDir="${build.drive}/" 
       
   192                                                     failOnError="false" 
       
   193                                                     outputLog="${sbs.log.file}"
       
   194                                                     instrumentType="${ctc.instrument.type}">
       
   195                                         <hlm:CTCOptions refid="ctc.build.options" />
       
   196                                     </hlm:ctctask>
       
   197                                 </then>
       
   198                             </elseif>
       
   199                             <else>
       
   200                                 <hlm:sbstask sbsinput="@{sbs.input}" 
       
   201                                                 sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 
       
   202                                                 layerPatternSetRef="${sbs.patternset}" 
       
   203                                                 errorOutput="${sbs.log.file}.sbs_error.log" 
       
   204                                                 workingDir="${build.drive}/" 
       
   205                                                 failOnError="false" 
       
   206                                                 outputLog="${sbs.log.file}" />
       
   207                             </else>
       
   208                         </if>
       
   209                         <hlm:assertFileExists file="${sbs.log.file}"/>
       
   210                         <hlm:assertFileExists file="${sbs.log.file}.sbs_error.log"/>
       
   211                         <!-- run arm license checking / setting arm version only for arm config --> 
       
   212                         <echo message="sbs.log.file: ${sbs.log.file}" />
       
   213                         <hlm:sbsProcessOutputMacro sbs.log.file="${sbs.log.file}"
       
   214                             sbs.ant.output.file="${sbs.log.file}" sbs.error.output.file="${sbs.log.file}.sbs_error.log"/>
       
   215                     </sequential>
       
   216                 </for>
       
   217             </then>
   174             </then>
   218         </if>
   175             <else>
       
   176                 <var name="sbs.patternset" unset="true"/>
       
   177                 <if>
       
   178                     <isreference refid="sysdef.layers.${sysdef.configuration}" />
       
   179                     <then>
       
   180                         <property name="sbs.patternset" value="sysdef.filters.${sysdef.configuration}" />
       
   181                         <echo message="sbs.patternset: ${sbs.patternset}" />
       
   182                         <copy file="${canonical.sysdef.file}" tofile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" />
       
   183                     </then>
       
   184                     <else>
       
   185                         <echo message="The sysdef.layers.${sysdef.configuration} patternset is not defined." />
       
   186                         <hlm:generate-layers />
       
   187                     </else>
       
   188                 </if>
       
   189             </else>
       
   190         </if>              
       
   191         <hlm:getsbsinputs config="sbs.${sysdef.configuration}" outputProperty="sbs.internal.inputs.list"/>
       
   192         <for list="${sbs.internal.inputs.list}" delimiter="," param="sbs.input">
       
   193             <sequential>
       
   194                 <echo message="building raptor input: @{sbs.input}" />
       
   195                 <var name="sbs.log.file" unset="true" />
       
   196                 <property name="sbs.log.file" location="${compile.log.dir}/${build.id}_${sysdef.configuration}_@{sbs.input}_compile.log" />
       
   197                 <!-- run arm license checking / setting arm version only for arm config -->
       
   198                 <hlm:getVariableValue name="-c" property="compilevalue.var" failOnerror="false">
       
   199                     <hlm:sbsinput refid="@{sbs.input}" />
       
   200                 </hlm:getVariableValue>
       
   201                 <echo message="config parameter -c : ${compilevalue.var}" />
       
   202                 <if>
       
   203                     <and>
       
   204                         <isset property="compilevalue.var"/>
       
   205                         <matches string="${compilevalue.var}" pattern="arm.*"/>
       
   206                     </and>
       
   207                     <then>
       
   208                         <runtarget target="set-arm-version"/>
       
   209                     </then>
       
   210                 </if>
       
   211                 <!-- Generate the filtered layers -->
       
   212                 <if>
       
   213                     <or>
       
   214                         <istrue value="${coverity.enabled}" />
       
   215                         <isset property="enabled.coverity"/>
       
   216                     </or>
       
   217                     <then>
       
   218                         <hlm:coveritybuild  sbsinput="@{sbs.input}" 
       
   219                                             sysdeffile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml"
       
   220                                             layerpatternsetref="${sbs.patternset}" 
       
   221                                             workingdir="${build.drive}/" 
       
   222                                             execute="true"
       
   223                                             failonerror="false"
       
   224                                             outputlog="${sbs.log.file}" 
       
   225                                             erroroutput="${sbs.log.file}.sbs_error.log">
       
   226                             <hlm:coverityoptions refid="coverity.build.options"/>
       
   227                         </hlm:coveritybuild>
       
   228                     </then>
       
   229                     <elseif>
       
   230                         <or>
       
   231                             <istrue value="${sbs.ctc.enabled}"/>
       
   232                             <isset property="sbs.build.ctc"/>
       
   233                         </or>
       
   234                         <then>
       
   235                             <hlm:ctctask sbsinput="@{sbs.input}" 
       
   236                                             sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 
       
   237                                             layerPatternSetRef="${sbs.patternset}" 
       
   238                                             errorOutput="${sbs.log.file}.sbs_error.log" 
       
   239                                             workingDir="${build.drive}/" 
       
   240                                             failOnError="false" 
       
   241                                             outputLog="${sbs.log.file}"
       
   242                                             instrumentType="${ctc.instrument.type}">
       
   243                                 <hlm:CTCOptions refid="ctc.build.options" />
       
   244                             </hlm:ctctask>
       
   245                         </then>
       
   246                     </elseif>
       
   247                     <else>
       
   248                         <hlm:sbstask sbsinput="@{sbs.input}" 
       
   249                                         sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 
       
   250                                         layerPatternSetRef="${sbs.patternset}" 
       
   251                                         errorOutput="${sbs.log.file}.sbs_error.log" 
       
   252                                         workingDir="${build.drive}/" 
       
   253                                         failOnError="false" 
       
   254                                         outputLog="${sbs.log.file}" />
       
   255                     </else>
       
   256                 </if>
       
   257                 <hlm:assertFileExists file="${sbs.log.file}"/>
       
   258                 <hlm:assertFileExists file="${sbs.log.file}.sbs_error.log"/>
       
   259                 <!-- run arm license checking / setting arm version only for arm config --> 
       
   260                 <hlm:sbsProcessOutputMacro sbsLogFile="${sbs.log.file}"
       
   261                                            sbsErrorOutputFile="${sbs.log.file}.sbs_error.log"/>
       
   262             </sequential>
       
   263         </for>
   219     </target>
   264     </target>
   220     
   265     
   221     
   266     
       
   267     <!-- Runs the SBS checksource filter on the SBS log file. -->
       
   268     <macrodef name="sbsChecksourceMacro" uri="http://www.nokia.com/helium">
       
   269         <attribute name="sbsLogFile" />
       
   270         <sequential>
       
   271             <var name="sbs.checksource.log.file" unset="true"/>
       
   272             <property name="sbs.checksource.log.file" location="@{sbsLogFile}.checksource.log" />
       
   273             <exec osfamily="windows" executable="cmd" dir="${build.drive}/" input="@{sbsLogFile}"
       
   274                   output="${sbs.checksource.log.file}" failonerror="false">
       
   275                 <arg value="/c" />
       
   276                 <arg value="sbs_filter.bat" />
       
   277                 <arg value="--filters=FilterCheckSource" />
       
   278             </exec>
       
   279             <hlm:metadatarecord database="${metadata.dbfile}">
       
   280                 <hlm:textmetadatainput>
       
   281                     <fileset file="${sbs.checksource.log.file}"/>
       
   282                     <metadatafilterset refid="filterset.sbs.checksource"/>
       
   283                 </hlm:textmetadatainput>
       
   284             </hlm:metadatarecord>
       
   285         </sequential>
       
   286     </macrodef>
       
   287     
       
   288     
   222     <macrodef name="sbsProcessOutputMacro" uri="http://www.nokia.com/helium">
   289     <macrodef name="sbsProcessOutputMacro" uri="http://www.nokia.com/helium">
   223         <attribute name="sbs.log.file" />
   290         <attribute name="sbsLogFile" />
   224         <attribute name="sbs.error.output.file" />
   291         <attribute name="sbsErrorOutputFile" />
   225         <attribute name="sbs.ant.output.file" />
       
   226         <sequential>
   292         <sequential>
   227             <var name="sbs.scan2.template" value="scan2_orm.html.ftl" />
   293             <var name="sbs.scan2.template" value="${helium.dir}/tools/common/templates/log/scan2_orm.html.ftl" />
   228             <var name="base.sbs.log" value="" unset="true"/>
   294             <var name="base.sbs.log" unset="true"/>
   229             <basename property="base.sbs.log" file="@{sbs.log.file}" />
   295             <basename property="base.sbs.log" file="@{sbsLogFile}" />
   230             <echo message="base.sbs.log: ${base.sbs.log}" />
   296             <echo message="base.sbs.log: ${base.sbs.log}" />
   231             <hlm:metadatarecord database="${metadata.dbfile}">
   297             <hlm:metadatarecord database="${metadata.dbfile}">
   232                 <hlm:textmetadatainput>
   298                 <hlm:textmetadatainput>
   233                     <fileset casesensitive="false" file="@{sbs.error.output.file}"/>
   299                     <fileset casesensitive="false" file="@{sbsErrorOutputFile}"/>
   234                     <metadatafilterset refid="filterset.sbs.cli" />
   300                     <metadatafilterset refid="filterset.sbs.cli" />
   235                 </hlm:textmetadatainput>
   301                 </hlm:textmetadatainput>
   236             </hlm:metadatarecord>
   302             </hlm:metadatarecord>
   237             <basename property="base.sbs.ant.output.log" file="@{sbs.ant.output.file}" />
   303             <hlm:signalMacro logfile="@{sbsErrorOutputFile}" 
   238             <hlm:signalMacro logfile="@{sbs.error.output.file}" 
   304                              signal.input="raptorErrorSignalInput" phase="compile"/>
   239                 signal.input="raptorErrorSignalInput" phase="compile"/>
       
   240             <!-- update the resultes to database -->
   305             <!-- update the resultes to database -->
   241             <echo message="Metadata enabled, storing build status in database" />
   306             <if>
   242             <echo message="sbs log file :@{sbs.log.file}" />
   307                 <available file="@{sbsLogFile}" />
   243             <trycatch property="hlm-sbs.parser.thrown">
   308                 <then>
   244                 <try>
   309                     <echo message="sbs log file: @{sbsLogFile}" />
   245                     <hlm:metadatarecord  database="${metadata.dbfile}">
       
   246                         <hlm:sbsmetadatainput>
       
   247                             <fileset casesensitive="false" file="@{sbs.log.file}"/>
       
   248                             <metadatafilterset refid="filterset.sbs" />
       
   249                         </hlm:sbsmetadatainput>
       
   250                     </hlm:metadatarecord>
       
   251                 </try>
       
   252                 <catch>
       
   253                     <if>
   310                     <if>
   254                         <istrue value="${skip.sbs.parser.exception}" />
   311                         <istrue value="${internal.compile.cmd.clean.enabled}" />
   255                         <then>
   312                         <then>
   256                             <var name="sbs.scan2.template" value="scan2_text_orm.html.ftl" />
   313                             <hlm:metadatarecord  database="${metadata.dbfile}">
   257                             <hlm:metadatadelete database="${metadata.dbfile}">
   314                                 <hlm:sbsmetadatainput failOnInvalidXml="false" checkMissing="false" epocroot="${build.drive}/">
   258                                 <fileset casesensitive="false" file="@{sbs.log.file}"/>
   315                                     <fileset casesensitive="false" file="@{sbsLogFile}"/>
   259                             </hlm:metadatadelete>
       
   260                             <hlm:metadatarecord database="${metadata.dbfile}" >
       
   261                                 <hlm:textmetadatainput>
       
   262                                     <fileset casesensitive="false" file="@{sbs.log.file}"/>
       
   263                                     <metadatafilterset refid="filterset.sbs" />
   316                                     <metadatafilterset refid="filterset.sbs" />
   264                                 </hlm:textmetadatainput>
   317                                 </hlm:sbsmetadatainput>
   265                             </hlm:metadatarecord>
   318                             </hlm:metadatarecord>
   266                         </then>
   319                         </then>
   267                         <else>
   320                         <else>
   268                             <loadfile property="sbs.error.output" srcfile="@{sbs.error.output.file}" failonerror="false"/>
   321                             <hlm:metadatarecord  database="${metadata.dbfile}">
   269                             <fail message="failed during raptor log parsing: might be due to invalid xml output from raptor ${hlm-sbs.parser.thrown}. ${sbs.error.output}" />
   322                                 <hlm:sbsmetadatainput failOnInvalidXml="false" epocroot="${build.drive}/">
       
   323                                     <fileset casesensitive="false" file="@{sbsLogFile}"/>
       
   324                                     <metadatafilterset refid="filterset.sbs" />
       
   325                                 </hlm:sbsmetadatainput>
       
   326                             </hlm:metadatarecord>
       
   327                             <if>
       
   328                                 <istrue value="${sbs.checksource.enabled}" />
       
   329                                 <then>
       
   330                                     <hlm:sbsChecksourceMacro sbsLogFile="@{sbsLogFile}" />
       
   331                                 </then>
       
   332                             </if>
   270                         </else>
   333                         </else>
   271                     </if>
   334                     </if>
   272                 </catch>
   335                     <fmpp sourceFile="${sbs.scan2.template}"
   273             </trycatch>
   336                           outputfile="${build.log.dir}/${base.sbs.log}.scan2.html">
   274             <fmpp sourceFile="${helium.dir}/tools/common/templates/log/${sbs.scan2.template}"
   337                         <freemarkerLinks expandProperties="yes">
   275                          outputfile="${build.log.dir}/${base.sbs.log}.scan2.html">
   338                             macro: ${helium.dir}/tools/common/templates/macro
   276                 <freemarkerLinks expandProperties="yes">
   339                         </freemarkerLinks>
   277                     macro: ${helium.dir}/tools/common/templates/macro
   340                         <data expandProperties="yes">
   278                 </freemarkerLinks>
   341                             dbPath: ${metadata.dbfile}
   279                 <data expandProperties="yes">
   342                             logfilename: @{sbsLogFile}
   280                     dbPath: ${metadata.dbfile}
   343                             ant: antProperties()
   281                     logfilename: @{sbs.log.file}
   344                         </data>
   282                     ant: antProperties()
   345                     </fmpp>
   283                 </data>
   346                     <hlm:assertFileExists file="${build.log.dir}/${base.sbs.log}.scan2.html"/>
   284             </fmpp>
   347                     
   285             <echo message="generating signal" />
   348                     <echo message="generating signal" />                    
   286             <hlm:assertFileExists file="${build.log.dir}/${base.sbs.log}.scan2.html"/>
   349                     <hlm:compileLogSignalMacro compile.summary.file="@{sbsLogFile}" 
   287             <hlm:compileLogSignalMacro compile.summary.file="@{sbs.log.file}" 
   350                         error.limit="${build.errors.limit}" phase="compile"/>
   288                 error.limit="${build.errors.limit}" phase="compile"/>
   351                     
   289             <!-- Blocks packaging configuration generation. -->
   352                     <!-- Blocks packaging configuration generation. -->
   290             <if>
   353                     <if>
   291                 <istrue value="${blocks.enabled}" />
   354                         <istrue value="${blocks.enabled}" />
   292                 <then>
   355                         <then>
   293                     <mkdir dir="${blocks.config.dir}" />
   356                             <mkdir dir="${blocks.config.dir}" />
   294                     <exec executable="python">
   357                             <exec executable="python">
   295                         <arg value="-m"/>
   358                                 <arg value="-m"/>
   296                         <arg value="packager.cli"/>
   359                                 <arg value="packager.cli"/>
   297                         <arg value="--epocroot=${build.drive}/" />
   360                                 <arg value="--epocroot=${build.drive}/" />
   298                         <arg value="--config=${blocks.config.dir}" />
   361                                 <arg value="--config=${blocks.config.dir}" />
   299                         <arg value="--datasource=sbs" />
   362                                 <arg value="--datasource=sbs" />
   300                         <arg value="-Dsbslog=${sbs.log.file}" />
   363                                 <arg value="-Dsbslog=${sbs.log.file}" />
   301                         <arg value="-Dsysdef=${canonical.sysdef.file}" />
   364                                 <arg value="-Dsysdef=${canonical.sysdef.file}" />
   302                         <arg value="-Dthreads=20" />
   365                                 <arg value="-Dthreads=20" />
   303                         <arg value="--updateData" />
   366                                 <arg value="--updateData" />
   304                     </exec>
   367                             </exec>
       
   368                         </then>
       
   369                     </if>
   305                 </then>
   370                 </then>
       
   371                 <else>
       
   372                     <echo>Could not find the sbs log: @{sbsLogFile}.</echo>
       
   373                 </else>
   306             </if>
   374             </if>
   307         </sequential>
   375         </sequential>
   308     </macrodef>
   376     </macrodef>
   309     
   377         
   310     <scriptdef language="jython" name="getSbsHome" uri="http://www.nokia.com/helium">
   378         
   311         <attribute name="property" />
   379     <!-- Uploads the SBS checksource results to Diamonds. -->
   312 if attributes.get("property") is None:
   380     <target name="sbs-checksource" if="build.system.sbs-any" />
   313     raise Exception("property attribute has not been set.")
   381     
   314 if project.getProperty(attributes.get("property")) is None:
       
   315     import symbian.raptor
       
   316     sbs_home = symbian.raptor.getSBSHome()
       
   317     if sbs_home is not None:
       
   318         #self.log("Found SBS_HOME as " + sbs_home)
       
   319         project.setNewProperty(attributes.get("property"), sbs_home)
       
   320     </scriptdef>
       
   321 
       
   322 </project>
   382 </project>
       
   383