<!--* @property sbs.ctc.enabled

    This property enables Raptor compilation using ctc. 

    @type boolean

    @editable required

    @scope public

    -->

    This property enables Raptor compilation using ctc. - deprecated: Start using sbs.ctc.enabled property.

    @type boolean

    @editable required

    @scope public

    @deprecated since 11.0

    -->

    <!--* @property sbs.checksource.enabled

    This property enables Raptor checksource analysis. 

    @type boolean

    @editable required

    @scope public

    -->

    <!-- This property enables the downgrading of the canonical system

         definition v3 model into 2.0 before passing the file to sbs.  

     @type boolean

    -->

    <property name="sbs.downgrade.sysdef.enabled" value="true" />

            <echo message="cannonical sysdef file: ${canonical.sysdef.file}" />

            <echo message="raptor-filters: raptor_${sysdef.configuration}" />

                            <property name="sbs.patternset" value="sysdef.layers.${sysdef.configuration}" />

    <condition property="build.system.sbs-any">

        <or>

            <equals arg1="${build.system}" arg2="sbs" />

            <equals arg1="${build.system}" arg2="sbs-ec" />

        </or>

    </condition>

    <!-- SBS build with gmake as engine type.

    Default is using sbs macro, to use old implementation to

    use using exec task, then sbs.using.exec needs to be set.

    -->

    <target name="compile-sbs" if="build.system.sbs-any">

        <echo message="Copying Helium filter plugin to sbs home" />

        <var name="sbs.internal.inputs.list" unset="true"/>

            <istrue value="${sysdef3.enabled}" />

                    <isreference refid="sysdef.filters.${sysdef.configuration}" />

                        <hlm:filterSysdef epocroot="${build.drive}/" srcfile="${canonical.sysdef.file}" 

                            destfile="${build.drive}/output/build/canonical_system_definition_filtered_${sysdef.configuration}.xml">

                            <filterSet refid="sysdef.filters.${sysdef.configuration}" />

                        </hlm:filterSysdef>

                    </then>

                    <else>

                        <echo message="The sysdef.filters.${sysdef.configuration} sysdefFilterSet is not defined." />

                        <copy file="${canonical.sysdef.file}"

                            tofile="${build.drive}/output/build/canonical_system_definition_filtered_${sysdef.configuration}.xml" />

                    </else>

                </if>

                <if>

                    <istrue value="${sbs.downgrade.sysdef.enabled}" />

                    <then>

                        <hlm:downgradeSysdef epocroot="${build.drive}/" srcfile="${build.drive}/output/build/canonical_system_definition_filtered_${sysdef.configuration}.xml" 

                    </then>

                    <else>

                        <echo message="Downgrading to 2.0 model disabled." />

                        <copy file="${build.drive}/output/build/canonical_system_definition_filtered_${sysdef.configuration}.xml"

                            tofile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" />

                    </else>

                </if>

                <var name="sbs.patternset" unset="true"/>

                <if>

                    <isreference refid="sysdef.layers.${sysdef.configuration}" />

                    <then>

                        <property name="sbs.patternset" value="sysdef.layers.${sysdef.configuration}" />

                        <echo message="sbs.patternset: ${sbs.patternset}" />

                    </then>

                    <else>

                        <echo message="The sysdef.layers.${sysdef.configuration} patternset is not defined." />

                    </else>

                </if>

            </then>

            <else>

                <var name="sbs.patternset" unset="true"/>

                <if>

                    <isreference refid="sysdef.layers.${sysdef.configuration}" />

                    <then>

                        <property name="sbs.patternset" value="sysdef.filters.${sysdef.configuration}" />

                        <echo message="sbs.patternset: ${sbs.patternset}" />

                        <copy file="${canonical.sysdef.file}" tofile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" />

                        <echo message="The sysdef.layers.${sysdef.configuration} patternset is not defined." />

                        <hlm:generate-layers />

                </if>

            </else>

        </if>              

        <hlm:getsbsinputs config="sbs.${sysdef.configuration}" outputProperty="sbs.internal.inputs.list"/>

        <for list="${sbs.internal.inputs.list}" delimiter="," param="sbs.input">

            <sequential>

                <echo message="building raptor input: @{sbs.input}" />

                <var name="sbs.log.file" unset="true" />

                <property name="sbs.log.file" location="${compile.log.dir}/${build.id}_${sysdef.configuration}_@{sbs.input}_compile.log" />

                <!-- run arm license checking / setting arm version only for arm config -->

                <hlm:getVariableValue name="-c" property="compilevalue.var" failOnerror="false">

                    <hlm:sbsinput refid="@{sbs.input}" />

                </hlm:getVariableValue>

                <echo message="config parameter -c : ${compilevalue.var}" />

                <if>

                    <and>

                        <isset property="compilevalue.var"/>

                        <matches string="${compilevalue.var}" pattern="arm.*"/>

                    </and>

                    <then>

                        <runtarget target="set-arm-version"/>

                    </then>

                </if>

                <!-- Generate the filtered layers -->

                <if>

                    <or>

                        <istrue value="${coverity.enabled}" />

                        <isset property="enabled.coverity"/>

                    </or>

                    <then>

                        <hlm:coveritybuild  sbsinput="@{sbs.input}" 

                                            sysdeffile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml"

                                            layerpatternsetref="${sbs.patternset}" 

                                            workingdir="${build.drive}/" 

                                            execute="true"

                                            failonerror="false"

                                            outputlog="${sbs.log.file}" 

                                            erroroutput="${sbs.log.file}.sbs_error.log">

                            <hlm:coverityoptions refid="coverity.build.options"/>

                        </hlm:coveritybuild>

                    </then>

                    <elseif>

                        <or>

                            <istrue value="${sbs.ctc.enabled}"/>

                            <isset property="sbs.build.ctc"/>

                        </or>

                        <then>

                            <hlm:ctctask sbsinput="@{sbs.input}" 

                                            sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 

                                            layerPatternSetRef="${sbs.patternset}" 

                                            errorOutput="${sbs.log.file}.sbs_error.log" 

                                            workingDir="${build.drive}/" 

                                            failOnError="false" 

                                            outputLog="${sbs.log.file}"

                                            instrumentType="${ctc.instrument.type}">

                                <hlm:CTCOptions refid="ctc.build.options" />

                            </hlm:ctctask>

                        </then>

                    </elseif>

                    <else>

                        <hlm:sbstask sbsinput="@{sbs.input}" 

                                        sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 

                                        layerPatternSetRef="${sbs.patternset}" 

                                        errorOutput="${sbs.log.file}.sbs_error.log" 

                                        workingDir="${build.drive}/" 

                                        failOnError="false" 

                                        outputLog="${sbs.log.file}" />

                    </else>

                </if>

                <hlm:assertFileExists file="${sbs.log.file}"/>

                <hlm:assertFileExists file="${sbs.log.file}.sbs_error.log"/>

                <!-- run arm license checking / setting arm version only for arm config --> 

                <hlm:sbsProcessOutputMacro sbsLogFile="${sbs.log.file}"

                                           sbsErrorOutputFile="${sbs.log.file}.sbs_error.log"/>

            </sequential>

        </for>

    <!-- Runs the SBS checksource filter on the SBS log file. -->

    <macrodef name="sbsChecksourceMacro" uri="http://www.nokia.com/helium">

        <attribute name="sbsLogFile" />

        <sequential>

            <var name="sbs.checksource.log.file" unset="true"/>

            <property name="sbs.checksource.log.file" location="@{sbsLogFile}.checksource.log" />

            <exec osfamily="windows" executable="cmd" dir="${build.drive}/" input="@{sbsLogFile}"

                  output="${sbs.checksource.log.file}" failonerror="false">

                <arg value="/c" />

                <arg value="sbs_filter.bat" />

                <arg value="--filters=FilterCheckSource" />

            </exec>

            <hlm:metadatarecord database="${metadata.dbfile}">

                <hlm:textmetadatainput>

                    <fileset file="${sbs.checksource.log.file}"/>

                    <metadatafilterset refid="filterset.sbs.checksource"/>

                </hlm:textmetadatainput>

            </hlm:metadatarecord>

        </sequential>

    </macrodef>

        <attribute name="sbsLogFile" />

        <attribute name="sbsErrorOutputFile" />

            <var name="sbs.scan2.template" value="${helium.dir}/tools/common/templates/log/scan2_orm.html.ftl" />

            <var name="base.sbs.log" unset="true"/>

            <basename property="base.sbs.log" file="@{sbsLogFile}" />

                    <fileset casesensitive="false" file="@{sbsErrorOutputFile}"/>

            <hlm:signalMacro logfile="@{sbsErrorOutputFile}" 

                             signal.input="raptorErrorSignalInput" phase="compile"/>

            <if>

                <available file="@{sbsLogFile}" />

                <then>

                    <echo message="sbs log file: @{sbsLogFile}" />

                        <istrue value="${internal.compile.cmd.clean.enabled}" />

                            <hlm:metadatarecord  database="${metadata.dbfile}">

                                <hlm:sbsmetadatainput failOnInvalidXml="false" checkMissing="false" epocroot="${build.drive}/">

                                    <fileset casesensitive="false" file="@{sbsLogFile}"/>

                                </hlm:sbsmetadatainput>

                            <hlm:metadatarecord  database="${metadata.dbfile}">

                                <hlm:sbsmetadatainput failOnInvalidXml="false" epocroot="${build.drive}/">

                                    <fileset casesensitive="false" file="@{sbsLogFile}"/>

                                    <metadatafilterset refid="filterset.sbs" />

                                </hlm:sbsmetadatainput>

                            </hlm:metadatarecord>

                            <if>

                                <istrue value="${sbs.checksource.enabled}" />

                                <then>

                                    <hlm:sbsChecksourceMacro sbsLogFile="@{sbsLogFile}" />

                                </then>

                            </if>

                    <fmpp sourceFile="${sbs.scan2.template}"

                          outputfile="${build.log.dir}/${base.sbs.log}.scan2.html">

                        <freemarkerLinks expandProperties="yes">

                            macro: ${helium.dir}/tools/common/templates/macro

                        </freemarkerLinks>

                        <data expandProperties="yes">

                            dbPath: ${metadata.dbfile}

                            logfilename: @{sbsLogFile}

                            ant: antProperties()

                        </data>

                    </fmpp>

                    <hlm:assertFileExists file="${build.log.dir}/${base.sbs.log}.scan2.html"/>

                    <echo message="generating signal" />                    

                    <hlm:compileLogSignalMacro compile.summary.file="@{sbsLogFile}" 

                        error.limit="${build.errors.limit}" phase="compile"/>

                    <!-- Blocks packaging configuration generation. -->

                    <if>

                        <istrue value="${blocks.enabled}" />

                        <then>

                            <mkdir dir="${blocks.config.dir}" />

                            <exec executable="python">

                                <arg value="-m"/>

                                <arg value="packager.cli"/>

                                <arg value="--epocroot=${build.drive}/" />

                                <arg value="--config=${blocks.config.dir}" />

                                <arg value="--datasource=sbs" />

                                <arg value="-Dsbslog=${sbs.log.file}" />

                                <arg value="-Dsysdef=${canonical.sysdef.file}" />

                                <arg value="-Dthreads=20" />

                                <arg value="--updateData" />

                            </exec>

                        </then>

                    </if>

                <else>

                    <echo>Could not find the sbs log: @{sbsLogFile}.</echo>

                </else>

    <!-- Uploads the SBS checksource results to Diamonds. -->

    <target name="sbs-checksource" if="build.system.sbs-any" />

</project>