build.generated.xml

<?xml version="1.0" encoding="UTF-8" ?>

<project name="build.generated">
    
        <target name="spoofaximp.default" depends="utils-files,sdf2table,ppgen,pppack,stratego.aster,stratego.ctree,sdf2imp,refresh"/>
    
        <!-- Initialization -->
        <available file="${trans}/${strmodule}.str" property="build.stratego.enabled"/>
        <dirname property="externaldefdir" file="${externaldef}"/>
        <condition property="externaldefimport" value="-I ${externaldefdir}" else="">
            <isset property="externaldef"/>
        </condition>
        <condition property="externaljarimport" value=":${externaljar}" else="">
            <isset property="externaljar"/>
        </condition>
        <condition property="build.compiler" value="org.eclipse.jdt.core.JDTCompilerAdapter">
            <isset property="eclipse.running"/>
        </condition>
        <condition property="externaljarflags" value="${externaljarflags}" else="">
            <isset property="externaljarflags"/>
        </condition>
        <mkdir dir="${build}"/>
        <mkdir dir="${src-gen}"/>
        <mkdir dir="${dist}"/>
        <mkdir dir="${include}"/>
        <mkdir dir="${lib}"/>
        <mkdir dir="${syntax}"/>

        <target name="sdf2imp" depends="sdf2table,sdf2imp.eclipse,sdf2imp.standalone"/>
        
        <target name="sdf2imp.eclipse" if="eclipse.running" depends="sdf2rtg">
            <java classname="org.strategoxt.imp.metatooling.building.AntDescriptorBuilder">
                <arg value="${include}/${esvmodule}.packed.esv"/>
            </java>
        </target>
        
        <target name="refresh" if="eclipse.running">
            <eclipse.convertPath fileSystemPath="${basedir}" property="projectdir"/>
            <eclipse.refreshLocal resource="${projectdir}/include" depth="infinite"/>
            <eclipse.refreshLocal resource="${projectdir}/syntax/${sdfmodule}.pp.generated" depth="infinite"/>
            <eclipse.refreshLocal resource="${projectdir}/lib/editor-common.generated.str" depth="infinite"/>
            <eclipse.refreshLocal resource="${projectdir}/build.generated.xml" depth="infinite"/>
            <eclipse.refreshLocal resource="${projectdir}/editor/${sdfmodule}-Builders.generated.esv" depth="infinite"/>
            <eclipse.refreshLocal resource="${projectdir}/editor/${sdfmodule}-Colorer.generated.esv" depth="infinite"/>
            <eclipse.refreshLocal resource="${projectdir}/editor/${sdfmodule}-Completions.generated.esv" depth="infinite"/>
            <eclipse.refreshLocal resource="${projectdir}/editor/${sdfmodule}-Folding.generated.esv" depth="infinite"/>
            <eclipse.refreshLocal resource="${projectdir}/editor/${sdfmodule}-References.generated.esv" depth="infinite"/>
            <eclipse.refreshLocal resource="${projectdir}/editor/${sdfmodule}-Syntax.generated.esv" depth="infinite"/>
        </target>
        
        <target name="sdf2imp.standalone" unless="eclipse.running" depends="sdf2rtg">
            <java classname="org.strategoxt.imp.generator.sdf2imp" failonerror="true">
                <arg value="-i"/>
                <arg value="${basedir}/editor/${esvmodule}.main.esv"/>
                <arg value="-p"/>
                <arg value="${include}/${sdfmodule}.tbl"/>
            </java>
        </target>
    
        <target name="sdf2table" depends="make-permissive">
            <apply executable="${build.strategoxt.sdf}sdf2table" dest="${include}" failonerror="true">
                <arg value="-i"/>
                <srcfile/>
                <arg value="-o"/>
                <targetfile/>
                <arg value="-m"/>
                <arg value="${sdfmodule}"/>
                
                <fileset file="${include}/${sdfmodule}-Permissive.def"/>
                <mapper type="glob" from="*-Permissive.def" to="*.tbl"/>
            </apply>
        </target>
        
        <target name="make-permissive" depends="pack-sdf,copy-sdf">
            <dependset>
                <srcfileset file="${include}/${sdfmodule}.def"/>
                <targetfileset file="${include}/${sdfmodule}-Permissive.def"/>
            </dependset>
            <available file="${include}/${sdfmodule}-Permissive.def" property="permissive-grammar.available"/>
            <antcall target="make-permissive.helper"/>
        </target>
    
        <target name="make-permissive.helper" unless="permissive-grammar.available">
            <java classname="org.strategoxt.permissivegrammars.make_permissive" failonerror="true">
                <arg value="-i"/>
                <arg value="${include}/${sdfmodule}.def"/>
                <arg value="-o"/>
                <arg value="${include}/${sdfmodule}-Permissive.def"/>
                <arg line="--optimize on"/>
            </java>
        </target>

        <target name="utils-files">
            <mkdir dir="utils"/>
            <copy file="${eclipse.spoofaximp.jars}/make_permissive.jar" todir="utils" failonerror="false"/>
            <copy file="${eclipse.spoofaximp.jars}/sdf2imp.jar" todir="utils" failonerror="false"/>
            <copy file="${eclipse.spoofaximp.jars}/aster.jar" todir="utils" failonerror="false"/>
            <copy file="${eclipse.spoofaximp.strategojar}" todir="utils" failonerror="false"/>
        </target>
    
        <target name="pack-sdf" unless="externaldef">
            <dependset>
                <srcfileset dir="${syntax}">
                    <include name="**/*.sdf"/>
                </srcfileset>
                <targetfileset file="${include}/${sdfmodule}.def"/>
            </dependset>
            <available file="${include}/${sdfmodule}.def" property="pack-sdf.available"/>
            <antcall target="pack-sdf.helper"/>
        </target>
    
        <target name="pack-sdf.helper" unless="pack-sdf.available">
            <java classname="run" failonerror="true">
                <arg value="org.strategoxt.tools.main-pack-sdf"/>
                <arg value="-i"/>
                <arg value="${syntax}/${sdfmodule}.sdf"/>
                <arg value="-o"/>
                <arg value="${include}/${sdfmodule}.def"/>
                <arg value="-I"/>
                <arg value="${syntax}"/>
                <arg value="-I"/>
                <arg value="${lib}"/>
                <arg line="${build.sdf.imports}"/>
            </java>
        </target>
    
        <target name="copy-sdf" if="externaldef">
            <copy file="${externaldef}" tofile="${include}/${sdfmodule}.def" preservelastmodified="true"/>
        </target>
    
        <target name="copy-jar" if="externaljar">
            <copy file="${externaljar}" todir="${include}" preservelastmodified="true"/>
        </target>
    
        <target name="rtg2sig" if="build.stratego.enabled" depends="sdf2rtg">
            <dependset>
                <srcfileset file="${include}/${sdfmodule}.rtg"/>
                <targetfileset file="${include}/${sdfmodule}.str"/>
            </dependset>
            <available file="${include}/${sdfmodule}.str" property="rtg2sig.available"/>
            <antcall target="rtg2sig.helper"/>
        </target>
    
        <target name="rtg2sig.helper" unless="rtg2sig.available">
            <java classname="run" failonerror="true">
                <arg value="org.strategoxt.tools.main-rtg2sig"/>
                <arg value="-i"/>
                <arg value="${include}/${sdfmodule}.rtg"/>
                <arg value="-o"/>
                <arg value="${include}/${sdfmodule}.str"/>
                <arg value="--module"/>
                <arg value="${sdfmodule}"/>
            </java>
        </target>
        
        <target name="sdf2rtg" depends="pack-sdf,copy-sdf">
            <dependset>
                <srcfileset file="${include}/${sdfmodule}.def"/>
                <targetfileset file="${include}/${sdfmodule}.rtg"/>
            </dependset>
            <available file="${include}/${sdfmodule}.rtg" property="sdf2rtg.available"/>
            <antcall target="sdf2rtg.helper"/>
        </target>
    
        <target name="sdf2rtg.helper" unless="sdf2rtg.available">
            <java classname="run" failonerror="true">
                <arg value="org.strategoxt.tools.main-sdf2rtg"/>
                <arg value="-i"/>
                <arg value="${include}/${sdfmodule}.def"/>
                <arg value="-m"/>
                <arg value="${sdfmodule}"/>
                <arg value="-o"/>
                <arg value="${include}/${sdfmodule}.rtg"/>
                <arg value="--ignore-missing-cons"/>
                <arg value="-Xnativepath"/>
                <arg value="${build.strategoxt.sdf}"/>
            </java>
        </target>
        
        <target name="ppgen" if="build.stratego.enabled" depends="pack-sdf">
            <dependset>
                <srcfileset file="${include}/${sdfmodule}.def"/>
                <targetfileset file="${syntax}/${sdfmodule}.generated.pp"/>
                <targetfileset file="${include}/${sdfmodule}.generated.pp.af"/>
            </dependset>
            <available file="${include}/${sdfmodule}.generated.pp.af" property="ppgen.available"/>
            <antcall target="ppgen.helper"/>
            <available file="${include}/${sdfmodule}.generated.pp.af" property="ppgen.available"/>
            <antcall target="ppgen.helper.fallback"/>
        </target>
    
        <target name="ppgen.helper" unless="ppgen.available">
            <!-- Any failures here are ignored; they are only a problem when imported from Stratego -->
            <java classname="run" failonerror="false">
                <arg value="org.strategoxt.tools.main-ppgen"/>
                <arg value="-i"/>
                <arg value="${include}/${sdfmodule}.def"/>
                <arg value="-o"/>
                <arg value="${include}/${sdfmodule}.generated.pp.af"/>
                <arg value="-t"/>
            </java>
            <java classname="run" failonerror="false">
                <arg value="org.strategoxt.tools.main-pp-pp-table"/>
                <arg value="-i"/>
                <arg value="${include}/${sdfmodule}.generated.pp.af"/>
                <arg value="-o"/>
                <arg value="${syntax}/${sdfmodule}.generated.pp"/>
            </java>
        </target>
    
        <target name="ppgen.helper.fallback" unless="ppgen.available">
            <echo file="${include}/${sdfmodule}.generated.pp.af" message="PP-Table([])"/>
        </target>
        
        <target name="pppack" if="build.stratego.enabled" depends="pack-sdf">
            <dependset>
                <srcfileset file="${syntax}/${sdfmodule}.pp"/>
                <targetfileset file="${include}/${sdfmodule}.pp.af"/>
            </dependset>
            <available file="${syntax}/${sdfmodule}.pp" property="pppack.source-available"/>
            <available file="${include}/${sdfmodule}.pp.af" property="pppack.available"/>
            <antcall target="pppack.helper"/>
            <available file="${include}/${sdfmodule}.pp.af" property="pppack.available"/>
            <antcall target="pppack.helper.fallback"/>
        </target>
    
        <target name="pppack.helper" unless="pppack.available" if="pppack.source-available">
            <java classname="run" failonerror="true">
                <arg value="org.strategoxt.tools.main-parse-pp-table"/>
                <arg value="-i"/>
                <arg value="${syntax}/${sdfmodule}.pp"/>
                <arg value="-o"/>
                <arg value="${include}/${sdfmodule}.pp.af"/>
            </java>
        </target>
    
        <target name="pppack.helper.fallback" unless="pppack.available">
            <echo file="${include}/${sdfmodule}.pp.af" message="PP-Table([])"/>
        </target>
    
        <!-- Aster to Stratego -->
        <target name="stratego.aster">
            <available file="${trans}/${strmodule}.rtree" property="aster-output.available"/>
            <dependset>
                <srcfileset dir="${basedir}">
                    <include name="**/*.astr"/>
                </srcfileset>
                <targetfileset file="${trans}/${strmodule}.rtree"/>
            </dependset>
            <condition property="aster-output.uptodate">
                <and>
                    <isset property="aster-output.available"/>
                    <available file="${trans}/${strmodule}.rtree"/>
                </and>
            </condition>
            <available file="${trans}/${strmodule}.rtree" property="aster-output.uptodate"/>
            <antcall target="stratego.aster.helper"/>
        </target>
    
        <target name="stratego.aster.helper" unless="aster-output.uptodate">
            <apply executable="java" failonerror="true">
                <arg line="-Xss8m -Xmx768m -client -jar utils/aster.jar"/>
                <arg value="-i"/>
                <fileset dir="${basedir}">
                    <include name="**/*.astr"/>
                </fileset>
            </apply>
        </target>
    
        <!-- Stratego to Java interpreter -->
        <target name="stratego.ctree" depends="rtg2sig">
            <dependset>
                <srcfileset dir="${basedir}">
                    <include name="**/*.str"/>
                    <include name="**/*.astr"/>
                    <exclude name="lib/editor-common.generated.str"/>
                </srcfileset>
                <targetfileset file="${include}/${strmodule}.ctree"/>
            </dependset>
            <available file="${include}/${strmodule}.ctree" property="strc-java.available"/>
            <antcall target="copy-jar"/>
            <antcall target="stratego.jvm.helper">
                <param name="build.stratego.outputpath" value="${include}"/>
                <param name="build.stratego.extraargs" value="-F"/>
                <param name="build.stratego.extension" value="ctree"/>
                <param name="build.stratego.compiler" value="strc"/>
            </antcall>
        </target>
    
        <!-- Stratego to Java compiler -->
        <target name="stratego.jar" depends="rtg2sig">
            <dependset>
                <srcfileset dir="${basedir}">
                    <include name="**/*.str"/>
                    <include name="**/*.astr"/>
                    <exclude name="lib/editor-common.generated.str"/>
                </srcfileset>
                <targetfileset file="${src-gen}/trans/Main.java"/>
            </dependset>
            <available file="${src-gen}/trans/Main.java" property="strc-java.available"/>
            <antcall target="copy-jar"/>
            <antcall target="stratego.jvm.helper">
                <param name="build.stratego.outputpath" value="${src-gen}/trans"/>
                <param name="build.stratego.extraargs" value="-la java-front"/>
                <param name="build.stratego.extension" value="java"/>
            </antcall>
            <javac classpath="utils/strategoxt.jar:${src-gen}${externaljarimport}" srcdir="${src-gen}" includes="trans/**" destdir="${build}" source="1.5" target="1.5" debug="on"/>
            <jar basedir="${build}" includes="trans/**" destfile="${include}/${strmodule}.jar"/>
        </target>
            
        <target name="stratego.jvm.helper" unless="strc-java.available" if="build.stratego.enabled">
            <delete file="${include}/${strmodule}.rtree" failonerror="false"/>
            <java classname="org.strategoxt.strj.Main" failonerror="true">
                <arg value="-i"/>
                <arg value="${trans}/${strmodule}.str"/>
                <arg value="-o"/>
                <arg value="${build.stratego.outputpath}/${strmodule}.${build.stratego.extension}"/>
                <arg value="-p"/>
                <arg value="trans"/>
                <arg value="--library"/>
                <arg value="--clean"/>
                <arg line="${build.stratego.args}"/>
                <arg line="${build.stratego.extraargs}"/>
                <arg line="${externaljarflags}"/>
                <arg line="${externaldefimport}"/>
            </java>
            <delete file="${include}/${strmodule}.rtree" failonerror="false"/>
            <mkdir dir="${build}/trans"/>
        </target>
                
        <!-- Stratego to C-based native executable -->
        <target name="stratego.c">
            <antcall target="stratego.c.helper">
                <param name="build.stratego.outputpath" value="${basedir}/include"/>
                <param name="build.stratego.extraargs" value=""/>
                <param name="build.stratego.extension" value=""/>
                <param name="build.stratego.compiler" value="strc"/>
            </antcall>
        </target>
        
        <!-- Helper target for calling the stratego compiler -->
        <target name="stratego.c.helper" depends="rtg2sig" if="build.stratego.enabled">
            <apply executable="${build.strategoxt.stratego}/${build.stratego.compiler}" dest="${build.stratego.outputpath}" failonerror="true">
                <arg value="-i"/>
                <srcfile/>
                <arg value="-o"/>
                <targetfile/>
                <arg line="${build.stratego.args}"/>
                <arg line="${build.stratego.extraargs}"/>
                <arg line="${externaldefimport}"/>
                
                <fileset file="${trans}/${strmodule}.str"/>
                <mapper type="glob" from="*.str" to="*.${build.stratego.extension}"/>
            </apply>
        </target>
        
        <target name="clean" description="clean up">
            <delete dir="${build}"/>
            <delete file="${src-gen}/trans/Main.java"/>
        </target>
    </project>