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.

       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)