NAME

       c - Command Interface Module

DESCRIPTION

       The c module enables users to enter the short form of some commonly used commands.

   Note:
       These  functions are are intended for interactive use in the Erlang shell only. The module
       prefix may be omitted.

EXPORTS

       bt(Pid) -> ok | undefined

              Types:

                 Pid = pid()

              Stack  backtrace  for  a   process.   Equivalent   to   erlang:process_display(Pid,
              backtrace).

       c(File) -> {ok, Module} | error

       c(File, Options) -> {ok, Module} | error

              Types:

                 File = file:name()
                 Options = [compile:option()]
                 Module = module()

              c/1,2  compiles  and then purges and loads the code for a file. Options defaults to
              []. Compilation is equivalent to:

              compile:file(File, Options ++ [report_errors, report_warnings])

              Note that purging the code means that any processes lingering in old code  for  the
              module are killed without warning. See code/3 for more information.

       cd(Dir) -> ok

              Types:

                 Dir = file:name()

              Changes working directory to Dir, which may be a relative name, and then prints the
              name of the new working directory.

              2> cd("../erlang").
              /home/ron/erlang

       flush() -> ok

              Flushes any messages sent to the shell.

       help() -> ok

              Displays help information: all valid shell internal commands, and commands in  this
              module.

       i() -> ok

       ni() -> ok

              i/0 displays information about the system, listing information about all processes.
              ni/0 does the same, but for all nodes the network.

       i(X, Y, Z) -> [{atom(), term()}]

              Types:

                 X = Y = Z = integer() >= 0

              Displays information about a process, Equivalent to process_info(pid(X, Y, Z)), but
              location transparent.

       l(Module) -> code:load_ret()

              Types:

                 Module = module()

              Purges  and  loads,  or reloads, a module by calling code:purge(Module) followed by
              code:load_file(Module).

              Note that purging the code means that any processes lingering in old code  for  the
              module are killed without warning. See code/3 for more information.

       lc(Files) -> ok

              Types:

                 Files = [File]
                 File = file:filename()

              Compiles   a   list   of   files   by  calling  compile:file(File,  [report_errors,
              report_warnings]) for each File in Files.

       ls() -> ok

              Lists files in the current directory.

       ls(Dir) -> ok

              Types:

                 Dir = file:name()

              Lists files in directory Dir or, if Dir is a file, only list it.

       m() -> ok

              Displays information about the loaded modules, including the files from which  they
              have been loaded.

       m(Module) -> ok

              Types:

                 Module = module()

              Displays information about Module.

       memory() -> [{Type, Size}]

              Types:

                 Type = atom()
                 Size = integer() >= 0

              Memory allocation information. Equivalent to erlang:memory/0.

       memory(Type) -> Size

       memory(Types) -> [{Type, Size}]

              Types:

                 Types = [Type]
                 Type = atom()
                 Size = integer() >= 0

              Memory allocation information. Equivalent to erlang:memory/1.

       nc(File) -> {ok, Module} | error

       nc(File, Options) -> {ok, Module} | error

              Types:

                 File = file:name()
                 Options = [Option] | Option
                 Option = compile:option()
                 Module = module()

              Compiles  and  then loads the code for a file on all nodes. Options defaults to [].
              Compilation is equivalent to:

              compile:file(File, Options ++ [report_errors, report_warnings])

       nl(Module) -> abcast | error

              Types:

                 Module = module()

              Loads Module on all nodes.

       pid(X, Y, Z) -> pid()

              Types:

                 X = Y = Z = integer() >= 0

              Converts X, Y, Z to the pid  <X.Y.Z>.  This  function  should  only  be  used  when
              debugging.

       pwd() -> ok

              Prints the name of the working directory.

       q() -> no_return()

              This  function is shorthand for init:stop(), that is, it causes the node to stop in
              a controlled fashion.

       regs() -> ok

       nregs() -> ok

              regs/0 displays information about all registered processes. nregs/0 does the  same,
              but for all nodes in the network.

       uptime() -> ok

              Prints  the  node  uptime  (as  given  by erlang:statistics(wall_clock)), in human-
              readable form.

       xm(ModSpec) -> void()

              Types:

                 ModSpec = Module | Filename
                  Module = atom()
                  Filename = string()

              This function finds undefined functions, unused functions, and calls to  deprecated
              functions in a module by calling xref:m/1.

       y(File) -> YeccRet

              Types:

                 File = name() -- see filename(3erl)
                 YeccRet = -- see yecc:file/2

              Generates an LALR-1 parser. Equivalent to:

              yecc:file(File)

       y(File, Options) -> YeccRet

              Types:

                 File = name() -- see filename(3erl)
                 Options, YeccRet = -- see yecc:file/2

              Generates an LALR-1 parser. Equivalent to:

              yecc:file(File, Options)

SEE ALSO

       compile(3erl), filename(3erl), erlang(3erl), yecc(3erl), xref(3erl)