Report Banner - Edit rsm.cfg File

           Resource Standard Metrics (TM) for C, C++, C# and Java
                   Version 7.71 -

  License Type: Company Site License
  Licensed To : M Squared Technologies LLC
  License No. : ST1000                          License Date: Mar 06, 2013
  Build Date  : Mar  7 2013                         Run Date: Mar 07, 2013
  (C)2013 M Squared Technologies LLC

  License File: C:\Program Files\MSquared\M2 RSM\rsm.lic
  Config. File: C:\Program Files\MSquared\M2 RSM\rsm.cfg
  Command Line: -Orsm_manual.txt -hf 
                         ~ RSM Help Documentation~ 

  Resource Standard Metrics provides a standardized approach to measure the
  quantity and quality of source code within a module or a project.  This
  program can analyze a C, C++, Java or C# source for metrics and semantic
  quality problems that most compilers do not identify.

                    ~ Source Code Metrics and Analysis ~

  RSM measures source code for quantity and quality metrics.  Size metrics
  are described by counting "lines of code".  Source code quality analysis
  is measured by semantic analysis of the code beyond the syntax rules of
  the language.

       (LOC) A line of code is defined as a line within a source file
       that is not a comment or blank line.  Lines that contain both
       source code and comments are counted as an instance of each.

       (eLOC) Resource Standard Metrics defines an effective line of code
       as a LOC which is not a stand-alone braces {} or parenthesis ().
       This metric more accurately defines the quantity of work performed in
       a source code module and is an invention of M Squared Technologies.
       We have found that eLOC is the metric we intuitively estimate as
       experienced software engineers.

       (lLOC) Logical Lines of code are defined as code statements or
       those lines which end in a semicolon.  The "for" loop structure
       accounts for one lLOC.

       Source code line              LOC   eLOC  lLOC  Comment  Blank
       if (x<10)   // test  range     x      x            x
       {                              x
         // update y coordinate                           x
          y = x + 1;                  x      x     x
       }                              x

  Logical lines within a source file can exceed the physical lines within a
  file code and comments occur on the same physical line.  The sum of code,
  blanks and comments equates to the logical lines.  Metrics programs that
  show code, comments and blank lines equal to the physical lines are not
  accounting for a second instance of code or comments.

  Various key words and statements are provided for code analysis.
  Readability and code quality can easily be determined by analyzing
  the quality notices, comment percentage, white space content and key
  words used within the source code.

                            ~ Program Operation ~

  Source files may be processed via wild cards, recursively down a file tree
  or from a specified list of files or directories.  The evaluation copy of
  this program will only process 20 files at one execution.  Files are normally
  processed in the order they are discovered by the input mode.  The option
  -Rn will sort the input list alphabetically for sorted processing.  The -F
  option processes a specific list of files or directories.

  RSM operates through a series of switches and options.  RSM processes
  files via several input modes and creates reports via several output modes.
  This user manual details the input modes, output formats, modes and runtime

  Switches start with a dash: -h -s -w
  Some switches can have options : -hs -wg
  Some switches have compound options: -O"my output file.txt" where
  the compound options must be delimited by quotes and be adjacent to the switch

                         ~ Operation Step by Step ~

  RSM is designed to operate according to the following process.
  Each step of the process is covered in detail in this manual.

  Step 1: Determine the output format, -H -C -X or no switch for text.
          "no option"                ASCII UNIX Text Format
          -C                         CSV format for spreadsheet import
          -X                         XML format for use with XSL files
                                     use with -u"File XSL /tmp/some.xsl"
                                     for custom HTML reports
          -H                         HTML format with hyperlinks

  Step 2: Determine the output file relative to the format.
          -O"report.htm" -H          WWW Browser Report
          -O"my report.csv" -C       Spreadsheet Report
          -O"report.txt"             Text Report

          An option to using the -O option is the use of the shell
          redirection to a file.  This is useful if a DOS text file
          is desired versus the RSM -O UNIX text format.
          rsm -s *.cpp > report.txt

  Step 3: Specify the report type using the various report switches
          individually or by aggregation.
          -fa -c -o                  Functions, Complexity, Objects
          -Es -Ec                    Extract strings and comments
          -hs                        Help Syntax

  Step 4: Specify the file input mode using file names, wild cards,
          file lists or recursive descent.
          .\inc\anyfile.h            Ordinary file names.
          *.h *.cpp                  Wild cards, command line expansion
          -F"somefilelist.txt"       File list of names and directories
          -r"h,c,cpp,java,cs ."      Recursive descent where . specifies
          -r"h,cpp,java,cs /project" The current working directory.

  Step 5: Creating the RSM command line.
          rsm anyfile.h anyfile.cpp
          rsm -O"analysis.txt" -n \proj\*.h \proj\*.cpp
          rsm -O"metrics.txt" -Ta -Tl -TN -F"project1_list.txt"
          rsm -H -O"metrics.htm" -fa -c -o -r"h,cpp,java,cs ."
          rsm -C -O"metricsdiff.csv" -w"x baseline1.dat, baseline2.dat"
          rsm -X -O"metricsdiff.xml" -u"File XSL /tmp/myrep.xsl" -w"x baseline1.dat, baseline2.dat"

                          ~ Program License File ~

  RSM uses an encrypted license file to provide each user with a
  unique license tailored to each user's runtime requirements.  RSM will
  look for the license file rsm.lic at the location specified by the
  environment variable RSMLICHOME before RSMHOME.

  If the license file is not found at the RSMLICHOME or RSMHOME location,
  RSM will search the system PATH for the rsm.lic file.  If the license file
  cannot be located, RSM will warn the users and default to the SHAREWARE
  mode.  If the rsm.lic file detects that the file contents have been
  modified, RSM will default to the SHAREWARE mode.  Hacking the RSM
  license file will void the end user license agreement.

                          ~ Program Configuration ~

  RSM is configured from a configuration file, rsm.cfg.  If the configuration
  file is not found, RSM creates a configuration file. You can edit the
  configuration file with an ASCII editor to change the operation parameters
  of RSM.  The configuration file is heavily commented to assist in this
  customization.  You may use the -hc option to examine the rsm.cfg file.

  RSM looks for the rsm.cfg file at the location where the license file
  was found. The rsm.cfg file, like the license file should be placed in
  a directory is located on your system path.  The file name has to be

                        ~ Source File Requirements ~

  RSM is designed to process only source code from the C, ANSI C, C++
  ANSI C++, Java 2.0, and C# languages. RSM requires that each source
  file be compilable.  RSM reads no preprocessor directives so that it
  may analyze all the source within a file.  RSM will always process header
  files prior to source files unless overridden by wild card ordering.

  There may be macros used within the source code of which RSM may not be
  aware.  Windows defines macros and keywords that are outside the language
  specification.  These macros must be defined to RSM in the rsm_macro.cfg
  file.  This configuration file is located with the rsm.cfg configuration

                          ~ Switches and Options ~

  RSM uses runtime switches to configure its operation.  There are two types
  of switches.  The plain switch takes no parameter and the complex switch
  requires a modification parameter.  Switches like f, o, v, c are plain
  switches that may be specified by using a dash for each switch or by running
  them as a single string.

       i.e.  Plain Switches:  rsm -fa -o -c -m -n -v *.cpp

  Complex switches must be separated by a dash(-) for each switch.  Each
  complex switch requires an additional modifier.

       i.e.  Compound switche options: rsm -k4 -r"h,cpp c:\src"

                 ~ Files/Directories Names and Wild Cards ~

  The Windows operating system requires DOS type paths and filenames. The UNIX
  OS requires UNIX paths and filenames.  Under Windows, filenames are case
  insensitive where in UNIX they are case sensitive.  The rsm.cfg configuration
  file has a setting that must reflect the case sensitive aspect of the (OS)
  operating system or incomplete identification of files may result.

  Windows files or directories with spaces within their names must have these
  names delimited with quotation marks, "c:\Program Files".

       i.e.  normal with wild cards: rsm -fa -c *.c *.cc
             recursive descent:      rsm -fa -o -r"c,cc,h,hh /proj"
             read a file list:       rsm -fa -o -c -F"filelist.txt"
       (Windows)                     rsm -fa -c c:\src\*.h c:\src\*.c
       (UNIX)                        rsm -fa -c /src/*.h /src/*.c

                      ~ Source Code File Input Modes ~

  RSM processes files in one of four modes.  Modes cannot be mixed.

       1. Direct Files
          rsm -fa -o /proj/src/filename.cpp

       2. Wild Cards
          rsm -fa -o /proj/inc/*.h /proj/src/*.cpp
          Note: The order of header files must come before cpp files.

       3. Recursive descent of a directory tree
          rsm -fa -o -r"h,cpp /proj/src"

       4. Reading from a list of files or directories
          rsm -fa -o -F"/proj/filelist.lst"

                          ~ Program Output Modes ~

  RSM can output its reports in three modes.  Modes cannot be mixed.

       1. Direct output to the screen
          rsm /proj/src/filename.cpp

       2. Direct output to a file
          rsm -O"report.txt" proj/src/*.cpp

       3. Redirection to a file
          rsm -r"h,cpp /proj/src" > report.txt

                       ~ Program Output File Formats ~

  RSM can create reports in four formats, text, HTML, CSV, and XML.

       1. Text or default mode
          rsm -O"report.txt" *.h *.cpp

       2. HTML Format
          rsm -O"report.htm" -H *.h *.cpp

       3. Comma Separated Variables (spreadsheet import)
          rsm -O"report.csv" -C -fa *.h *.cpp
       4. XML Format
          RSM -O"report.xml" -X -u"File XML myreport.xsl" -Td *.cpp

                         ~ Run Time Switch Options ~

  This document is a simple contextual reference to help users with RSM
  switches and options.

  The options shown with an asterisk '*' can be aggregated together to form
  compound reports.  Some experimentation will be required to find the
  combination of options that yield the desired result.  For a complete
  cross correlation of all switches and options, please reference the 
  on-line manual.

  Detailed use and examples for runtime switchs/options can be found through
  the user's manual located in the rsm directory, manual.htm.  Open this file
  in a web browser or access the manual via the internet at:

  * Allocation/De-allocation of Memory Mode

  Produces metrics on memory creation through the counting of instances
  of malloc, calloc, realloc and new.  Memory de-allocation is measured
  by counting free and delete.  This metric is useful for focusing on
  functions which use dynamic memory.  Most program bugs can be attributed
  to problems in dynamic memory management.

       i.e.  rsm -a *.c

  * Benchmark Mode

  This mode tracks the CPU, User, Wait and elapsed time for the running
  of RSM.  This mode is intended to create a timing metric for RSM so
  that the time required to execute metrics is known.  It may also
  serve as a benchmark for comparing RSM to other like products,
  although no other products are known which have as many features as RSM.

       i.e.  rsm -b *.c

  * CSV File Output Format

  The CSV mode creates a Comma Separated Variables output for import
  of metrics directly into spreadsheet programs.  This output can be
  redirected to a file then directly opened by MS Excel.

       -C -fa  Functions and Files
       -C -fp  Function points derived from LOC
       -C -i   Inheritance Tree
       -C -s   File Summary
       -C -T*  All -T reports
       -C -w"x old.dat, new.dat"  Work file extraction

       i.e.  rsm -C -fa *.cpp *.c > metrics.csv
             rsm -C -Ta -k5 *.h *.cpp > metrics.csv
             rsm -C *.h *.cpp > diff.csv
             rsm -C -O"baseline_diff.csv" -wp -w"x oldfile.dat, newfile.dat"
             rsm -C -Ti -O"proj_inherit.csv" -F"projfiles.txt"

  * Complexity Mode

  This mode measures both cyclomatic complexity and function interface
  complexity.  Function cyclomatic and interface complexity are combined
  to form function total complexity.

  Cyclomatic complexity is consistent with McCabe's definition where each
  decision point or predicate node is counted plus 1 for the function body.
  Cyclomatic complexity describes the number of logical pathways through a
  function and is typically used to asses whether a function can be de-
  composed into several functions.  V(g) is the symbol used to describe
  this metric.  This metric can also indicate the number of test cases
  required in unit test to fully test a method.

  You may redefine how RSM calculates the cyclomatic complexity by modifying
  the cyclomatic complexity includes that are detailed in the rsm.cfg file.
  You may generate the initial configuration file by using the -y parameter.
  The default behavior for RSM is McCabe compatibility.

  Functional interface complexity is calculated by summing the number
  of function input parameters and the number of return states.  This
  metric can be useful when analyzing the complexity of a function's
  interface.  A function's estimated size can be related to a function's
  interface complexity using the -e option.

  Function complexity is calculated by the sum of cyclomatic complexity and
  the interface complexity.  The maximum and average complexity is reported
  for the file and for all files processed or the entire project.

       i.e.  rsm -c *.java

  De-Character Source Files

  De-character source code to remove tabs and convert source code from
  DOS to UNIX and UNIX to DOS format.  This option operates in a
  standalone mode and modifies the original source.  You must have the
  source code "checked out" and have write permissions to use this

       -Dt   Remove tabs where the tabs/space setting is in the
             rsm.cfg file.
       -Dd   Create DOS formatted files where each line terminates
             in a carriage return and new line.
       -Du   Create UNIX formatted files where each line terminates
             in a new line.

       i.e.  rsm -Dt -Du *.h *.cpp
             rsm -Dt -Dd -r"h,c,cpp,java,cs c:\proj\game"

  Deterministic Mode

  This mode will show the user how a line of code is interpreted by RSM
  Many metrics tools yield metrics that create metrics of LOC, Comments
  and blanks lines.  When these metrics are added, the number equals the
  number of physical lines.  Therefore, if comments are on the same line
  as the code, what metrics has the tool not accounted for.

  RSM counts all LOC, comments and blanks and sums these metrics into a
  logical line count that usually is greater then the physical line count.
  RSM measures effective lines of code by accounting for the lines of
  code that are single "{", "}", "};", "(" or ")" characters.

       i.e.  rsm -d source.c

  This mode produces the validation of the given source against the LOC
  algorithm of Resource Standard Metrics.  Output will echo each
  line of code and a state of the LOC determination.
  Example Output:
  Line 1: /* functions using pointers to functions */
  LOC Type(s): <C Comment>
  Line 2:
  LOC Type(s): <Blank>
  Line 3: void calculate(int x) /*standard includes*/
  LOC Type(s): <Code> <C Comment>
  Line 4: {
  LOC Type(s): <Non-Effective LOC>

  Extract Strings or Comments from Source Code

  Extract strings or comments from a source file.  This feature allows
  for the creation of a file which contains text.  The file can be
  processed by spell checker such as MSWord or GNU ispell. Each string
  and/or comment is output with the line number where it is located
  within the source file.  This option should be used without any other
  RSM formatting options.

       -Ec   Extract comments
       -Es   Extract literal strings
       -EC   This mode extracts comments relative to functions and
             classes for the specified files by either wild cards or
             file specification options. This mode should not be used
             with other metrics options.

       i.e.  rsm -O"spellcheck.txt" -Es -Ec *.h *.cpp
             rsm -Es -r"h,c,cpp,java c:\proj\game" > spellcheck.txt
             rsm -EC *.cpp

  * Estimation Analysis Based on LOC and Complexity

  Estimation analysis presents LOC, eLOC, lLOC per: function
  input parameter; function return state; interface complexity
  (parameters + returns); cyclomatic complexity and total
  functional complexity (Interface + Cyclo) complexity.

       i.e.  rsm -e *.c

  * File List Mode

  This mode will process files and directories from a text list file.
  The list must be a text file compliant to the specified format.  The
  -RL mode can be helpful in creating a file list.
  This switch requires a compound option which much be delimited with
  quotes and located directly adjacent to the switch.

  Windows Command Line Example:
  c:\rsm\rsm.exe -k1 -TL -Rl -F"d:\Project 1\rsminput.txt"

  UNIX Command Line Example:
  /usr/rsm/rsm -k1 -TL -Rl -F"/Proj/rsminput.txt"

  File List Content Syntax

  File Format:
       Files must be the complete path and file name.
       i.e.  c:\project\src\

  Directory Format:
       Directories must the full path.  The following parameters to
       the directory are required for processing the directory.
             -r         Recursive descent of the directory
             -n         No Recursive descent
             c,h,cpp    Types string tells RSM which kind of files
             directory  Starting point for processing

       i.e.  -r java /proj/java/source
             -n h,cpp /proj/cpp/source

  Environment Variable Expansion:
       A line in the input file can expand environment variables to
       enhance the flexibility in programming mode.  The enviroment
       variable must be in the format %ENVAR% in the file line.

       i.e.  -r h,cpp %PROJ%

       This format is how RSM expands the environment variable regardless
       of the operating system or shell used.

  Example File

  -r h,c,cpp,java,cs %PROJ1%
  -n java d:\javasrc\src

  Note that no wild cards are valid in this mode.  Blank lines are ignored.
  Lines leading with a # character are not processed and considered comments.

  * Function Analysis Mode

  Functional analysis mode determines the functions in a source file and
  if quality notices are turned on, it will perform quality checking upon
  the functions.  Modes -f and -n are often used together.

       -fa  Functional LOC and Identification Analysis
       -fd  Functional cyclomatic complexity detailed metrics
            Shows counts of branching structures, works with -c and -fa
       -fp  Function Points derived from LOC metrics.  The default values
            originate from:
            Applied Software Measurement, Caper Jones, McGraw Hill, 1996.

            Language  LOC per Function Point
            C         128
            C++       53
            C#        53
            Java      53

       -fm  Function methods and attributes annotated from a class.

       i.e.  rsm -fa -fp -n *.c

  * HTML Output Mode

  This mode creates HTML output with color, fonts and hyperlinks to the report
  files.  Such output is meant to be processed by a WWW browser like Netscape
  Navigator or MS Explorer.  You may set the background color of the HTML
  reports by setting the associated parameter in the rsm.cfg file.  If the
  background is not set, then the browser default background color will be
  used.  The HTML option is designed for use with all RSM reports and options
  designated with an asterisk '*'.

      i.e.  rsm -H -O"metrics.htm" -fa -cn *.c
            rsm -H -O"metrics.htm" -wp -w"x rm122819.97, rm122919.97"
            rsm -H -w"x rm122819.97, rm122919.97" > metrics.html

  The HTML text, vlink and link color must be specified together to
  override the standard browser default.  You may redefine the specified
  HTML colors by setting the configuration item associated with each
  color.  HTML colors may be specified by the #000000 hex value or by
  the text word.

  HTML hyperlinks are by default the literal file name.  If you
  desire relative hyperlinks you can set the associated rsm.cfg file
  setting, Relative HTML Links: Yes.

  Help Mode

  Produces the help output.  Such output can be printed under UNIX
  by piping the output to a printer (lpr) or redirecting it to a file.
       -hc  Configuration Settings
       -hs  Syntax only
       -hf  Full Help Text Document
       -hl  License Information
       -hn  Quality Notice Types
       -hp  Small Syntax and Pause Prompt
       -hu  EULA, End User License Agreement
       i.e.  rsm -hs | lpr
             rsm -hf > help.txt
             rsm -O"help.txt" -hf
       i.e.  rsm -hs > prn
             rsm -hf > help.txt

  * Inheritance Tree Generation

  This mode will generate an inheritance tree of all classes in the
  current file set.  It is assumed that the user creates a file set
  that has some meaning to a design.  When using wild cards, one should
  process header files before the implementation files.

       i.e.  rsm -i *.h *.cpp

  * Key for Report Sorting

  This mode will sort the respective summary data as specified by the key
  numeric identifier.  This mode requires a modifier as specified below.

       -kd   Sort in descending order, default is ascending
       -k0   No sorting methods -T reports (default & fastest operation)
       -k1   Sort by namespace/package, class or function name
       -k2   Sort by LOC
       -k3   Sort by eLOC
       -k4   Sort by lLOC
       -k5   Sort by Cyclomatic Complexity
       -k6   Sort by Work File Difference State
       -k7   -Td report sorted by function count
       -k8   -Td report sorted by quality notice count
       -k9   -Td report sorted by file date
       -k10  -Td report sorted by file size

       i.e.  rsm -fa -o -k3 *.h *.cpp

  * List Function Name Mode

  This mode produces a list of functions that can be cut and pasted from
  the output into the comment header of the file which was processed.  It
  will create a report where all function names are correlated with their
  parent file.  This is useful when documenting the system.

       i.e.  rsm -l *.cc *.c

  Example Output:
    Function: Show
    Function: Drawable::Drawable
    Function: Drawable::Show

  * Macro Mode

  Macro mode is similar to function mode except it reports the names of
  the macros within the source.  Macros are a common cause of maintenance
  and portability headaches, so locating their existence is quite

  In Windows code there may be an occurrence of placing a macro between the
  function name and the function open parenthesis or between the class
  name and the opening brace.  You must tell RSM about the macros by either
  processing the macro prior to its use or you may added the macro by
  name to a special file called rsm_macro.cfg.  Names in this file
  are read at startup so that RSM knows about your macros defined in other
  portions of the code that may not be processed by RSM.  The rsm_macro.cfg
  file is located with your rsm.lic license file.

       i.e.  rsm -O"metrics.txt" -fa -m *.c

  * Quality Notice Format Mode

  Quality notices by default are displayed in a verbose format.
  This option displays a single line summary of the quality notice.

       -Ns  Single line summary format
       -Nv  Visual Studio and KAWA interactive format

  Quality notices output in Visual Studio format allows the user,
  inside Visual Studio environment, to double click on a quality
  notice and jump directly to the file and specified line number.  For
  specific information on setting up RSM as an integrated tool to Visual
  Studio visit the RSM web site,

       i.e.  rsm -fa -o -c -Nv *.h *.cpp
       i.e.  rsm -fa -o -c -Ns *.h *.cpp

  * Quality Notice Mode

  Turns on quality checking on the source for approximately 50
  common problems which create difficult maintenance, porting or
  semantic bugs the compiler simply misses.  This mode will return
  the number of notices to the operating system upon RSM normal
  exit.  This will enable scripting languages to pick up the non-zero
  exit state and flag the end user.

       i.e.  rsm -O"metrics.txt" -fa -n *.cc *.c *.cpp

  * Output Report to a file

  This mode routes the RSM report from the stdout or screen to a file.
  If the file cannot be opened, RSM will output the report to the screen.
  This switch requires a compound option which much be delimited with
  quotes and located directly adjacent to the switch.

       i.e.  rsm -H -o -fa -O"rsm_report.htm" *.cc *.cpp
             rsm -C -Ta -O"rsm_report.csv" -F"project_files.txt"
             rsm -O"proj.txt" -r"h,c /proj"

  * Object Class/Struct Metrics

  This mode details metrics for each class specification identified
  within the source code.  Metrics include LOC, lines of code, eLOC,
  comments, blanks, the number of public, protected, private
  attributes and methods.  If a class implements inheritance, it is
  shown with the respective base classes.

       i.e.  rsm -o -fa *.cc *.cpp

  Print Format, Code Listing Mode

  This mode generates a code listing for the files specified by
  name, wild card, file list or recursive mode.  Files are created with
  a user specified header, file name, page number, file date and line
  numbers for each line of code.  Line numbers correspond with the
  line numbers generated from other RSM modes.  This output is
  suitable for publication and peer reviews.

       i.e.  rsm -p *.cc *.c *.cpp
             rsm -p -F"filelist.txt"
             rsm -p -r"cpp,h,hh ."

  Page format switches that apply to print code-listing mode.
       -B1          Top Margin,  Default 0
       -M10         Left Margin, Default 5
       -P66         Page Length, Default 55
       -L72         Line Length, Default 80

       i.e..  rsm -O"lst.txt" -p -B5 -M5 -P60 -L78 -S"My Code" .\src\*.c

  * Read File Processing Options

  RSM processes files from 1 of four modes.
       1. Direct Files
          rsm -fa -o /proj/src/file
       2. Wild Cards
          rsm -fa -o /proj/src/*.cpp
       3. Recursive descent of a directory tree
          rsm -fa -o -r"h,cpp /proj/src"
       4. Reading from a list of files or directories
          rsm -fa -o -F"/proj/filelist.lst"

  The following options modify the way RSM processes the files
  to be analyzed.

       -Rl Generate a list of all files which will be processed
           in RSM operation.  This list may be cut from the report
           to provide a project file inventory or used at a stating
           point for creating a file list to process.  This option
           exits upon listing the files.

       -Rn Sort the file names found by the file read mode.
           Normally, RSM does not sort alphabetically, but this
           option will process files in a sorted order instead
           of the order they were listed or found in the directory

       -Rd This mode turn off recursive decent for a directory.
           This option does not apply to the recursive flag in the
           file list.  See the file list section for more information.

       i.e.  rsm -Rn *.h *.cpp
             rsm -Rn -r"c,cpp .\proj"
             rsm -Rd -r"h,cpp c:\Program Files\proj"

  * Recursive Descent Mode
  -r"ext,ext directory"

  Recursive descent mode will process all the specified files
  from a given point in the directory tree.  A file spec must
  be specified as a list of file extensions separated by commas.
  The starting point must be a directory.
  This switch requires a compound option which much be delimited with
  quotes and located directly adjacent to the switch.

       i.e.  rsm -r"h,c,cpp,java,cs c:\My Project"
             rsm -fa -a -c -r"c,cpp ./proj"
             rsm -fa -a -c -r"cc,c,h,hh .\mysrc"
             rsm -v -RN -r"h,c c:\srcs"

  * Summary Mode

  Summary mode summarizes the LOC, eLOC comments and blanks per file.
  This mode presents the metrics in a summarized format.

       i.e.  rsm -H -O"summary.htm" -s *.c

  String Title
  -S"Report Title String"

  The string specified places a report title at the top of the RSM
  report page.  Typically this is used to identify the project.

       i.e.  rsm -H -O"summary.htm" -s -S"My Project Metrics" *.c

  * Totals Only Mode

  This mode only displays project totals for all files processed.
  In this mode, other reporting data is suppressed.  This mode
  makes it easy to determine grand totals for your project.  This
  mode requires a modifier as specified below.  You may use the -k
  option for sorting the report by different keys.

       -Ta   All Totals, Functions, Classes, Interfaces, Namespaces
             Quality Notices and LOC Summary
       -Td   Total File Details List (-k sorting)
       -Tf   Total Functions
       -Ti   Inheritance Tree Only
       -Tl   Summaries Only, No Lists of functions, classes etc.
       -TL   Language Metric Summary
       -Tn   Quality Notices by file and line number
       -TN   No Filename output for total report
       -Tq   Total Quality Notice Summary List
       -To   Total Structs, Classes, Interfaces, Namespaces
       -Tp   Total Quality Notice Profile
       -Ts   Total LOC Summary
       -Tv   Total verbose metrics
       -Tw   Totals for work file metrics differentials

       i.e.  rsm -Ta -k3 *.c *.cpp
             rsm -Ta -TN -r"c,h c:\src"
             rsm -Tn -TN -r"c ./project"

  User Management Mode

  Administration mode for RSM has some features that are license dependent.
  The user log is called rsm.log and is located in the rsm directory.

       All RSM Licenses
       -us   Show User Log
       -u"File CFG path\file.cfg"  User defined RSM config file
       -u"File XML path\file.xsl"  User defined XML XSL translation

       Network License Options
       -ua   Archive the user log
       -ur   Remove user from the user log 

       i.e.  rsm -us
             rsm -ua
             rsm -ur

  * Verbose Mode

  Verbose output shows many metrics for each file and a grand
  total for all files.  This mode provides many different numbers
  which the user can interpret.

       i.e.  rsm -fa -o -a -c -m -n -v *.cpp *.c

  Work Analysis Based on Baseline Metric Differentials

  Work analysis is the capability to track LOC metrics on a specific
  code tree over time.  This facility will create a differential metrics
  file for use with the -wx mode.  The -wx mode can process any two work files.
  Some -w switches requires a compound option which much be delimited with
  quotes and located directly adjacent to the switch.

       -wb  Display the basis for estimate of the work productivity
            calculation.  This parameter is normally used with -wp and -wx

       -w"create baseline_top_dir"
            Creates a work file where all files are processed relative
            to the specified baseline top directory.  The work file name
            is by default named after the date, rm112220.00 and stored in
            the current working directory.  The work file name can be
            changed by using the -w"File dat " option.  If you desire
            non-relative files in the work file you can specify this in
            the rsm.cfg file.

            i.e.  rsm.exe -w"create c:\My Project" -r"h,cpp c:\My Project"

       -wD  Deterministic mode for differentials showing the format
            of the code differential file when using -wc.

       -wd  Perform individual file differentials for lines of code
            metrics.  The normal baseline metrics comparison mode
            shows a file is modified when a net change in LOC size is
            made to the size of the file in LOC.  This switch identifies
            lines in a file that have changed from one source file to
            another.  This mode create a differential file for each
            source file whereby being time and space intensive.  A
            modified file will show lines that have been added, delete
            and modified.  Each differential file name is shown using
            the -wv option.  This option is used with -wc and -wx.

       -we  This option does not process those files that are equal
            between the old baseline and new baseline.

       -w"File dat usernamedfile.dat"

            This option allows the user to specify the name of the
            generated work file.  The date named file rm081420.02 is replaced
            by the user specified filename.

            i.e.  rsm -w"File dat mywork.dat" -w"create ." -r"h,cpp,java ."

       -w"File cfg myconfig.cfg"
            This option allows the user to specify a configuration file
            for the baseline differential report.  Upon the first use of
            -wx, RSM generates the file rsm_workdiff.cfg.  This file maybe
            copied and tailored to provide the specific type of metrics
            differential report desired.  The use may specify which data
            metrics to include in the report and indicate how removed file
            metrics effect the total baseline metric in either a positive
            of negative manner.

            i.e.  rsm -wg -wp -w"File cfg mydiff.cfg" -w"x old.dat, new.dat"

       -wg  This option provide a glossary for the work differential
            report.  This information will help you understand the
            the abbreviations of the report.

       -wm  This option does not process those files that are modified
            between the old baseline and new baseline.

       -wn  This option does not process those files that are new
            between the new baseline and old baseline.

       -wp  This option creates productivity metrics based upon user defined
            data for work hours, days, shifts and man hours.  This data
            can be used to track and predict programmer productivity
            between baselines.

       -wr  This option does not process those files that are removed
            between the old baseline and new baseline.

       -ws  Show code differential details for each file showing line
            number, removed or modified, and line type.

       -wv  Verbose mode for metrics differential file names

       -w"x old.dat, new.dat"
            Work Analysis Extraction from Work Analysis Files
            This mode extracts the work analysis differential between two
            work analysis files.  These work analysis files must be based
            on the same code tree.  The reported metrics will show LOC
            information based upon the time differential between these
            two files.  Always specify the older baseline work file before the
            newer baseline work file.

            i.e.  rsm -w"x <ancestor file>, <current file>"
                  rsm -H -O"diff.htm" -w"x baseline1.dat, baseline2.dat"
                  rsm -C -O"diff.csv" -w"x rm111019.97, rm111419.97"

  * XML File Output Format

  The XML mode creates a extensible markup language output for the
  creation of customer HTML reports using an XSL translation or for
  parsing and input into other metrics accounting systems.  This mode
  is most powerful with the -u"File XSL file.xsl" switch.

       -X -T*  All -T reports
       -X -w"x old.dat, new.dat"  Work file extraction

       i.e.  rsm -X -Ta -k5 *.h *.cpp > metrics.xml
             rsm -X -u"File XSL report.xsl" *.h *.cpp > custom_report.xml
             rsm -X -O"baseline_diff.xml" -wp -w"x oldfile.dat, newfile.dat"
             rsm -X -Ti -O"proj_inherit.xml" -F"projfiles.txt"

  Extended Option Mode

  The extended options effect the basic operation of RSM.  These options
  usually include options that generically effect all reporting modes.

      -xNOCONFIG   No configuration file reporting in output
      -xNOCOMMAND  No command line reporting in output
      -xUDQNSHOW   Show the User Defined Quality Notices loaded from the
                   RSM configuration file, rsm.cfg.  An example file is
                   provided, rsm_udqn.cfg.
      -xNOWRAP     Do not wrap long names in reports.

  For Example:

  rsm -s -xNOCONFIG -xNOCOMMAND *.h *.cpp
  rsm -xUDQNSHOW

  RSM Configuration Parameters
  -y or -hc

  This option shows the RSM configuration parameters.  These settings
  can be made by specifying their values in the rsm.cfg file.

  The emitted format is compliant with the rsm.cfg syntax.  You can
  easily create the rsm.cfg file by redirecting the output to a file
  called rsm.cfg.

       i.e.  rsm -y > c:\rsm\rsm.cfg

  Please note the rsm.cfg and rsm.lic file must be found in a directory in
  the system path or at the location specified by the environment
  variable RSMHOME

                       ~ Support, Sales and Licenses ~

  Please contact M Squared Technologies for all RSM licenses.  All
  licenses turn on the unlimited file processing.

  License     : Company Site License
  Licensed To : M Squared Technologies LLC
  License No. : ST1000              
  License Date: 03/06/2009
  Compile Date: Mar  7 2009

  Paid Licenses include the latest revision, pre-compiled for Windows
  Vista/XP/2000 or UNIX.  Single user or Network licenses available.  UNIX
  licenses include un-modifiable source code for compiling on your exact
  machine and UNIX operating system.  The source is compilable on any ANSI
  UNIX C compiler.

  If the information you desire is not located in this manual please refer
  to the on-line manual on our website.

  Resource Standard Metrics and M Squared Technologies are Trademarks owned
  by M Squared Technologies.

                (C) 2013 M Squared Technologies
                    All rights reserved

                    Email     -
                    Web Site  -