NAME

       nescc - nesC compiler

SYNOPSIS

       nescc [-gcc=gcc-name] [-fnesc-gcc=gcc-name] [-fnesc-mingw-gcc]
           [-fnesc-target=architecture] [-fnesc-docdir=dir]
           [-fnesc-topdir=dir] [-fnesc-docs-use-graphviz] [-fnesc-is-app]
           [-fnesc-simulate]
           [-fnesc-nido-tosnodes=n] [-fnesc-nido-motenumber=expression]
           [-conly] [-fnesc-cfile=file] [-fnesc-gccize]
           [-fnesc-cppdir=directory] [-fnesc-separator=separator]
           [-fnesc-no-inline] [-fnesc-optimize-atomic]
           [--version] [-fnesc-include=file] [-fnesc-verbose] [-Wnesc-...]
           [-fnesc-dump=specification] [-fnesc-dumpfile=file]
           [-fnesc-scheduler=specification] [-fnesc-path=path]
           [-fnesc-no-debug]
           [-fnesc-deputy] [-fnesc-no-deputy]
           [-fnesc-default-safe] [-fnesc-default-unsafe]
           [any gcc option] files...

DESCRIPTION

       nescc  is an extension to gcc that knows how to compile nesC applications. If invoked on regular C files,
       it behaves exactly like gcc. When invoked on a nesC  component  or  interface  (.nc  extension)  file  it
       compiles  and  links  (except if the -c, -S, -conly, -E or -fsyntax-only options are used) that component
       with the other files specified on the command line.

OPTIONS

       nescc accepts all gcc options, and some additional nesC specific options:

       -gcc=gcc-name -fnesc-gcc=gcc-name
              Specify which gcc compiler to use to compile and link any C files, either explicitly specified, or
              generated as the output of the nesC-to-C compiler.  This option supports cross-compilation of nesC
              code (the usual mode of operation...).

       -fnesc-mingw-gcc
              Pass this option if the gcc version specified  with  -gcc=...  was  compiled  for  Window's  mingw
              environment, and hence expects Windows-style rather than Unix-style paths.

       -fnesc-target=architecture
              Specify  the  target architecture to compile for. Currently supported platforms are avr (the Atmel
              AVR family), msp430 (the TI MSP430 family) and self (the machine the nesC compiler is running on).
              If  you  use  the  env target, the architecture details are read from the NESC_MACHINE environment
              variable. See the separate env target documentation for details.

       -fnesc-docdir=dir
              Generate documentation for the compiled component in directory dir.

       -fnesc-topdir=dir
              Specify directory paths that should be  stripped  from  the  source  file  names  when  generating
              "package names" for the documentation files.

       -fnesc-docs-use-graphviz
              Explicitly  enable or disable the use of the graphviz tool in the generated documentation. Without
              this option, graphviz is enabled iff the dot program is found in the current path. Use of graphviz
              requires  dot.   The  documentation generation tool checks the version of dot, and enables client-
              side image maps, if supported.

       -fnesc-is-app
              Tell nescc that the source being compiled is an application, and to generate  an  app  description
              page for the entire application.

       -fnesc-simulate
              Compile for a simulation environment.

       -fnesc-nido-tosnodes=n, -fnesc-nido-motenumber=expression
              When  -fnesc-simulate  is  specified,  the  nesC program is compiled for a simulation environment,
              where a single executable will simulate n nodes. Specifically, in the generated code, each  global
              variable  becomes  an  n  element  array,  and  all  accesses to global variables are indexed with
              expression.

       -conly Just compile to C, leaving the generated source code for top-level-component  comp.nc  in  C  file
              comp.c (except if the -fnesc-cfile option is specified).

       -fnesc-cfile=file
              Specify  a  file  in  which  to save the C code generated when compiling a component. Note: if you
              specify two components on the command line, then the C code from the second one will overwrite the
              C code from the first.

       -fnesc-gccize
              Output  target-specific extensions as gcc-style attributes rather than using the target's original
              syntax. Can help if using -conly and sending the nesC output from some other tool that understands
              gcc attributes but not the target-specific extensions.

       -fnesc-cppdir=directory
              Save  all  preprocessing  results in directory. The directory is created if it doesn't exist. This
              can be helpful to track down preprocessor-related  compilation  problems.  You  probably  want  to
              ensure  that  directory  is  empty  when  you  call  nescc,  to  make it obvious which files where
              preprocessed as part of the current compilation.

       -fnesc-separator=separator
              Set separator used to create symbol names in the generated C code (default $).  The compiler needs
              to generate unique names to denote, e.g., a module variable. It does this by concatenating various
              symbol names to ensure that it generates unique names. For instance, variable bar  in  module  Maz
              becomes  a  global  C  variable Maz$bar in the compiler output.  Some C compilers do not like $ in
              symbol names, so you can specify a different separator, e.g., __  (leading  to  generated  symbols
              like Maz__bar).

              You  will  get  a  compile-time  warning  if any symbol in the program being compiled contains the
              separator you specify (the presence of the separator in a symbol could lead to the  generation  of
              incorrect code).  The separator can however start or end a symbol.

       -fnesc-no-inline
              Disabled  the  automatic  inlining of all small functions, and of all functions with a single call
              site.

       -fnesc-optimize-atomic
              Optimize atomic statements [EXPERIMENTAL]: reduce or remove the overhead of atomic  statements  in
              simple cases (e.g., single-byte reads).

       --version
              Print the version of nescc and of the selected gcc compiler (see -gcc).

       -fnesc-include=header-file
              Include  the specified file before compiling a nesC component. Behaves as if includes header-file;
              was included at the start of that component.

       -fnesc-dump=specification
              Output information on the compiled  programs  structure,  and  in  particular  its  user-specified
              attributes. For more details, see the separate nesC dump documentation.

       -fnesc-dumpfile=file
              Where to output the information requested by -fnesc-dump. Defaults to stdout.

       -fnesc-verbose
              Be more verbose than -v.

       -fnesc-scheduler=component,unique-string,interface-name,interface-definition,run-event,post-command
              By default, nesC compiles uses of task void taskname() ... to void taskname(), and post taskname()
              to TOS_post(taskname).

              With this option, each task gets its own interface-definition interface, the  task  implementation
              is  transformed  into a run-event event and posts becomes a call to the post-command command. This
              per-task interface is automatically connected to the  parameterised  interface-name  interface  of
              scheduler  component component. The parameter id for the connection is chosen with unique("unique-
              string").

       -fnesc-path=path
              Add colon separated directories to the nescc search path.

       -fnesc-no-debug
              Remove the functions dbg(), dbg_clear(), dbg_active() from the source code.

       -fnesc-deputy
              Compile with the deputy compiler.

       -fnesc-no-deputy
              Do not use the deputy compiler. This is the default.

       -fnesc-default-safe
              Make modules default to having the @safe() attribute. Has no effect if -fnesc-deputy is not set.

       -fnesc-default-unsafe
              Make modules default to having the @unsafe() attribute. Has no effect if -fnesc-deputy is not set.

       There are a number of warnings specific to nesC, specified with -Wnesc- (all these warnings  are  off  by
       default):

       -Wnesc-fnptr
              Warn  when function pointers are used (use of function pointers is deprecated in nesC and leads to
              inaccurate data race detection).

       -Wnesc-async
              Warn when interrupt handlers call commands or events not annotated with async.

       -Wnesc-data-race
              Warn about potential data races.

       -Wnesc-combine
              Warn when configuration wiring leads to "fan-out" and the function return type  does  not  have  a
              combining function defined.

       -Wnesc-docstring
              Warn when unexpected documentation strings (starting with /**) are seen.

       -Wnesc-implicit-conn
              Warn when implicit connections between components are used.

       -Wnesc-all
              Turns on -Wnesc-fnptr, -Wnesc-async, -Wnesc-combine and-Wnesc-data-race.

       -Wnesc-error
              Turns the -Wnesc-fnptr, -Wnesc-async, -Wnesc-combine and -Wnesc-data-race warnings into errors.

       When  compiling  a  nesC  component,  the nesC compiler recognizes the gcc C language (-f...) and warning
       (-W...) options. The -S, -c and -o options work as usual, the -x  option  accepts  nesc.  The  -v  option
       causes  the  nesC  compiler  to  print  out  the  paths of all components and interfaces that are loaded.
       Directories can be added to nesCs search path with -I.

EXAMPLES

       If you wish to compile a component Bar.nc to a C file, you can do:

              nescc -c -o /dev/null -fnesc-cfile=Bar.c Bar.nc

PREPROCESSOR SYMBOLS

       nescc defines the following preprocessor symbol:

       NESC (since v1.1)
              set to XYZ where x.yz is the nesC version

ENVIRONMENT VARIABLES

       NESCPATH
              A colon separated list of additional search directories for nesC components.

SEE ALSO

       gcc(1), platform-specific gcc

NOTES

       The warnings for the new nesC 1.1 features (see -Wnesc-all) are off by default to increase  compatibility
       with  nesC  1.0  code.  To  match the language specification in the nesC 1.1 reference manual, you should
       compile with -Wnesc-all and -Wnesc-error. These options will become the default in future releases.

                                                  May 22, 2013                                          nescc(1)