Changeset 3660

Show
Ignore:
Timestamp:
04/22/09 07:40:27 (7 months ago)
Author:
dr2chase
Message:

It is supposed to generate code for overloaded natives, but the code is not coming out.

Location:
trunk
Files:
6 modified

Legend:

Unmodified
Added
Removed

  • trunk/ProjectFortress/ant

    r3538 r3660  
    1818################################################################################ 
    1919 
    20 # 
    21 # For NetBeans, you should not need to adjust anything to 
    22 # build and test Fortress. 
    23 # 
    24 # For Eclipse, workspace and ant builds should not require any 
    25 # adjustments, but to run tests using Ant within Eclipse, you 
    26 # will need to add junit.jar to 
    27 # build.xml -> Run As -> Ant Build... -> Classpath -> User Entries -> Add JARs... 
    28 # 
    29  
    30 find_ant(){ 
    31   # Strip "." from the path, and look for ant. 
    32   # This avoids infinite regress if this is the first or only "ant" on the normal PATH. 
    33   export NODOTPATH="`echo "$PATH" | sed -e '1,$s/^[.]://g'`" 
    34   NODOTPATH="`echo "$NODOTPATH" | sed -e '1,$s/:[.]:/:/g'`" 
    35   NODOTPATH="`echo "$NODOTPATH" | sed -e '1,$s/:[.]$//g'`" 
    36   result="`(PATH="$NODOTPATH" which ant 2>/dev/null)`" 
    37   if [ -z "$result" ]; then 
    38     echo "Could not find ant. You need to install it. See http://ant.apache.org/ for details." >&2 
    39     exit 1 
    40   fi 
    41   echo $result 
    42   exit 0 
    43 } 
    44  
    45 ant_exec="`find_ant`" 
    46 n=$? 
    47 if [ $n -ne 0 ]; then 
    48         exit $n 
    49 fi 
    50  
    51 # Note that the scripts reference must export their symbols so that they are available below. 
    52 . ../antrc_suggested 
    53  
    54 "$ant_exec" -noclasspath "$@" 
     20cd .. 
     21exec ./ant "$@" 

  • trunk/ProjectFortress/build.xml

    r3657 r3660  
    2222CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    2323 
    24 This is the main Ant build file for the Fortress reference 
    25 implementation. Declarations are separated by type (e.g., taskdefs, 
    26 properties, targets, etc.). To add a new declaration, please find the 
    27 appropriate place in the file. For the sake of readability, please 
    28 maintain proper indentation. 
    2924--> 
    30  
    31 <!-- 
    32 THIS FILE IS DEPRECATED. 
    33 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    34 --> 
    35  
    36 <project name="Fortress" default="help"> 
    37   <description> 
    38     A reference implementation of the Fortress programming language. 
    39   </description> 
    40  
    41  
    42   <!-- 
    43        Properties 
    44   --> 
    45  
    46   <!-- Global properties for this build. --> 
    47   <property name="packagePrefix" value="com/sun/fortress"/> 
    48   <property name="package.prefix" value="com.sun.fortress"/> 
    49   <property name="interpreterPrefix" value="com/sun/fortress/interpreter"/> 
    50   <property name="interpreter.prefix" value="com.sun.fortress.interpreter"/> 
    51   <property name="blahblahblah" value="com/sun/fortress"/> 
    52  
    53 <!-- 
    54 THIS FILE IS DEPRECATED. 
    55 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    56 --> 
    57   <!-- Directories in the ${basedir} directory --> 
    58   <property name="cache0" location="${basedir}/../default_repository/caches"/> 
    59   <property name="cache1" location="${basedir}/../.fortress_cache"/> 
    60   <property name="cache2" location="${basedir}/../.interpreter_cache"/> 
    61   <property name="cache3" location="${basedir}/.interpreter_cache"/> 
    62   <property name="cache4" location="${basedir}/../.syntax_cache"/> 
    63   <property name="cache5" location="${basedir}/.syntax_cache"/> 
    64   <property name="cache6" location="${basedir}/../.analyzed_cache"/> 
    65   <property name="cache7" location="${basedir}/.analyzed_cache"/> 
    66   <property name="cache8" location="${basedir}/../.presyntax_cache"/> 
    67   <property name="cache9" location="${basedir}/.presyntax_cache"/> 
    68   <property name="cache10" location="${basedir}/../.bytecode_cache"/> 
    69   <property name="cache11" location="${basedir}/.bytecode_cache"/> 
    70   <property name="cache12" location="${basedir}/../local_repository/caches"/> 
    71   <property name="astgen.src" location="${basedir}/astgen"/> 
    72   <property name="build" location="${basedir}/build"/> 
    73   <property name="docs" location="${basedir}/docs"/> 
    74   <property name="src" location="${basedir}/src"/> 
    75   <property name="library" location="${basedir}/../Library"/> 
    76   <property name="astgen.generators.src" 
    77             location="${src}/${packagePrefix}/astgen"/> 
    78  
    79 <!-- 
    80 THIS FILE IS DEPRECATED. 
    81 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    82 --> 
    83   <!-- Third party jar files --> 
    84   <property name="asm" location="${basedir}/third_party/asm"/> 
    85   <property name="astgen.third" location="${basedir}/third_party/astgen"/> 
    86   <property name="jsr166y" location="${basedir}/third_party/jsr166y"/> 
    87   <property name="junit" location="${basedir}/third_party/junit"/> 
    88   <property name="plt" location="${basedir}/third_party/plt"/> 
    89   <property name="unicode.third" location="${basedir}/third_party/unicode"/> 
    90   <property name="xtc" location="${basedir}/third_party/xtc"/> 
    91   <property name="unsigned" location="${basedir}/third_party/unsigned"/> 
    92  
    93   <!-- Scala jar files --> 
    94   <property name="scala-compiler.jar" 
    95             value="${basedir}/third_party/scala/scala-compiler-2.7.2.jar"/> 
    96   <property name="scala-library.jar" 
    97             value="${basedir}/third_party/scala/scala-library-2.7.2.jar"/> 
    98  
    99 <!-- 
    100 THIS FILE IS DEPRECATED. 
    101 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    102 --> 
    103   <!-- ASTGen --> 
    104   <property name="generate-sourcefile" value="${astgen.src}/Fortress.ast" /> 
    105  
    106   <!-- Package nodes --> 
    107   <property name="nodesPackage" value="${packagePrefix}/nodes"/> 
    108   <property name="scala.nodes.package" value="${packagePrefix}/scala_src/nodes"/> 
    109   <property name="nodes"  location="${src}/${nodesPackage}"/> 
    110   <property name="scala.nodes"  location="${src}/${scala.nodes.package}"/> 
    111   <property name="nodesBuild" location="${build}/${nodesPackage}"/> 
    112  
    113   <!-- Package nodes_util --> 
    114   <property name="nodesUtil"  location="${src}/${packagePrefix}/nodes_util"/> 
    115  
    116 <!-- 
    117 THIS FILE IS DEPRECATED. 
    118 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    119 --> 
    120   <!-- Parser packages --> 
    121   <property name="parser"  location="${src}/${packagePrefix}/parser"/> 
    122   <property name="preparser" location="${src}/${packagePrefix}/parser/preparser"/> 
    123   <property name="importcollector" location="${src}/${packagePrefix}/parser/import_collector"/> 
    124   <property name="templateparser" 
    125             location="${src}/${packagePrefix}/parser/templateparser"/> 
    126   <property name="parserUtil"  location="${src}/${packagePrefix}/parser_util"/> 
    127   <property name="precedence" location="${parserUtil}/precedence"/> 
    128   <property name="precedenceResolver" 
    129             location="${parserUtil}/precedence_resolver"/> 
    130  
    131 <!-- 
    132 THIS FILE IS DEPRECATED. 
    133 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    134 --> 
    135   <!-- Unicode packages --> 
    136   <property name="unicodePackage" value="${packagePrefix}/unicode"/> 
    137   <property name="unicode" location="${src}/${packagePrefix}/unicode"/> 
    138   <property name="unicodeBuild" location="${build}/${unicodePackage}"/> 
    139  
    140   <!-- Package useful --> 
    141   <property name="usefulPackage" value="${packagePrefix}/useful"/> 
    142  
    143   <!-- For fortress installation --> 
    144   <property name="testFortress" location=".TEST_FORTRESS"/> 
    145   <property name="installerDir" location=".installer"/> 
    146   <property name="protofortress" location="${basedir}/fortress/FORTRESS"/> 
    147   <property name="protofortress.lib" location="${protofortress}/lib"/> 
    148  
    149 <!-- 
    150 THIS FILE IS DEPRECATED. 
    151 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    152 --> 
    153   <!-- Instrumentation --> 
    154   <property name="instrumentation.package" 
    155             value="${package.prefix}.parser_util.instrumentation"/> 
    156   <property name="instrumentationPackage" 
    157             value="${packagePrefix}/parser_util/instrumentation"/> 
    158   <property name="instrumentation.outfile" 
    159             location="${parserUtil}/instrumentation/coverage-report.txt"/> 
    160   <property name="instrumentation.transient" 
    161             location="${parserUtil}/instrumentation/transient.txt"/> 
    162  
    163   <!-- For tests --> 
    164   <property name="test.results" location="${basedir}/TEST-RESULTS"/> 
    165  
    166 <!-- 
    167 THIS FILE IS DEPRECATED. 
    168 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    169 --> 
    170   <!-- Other settings --> 
    171   <property name="junitMem" value="768m"/> 
    172   <property name="junit.dir" value="junit-results"/> 
    173   <property name="javaSourceVersion" value="1.5"/> 
    174   <property environment="env"/> 
    175   <condition property="correct.environment"> 
    176     <and> 
    177       <equals arg1="${ant.java.version}" arg2="1.6"/> 
    178       <equals arg1="${env.ANT_CALLED_FROM_SCRIPT}" arg2='yes'/> 
    179     </and> 
    180   </condition> 
    181  
    182  
    183   <!-- 
    184        Paths 
    185   --> 
    186 <!-- 
    187 THIS FILE IS DEPRECATED. 
    188 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    189 --> 
    190   <path id="scala.classpath"> 
    191     <pathelement location="${scala-compiler.jar}"/> 
    192     <pathelement location="${scala-library.jar}"/> 
    193   </path> 
    194  
    195   <path id="astgen.path"> 
    196     <path refid="scala.classpath"/> 
    197     <pathelement location="${astgen.third}/astgen.jar" /> 
    198     <pathelement location="${build}" /> 
    199   </path> 
    200  
    201 <!-- 
    202 THIS FILE IS DEPRECATED. 
    203 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    204 --> 
    205   <path id="astgen.classpath"> 
    206     <path refid="scala.classpath"/> 
    207     <pathelement location="${build}"/> 
    208     <pathelement location="${astgen.third}/astgen.jar"/> 
    209   </path> 
    210  
    211   <path id="instrumentedparser.classpath"> 
    212     <path refid="scala.classpath"/> 
    213     <pathelement location="${build}"/> 
    214     <pathelement location="${xtc}/xtc.jar"/> 
    215     <pathelement location="${plt}/plt.jar"/> 
    216   </path> 
    217  
    218 <!-- 
    219 THIS FILE IS DEPRECATED. 
    220 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    221 --> 
    222   <path id="compile.classpath"> 
    223     <path refid="scala.classpath"/> 
    224     <pathelement location="${build}"/> 
    225     <pathelement location="${asm}/asm-3.1.jar"/> 
    226     <pathelement location="${asm}/asm-tree-3.1.jar"/> 
    227     <pathelement location="${xtc}/xtc.jar"/> 
    228     <pathelement location ="${unsigned}/unsigned.jar"/> 
    229     <pathelement location="${jsr166y}/jsr166y.jar"/> 
    230     <pathelement location="${plt}/plt.jar"/> 
    231     <pathelement location="${astgen.third}/astgen.jar" /> 
    232     <pathelement location="${junit}/junit.jar"/> 
    233     <pathelement location="${ant.home}/lib/ant.jar"/> 
    234     <pathelement location="${java.home}/../lib/tools.jar"/> 
    235   </path> 
    236  
    237   <!-- 
    238        Taskdefs 
    239   --> 
    240   <taskdef resource="scala/tools/ant/antlib.xml"> 
    241     <classpath refid="scala.classpath"/> 
    242   </taskdef> 
    243  
    244  
    245   <!-- 
    246        Targets 
    247   --> 
    248 <!-- 
    249 THIS FILE IS DEPRECATED. 
    250 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    251 --> 
    252   <target name="help"> 
    253     <echo message="ant checkEnv, checkNodesUptodate, checkOperatorsUptodate, 
    254                    checkParserUptodate, clean, cleanCache, compileJava, compileAll, 
    255                    compileCommon, compileCommonLint, compileLint, doc, 
    256                    grammarCoverage, help, init, interpreter-jar, 
    257                    makeAST, operatorsGen, fortressparser, preparser, 
    258                    parser, reportNotPassing, systemProperties, test, 
    259                    testAll, testDemos, testSystem, testOnly 
    260                    -DtestPattern='some pattern', testCruiseControl"/> 
    261     <echo message="If you are building Fortress, you want ant compile or ant test."/> 
    262   </target> 
    263  
    264   <target name="systemProperties"> 
    265     <echo message="Environment variables set correctly? ${correct.environment}"/> 
    266     <echo message="basedir: ${basedir}"/> 
    267     <echo message="Ant Java version: ${ant.java.version}"/> 
    268     <echo message="Ant called from script? ${env.ANT_CALLED_FROM_SCRIPT}"/> 
    269     <echo message="ANT_ARGS: ${env.ANT_ARGS}"/> 
    270     <echo message="ANT_OPTS: ${env.ANT_OPTS}"/> 
    271     <echo message="Scala version: ${scalac.version}" /> 
    272     <echo message="Java Runtime Environment 
    273                    version: ${java.version}"/> 
    274     <echo message="Java Runtime Environment 
    275                    vendor: ${java.vendor}"/> 
    276     <echo message="Java Runtime Environment 
    277                    vendor URL: ${java.vendor.url}"/> 
    278     <echo message="Java installation 
    279                    directory: ${java.home}"/> 
    280     <echo message="Java Virtual Machine 
    281                    specification version: 
    282                    ${java.vm.specification.version}"/> 
    283     <echo message="Java Virtual Machine 
    284                    specification vendor: 
    285                    ${java.vm.specification.vendor}"/> 
    286     <echo message="Java Virtual Machine 
    287                    specification name: 
    288                    ${java.vm.specification.name}"/> 
    289     <echo message="Java Virtual Machine 
    290                    implementation version: 
    291                    ${java.vm.version}"/> 
    292     <echo message="Java Virtual Machine 
    293                    implementation vendor: 
    294                    ${java.vm.vendor}"/> 
    295     <echo message="Java Virtual Machine 
    296                    implementation name: ${java.vm.name}"/> 
    297     <echo message="Java Runtime Environment 
    298                    specification version: 
    299                    ${java.specification.version}"/> 
    300     <echo message="Java Runtime Environment 
    301                    specification vendor: 
    302                    ${java.specification.vendor}"/> 
    303     <echo message="Java Runtime Environment 
    304                    specification name: 
    305                    ${java.specification.name}"/> 
    306     <echo message="Java class format version 
    307                    number: ${java.class.version}"/> 
    308     <echo message="Java class path: 
    309                    ${java.class.path}"/> 
    310     <echo message="List of paths to search when 
    311                    loading libraries: ${java.library.path}"/> 
    312     <echo message="Path of extension directory 
    313                    or directories: ${java.ext.dirs}"/> 
    314     <echo message="Default temp file path: 
    315                    ${java.io.tmpdir}"/> 
    316     <echo message="Operating system name: 
    317                    ${os.name}"/> 
    318     <echo message="Operating system 
    319                    architecture: ${os.arch}"/> 
    320     <echo message="Operating system version: 
    321                    ${os.version}"/> 
    322   </target> 
    323  
    324 <!-- 
    325 THIS FILE IS DEPRECATED. 
    326 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    327 --> 
    328   <target name="checkEnv"> 
    329     <echo message="Environment variables set correctly? ${correct.environment}"/> 
    330     <fail unless="correct.environment" 
    331           message="ERROR: This build script requires specific command-line arguments to Ant. Please call it using the script provided at ${basedir}/ant."/> 
    332   </target> 
    333  
    334   <target name="init"> 
    335     <echo message="basedir: ${basedir}"/> 
    336     <!-- Create the time stamp. --> 
    337     <tstamp/> 
    338     <!-- Create the build directory structure used by compile. --> 
    339     <mkdir dir="${build}"/> 
    340     <mkdir dir="${junit.dir}"/> 
    341   </target> 
    342  
    343 <!-- 
    344 THIS FILE IS DEPRECATED. 
    345 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    346 --> 
    347   <target name="cleanAst" depends="cleanCache" 
    348           description="Delete the ${nodes} directory tree and cached asts."> 
    349     <delete dir="${nodes}"/> 
    350   </target> 
    351  
    352   <target name="clean" depends="cleanAst" 
    353           description="Delete the ${build} directory tree and generated files."> 
    354     <delete dir="${build}"/> 
    355     <delete dir="${nodes}"/> 
    356     <delete dir="${junit.dir}"/> 
    357  
    358     <!-- No longer needed, but eases the upgrade--> 
    359     <delete file="${nodesUtil}/BaseNodeMaker.java"/> 
    360     <!-- No longer needed, but eases the upgrade--> 
    361     <delete file="${nodesUtil}/InterfaceMaker.java"/> 
    362     <delete file="${parser}/Fortress.java"/> 
    363     <delete file="${parser}/FortressInstrumented.java"/> 
    364     <delete file="${preparser}/PreFortress.java"/> 
    365     <delete file="${importcollector}/ImportCollector.java"/> 
    366     <delete file="${templateparser}/TemplateParser.java"/> 
    367     <delete file="${precedenceResolver}/Operators.java"/> 
    368     <!-- No longer needed, but eases the upgrade--> 
    369     <delete file="${src}/com/sun/fortress/parser/precedence/resolver/Operators.java"/> 
    370     <delete file="${instrumentation.outfile}"/> 
    371     <delete file="${library}/FortressAst.fsi" /> 
    372     <delete file="${library}/FortressAst.fss" /> 
    373     <delete file="${astgen.src}/FortressAst.scala" /> 
    374     <delete file="FortressLibrary.ast"/> 
    375     <delete file="FortressLibrary.tfs"/> 
    376     <delete file="${basedir}/tests/printing/test_output.txt" /> 
    377     <delete file="testFile.txt"/> 
    378     <delete file="${src}/com/sun/fortress/scala_src/nodes/FortressAst.scala" /> 
    379     <delete dir="${src}/com/sun/fortress/scalasrc" /> 
    380     <delete dir="${basedir}/test-tmp" /> 
    381     <delete> 
    382       <fileset dir="src" includes="**/*.class" /> 
    383     </delete> 
    384   </target> 
    385  
    386 <!-- 
    387 THIS FILE IS DEPRECATED. 
    388 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    389 --> 
    390   <target name="cleanCache" 
    391           description="Delete any cached Fortress ASTs in the development tree"> 
    392     <delete dir="${cache0}"/> 
    393     <delete dir="${cache1}"/> 
    394     <delete dir="${cache2}"/> 
    395     <delete dir="${cache3}"/> 
    396     <delete dir="${cache4}"/> 
    397     <delete dir="${cache5}"/> 
    398     <delete dir="${cache6}"/> 
    399     <delete dir="${cache7}"/> 
    400     <delete dir="${cache8}"/> 
    401     <delete dir="${cache9}"/> 
    402     <delete dir="${cache10}"/> 
    403     <delete dir="${cache11}"/> 
    404     <delete dir="${cache12}"/> 
    405   </target> 
    406  
    407 <!-- 
    408 THIS FILE IS DEPRECATED. 
    409 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    410 --> 
    411   <!-- Generation of Operators.java depends only on the files listed below. 
    412        Note that there are class files it depends on; if these class files are 
    413        not up to date with respect to their sources, they are themselves 
    414        recompiled by the compileCommon target.--> 
    415   <target name="checkOperatorsUptodate" depends="init, compileCommon"> 
    416     <condition property="operators.uptodate"> 
    417       <and> 
    418         <uptodate srcfile="${unicode.third}/UnicodeData.500.txt" 
    419                   targetfile="${precedenceResolver}/Operators.java"/> 
    420         <uptodate srcfile="${precedenceResolver}/operators.txt" 
    421                   targetfile="${precedenceResolver}/Operators.java"/> 
    422         <uptodate srcfile="${unicodeBuild}/OperatorStuffGenerator.class" 
    423                   targetfile="${precedenceResolver}/Operators.java"/> 
    424         <uptodate srcfile="${unicodeBuild}/Element.class" 
    425                   targetfile="${precedenceResolver}/Operators.java"/> 
    426       </and> 
    427     </condition> 
    428     <echo message="Operators up to date? ${operators.uptodate}"/> 
    429   </target> 
    430  
    431 <!-- 
    432 THIS FILE IS DEPRECATED. 
    433 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    434 --> 
    435   <target name="operatorsGen"  unless="operators.uptodate" 
    436           depends="init, compileCommon, checkOperatorsUptodate" 
    437           description="Automatically generate visitors for AST nodes."> 
    438     <echo message="Regenerating operators"/> 
    439     <java classname="${package.prefix}.unicode.OperatorStuffGenerator" 
    440           fork="true"> 
    441       <classpath> 
    442         <pathelement location="${build}"/> 
    443         <pathelement location="${basedir}/third_party/plt/plt.jar"/> 
    444       </classpath> 
    445     </java> 
    446   </target> 
    447  
    448   <target name="DumpProperties" 
    449           description="Dump properties as seen by a Java program."> 
    450     <java classname="${package.prefix}.repository.DumpProperties" 
    451           fork="true"> 
    452       <sysproperty key="DEBUG" value="true"/> 
    453       <classpath> 
    454         <pathelement location="${build}"/> 
    455       </classpath> 
    456     </java> 
    457   </target> 
    458  
    459 <!-- 
    460 THIS FILE IS DEPRECATED. 
    461 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    462 --> 
    463   <target name="checkAstgen"> 
    464     <condition property="astgenerators.uptodate"> 
    465       <uptodate targetfile="${basedir}/build/com/sun/fortress/astgen/FortressAstGenerator.class"> 
    466         <srcfiles dir="${basedir}/src/com/sun/fortress/astgen/" includes="*.java"/> 
    467       </uptodate> 
    468     </condition> 
    469   </target> 
    470  
    471 <!-- 
    472 THIS FILE IS DEPRECATED. 
    473 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    474 --> 
    475   <target name="astGenerators" 
    476           unless="astgenerators.uptodate" 
    477           depends="init,checkAstgen" 
    478           description="Compile all ASTGen custom generators."> 
    479     <depend srcdir="${astgen.generators.src}" 
    480             destdir="${build}" 
    481             closure="yes" 
    482             cache="${basedir}/.dependencies"/> 
    483     <javac 
    484         srcdir="${astgen.generators.src}" 
    485         destdir="${build}" 
    486         source="${javaSourceVersion}" 
    487         debug="true" 
    488         includeantruntime="false" 
    489         fork="true" 
    490         memorymaximumsize="${junitMem}"> 
    491       <!-- Uncomment the following line to print unchecked warnings 
    492            (here and in the 'compileCommon' target. --> 
    493       <!-- <compilerarg value="-Xlint:unchecked"/> --> 
    494       <classpath refid="astgen.classpath"/> 
    495       <include name="**/*.java"/> 
    496       <exclude name="${usefulPackage}/*.java"/> 
    497       <exclude name="${unicodePackage}/*.java"/> 
    498     </javac> 
    499     <scalac 
    500         srcdir="${astgen.generators.src}" 
    501         destdir="${build}" 
    502         classpathref="astgen.classpath" 
    503         addparams="" 
    504         deprecation="yes"> 
    505       <include name="**/*.scala"/> 
    506       <exclude name="${usefulPackage}/*.scala"/> 
    507       <exclude name="${unicodePackage}/*.scala"/> 
    508     </scalac> 
    509   </target> 
    510  
    511 <!-- 
    512 THIS FILE IS DEPRECATED. 
    513 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    514 --> 
    515   <target name="checkNodesUptodate" depends="astGenerators"> 
    516     <condition property="nodes.uptodate"> 
    517       <and> 
    518         <available file="${nodes}/AbstractNode.java"/> 
    519         <uptodate srcfile="${astgen.src}/Fortress.ast" 
    520                   targetfile="${nodes}/AbstractNode.java"/> 
    521         <available file="${library}/FortressAst.fsi" /> 
    522         <uptodate srcfile="${astgen.src}/Fortress.ast" 
    523                   targetfile="${library}/FortressAst.fsi" /> 
    524         <available file="${library}/FortressAst.fss" /> 
    525         <uptodate srcfile="${astgen.src}/Fortress.ast" 
    526                   targetfile="${library}/FortressAst.fss" /> 
    527         <uptodate targetfile="${library}/FortressAst.fsi"> 
    528           <srcfiles dir="${basedir}/src/com/sun/fortress/astgen/" includes="**/*.java"/> 
    529         </uptodate> 
    530       </and> 
    531     </condition> 
    532     <echo message="Nodes up to date? ${nodes.uptodate}"/> 
    533   </target> 
    534  
    535 <!-- 
    536 THIS FILE IS DEPRECATED. 
    537 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    538 --> 
    539   <taskdef name="astgen" classpath="${astgen.third}/astgen.jar;${build}" 
    540            classname="edu.rice.cs.astgen.AntTask"/> 
    541  
    542 <!-- 
    543 THIS FILE IS DEPRECATED. 
    544 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    545 --> 
    546   <target name="makeAST" unless="nodes.uptodate" depends="checkNodesUptodate" 
    547           description="Automatically generate AST nodes."> 
    548     <echo message="Processing ${generate-sourcefile}" /> 
    549     <astgen file="${generate-sourcefile}" /> 
    550     <move todir="${nodes}"> 
    551       <fileset dir="${astgen.src}"> 
    552         <include name="**/*.java"/> 
    553         <exclude name="**/Fortress.ast"/> 
    554       </fileset> 
    555     </move> 
    556     <move todir="${library}"> 
    557       <fileset dir="${astgen.src}"> 
    558         <include name="FortressAst.fss" /> 
    559         <include name="FortressAst.fsi" /> 
    560       </fileset> 
    561     </move> 
    562     <move todir="${scala.nodes}"> 
    563       <fileset dir="${astgen.src}"> 
    564         <include name="FortressAst.scala" /> 
    565       </fileset> 
    566     </move> 
    567   </target> 
    568  
    569 <!-- 
    570 THIS FILE IS DEPRECATED. 
    571 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    572 --> 
    573   <target name="compileJava" depends="compileCommon, makeAST, parser, operatorsGen" 
    574           description="Compile all Fortress code written in Java (Scala code is ignored)."> 
    575     <depend srcdir="${src}" 
    576             destdir="${build}" 
    577             closure="yes" 
    578             cache="${basedir}/.dependencies"/> 
    579     <javac 
    580         srcdir="${src}" 
    581         destdir="${build}" 
    582         debug="true" 
    583         includeantruntime="false" 
    584         fork="true" 
    585         memorymaximumsize="${junitMem}"> 
    586       <!-- Uncomment the following line to print unchecked warnings 
    587            (here and in the 'compileCommon' target. --> 
    588       <!-- <compilerarg value="-Xlint:unchecked"/> --> 
    589       <classpath refid="compile.classpath"/> 
    590       <include name="**/*.java"/> 
    591       <exclude name="${usefulPackage}/*.java"/> 
    592       <exclude name="${unicodePackage}/*.java"/> 
    593     </javac> 
    594   </target> 
    595  
    596 <!-- 
    597 THIS FILE IS DEPRECATED. 
    598 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    599 --> 
    600   <target name="compileAll" depends="compileCommon, makeAST, parser, operatorsGen" 
    601           description="Compile all Fortress code."> 
    602     <scalac 
    603         srcdir="${src}" 
    604         destdir="${build}" 
    605         classpathref="compile.classpath" 
    606         deprecation="yes"> 
    607       <include name="**/*.java"/> 
    608       <include name="**/*.scala"/> 
    609       <exclude name="${usefulPackage}/*.java"/> 
    610       <exclude name="${unicodePackage}/*.java"/> 
    611     </scalac> 
    612     <javac 
    613         srcdir="${src}" 
    614         destdir="${build}" 
    615         debug="true" 
    616         includeantruntime="false" 
    617         fork="true" 
    618         memorymaximumsize="${junitMem}"> 
    619       <!-- Uncomment the following line to print unchecked warnings 
    620            (here and in the 'compileCommon' target. --> 
    621       <!-- <compilerarg value="-Xlint:unchecked"/> --> 
    622       <classpath refid="compile.classpath"/> 
    623       <include name="**/*.java"/> 
    624       <exclude name="${usefulPackage}/*.java"/> 
    625       <exclude name="${unicodePackage}/*.java"/> 
    626     </javac> 
    627   </target> 
    628  
    629 <!-- 
    630 THIS FILE IS DEPRECATED. 
    631 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    632 --> 
    633   <target name="compile" depends="compileAll"/> 
    634  
    635   <target name="check.blas" depends="init"> 
    636     <javac destdir="${build}" srcdir="${src}/com/sun/fortress/numerics"> 
    637       <classpath refid="compile.classpath"/> 
    638     </javac> 
    639  
    640     <java failonerror="true" 
    641           classname="com.sun.fortress.numerics.CheckBlasEnvironment"> 
    642       <classpath refid="compile.classpath"/> 
    643     </java> 
    644   </target> 
    645  
    646 <!-- 
    647 THIS FILE IS DEPRECATED. 
    648 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    649 --> 
    650   <target name="check.linux"> 
    651     <condition property="blas.islinux"> 
    652       <equals arg1="${os.name}" arg2="Linux" /> 
    653     </condition> 
    654   </target> 
    655  
    656   <target name="blas.linux" depends="check.linux" if="blas.islinux"> 
    657     <echo message="Generating C header and stub files." /> 
    658     <javah class="com.sun.fortress.numerics.Blas" 
    659            destdir="c" 
    660            classpath="build" 
    661            /> 
    662     <echo message="Now compiling C stubs for blas on arch linux."/> 
    663     <exec executable="gcc" failonerror="true"> 
    664       <arg value="-fPIC" /> 
    665       <arg value="-Ic" /> 
    666       <arg value="-I${env.BLAS_INCLUDE}" /> 
    667       <arg value="-L${env.BLAS_LIB}" /> 
    668       <arg value="-I${env.JAVA_HOME}/include" /> 
    669       <arg value="-I${env.JAVA_HOME}/include/linux" /> 
    670       <arg value="c/blas.c" /> 
    671       <arg value="-lcblas" /> 
    672       <arg value="-lblas" /> 
    673       <arg value="-shared" /> 
    674       <arg value="-olibblas.so" /> 
    675     </exec> 
    676   </target> 
    677  
    678 <!-- 
    679 THIS FILE IS DEPRECATED. 
    680 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    681 --> 
    682   <target name="check.osx"> 
    683     <condition property="blas.is.osx"> 
    684       <equals arg1="${os.name}" arg2="Mac OS X" /> 
    685     </condition> 
    686   </target> 
    687  
    688 <!-- 
    689 THIS FILE IS DEPRECATED. 
    690 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    691 --> 
    692   <target name="blas.osx" depends="check.osx" if="blas.is.osx"> 
    693     <echo message="Generating C header and stub files." /> 
    694     <javah class="com.sun.fortress.numerics.Blas" 
    695            destdir="c" 
    696            classpath="build" 
    697            /> 
    698     <echo message="Now compiling C stubs for blas on arch OS X."/> 
    699     <exec executable="gcc" failonerror="true"> 
    700       <arg line="-D OSX" /> 
    701       <arg value="-fPIC" /> 
    702       <arg value="-Ic" /> 
    703       <arg line="-framework Accelerate" /> 
    704       <arg value="-I${env.JAVA_LIB}/Headers" /> 
    705       <arg value="c/blas.c" /> 
    706       <arg value="-lcblas" /> 
    707       <arg value="-lblas" /> 
    708       <arg value="-shared" /> 
    709       <arg value="-bundle" /> 
    710       <arg line="-o libblas.dylib" /> 
    711     </exec> 
    712   </target> 
    713  
    714   <target name="check.sunos"> 
    715     <condition property="blas.is.sunos"> 
    716       <equals arg1="${os.name}" arg2="SunOS" /> 
    717     </condition> 
    718   </target> 
    719  
    720 <!-- 
    721 THIS FILE IS DEPRECATED. 
    722 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    723 --> 
    724   <target name="blas.sunos" depends="check.sunos" if="blas.is.sunos"> 
    725     <echo message="Generating C header and stub files." /> 
    726     <javah class="com.sun.fortress.numerics.Blas" 
    727            destdir="c" 
    728            classpath="build" 
    729            /> 
    730     <echo message="Now compiling C stubs for blas on arch SunOS."/> 
    731     <exec executable="cc" failonerror="true"> 
    732       <arg line="-D SUNOS" /> 
    733       <arg value="-fPIC" /> 
    734       <arg value="-Ic" /> 
    735       <arg value="-I${env.JAVA_HOME}/include" /> 
    736       <arg value="-I${env.JAVA_HOME}/include/solaris" /> 
    737       <arg value="c/sunperf_blas.c" /> 
    738       <arg value="-shared" /> 
    739       <arg value="-dalign" /> 
    740       <arg value="-xlic_lib=sunperf" /> 
    741       <arg value="-olibblas.so" /> 
    742     </exec> 
    743   </target> 
    744  
    745   <target name="blas" depends="check.blas,blas.linux,blas.osx,blas.sunos"></target> 
    746  
    747 <!-- 
    748 THIS FILE IS DEPRECATED. 
    749 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    750 --> 
    751   <target name="compileLint" 
    752           depends="compileCommonLint, makeAST, parser, operatorsGen" 
    753           description="Compile all interpreter code."> 
    754     <depend srcdir="${src}" 
    755             destdir="${build}" 
    756             closure="yes" 
    757             cache="${basedir}/.dependencies"/> 
    758     <javac 
    759         srcdir="${src}" 
    760         destdir="${build}" 
    761         source="${javaSourceVersion}" 
    762         debug="true" 
    763         includeantruntime="false" 
    764         fork="true" 
    765         memorymaximumsize="${junitMem}"> 
    766       <!-- Uncomment the following line to print unchecked warnings. --> 
    767       <classpath refid="compile.classpath"/> 
    768       <compilerarg value="-Xlint:unchecked"/> 
    769       <include name="**/*.java"/> 
    770       <exclude name="${usefulPackage}/*.java"/> 
    771       <exclude name="${unicodePackage}/*.java"/> 
    772     </javac> 
    773   </target> 
    774  
    775 <!-- 
    776 THIS FILE IS DEPRECATED. 
    777 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    778 --> 
    779   <target name="compileCommon" depends="init" 
    780           description="Compile interpreter-indepedent code."> 
    781     <depend srcdir="${src}" 
    782             destdir="${build}" 
    783             closure="yes" 
    784             cache="${basedir}/.dependencies"/> 
    785     <javac 
    786         srcdir="${src}" 
    787         destdir="${build}" 
    788         source="${javaSourceVersion}" 
    789         debug="true" 
    790         includeantruntime="false" 
    791         fork="true"> 
    792       <!-- Uncomment the following line to print unchecked warnings. --> 
    793       <!-- <compilerarg value="-Xlint:unchecked"/>  --> 
    794       <classpath refid="compile.classpath"/> 
    795       <include name="${blahblahblah}/useful/*.java"/> 
    796       <include name="${blahblahblah}/unicode/*.java"/> 
    797     </javac> 
    798   </target> 
    799  
    800 <!-- 
    801 THIS FILE IS DEPRECATED. 
    802 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    803 --> 
    804   <target name="compileCommonLint" depends="init" 
    805           description="Compile interpreter-indepedent code."> 
    806     <depend srcdir="${src}" 
    807             destdir="${build}" 
    808             closure="yes" 
    809             cache="${basedir}/.dependencies"/> 
    810     <javac 
    811         srcdir="${src}" 
    812         destdir="${build}" 
    813         source="${javaSourceVersion}" 
    814         debug="true" 
    815         includeantruntime="false" 
    816         fork="true"> 
    817       <classpath refid="compile.classpath"/> 
    818       <!-- Uncomment the following line to print unchecked warnings. --> 
    819       <compilerarg value="-Xlint:unchecked"/> 
    820       <include name="${usefulPackage}/*.java"/> 
    821       <include name="${unicodePackage}/*.java"/> 
    822     </javac> 
    823   </target> 
    824  
    825  
    826   <target name="interpreter-jar" depends="compileAll" 
    827           description="Package up the interpreter in a jar."> 
    828     <jar 
    829         destfile="../bin/interpreter.jar" 
    830         basedir="${build}" 
    831         includes="**/*"/> 
    832   </target> 
    833  
    834 <!-- 
    835 THIS FILE IS DEPRECATED. 
    836 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    837 --> 
    838   <target name="testOnly" depends="compileAll" 
    839           description="Run specific tests (use -DtestPattern=...)."> 
    840     <mkdir dir="${test.results}"/> 
    841     <mkdir dir="${basedir}/test-tmp" /> 
    842     <junit printsummary="off" 
    843            haltonerror="off" 
    844            haltonfailure="off" 
    845            showoutput="yes" 
    846            fork="true" 
    847            maxmemory="${junitMem}" 
    848            errorProperty="tests.failed" 
    849            failureProperty="tests.failed"> 
    850       <classpath refid="compile.classpath"/> 
    851       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    852       <formatter type="plain" usefile="false"/> 
    853       <syspropertyset> 
    854         <propertyref prefix="plt." /> 
    855       </syspropertyset> 
    856       <batchtest fork="true" todir="${test.results}"> 
    857         <fileset dir="${build}"> 
    858           <and> 
    859             <filename name="**/*${testPattern}*/**" /> 
    860             <or> 
    861               <filename name="**/*JUTest.class" /> 
    862               <filename name="**/*JUTestAll.class" /> 
    863               <filename name="**/*JxTest.class" /> 
    864             </or> 
    865           </and> 
    866           <exclude name="**/*$*.class"/> 
    867         </fileset> 
    868       </batchtest> 
    869     </junit> 
    870     <delete dir="${basedir}/test-tmp" /> 
    871     <fail message="Tests expected to pass are failing!" if="tests.failed"/> 
    872   </target> 
    873  
    874 <!-- 
    875 THIS FILE IS DEPRECATED. 
    876 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    877 --> 
    878   <target name="test" depends="compileAll, testFast" 
    879           description="Clean, compile everything, and run all unit and system tests."> 
    880   </target> 
    881  
    882   <target name ="testNative" depends="cleanCache, compile" 
    883           description="Test the native code generator"> 
    884     <mkdir dir="${test.results}"/> 
    885     <mkdir dir="${basedir}/test-tmp" /> 
    886     <junit printsummary="on" 
    887            haltonerror="off" 
    888            haltonfailure="off" 
    889            showoutput="yes" 
    890            fork="true" 
    891            maxmemory="${junitMem}" 
    892            errorProperty="tests.failed" 
    893            failureProperty="tests.failed"> 
    894       <classpath refid="compile.classpath"/> 
    895       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    896       <formatter type="plain" usefile="true"/> 
    897       <batchtest fork="true" todir="${test.results}"> 
    898         <fileset dir="${build}"> 
    899           <include name="**/WrapperGeneratorJUTest.class"/> 
    900         </fileset> 
    901       </batchtest> 
    902     </junit> 
    903     <delete dir="${basedir}/test-tmp" /> 
    904     <fail message="Tests expected to pass are failing!" if="tests.failed"/> 
    905   </target> 
    906  
    907 <!-- 
    908 THIS FILE IS DEPRECATED. 
    909 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    910 --> 
    911   <target name="testFast" 
    912           description="Run all unit and system tests expected to pass."> 
    913     <mkdir dir="${test.results}"/> 
    914     <mkdir dir="${basedir}/test-tmp" /> 
    915     <junit printsummary="on" 
    916            haltonerror="off" 
    917            haltonfailure="off" 
    918            showoutput="yes" 
    919            fork="true" 
    920            maxmemory="${junitMem}" 
    921            errorProperty="tests.failed" 
    922            failureProperty="tests.failed"> 
    923       <classpath refid="compile.classpath"/> 
    924       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    925       <formatter type="plain" usefile="true"/> 
    926       <batchtest fork="true" todir="${test.results}"> 
    927         <fileset dir="${build}"> 
    928           <include name="**/*JUTest.class"/> 
    929           <include name="**/*JUTests.class"/> 
    930           <exclude name="**/*$*.class"/> 
    931           <exclude name="**/SyntaxAbstractionJUTestAll.class"/> 
    932           <exclude name="**/tools/AstJUTest.class"/> 
    933         </fileset> 
    934       </batchtest> 
    935     </junit> 
    936     <delete dir="${basedir}/test-tmp" /> 
    937     <fail message="Tests expected to pass are failing!" if="tests.failed"/> 
    938   </target> 
    939  
    940 <!-- 
    941 THIS FILE IS DEPRECATED. 
    942 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    943 --> 
    944   <target name="testCruiseControl" depends="compileAll" 
    945           description="Run all unit and system tests expected to pass."> 
    946     <mkdir dir="${test.results}"/> 
    947     <mkdir dir="${basedir}/test-tmp" /> 
    948     <junit printsummary="on" 
    949            haltonerror="off" 
    950            haltonfailure="off" 
    951            showoutput="yes" 
    952            fork="true" 
    953            maxmemory="${junitMem}" 
    954            errorProperty="tests.failed" 
    955            failureProperty="tests.failed"> 
    956       <classpath refid="compile.classpath"/> 
    957       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    958       <formatter type="plain" usefile="true"/> 
    959       <batchtest fork="true" todir="${junit.dir}"> 
    960         <formatter type="brief" usefile="false" /> 
    961         <formatter type="xml" /> 
    962         <fileset dir="${build}"> 
    963           <include name="**/*JUTest.class"/> 
    964           <include name="**/*JUTests.class"/> 
    965           <exclude name="**/*$*.class"/> 
    966           <exclude name="**/SyntaxAbstractionJUTestAll.class"/> 
    967           <exclude name="**/tools/AstJUTest.class"/> 
    968         </fileset> 
    969       </batchtest> 
    970     </junit> 
    971     <delete dir="${basedir}/test-tmp" /> 
    972     <fail message="Tests expected to pass are failing!" if="tests.failed"/> 
    973   </target> 
    974  
    975 <!-- 
    976 THIS FILE IS DEPRECATED. 
    977 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    978 --> 
    979   <target name="testNotPassing" depends="compileAll" 
    980           description="Run system tests that aren't passing yet."> 
    981     <mkdir dir="${test.results}"/> 
    982     <mkdir dir="${basedir}/test-tmp" /> 
    983     <junit printsummary="on" 
    984            haltonerror="off" 
    985            haltonfailure="off" 
    986            showoutput="yes" 
    987            fork="true" 
    988            maxmemory="${junitMem}" 
    989            errorProperty="tests.failed" 
    990            failureProperty="tests.failed"> 
    991       <classpath refid="compile.classpath"/> 
    992       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    993       <formatter type="brief" usefile="true"/> 
    994       <batchtest fork="true" todir="${test.results}"> 
    995         <fileset dir="${build}"> 
    996           <include name="**/*NotPassingYet.class"/> 
    997         </fileset> 
    998       </batchtest> 
    999     </junit> 
    1000     <delete dir="${basedir}/test-tmp" /> 
    1001     <fail message="Tests expected to fail are failing!" if="tests.failed"/> 
    1002   </target> 
    1003  
    1004 <!-- 
    1005 THIS FILE IS DEPRECATED. 
    1006 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1007 --> 
    1008   <target name="testSpecData" depends="compileAll" 
    1009           description="Run SpecDataJUTests."> 
    1010     <mkdir dir="${test.results}"/> 
    1011     <mkdir dir="${basedir}/test-tmp" /> 
    1012     <junit printsummary="on" 
    1013            haltonerror="off" 
    1014            haltonfailure="off" 
    1015            showoutput="yes" 
    1016            fork="true" 
    1017            maxmemory="${junitMem}" 
    1018            errorProperty="tests.failed" 
    1019            failureProperty="tests.failed"> 
    1020       <classpath refid="compile.classpath"/> 
    1021       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    1022       <formatter type="plain" usefile="true"/> 
    1023       <batchtest fork="true" todir="${test.results}"> 
    1024         <fileset dir="${build}"> 
    1025           <include name="**/SpecDataJUTest.class"/> 
    1026         </fileset> 
    1027       </batchtest> 
    1028     </junit> 
    1029     <delete dir="${basedir}/test-tmp" /> 
    1030     <fail message="Tests expected to pass are failing!" if="tests.failed"/> 
    1031   </target> 
    1032  
    1033 <!-- 
    1034 THIS FILE IS DEPRECATED. 
    1035 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1036 --> 
    1037   <target name="testSystem" depends="compileAll" 
    1038           description="Run SystemJUTests."> 
    1039     <mkdir dir="${test.results}"/> 
    1040     <mkdir dir="${basedir}/test-tmp" /> 
    1041     <junit printsummary="on" 
    1042            haltonerror="off" 
    1043            haltonfailure="off" 
    1044            showoutput="yes" 
    1045            fork="true" 
    1046            maxmemory="${junitMem}" 
    1047            errorProperty="tests.failed" 
    1048            failureProperty="tests.failed"> 
    1049       <classpath refid="compile.classpath"/> 
    1050       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    1051       <formatter type="plain" usefile="true"/> 
    1052       <batchtest fork="true" todir="${test.results}"> 
    1053         <fileset dir="${build}"> 
    1054           <include name="**/SystemJUTest.class"/> 
    1055         </fileset> 
    1056       </batchtest> 
    1057     </junit> 
    1058     <delete dir="${basedir}/test-tmp" /> 
    1059     <fail message="Tests expected to pass are failing!" if="tests.failed"/> 
    1060   </target> 
    1061  
    1062 <!-- 
    1063 THIS FILE IS DEPRECATED. 
    1064 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1065 --> 
    1066   <target name="testblas" depends="compile,blas" description="Test blas"> 
    1067     <mkdir dir="${basedir}/test-tmp" /> 
    1068     <junit printsummary="on" 
    1069            haltonerror="off" 
    1070            haltonfailure="off" 
    1071            showoutput="yes" 
    1072            fork="true" 
    1073            maxmemory="${junitMem}" 
    1074            errorProperty="tests.failed" 
    1075            failureProperty="tests.failed"> 
    1076       <classpath refid="compile.classpath"/> 
    1077       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    1078       <formatter type="plain" usefile="true"/> 
    1079       <batchtest fork="true" todir="${test.results}"> 
    1080         <fileset dir="${build}"> 
    1081           <include name="**/BlasJxTest.class"/> 
    1082         </fileset> 
    1083       </batchtest> 
    1084     </junit> 
    1085     <delete dir="${basedir}/test-tmp" /> 
    1086     <fail message="Tests expected to pass are failing!" if="tests.failed"/> 
    1087   </target> 
    1088  
    1089 <!-- 
    1090 THIS FILE IS DEPRECATED. 
    1091 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1092 --> 
    1093   <target name="testsyntax" depends="compileAll" 
    1094           description="Run SyntaxAbstractionJUTests."> 
    1095     <mkdir dir="${test.results}"/> 
    1096     <mkdir dir="${basedir}/test-tmp" /> 
    1097     <junit printsummary="on" 
    1098            haltonerror="off" 
    1099            haltonfailure="off" 
    1100            showoutput="yes" 
    1101            fork="true" 
    1102            maxmemory="${junitMem}" 
    1103            errorProperty="tests.failed" 
    1104            failureProperty="tests.failed"> 
    1105       <classpath refid="compile.classpath"/> 
    1106       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    1107       <formatter type="plain" usefile="true"/> 
    1108       <batchtest fork="true" todir="${test.results}"> 
    1109         <fileset dir="${build}"> 
    1110           <include name="**/SyntaxAbstractionJUTest.class"/> 
    1111           <include name="**/SyntaxAbstractionJUTestAll.class"/> 
    1112         </fileset> 
    1113       </batchtest> 
    1114     </junit> 
    1115     <delete dir="${basedir}/test-tmp" /> 
    1116     <fail message="Tests expected to pass are failing!" if="tests.failed"/> 
    1117   </target> 
    1118  
    1119 <!-- 
    1120 THIS FILE IS DEPRECATED. 
    1121 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1122 --> 
    1123   <target name="testDemos" depends="compileAll" 
    1124           description="Run demos in a test harness."> 
    1125     <mkdir dir="${test.results}"/> 
    1126     <mkdir dir="${basedir}/test-tmp" /> 
    1127     <junit printsummary="on" 
    1128            haltonerror="off" 
    1129            haltonfailure="off" 
    1130            showoutput="yes" 
    1131            fork="true" 
    1132            maxmemory="${junitMem}" 
    1133            errorProperty="tests.failed" 
    1134            failureProperty="tests.failed"> 
    1135       <classpath refid="compile.classpath"/> 
    1136       <jvmarg value="-Djava.io.tmpdir=${basedir}/test-tmp" /> 
    1137       <formatter type="brief" usefile="true"/> 
    1138       <batchtest fork="true" todir="${test.results}"> 
    1139         <fileset dir="${build}"> 
    1140           <include name="**/DemoTests.class"/> 
    1141         </fileset> 
    1142       </batchtest> 
    1143     </junit> 
    1144     <delete dir="${basedir}/test-tmp" /> 
    1145     <fail message="Tests expected to pass are failing!" if="tests.failed"/> 
    1146   </target> 
    1147  
    1148   <target name="testAll" 
    1149           depends="test, testNotPassing, testDemos, reportNotPassing" 
    1150           description="Run all tests, including those known not to pass yet."> 
    1151   </target> 
    1152  
    1153   <target name="testNightly" depends="test, testDemos, testsyntax" 
    1154           description="Run tests, demos, and syntax abstraction tests."> 
    1155   </target> 
    1156  
    1157   <target name="reportNotPassing" 
    1158           if="not.passing.yet" 
    1159           depends="test,testNotPassing"> 
    1160     <echo message="Some tests expected to fail still aren't passing."/> 
    1161   </target> 
    1162  
    1163 <!-- 
    1164 THIS FILE IS DEPRECATED. 
    1165 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1166 --> 
    1167   <!-- If the generated file Fortress.java is no older than all rats files 
    1168        in the parser directory, then the parser must be up to date. 
    1169        This is a conservative test; a more precise test would perform a 
    1170        dependency analysis over Rats! code.--> 
    1171   <target name="checkParserUptodate" depends="init"> 
    1172     <condition property="parser.uptodate"> 
    1173       <and> 
    1174         <uptodate targetfile="${parser}/Fortress.java"> 
    1175           <srcfiles dir="${parser}" includes="**/*.rats"/> 
    1176         </uptodate> 
    1177         <uptodate targetfile="${preparser}/PreFortress.java"> 
    1178           <srcfiles dir="${parser}" includes="**/*.rats"/> 
    1179           <srcfiles dir="${preparser}" includes="**/*.rats"/> 
    1180         </uptodate> 
    1181         <uptodate targetfile="${importcollector}/ImportCollector.java"> 
    1182           <srcfiles dir="${parser}" includes="**/*.rats"/> 
    1183           <srcfiles dir="${importcollector}" includes="**/*.rats"/> 
    1184         </uptodate> 
    1185         <uptodate targetfile="${templateparser}/TemplateParser.java"> 
    1186           <srcfiles dir="${parser}" includes="**/*.rats"/> 
    1187           <srcfiles dir="${templateparser}" includes="**/*.rats"/> 
    1188         </uptodate> 
    1189       </and> 
    1190     </condition> 
    1191     <echo>Parser up to date? ${parser.uptodate}</echo> 
    1192   </target> 
    1193  
    1194   <target name="checkFortressParserUptodate" depends="init"> 
    1195     <uptodate property="fortressparser.uptodate" 
    1196               targetfile="${parser}/Fortress.java"> 
    1197       <srcfiles dir="${parser}" includes="**/*.rats"/> 
    1198     </uptodate> 
    1199     <echo>Fortress parser up to date? ${parser.uptodate}</echo> 
    1200   </target> 
    1201  
    1202 <!-- 
    1203 THIS FILE IS DEPRECATED. 
    1204 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1205 --> 
    1206   <target name="checkPreparserUptodate" depends="init"> 
    1207     <uptodate property="preparser.uptodate" 
    1208               targetfile="${preparser}/PreFortress.java"> 
    1209       <srcfiles dir="${parser}" includes="**/*.rats"/> 
    1210       <srcfiles dir="${preparser}" includes="**/*.rats"/> 
    1211     </uptodate> 
    1212     <echo>Preparser up to date? ${preparser.uptodate}</echo> 
    1213   </target> 
    1214  
    1215   <target name="checkImportCollectorUptodate" depends="init"> 
    1216     <uptodate property="importcollector.uptodate" 
    1217               targetfile="${importcollector}/ImportCollector.java"> 
    1218       <srcfiles dir="${parser}" includes="**/*.rats"/> 
    1219       <srcfiles dir="${importcollector}" includes="**/*.rats"/> 
    1220     </uptodate> 
    1221     <echo>ImportCollector up to date? ${importcollector.uptodate}</echo> 
    1222   </target> 
    1223  
    1224   <target name="checkTemplateparserUptodate" depends="init"> 
    1225     <uptodate property="templateparser.uptodate" 
    1226               targetfile="${templateparser}/TemplateParser.java"> 
    1227       <srcfiles dir="${parser}" includes="**/*.rats"/> 
    1228       <srcfiles dir="${templateparser}" includes="**/*.rats"/> 
    1229     </uptodate> 
    1230     <echo>Templateparser up to date? ${templateparser.uptodate}</echo> 
    1231   </target> 
    1232  
    1233 <!-- 
    1234 THIS FILE IS DEPRECATED. 
    1235 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1236 --> 
    1237   <target name="checkInstrumentedParserUptodate" depends="init"> 
    1238     <uptodate property="instrumentedparser.uptodate" 
    1239               targetfile="${parser}/FortressInstrumented.java"> 
    1240       <srcfiles dir="${parser}" includes="**/*.rats"/> 
    1241       <srcfiles dir="${src}/${instrumentationPackage}" 
    1242                 includes="*.java"/> 
    1243     </uptodate> 
    1244     <echo>Fortress parser up to date? ${parser.uptodate}</echo> 
    1245   </target> 
    1246  
    1247 <!-- 
    1248 THIS FILE IS DEPRECATED. 
    1249 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1250 --> 
    1251   <macrodef name="buildparser"> 
    1252     <attribute name="name" /> 
    1253     <attribute name="file" /> 
    1254     <attribute name="dir" /> 
    1255     <sequential> 
    1256       <echo message="Rebuilding @{name}..."/> 
    1257       <java fork="yes" 
    1258             failonerror="yes" 
    1259             dir="@{dir}" 
    1260             classname="xtc.parser.Rats" 
    1261             classpath="${xtc}/xtc.jar"> 
    1262         <arg value="-in"/> 
    1263         <arg value="${src}"/> 
    1264         <arg value="@{file}"/> 
    1265       </java> 
    1266     </sequential> 
    1267   </macrodef> 
    1268  
    1269 <!-- 
    1270 THIS FILE IS DEPRECATED. 
    1271 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1272 --> 
    1273   <target name="fortressparser" unless="fortressparser.uptodate" 
    1274           depends="checkFortressParserUptodate" 
    1275           description="Fortress Parser"> 
    1276     <buildparser name="Fortress" dir="${parser}" file="Fortress.rats" /> 
    1277   </target> 
    1278  
    1279   <target name="preparser" unless="preparser.uptodate" 
    1280           depends="checkPreparserUptodate" 
    1281           description="Preparser"> 
    1282     <buildparser name="preparser" dir="${preparser}" file="PreFortress.rats" /> 
    1283   </target> 
    1284  
    1285   <target name="importcollector" unless="importcollector.uptodate" 
    1286           depends="checkImportCollectorUptodate" 
    1287           description="ImportCollector"> 
    1288     <buildparser name="importcollector" dir="${importcollector}" file="ImportCollector.rats" /> 
    1289   </target> 
    1290  
    1291   <target name="templateparser" unless="templateparser.uptodate" 
    1292           depends="checkTemplateparserUptodate" 
    1293           description="Templateparser"> 
    1294     <buildparser name="template parser" dir="${templateparser}" 
    1295                  file="TemplateParser.rats" /> 
    1296   </target> 
    1297  
    1298 <!-- 
    1299 THIS FILE IS DEPRECATED. 
    1300 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1301 --> 
    1302   <target name="instrumentedparser" unless="instrumentedparser.uptodate" 
    1303           depends="compile, checkInstrumentedParserUptodate" 
    1304           description="Instrumented Parser"> 
    1305     <java fork="yes" 
    1306           maxmemory="512m" 
    1307           failonerror="yes" 
    1308           classname="${instrumentation.package}.InstrumentedParserGenerator"> 
    1309       <classpath refid="instrumentedparser.classpath"/> 
    1310       <arg value="${parser}"/> <!-- input dir --> 
    1311       <arg value="${parser}"/> <!-- output dir for FortressInstrumented.java --> 
    1312     </java> 
    1313   </target> 
    1314  
    1315 <!-- 
    1316 THIS FILE IS DEPRECATED. 
    1317 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1318 --> 
    1319   <target name="optimizeParser" 
    1320           depends="compile" 
    1321           description="Optimized Parser"> 
    1322     <java fork="yes" 
    1323           maxmemory="512m" 
    1324           failonerror="yes" 
    1325           classname="${instrumentation.package}.OptimizedParserGenerator"> 
    1326       <classpath refid="instrumentedparser.classpath"/> 
    1327       <arg value="${parser}"/> <!-- input dir --> 
    1328       <arg value="${parser}"/> <!-- output dir for Fortress.java --> 
    1329       <arg value="${instrumentation.transient}"/> 
    1330     </java> 
    1331     <ant target="compile"/> 
    1332   </target> 
    1333  
    1334   <target name="parser" unless="parser.uptodate" 
    1335           depends="checkParserUptodate, operatorsGen" 
    1336           description="Fortress Parser"> 
    1337     <ant target="fortressparser" /> 
    1338     <ant target="preparser" /> 
    1339     <ant target="importcollector" /> 
    1340     <ant target="templateparser" /> 
    1341   </target> 
    1342  
    1343 <!-- 
    1344 THIS FILE IS DEPRECATED. 
    1345 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1346 --> 
    1347   <target name="compileGrammarCoverage" depends="compile, instrumentedparser"> 
    1348     <depend srcdir="${src}" 
    1349             destdir="${build}" 
    1350             closure="yes" 
    1351             cache="${basedir}/.dependencies"/> 
    1352     <javac 
    1353         srcdir="${src}" 
    1354         destdir="${build}" 
    1355         source="${javaSourceVersion}" 
    1356         debug="true" 
    1357         includeantruntime="false" 
    1358         fork="true" 
    1359         memorymaximumsize="${junitMem}"> 
    1360       <!-- Uncomment the following line to print unchecked warnings 
    1361            (here and in the 'compileCommon' target. --> 
    1362       <!-- <compilerarg value="-Xlint:unchecked"/> --> 
    1363       <classpath refid="compile.classpath"/> 
    1364       <include name="${packagePrefix}/parser/FortressInstrumented.java"/> 
    1365     </javac> 
    1366   </target> 
    1367  
    1368   <target name="grammarCoverage" depends="compileGrammarCoverage"> 
    1369     <java fork="yes" 
    1370           failonerror="yes" 
    1371           classname="${instrumentation.package}.Coverage" 
    1372           output="${instrumentation.outfile}"> 
    1373       <classpath refid="compile.classpath"/> 
    1374     </java> 
    1375     <echo message="Wrote grammar coverage report to ${instrumentation.outfile}"/> 
    1376   </target> 
    1377  
    1378 <!-- 
    1379 THIS FILE IS DEPRECATED. 
    1380 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1381 --> 
    1382   <target name="doc" depends="compileAll"> 
    1383     <javadoc overview="${src}/overview.html" destdir="${docs}" maxmemory="${junitMem}"> 
    1384       <classpath refid="compile.classpath"/> 
    1385       <packageset dir="${src}"> 
    1386         <include name="**/*"/> 
    1387       </packageset> 
    1388       <header><![CDATA[Fortress Interpreter]]></header> 
    1389       <doctitle><![CDATA[<h1>Fortress Interpreter Source Code</h1>]]></doctitle> 
    1390       <group title="Evaluator Packages" 
    1391              packages="com.sun.fortress.interpreter.evaluator.*"/> 
    1392       <link href="http://junit.org/junit/javadoc/3.8.1/"/> 
    1393       <link href="http://java.sun.com/j2se/1.5/docs/api/"/> 
    1394       <link href="http://drjava.org/javadoc/plt/"/> 
    1395     </javadoc> 
    1396   </target> 
    1397  
    1398 <!-- 
    1399 THIS FILE IS DEPRECATED. 
    1400 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1401 --> 
    1402   <target name="jar" 
    1403           depends="compileAll" 
    1404           description="Package up a Fortress distribution as a self-extracting jar."> 
    1405     <tstamp> 
    1406       <format 
    1407           property="jar.DSTAMP" 
    1408           timezone="GMT" 
    1409           pattern="yyyy_MMdd_hhmm"/> 
    1410     </tstamp> 
    1411  
    1412     <!-- Extract Ant jars into build directory to be packaged up.--> 
    1413     <unjar src="${protofortress}/lib/ant.jar" dest="${build}"/> 
    1414     <unjar src="${protofortress}/lib/ant-launcher.jar" dest="${build}"/> 
    1415  
    1416     <!-- Place anthooks.jar in the protofortress. --> 
    1417     <copy file="${src}/com/sun/fortress/shell/anthooks.xml" 
    1418           todir="${protofortress}/bin"/> 
    1419  
    1420     <!-- Package up class files as a new shell.jar, 
    1421          and place them in the protofortress. --> 
    1422     <jar 
    1423         destfile="fortress/FORTRESS/lib/shell.jar" 
    1424         basedir="${build}" 
    1425         includes="**/*"/> 
    1426  
    1427     <!-- Then package up the protofortress and place it 
    1428          in the build directory (so it can be extracted later). --> 
    1429     <jar 
    1430         destfile="${build}/com/sun/fortress/shell/fortress.jar" 
    1431         basedir="fortress" 
    1432         includes="**/*" /> 
    1433  
    1434     <!-- Write timestamp of jar creation to a file for retrieval during 
    1435          extraction. --> 
    1436     <echo message="${jar.DSTAMP}" file="${build}/TIMESTAMP"/> 
    1437  
    1438     <!-- Finally, package up the build directory into a jar that 
    1439          extracts the protofortress at a destination site. --> 
    1440     <jar 
    1441         destfile="Fortress_${jar.DSTAMP}.jar" 
    1442         basedir="${build}" 
    1443         includes="**/*" > 
    1444       <manifest> 
    1445         <attribute name="Manifest-Version" value="${jar.DSTAMP}"/> 
    1446         <attribute name="Created-By" value="Sun Microsystems, Inc."/> 
    1447         <attribute name="Main-Class" value="com.sun.fortress.shell.Extractor"/> 
    1448         <section name="common/class1.class"> 
    1449           <attribute name="Sealed" value="false"/> 
    1450         </section> 
    1451       </manifest> 
    1452     </jar> 
    1453   </target> 
    1454  
    1455 <!-- 
    1456 THIS FILE IS DEPRECATED. 
    1457 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1458 --> 
    1459   <target name="copy.anthooks" depends="init" unless="anthooks.uptodate"> 
    1460     <copy file="${src}/com/sun/fortress/shell/anthooks.xml" 
    1461           todir="${build}/com/sun/fortress/shell" 
    1462           overwrite="false"/> 
    1463   </target> 
    1464  
    1465   <target name="installer" depends="compileAll" 
    1466           description="build a new installer as a jar"> 
    1467     <delete dir="${installerDir}"/> 
    1468     <mkdir dir="${installerDir}/fortress"/> 
    1469     <copy todir="${installerDir}/fortress/FORTRESS"> 
    1470       <fileset dir="FORTRESS"/> 
    1471     </copy> 
    1472     <copy todir="${installerDir}/fortress/bin"> 
    1473       <fileset dir="bin"/> 
    1474     </copy> 
    1475     <copy file="docs/installer/README.txt" todir="${installerDir}/fortress"/> 
    1476     <tar 
    1477         destfile="fortress.tar.gz" 
    1478         basedir="${installerDir}" 
    1479         longfile="fail" 
    1480         compression="gzip" 
    1481         /> 
    1482     <delete dir="${installerDir}"/> 
    1483   </target> 
    1484  
    1485 <!-- 
    1486 THIS FILE IS DEPRECATED. 
    1487 CHANGES SHOULD BE MADE TO BUILD.XML IN THE PARENT (ROOT) DIRECTORY. 
    1488 --> 
    1489   <target name="createNestedJarUpgrade" 
    1490           description="wrap up a jar for inclusion in a mock upgrade"> 
    1491     <jar 
    1492         destfile="jars/fortress_mock_upgrade/java/mock_upgrade.jar" 
    1493         basedir="jars/nested_jar_upgrade" 
    1494         includes="**/*" 
    1495         /> 
    1496   </target> 
    1497  
    1498   <target name="createMockUpgrade" depends="createNestedJarUpgrade" 
    1499           description="build a mock upgrade file for testing selfupgrade"> 
    1500     <jar 
    1501         destfile="FORTRESS/test/fortress_mock_upgrade.jar" 
    1502         basedir="jars/fortress_mock_upgrade" 
    1503         includes="**/*" 
    1504         /> 
    1505   </target> 
    1506 </project> 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/nativeInterface/FortressMethodAdapter.java

    r3653 r3660  
    5959    private HashMap conversionTable; 
    6060    private final Set<OverloadSet> overloads; 
     61    boolean overloadsDone = false; 
    6162 
    6263    private void initializeEntry(String fortressRuntimeType, 
    … …  
    8182        initializeEntry("FBool",   "getValue", "()Z", "make", "(Z)L" + prefix + "FBool;"); 
    8283        initializeEntry("FVoid",   "getValue", "()",  "make", "()L" + prefix + "FVoid;"); 
    83         initializeEntry("FString", "getValue", "()Ljava/lang/String;", "make", "(Ljava/lang/String;)L" +  
     84        initializeEntry("FString", "getValue", "()Ljava/lang/String;", "make", "(Ljava/lang/String;)L" + 
    8485                        prefix + "FString;"); 
    8586    } 
    … …  
    127128            generateNewBody(access, desc, signature, exceptions, name, name); 
    128129        } 
     130 
     131        if (!overloadsDone) { 
     132            // Generate all the overloadings. 
     133            overloadsDone = true; 
     134            for (OverloadSet o : overloads) { 
     135                generateAnOverload(cv, o); 
     136            } 
     137        } 
     138 
    129139        return super.visitMethod(access, name, desc, signature, exceptions); 
     140    } 
     141 
     142    private static void generateAnOverload(ClassVisitor cv, OverloadSet o) { 
     143 
     144        // 
     145        String name = o.getName().stringName(); 
     146 
     147        // "(" anOverloadedArg^N ")" returnType 
     148        // Not sure what to do with return type. 
     149        String signature = o.getSignature(); 
     150        String[] exceptions = o.getExceptions(); 
     151        MethodVisitor mv = cv.visitMethod( 
     152                Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, // access, 
     153                name, // name, 
     154                signature, // sp.getFortressifiedSignature(), 
     155                null, // signature, // depends on generics, I think 
     156                exceptions); // exceptions); 
     157 
     158        mv.visitCode(); 
     159        Label fail = new Label(); 
     160 
     161        o.generateCall(mv, 0, fail); 
     162 
     163        // Emit failure case 
     164        mv.visitLabel(fail); 
     165        // Boilerplate for throwing an error. 
     166        mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); 
     167        mv.visitTypeInsn(Opcodes.NEW, "java/lang/Error"); 
     168        mv.visitInsn(Opcodes.DUP); 
     169        mv.visitLdcInsn("Should not happen"); 
     170        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Error", "<init>", "(Ljava/lang/String;)V"); 
     171        mv.visitInsn(Opcodes.ATHROW); 
     172 
     173        mv.visitMaxs(0,0); // autocomputed 
     174        mv.visitEnd(); 
     175 
    130176    } 
    131177 
    … …  
    153199            fortressConverter converter = (fortressConverter) conversionTable.get(stripped); 
    154200            if (converter == null) 
    155                 throw new RuntimeException("Can't generate header for method " +  
    156                                             name + " problem =" + s +  
     201                throw new RuntimeException("Can't generate header for method " + 
     202                                            name + " problem =" + s + 
    157203                                            " stripped = " + stripped); 
    158204            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, 
    … …  
    176222        if (converter == null) 
    177223            throw new RuntimeException("Can't generate return type for method " + name + " value " + result); 
    178          
     224 
    179225        mv.visitMethodInsn(Opcodes.INVOKESTATIC, prefix + strip(result), 
    180226                           converter.constructor, 
    … …  
    187233 
    188234    public void visitEnd() { 
    189         // Generate all the overloadings. 
    190         for (OverloadSet o : overloads) { 
    191             generateAnOverload(o); 
    192         } 
    193          
     235 
    194236        super.visitEnd(); 
    195237    } 
    196238 
    197     private void generateAnOverload(OverloadSet o) { 
    198          
    199 //        MethodVisitor mv = cv.visitMethod( 
    200 //                0, // access, 
    201 //                null, // name, 
    202 //                null, // sp.getFortressifiedSignature(), 
    203 //                null, // signature, 
    204 //                null); // exceptions); 
    205 //         
    206 //        mv.visitCode(); 
    207         // TODO Auto-generated method stub 
    208          
    209     } 
    210239 
    211240} 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/nativeInterface/FortressTransformer.java

    r3646 r3660  
    2121import java.io.FileOutputStream; 
    2222import org.objectweb.asm.*; 
     23 
    2324import com.sun.fortress.compiler.ByteCodeWriter; 
    2425import com.sun.fortress.compiler.phases.OverloadSet; 
    … …  
    3435        try { 
    3536            ClassReader cr = new ClassReader(inputClassName); 
    36             ClassWriter cw = new ClassWriter(1); 
     37            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); 
     38 
     39 
    3740            FortressMethodAdapter fa = new FortressMethodAdapter(cw, inputClassName, overloads); 
    3841            cr.accept(fa, 0); 
     42 
     43            cw.visitEnd(); 
    3944            byte[] b2 = cw.toByteArray(); 
    4045            ByteCodeWriter.writeClass(repository, inputClassName, b2); 
    … …  
    4348        } 
    4449    } 
     50 
     51 
    4552} 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/phases/OverloadSet.java

    r3653 r3660  
    2323import java.util.Set; 
    2424 
     25import org.objectweb.asm.Label; 
     26import org.objectweb.asm.MethodVisitor; 
     27import org.objectweb.asm.Opcodes; 
     28 
     29import com.sun.fortress.compiler.NamingCzar; 
    2530import com.sun.fortress.compiler.index.Function; 
    2631import com.sun.fortress.compiler.typechecker.TypeAnalyzer; 
    2732import com.sun.fortress.exceptions.InterpreterBug; 
     33import com.sun.fortress.nodes.BaseType; 
    2834import com.sun.fortress.nodes.IdOrOpOrAnonymousName; 
    2935import com.sun.fortress.nodes.Param; 
    3036import com.sun.fortress.nodes.Type; 
     37import com.sun.fortress.nodes_util.NodeFactory; 
    3138import com.sun.fortress.useful.BASet; 
    3239import com.sun.fortress.useful.DefaultComparator; 
    … …  
    4249 
    4350public class OverloadSet implements Comparable<OverloadSet> { 
    44      
     51 
    4552    static class POType extends TopSortItemImpl<Type> { 
    4653        public POType(Type x) { 
    … …  
    4855        } 
    4956    } 
    50      
     57 
    5158    /** 
    5259     * The set of functions that are less-specific-than-or-equal to the 
    … …  
    7077     */ 
    7178    final BASet<Integer> testedIndices; 
    72      
     79 
    7380    /** 
    7481     * Assuming we have a parent (are not the root of a tree of OverloadSets), 
    … …  
    8188     */ 
    8289    final Type selectedParameterType; 
    83      
     90 
    8491    final int paramCount; 
    8592 
    … …  
    9097    OverloadSet[] children; 
    9198    boolean splitDone; 
    92      
     99 
    93100    OverloadSet(IdOrOpOrAnonymousName name, TypeAnalyzer ta, 
    94101                Set<Function> lessSpecificThanSoFar, 
    … …  
    102109        this.paramCount = paramCount; 
    103110    } 
    104      
     111 
    105112    OverloadSet(IdOrOpOrAnonymousName name, TypeAnalyzer ta, Set<Function> defs, int n) { 
    106113        this(name, ta, defs, 
    107114            new BASet<Integer>(DefaultComparator.<Integer>normal()), 
    108115            null, null, n); 
    109          
     116 
    110117        // Ensure that they are all the same size. 
    111118        for (Function f : lessSpecificThanSoFar) { 
    … …  
    116123            if (this_size != paramCount) 
    117124                InterpreterBug.bug("Need to handle variable arg dispatch elsewhere " + name); 
    118              
    119         } 
    120     } 
    121      
    122     public String toString() { 
    123         if (lessSpecificThanSoFar.size() == 1) { 
    124             return lessSpecificThanSoFar.iterator().next().toString(); 
    125         } 
    126         if (splitDone) { 
    127             return toStringR(""); 
    128         } else { 
    129             return lessSpecificThanSoFar.toString(); 
    130         } 
    131     } 
    132      
    133     private String toStringR(String indent) { 
    134         if (lessSpecificThanSoFar.size() == 1) { 
    135             return indent + lessSpecificThanSoFar.iterator().next().toString(); 
    136         } else { 
    137             String s =  indent + "#" + dispatchParameterIndex + "\n"; 
    138             for (int i = 0; i < children.length; i++) { 
    139                 OverloadSet os = children[i]; 
    140                 s += indent + os.selectedParameterType + "->" + os.toStringR(indent + "   ") + "\n"; 
    141             } 
    142             return s; 
    143         } 
    144     } 
    145      
     125 
     126        } 
     127    } 
     128 
    146129    void split() { 
    147130        if (splitDone) 
    148131            return; 
    149          
     132 
    150133        if (lessSpecificThanSoFar.size() == 1) { 
     134                splitDone = true; 
    151135                return; 
    152136            // If there are no other alternatives, then we are done. 
    153137        } 
    154          
     138 
    155139        { 
    156140            // Accumulate sets of parameter types. 
    157141            int nargs = paramCount;; 
    158              
     142 
    159143            MultiMap<Type, Function>[] typeSets = new MultiMap[nargs]; 
    160144            for (int i = 0; i < nargs; i++) { 
    161145                typeSets[i] = new MultiMap<Type, Function>(); 
    162146            } 
    163              
     147 
    164148            for (Function f : lessSpecificThanSoFar) { 
    165149                List<Param> parameters = f.parameters(); 
    … …  
    180164                    Type t = ot.unwrap(); 
    181165                    typeSets[i++].putItem(t, f); 
    182                 }        
    183             } 
    184              
     166                } 
     167            } 
     168 
    185169            // Choose parameter index with greatest variation. 
    186170            // Choose parameter index with the smallest largest subset. 
    … …  
    208192                } 
    209193            } 
    210              
     194 
    211195            // dispatch on maxi'th parameter. 
    212196            dispatchParameterIndex = besti; 
    213197            Set<Type> dispatchTypes = typeSets[dispatchParameterIndex].keySet(); 
    214             
    215             
     198 
     199 
    216200            children = new OverloadSet[best]; 
    217201            BASet<Integer> childTestedIndices = testedIndices.putNew(besti); 
    218              
     202 
    219203            int i = 0; 
    220204            TopSortItemImpl<Type>[] potypes = 
    … …  
    226210                i++; 
    227211            } 
    228              
     212 
    229213            /* 
    230214             * Figure out ordering relationship for top sort.  O(N^2) work, 
    … …  
    242226                } 
    243227            } 
    244              
     228 
    245229            List<TopSortItemImpl<Type>> specificFirst = TopSort.depthFirst(potypes); 
    246230            children = new OverloadSet[specificFirst.size()]; 
    247             Set<Function> alreadySelected = new HashSet<Function>();     
    248              
     231            Set<Function> alreadySelected = new HashSet<Function>(); 
     232 
    249233            // fill in children. 
    250234            for (i = 0; i < specificFirst.size(); i++) { 
    251235                Type t = specificFirst.get(i).x; 
    252236                Set<Function> childLSTSF = new HashSet<Function>(); 
    253                  
     237 
    254238                    for (Function f : lessSpecificThanSoFar) { 
    255239//                        if (alreadySelected.contains(f)) 
    … …  
    261245                            childLSTSF.add(f); 
    262246                            alreadySelected.add(f); 
    263                            
     247 
    264248                        } 
    265249                    } 
    266                  
     250 
    267251               childLSTSF = thin(childLSTSF, childTestedIndices); 
    268                      
     252 
    269253               // ought to not be necessary 
    270254               if (paramCount == childTestedIndices.size()) { 
    271255                        // Choose most specific member of lessSpecificThanSoFar 
    272256                   childLSTSF = mostSpecificMemberOf(childLSTSF); 
    273                          
    274                 } 
    275                      
     257 
     258                } 
     259 
    276260                children[i] = 
    277261                    new OverloadSet(name, ta, childLSTSF, 
    … …  
    309293            public long hash(Function x) { 
    310294                int h = MagicNumbers.T; 
    311                  
     295 
    312296                List<Param> px = x.parameters(); 
    313297                for (int i = 0; i < px.size(); i++) { 
    … …  
    319303                return h; 
    320304            } 
    321              
     305 
    322306        }; 
    323          
     307 
    324308        /* 
    325309         * Creates map from (some) functions to the 
    … …  
    329313        for (Function f : childLSTSF) 
    330314            eqSetMap.putItem(f, f); 
    331          
     315 
    332316        Set<Function> tmp = new HashSet<Function>(); 
    333          
     317 
    334318        /* 
    335319         * Take the most specific member of each equivalence set, and union 
    … …  
    338322        for (Set<Function> sf : eqSetMap.values()) 
    339323            tmp.addAll(mostSpecificMemberOf(sf)); 
    340          
     324 
    341325        return tmp; 
    342326    } 
    343327 
    344328    /** 
    345      *  
     329     * 
    346330     */ 
    347331    private Set<Function> mostSpecificMemberOf(Set<Function> set) { 
    … …  
    361345                    Type msf_t = msf_parameters.get(i).getIdType().unwrap(); 
    362346                    Type cand_t = cand_parameters.get(i).getIdType().unwrap(); 
    363                     // if any type of the candidate is not a subtype(or eq)  
     347                    // if any type of the candidate is not a subtype(or eq) 
    364348                    // of the corresponding type of the msf, then the candidate 
    365349                    // is NOT better. 
    … …  
    371355                if (cand_better) 
    372356                    msf = candidate; 
    373                  
     357 
    374358            } 
    375359        } 
    … …  
    385369        return name.stringName().compareTo(o.name.stringName()); 
    386370    } 
    387      
     371 
    388372    public IdOrOpOrAnonymousName getName() { 
    389373        return name; 
    390374    } 
    391      
     375 
     376    public int getParamCount() { 
     377        return paramCount; 
     378    } 
     379 
     380    /** 
     381     * returns the code generation signature for the overloaded function. 
     382     * (separation of concerns problem here -- taking joins of types, 
     383     * and returning a target-platform (i.e., Java) signature). 
     384     * 
     385     * @return 
     386     */ 
     387    public String getSignature() { 
     388        String s = "("; 
     389        String anOverloadedArg = "Ljava/lang/Object;"; 
     390 
     391        for (int i = 0; i < paramCount; i++) { 
     392            s += anOverloadedArg; 
     393        } 
     394        s += ")"; 
     395 
     396        Type r = null; 
     397        boolean isAny = false; 
     398 
     399        for (Function f : lessSpecificThanSoFar) { 
     400            Type r0 = f.getReturnType(); 
     401            if (r == null) 
     402                r = r0; 
     403            else if (r.equals(r0)) { 
     404                // ok 
     405            } else if (!isAny) { 
     406                isAny = true; 
     407                // Locate the any at the place we realized it was necessary. 
     408                r = NodeFactory.makeAnyType(r0.getInfo().getSpan()); 
     409            } 
     410        } 
     411        s += NamingCzar.only.boxedImplDesc(r); 
     412 
     413        return s; 
     414    } 
     415 
     416    public String[] getExceptions() { 
     417        HashSet<Type> exceptions = new HashSet<Type>(); 
     418        for (Function f : lessSpecificThanSoFar) { 
     419            List<BaseType> f_exceptions =  f.thrownTypes(); 
     420            exceptions.addAll(f_exceptions); 
     421        } 
     422        String[] string_exceptions = new String[exceptions.size()]; 
     423        int i = 0; 
     424        for (Type e : exceptions) { 
     425            string_exceptions[i++] = NamingCzar.only.boxedImplDesc(e); 
     426        } 
     427        return string_exceptions; 
     428    } 
     429 
     430    public void generateCall(MethodVisitor mv, int firstArgIndex, Label failLabel) { 
     431        if (!splitDone) { 
     432             InterpreterBug.bug("Must split overload set before generating call(s)"); 
     433             return; 
     434        } 
     435 
     436        if (lessSpecificThanSoFar.size() == 1) { 
     437            // Emit casts and call of f. 
     438            Function f =  lessSpecificThanSoFar.iterator().next(); 
     439            List<Param> params = f.parameters(); 
     440            int i = firstArgIndex; 
     441            String sig = "("; 
     442            for (Param p : params ) { 
     443                mv.visitVarInsn(Opcodes.ALOAD, i); 
     444                String toType = NamingCzar.only.boxedImplDesc(p.getIdType().unwrap()); 
     445                sig += toType; 
     446                mv.visitTypeInsn(Opcodes.CHECKCAST, toType); 
     447                i++; 
     448            } 
     449            sig += ")"; 
     450            sig += NamingCzar.only.boxedImplDesc(f.getReturnType()); 
     451            mv.visitMethodInsn(Opcodes.INVOKESTATIC, "OLT", f.toString(), sig); 
     452            mv.visitInsn(Opcodes.ARETURN); 
     453 
     454        } else { 
     455            // Perform instanceof checks on specified parameter to dispatch to children. 
     456            Label lookahead = new Label(); 
     457            for (int i = 0; i < children.length; i++) { 
     458                OverloadSet os = children[i]; 
     459                mv.visitVarInsn(Opcodes.ALOAD, dispatchParameterIndex + firstArgIndex); 
     460                mv.visitTypeInsn(Opcodes.INSTANCEOF, NamingCzar.only.boxedImplDesc(os.selectedParameterType)); 
     461                mv.visitJumpInsn(Opcodes.IFEQ, lookahead); 
     462                os.generateCall(mv, firstArgIndex, failLabel); 
     463                mv.visitLabel(lookahead); 
     464                lookahead = new Label(); 
     465            } 
     466            mv.visitJumpInsn(Opcodes.GOTO, failLabel); 
     467        } 
     468    } 
     469 
     470    public String toString() { 
     471        if (lessSpecificThanSoFar.size() == 1) { 
     472            return lessSpecificThanSoFar.iterator().next().toString(); 
     473        } 
     474        if (splitDone) { 
     475            return toStringR(""); 
     476        } else { 
     477            return lessSpecificThanSoFar.toString(); 
     478        } 
     479    } 
     480 
     481    private String toStringR(String indent) { 
     482        if (lessSpecificThanSoFar.size() == 1) { 
     483            return indent + lessSpecificThanSoFar.iterator().next().toString(); 
     484        } else { 
     485            String s =  indent + "#" + dispatchParameterIndex + "\n"; 
     486            for (int i = 0; i < children.length; i++) { 
     487                OverloadSet os = children[i]; 
     488                s += indent + os.selectedParameterType + "->" + os.toStringR(indent + "   ") + "\n"; 
     489            } 
     490            return s; 
     491        } 
     492    } 
     493 
     494 
     495 
    392496} 

  • trunk/ant

    r3389 r3660  
    22 
    33################################################################################ 
    4 #    Copyright 2008 Sun Microsystems, Inc., 
     4#    Copyright 2009 Sun Microsystems, Inc., 
    55#    4150 Network Circle, Santa Clara, California 95054, U.S.A. 
    66#    All rights reserved. 
    … …  
    1818################################################################################ 
    1919 
    20 cd ProjectFortress 
    21 . ./ant 
     20# 
     21# For NetBeans, you should not need to adjust anything to 
     22# build and test Fortress. 
     23# 
     24# For Eclipse, workspace and ant builds should not require any 
     25# adjustments, but to run tests using Ant within Eclipse, you 
     26# will need to add junit.jar to 
     27# build.xml -> Run As -> Ant Build... -> Classpath -> User Entries -> Add JARs... 
     28# 
     29 
     30find_ant(){ 
     31  # Strip "." from the path, and look for ant. 
     32  # This avoids infinite regress if this is the first or only "ant" on the normal PATH. 
     33  export NODOTPATH="`echo "$PATH" | sed -e '1,$s/^[.]://g'`" 
     34  NODOTPATH="`echo "$NODOTPATH" | sed -e '1,$s/:[.]:/:/g'`" 
     35  NODOTPATH="`echo "$NODOTPATH" | sed -e '1,$s/:[.]$//g'`" 
     36  result="`(PATH="$NODOTPATH" which ant 2>/dev/null)`" 
     37  if [ -z "$result" ]; then 
     38    echo "Could not find ant. You need to install it. See http://ant.apache.org/ for details." >&2 
     39    exit 1 
     40  fi 
     41  echo $result 
     42  exit 0 
     43} 
     44 
     45ant_exec="`find_ant`" 
     46n=$? 
     47if [ $n -ne 0 ]; then 
     48        exit $n 
     49fi 
     50 
     51# Note that the scripts reference must export their symbols so that they are available below. 
     52. ./antrc_suggested 
     53 
     54"$ant_exec" -noclasspath "$@"