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)