ROSE (pre-release beta version: 0.9.5a)
   --- using EDG C/C++ front-end version: edg-3.3
   --- using OFP Fortran parser version: ofp-0.8.2

This ROSE translator provides a means for operating on C, C++, Fortran and Java
source code; as well as on x86, ARM, and PowerPC executable code (plus object files 
and libraries).

Usage: rose [OPTION]... FILENAME...

If a long option shows a mandatory argument, it is mandatory for the equivalent
short option as well, and similarly for optional arguments.

Main operation mode:
     -rose:(o|output) FILENAME
                             file containing final unparsed C++ code
                             (relative or absolute paths are supported)

Operation modifiers:
     -rose:output_warnings   compile with warnings mode on
     -rose:C_only, -rose:C   follow C89 standard, disable C++
     -rose:C99_only, -rose:C99
                             follow C99 standard, disable C++
     -rose:Cxx_only, -rose:Cxx
                             follow C++ 89 standard
     -rose:Java, -rose:java, -rose:J, -rose:j
                             compile Java code (work in progress)
     -rose:OpenMP, -rose:openmp
                             follow OpenMP 3.0 specification for C/C++ and Fortran, perform one of the following actions:
     -rose:OpenMP:parse_only, -rose:openmp:parse_only
                             parse OpenMP directives to OmpAttributes, no further actions (default behavior now)
     -rose:OpenMP:ast_only, -rose:openmp:ast_only
                             on top of -rose:openmp:parse_only, build OpenMP AST nodes from OmpAttributes, no further actions
     -rose:OpenMP:lowering, -rose:openmp:lowering
                             on top of -rose:openmp:ast_only, transform AST with OpenMP nodes into multithreaded code 
                             targeting GCC GOMP runtime library
     -rose:UPC_only, -rose:UPC
                             follow Unified Parallel C 1.2 specification
     -rose:UPCxx_only, -rose:UPCxx
                             allows C++ within UPC (follows UPC 1.2 but simpily allows 
                             using C++ as the base language) (not a legitimate language, 
                             since there is no backend compiler to support this).
     -rose:upc_threads n     Enable UPC static threads compilation with n threads
                             n>=1: static threads; dynamic(default) otherwise
     -rose:Fortran, -rose:F, -rose:f
                             compile Fortran code, determining version of
                             Fortran from file suffix)
     -rose:CoArrayFortran, -rose:CAF, -rose:caf
                             compile Co-Array Fortran code (extension of Fortran 2003)
     -rose:CAF2.0, -rose:caf2.0
                             compile Co-Array Fortran 2.0 code (Rice CAF extension)
     -rose:Fortran2003, -rose:F2003, -rose:f2003
                             compile Fortran 2003 code
     -rose:Fortran95, -rose:F95, -rose:f95
                             compile Fortran 95 code
     -rose:Fortran90, -rose:F90, -rose:f90
                             compile Fortran 90 code
     -rose:Fortran77, -rose:F77, -rose:f77
                             compile Fortran 77 code
     -rose:Fortran66, -rose:F66, -rose:f66
                             compile Fortran 66 code
     -rose:FortranIV, -rose:FIV, -rose:fIV
                             compile Fortran IV code
     -rose:FortranII, -rose:FII, -rose:fII
                             compile Fortran II code (not implemented yet)
     -rose:FortranI, -rose:FI, -rose:fI
                             compile Fortran I code (not implemented yet)
     -rose:strict            strict enforcement of ANSI/ISO standards
     -rose:binary, -rose:binary_only
                             assume input file is for binary analysis (this avoids
                             ambiguity when ROSE might want to assume linking instead)
     -rose:astMerge          merge ASTs from different files
     -rose:astMergeCommandFile FILE
                             filename where compiler command lines are stored
                             for later processing (using AST merge mechanism)
     -rose:compilationPerformanceFile FILE
                             filename where compiler performance for internal
                             phases (in CSV form) is placed for later
                             processing (using script/graphPerformance)
     -rose:exit_after_parser just call the parser (C, C++, and fortran only)
     -rose:skip_syntax_check skip Fortran syntax checking (required for F2003 and Co-Array Fortran code
                             when using gfortran versions greater than 4.1)
     -rose:relax_syntax_check skip Fortran syntax checking (required for some F90 code
                             when using gfortran based syntax checking)
     -rose:skip_rose         process command line and call backend directly,
                             skipping all ROSE-specific processing
     -rose:skip_transformation
                             read input file and skip all transformations
     -rose:skip_unparse      read and process input file but skip generation of
                             final C++ output file
     -rose:skipfinalCompileStep
                             read and process input file, 
                             but skip invoking the backend compiler
     -rose:collectAllCommentsAndDirectives
                             store all comments and CPP directives in header
                             files into the AST
     -rose:excludeCommentsAndDirectives PATH
                             provide path to exclude when using the
                             collectAllCommentsAndDirectives option
     -rose:excludeCommentsAndDirectivesFrom FILENAME
                             provide filename to file with paths to exclude
                             when using the collectAllCommentsAndDirectives
                             option
     -rose:includeCommentsAndDirectives PATH
                             provide path to include when using the
                             collectAllCommentsAndDirectives option
     -rose:includeCommentsAndDirectivesFrom FILENAME
                             provide filename to file with paths to include
                             when using the collectAllCommentsAndDirectives
                             option
     -rose:skip_commentsAndDirectives
                             ignore all comments and CPP directives (can
                             generate (unparse) invalid code if not used with
                             -rose:unparse_includes)
     -rose:prelink           activate prelink mechanism to force instantiation
                             of templates and assignment to files
     -rose:instantiation XXX control template instantiation
                             XXX is one of (none, used, all, local)
     -rose:read_executable_file_format_only
                             ignore disassemble of instructions (helps debug binary 
                             file format for binaries)

GNU g++ options recognized:
     -ansi                   equivalent to -rose:strict
     -fno-implicit-templates disable output of template instantiations in
                             generated source
     -fno-implicit-inline-templates
                             disable output of inlined template instantiations
                             in generated source

Informative output:
     -rose:help, --help, -help, --h
                             print this help, then exit
     -rose:version, --version, --V
                             print ROSE program version number, then exit
     -rose:markGeneratedFiles
                             add "#define ROSE_GENERATED_CODE" to top of all
                               generated code
     -rose:verbose [LEVEL]   verbosely list internal processing (default=0)
                               Higher values generate more output (can be
                               applied to individual files and to the project
                               separately).
     -rose:output_parser_actions
                             call parser with --dump option (fortran only)
     -rose:output_tokens     call parser with --tokens option (fortran only)
                             (not yet supported for C/C++)
     -rose:embedColorCodesInGeneratedCode LEVEL
                             embed color codes into generated output for
                               visualization of highlighted text using tview
                               tool for constructs specified by LEVEL
                             LEVEL is one of:
                               1: missing position information
                               2: compiler-generated code
                               3: other code
     -rose:generateSourcePositionCodes LEVEL
                             generate separate file of source position
                               information for highlighting original source
                               file using tview tool for constructs specified
                               by LEVEL
                             LEVEL is one of:
                               1: statements, preprocessor directives and
                                  comments
                               2: expressions

Control EDG frontend processing:
     -edg:new_frontend       force use of external EDG front end (disables use
                               of rest of ROSE/SAGE)
     -edg:KCC_frontend       for use of KCC (with -c option) as new frontend
                               (must be specified with -edg:new_frontend)
     -edg:XXX                pass -XXX to EDG front-end
    --edg:XXX                pass --XXX to EDG front-end
     -edg_parameter: XXX YYY pass -XXX YYY to EDG front-end
    --edg_parameter: XXX YYY pass --XXX YYY to EDG front-end

Control Fortran frontend processing:
     -rose:cray_pointer_support
                             turn on internal support for cray pointers
                             (Note: not implemented in front-end (OFP) yet.)
     -fortran:XXX            pass -XXX to independent semantic analysis
                             (useful for turning on specific warnings in front-end)

Control Disassembly:
     -rose:disassembler_search HOW
                             Influences how the disassembler searches for instructions
                             to disassemble. HOW is a comma-separated list of search
                             specifiers. Each specifier consists of an optional
                             qualifier followed by either a word or integer. The
                             qualifier indicates whether the search method should be
                             added ('+') or removed ('-') from the set. The qualifier
                             '=' acts like '+' but first clears the set.  The words
                             are the lower-case versions of the Disassembler::SearchHeuristic
                             enumerated constants without the leading "SEARCH_" (see
                             doxygen documentation for the complete list and and their
                             meanings).   An integer (decimal, octal, or hexadecimal using
                             the usual C notation) can be used to set/clear multiple
                             search bits at one time. See doxygen comments for the
                             Disassembler::parse_switches class method for full details.
     -rose:partitioner_search HOW
                             Influences how the partitioner searches for functions.
                             HOW is a comma-separated list of search specifiers. Each
                             specifier consists of an optional qualifier followed by
                             either a word or integer. The qualifier indicates whether
                             the search method should be added ('+') or removed ('-')
                             from the set. The qualifier '=' acts like '+' but first
                             clears the set.  The words are the lower-case versions of
                             most of the SgAsmFunctionDeclaration::FunctionReason
                             enumerated constants without the leading "FUNC_" (see
                             doxygen documentation for the complete list and and their
                             meanings).   An integer (decimal, octal, or hexadecimal using
                             the usual C notation) can be used to set/clear multiple
                             search bits at one time. See doxygen comments for the
                             Partitioner::parse_switches class method for full details.
     -rose:partitioner_config FILENAME
                             File containing configuration information for the
                             instruction/block/function partitioner. This config
                             file can be used to override block successors,
                             alias two or more blocks that have identical
                             semantics, assign particular blocks to functions,
                             override function return analysis, provide or
                             override function names, etc. See documentation for
                             the IPDParser class for details.

Control code generation:
     -rose:unparse_line_directives
                               unparse statements using #line directives with
                               reference to the original file and line number
                               to support view of original source in debuggers
                               and external tools
     -rose:unparse_instruction_addresses
                               Outputs the addresses in left column (output
                               inappropriate as input to assembler)
     -rose:unparse_raw_memory_contents
                               Outputs memory contents in left column
     -rose:unparse_binary_file_format
                               Outputs binary executable file format information
     -rose:unparse_includes
                               unparse all include files into the source file.
                               This is a backup option for fail-safe processing
                               of CPP directives (which can be tricky)
     -rose:C_output_language
                             force use of C as output language (currently
                               generates C/C++)
     -rose:Cxx_output_language
                             force use of C++ as output language
     -rose:Fortran_output_language
                             force use of Fortran as output language
     -rose:Promela_output_language
                             force use of Promela as output language (not
                               supported)
     -rose:PHP_output_language
                             force use of PHP as output language
     -rose:outputFormat      generate code in either fixed/free format (fortran only)
                               options are: fixedOutput|fixedFormatOutput or 
                                            freeOutput|freeFormatOutput
     -rose:backendCompileFormat
                             use backend compiler option to compile generated code
                               in either fixed/free format (fortran only)
                               options are: fixedOutput|fixedFormatOutput or 
                                            freeOutput|freeFormatOutput

Testing Options:
     -rose:negative_test     test ROSE using input that is expected to fail
                               (returns 0 if input test failed, else error if
                               passed)
     -rose:test LEVEL        limit parts of ROSE which are run
                             LEVEL is one of:
                               0: transparent (ROSE translator does nothing)
                               1: run the KCC front end only (assumes it is in
                                    path)
                               2: run the newer version of EDG (compiled
                                    separately from SAGE) 'edgFrontEnd'
                                    (see
                                    src/frontend/EDG/EDG_3.3/src/Makefile.am
                                    for instructions on how to build EDG
                                    without SAGE III)
                               3: run internal (older) version of edg front end
                                    (deprecated option)
                               4: same as 3 plus parse into Sage III program
                                    tree
                               5: same as 4 plus unparse untransformed source
                                    code
                               6: same as 5 plus compile generated source code
                               7: same as 5 plus build higher level grammars
                                    before unparsing
                               8: same as 6 plus run midend (transformations)
                                    before unparsing

Report bugs to <dquinlan@llnl.gov>.
