Man Linux: Main Page and Category List


       mcedit - Internal file editor of GNU Midnight Commander.


       mcedit [-bcCdfhstVx?] [+lineno] file

       mcedit [-bcCdfhstVx?] file:lineno[:]


       mcedit  is  a  link  to mc, the main GNU Midnight Commander executable.
       Executing GNU Midnight Commander under this name requests  staring  the
       internal  editor  and  opening  the file specified on the command line.
       The editor is based on the terminal version of  cooledit  -  standalone
       editor for X Window System.


              Go  to  the line specified by number (do not put a space between
              the + sign and the number).

       -b     Force black and white display.

       -c     Force ANSI color mode on terminals that don’t seem to have color

       -C <keyword>=<FGcolor>,<BGcolor>:<keyword>= ...
              Specify  a different color set.  See the Colors section in mc(1)
              for more information.

       -d     Disable mouse support.

       -f     Display the compiled-in search path for GNU  Midnight  Commander
              data files.

       -t     Force  using  termcap database instead of terminfo.  This option
              is only applicable if GNU Midnight Commander was  compiled  with
              S-Lang library with terminfo support.

       -V     Display the version of the program.

       -x     Force  xterm mode.  Used when running on xterm-capable terminals
              (two screen modes, and able to send mouse escape sequences).


       The internal file editor is a full-featured full screen editor.  It can
       edit  files  up  to 64 megabytes.  It is possible to edit binary files.
       The features it presently supports are: block copy, move, delete,  cut,
       paste;  key  for  key  undo;  pull-down  menus;  file  insertion; macro
       commands;  regular  expression  search  and  replace   (and   our   own
       scanf-printf  search  and  replace);  shift-arrow text highlighting (if
       supported  by  the  terminal);  insert-overwrite  toggle;  word   wrap;
       autoindent;  tunable  tab  size;  syntax  highlighting for various file
       types; and an option to pipe text blocks through  shell  commands  like
       indent and ispell.


       The  editor  is  easy  to  use  and  can be used without learning.  The
       pull-down menu is invoked by pressing F9.  You  can  learn  other  keys
       from the menu and from the button bar labels.

       In  addition to that, Shift combined with arrows does text highlighting
       (if  supported  by  the  terminal):  Ctrl-Ins  copies   to   the   file
       ~/.mc/cedit/cooledit.clip,         Shift-Ins         pastes        from
       ~/.mc/cedit/cooledit.clip, Shift-Del cuts to ~/.mc/cedit/cooledit.clip,
       and  Ctrl-Del  deletes highlighted text.  Mouse highlighting also works
       on some terminals.  To use the standard mouse support provided by  your
       terminal,  hold  the  Shift key.  Please note that the mouse support in
       the terminal doesn’t share the clipboard with mcedit.

       The completion key (usually Meta-Tab or Escape Tab) completes the  word
       under the cursor using the words used earlier in the file.

       To  define a macro, press Ctrl-R and then type out the keys you want to
       be executed.  Press Ctrl-R again when finished.  You  can  then  assign
       the  macro  to  any  key  you  like by pressing that key.  The macro is
       executed when you press Ctrl-A and then the assigned key.  The macro is
       also  executed  if  you  press Meta, Ctrl, or Esc and the assigned key,
       provided that the key is not used for any other  function.   The  macro
       commands  are  stored  in the file ~/.mc/cedit/cooledit.macros.  Do NOT
       edit this file if you are going to use macros again in the same editing
       session, because mcedit caches macro key defines in memory.  mcedit now
       overwrites a macro if a macro with the same key already exists, so  you
       won’t  have  to  edit  this  file.  You will also have to restart other
       running editors for macros to take effect.

       F19 will format C, C++, Java or HTML code when it is  highlighted.   An
       executable  file  called ~/.mc/cedit/edit.indent.rc will be created for
       you from the default template.  Feel free to edit it if you need.

       C-p will run ispell on a block of text in a similar  way.   The  script
       file will be called ~/.mc/cedit/edit.spell.rc.

       If some keys don’t work, you can use Learn Keys in the Options menu.


       mcedit  can  be used to navigation through code with tags files created
       by etags or ctags commands. If there is no file  TAGS  code  navigation
       would  not work.  In example, in case of exuberant-ctags for C language
       command will be:

       ctags -e --language-force=C -R ./

       Meta-Enter show list box to select  item  under  cursor  (cusor  should
       stand at end of word).

       Meta-Minus  where  minus  is  symbol  "-"  go  to  previous function in
       navigation list (like a browser Back).

       Meta-Equal where equal is symbol "=" go to next function in  navigation
       list (like a browser Forward).


       mcedit  supports  syntax  highlighting.   This  means that keywords and
       contexts (like C comments, string constants, etc)  are  highlighted  in
       different  colors.   The  following  section explains the format of the
       file  ~/.mc/cedit/Syntax.   If  this  file  is   missing,   system-wide
       /usr/share/mc/syntax/Syntax  is  used.   The file ~/.mc/cedit/Syntax is
       rescanned on opening of a any new editor file.  The file contains rules
       for highlighting, each of which is given on a separate line, and define
       which keywords will be highlighted to what color.

       The file is divided into sections, each beginning with a line with  the
       file  command.  The sections are normally put into separate files using
       the include command.

       The file command has three arguments.  The first argument is a  regular
       expression  that  is  applied  to  the  file  name  to determine if the
       following section applies to the file.   The  second  argument  is  the
       description  of the file type.  It is used in cooledit; future versions
       of mcedit may use it as well.  The third optional argument is a regular
       expression  to  match the first line of text of the file.  The rules in
       the following section apply if either the file name or the  first  line
       of text matches.

       A  section  ends  with  the  start of another section.  Each section is
       divided into contexts, and each context contains rules.  A context is a
       scope  within  the text that a particular set of rules belongs to.  For
       instance, the text within a C style comment (i.e. between  /*  and  */)
       has its own color.  This is a context, although it has no further rules
       inside it because there is probably nothing that  we  want  highlighted
       within a C comment.

       A trivial C programming section might look like this:

       file .\*\\.c C\sProgram\sFile (#include|/\\\*)

       wholechars abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_

       # default colors
       define  comment   brown
       context default
         keyword  whole  if       yellow
         keyword  whole  else     yellow
         keyword  whole  for      yellow
         keyword  whole  while    yellow
         keyword  whole  do       yellow
         keyword  whole  switch   yellow
         keyword  whole  case     yellow
         keyword  whole  static   yellow
         keyword  whole  extern   yellow
         keyword         {        brightcyan
         keyword         }        brightcyan
         keyword         ’*’      green

       # C comments
       context /\* \*/ comment

       # C preprocessor directives
       context linestart # \n red
         keyword  \\\n  brightred

       # C string constants
       context " " green
         keyword  %d    brightgreen
         keyword  %s    brightgreen
         keyword  %c    brightgreen
         keyword  \\"   brightgreen

       Each context starts with a line of the form:

       context   [exclusive]  [whole|wholeright|wholeleft]  [linestart]  delim
       [linestart] delim [foreground] [background]

       The first context is an exception.  It must start with the command

       context default [foreground] [background]

       otherwise mcedit will report an error.  The linestart option  specifies
       that  delim  must  start  at the beginning of a line.  The whole option
       tells that delim must be a whole word.  To specify  that  a  word  must
       begin  on  the  word  boundary  only  on the left side, you can use the
       wholeleft option, and similarly a  word  that  must  end  on  the  word
       boundary is specified by wholeright.

       The  set  of  characters that constitute a whole word can be changed at
       any point in the file with the wholechars command.  The left and  right
       set of characters can be set separately with

       wholechars [left|right] characters

       The  exclusive  option  causes  the  text  between the delimiters to be
       highlighted, but not the delimiters themselves.

       Each rule is a line of the form:

       keyword  [whole|wholeright|wholeleft]  [linestart]  string   foreground

       Context  or  keyword  strings  are interpreted, so that you can include
       tabs and spaces with the sequences \t and \s.  Newlines and backslashes
       are specified with \n and \\ respectively.  Since whitespace is used as
       a separator, it may not be used as  is.   Also,  \*  must  be  used  to
       specify  an  asterisk.   The  *  itself  is a wildcard that matches any
       length of characters.  For example,

         keyword         ’*’      green

       colors all C single character constants green.  You also could use

         keyword         "*"      green

       to color string constants, but the matched string would not be  allowed
       to  span  across  multiple  newlines.   The wildcard may be used within
       context delimiters as well, but you cannot have a wildcard as the  last
       or first character.

       Important to note is the line

         keyword  \\\n  brightgreen

       This  line  defines  a  keyword  containing  the  backslash and newline
       characters.   Since  the  keywords  are  matched  before  the   context
       delimiters, this keyword prevents the context from ending at the end of
       the lines that  end  in  a  backslash,  thus  allowing  C  preprocessor
       directive to continue across multiple lines.

       The   possible   colors   are:  black,  gray,  red,  brightred,  green,
       brightgreen, brown, yellow, blue, brightblue,  magenta,  brightmagenta,
       cyan,  brightcyan,  lightgray  and white.  If the syntax file is shared
       with cooledit, it is possible to specify different  colors  for  mcedit
       and cooledit by separating them with a slash, e.g.

       keyword  #include  red/Orange

       mcedit  uses the color before the slash.  See cooledit(1) for supported
       cooledit colors.

       Comments may be put on a separate line starting with the hash sign (#).

       Because  of  the  simplicity  of  the  implementation,  there are a few
       intricacies that will not be dealt with correctly but these are a minor
       irritation.   On  the  whole,  a  broad  spectrum  of quite complicated
       situations are handled with these simple rules.  It is a good  idea  to
       take  a look at the syntax file to see some of the nifty tricks you can
       do with a little imagination.  If you cannot get by with  the  rules  I
       have  coded, and you think you have a rule that would be useful, please
       email me with your request.  However, do not ask for regular expression
       support, because this is flatly impossible.

       A  useful  hint is to work with as much as possible with the things you
       can do rather than try to do things  that  this  implementation  cannot
       deal  with.   Also  remember  that the aim of syntax highlighting is to
       make programming less prone to error, not to make code look pretty.


       The default colors may be changed by appending  to  the  MC_COLOR_TABLE
       environment  variable.   Foreground  and background colors pairs may be
       specified for example with:



       Most options can now be set from the editors options dialog  box.   See
       the  Options  menu.  The following options are defined in ~/.mc/ini and
       have obvious counterparts in the dialog box.  You can  modify  them  to
       change the editor behavior, by editing the file.  Unless specified, a 1
       sets the option to on, and a 0 sets it to off, as is usual.

              This option is ignored when invoking mcedit.

              Interpret the tab character as being of this length.  Default is
              8.  You should avoid using other than 8 since most other editors
              and  text   viewers   assume   a   tab   spacing   of   8.   Use
              editor_fake_half_tabs to simulate a smaller tab spacing.

              Never  insert  a  tab space. Rather insert spaces (ascii 20h) to
              fill to the desired tab size.

              Pressing return will tab across to match the indentation of  the
              first line above that has text on it.

              Make  a single backspace delete all the space to the left margin
              if there is no text between the cursor and the left margin.

              This will emulate a half tab for those who want to program  with
              a  tab spacing of 4, but do not want the tab size changed from 8
              (so that the code will be formatted the same when  displayed  by
              other  programs). When editing between text and the left margin,
              moving and tabbing will be as though a tab space were  4,  while
              actually using spaces and normal tabs for an optimal fill.  When
              editing anywhere else, a normal tab is inserted.

              Possible values 0, 1 and 2.  The save mode (see the options menu
              also)  allows  you to change the method of saving a file.  Quick
              save (0) saves the file by immediately, truncating the disk file
              to  zero  length  (i.e.   erasing it) and the writing the editor
              contents to the file.  This method is fast, but dangerous, since
              a  system  error  during  a  file  save will leave the file only
              partially written, possibly rendering  the  data  irretrievable.
              When  saving,  the  safe  save  (1) option enables creation of a
              temporary file into which the file contents are  first  written.
              In  the  event  of  an  problem, the original file is untouched.
              When the temporary file is successfully written, it  is  renamed
              to the name of the original file, thus replacing it.  The safest
              method is create backups (2).  Where a backup  file  is  created
              before  any  changes  are made.  You can specify your own backup
              file extension in the  dialog.   Note  that  saving  twice  will
              replace your backup as well as your original file.

              line length to wrap. 72 default.

              symbol for add extension to name of backup files. Default "~".

              show  state  line  of editor now it show number of file line (in
              future it can show things like folding, breakpoints, etc.).  M-n
              toglle this option.

              Toggle     show    visible    trailing    spaces    (TWS),    if
              editor_visible_spaces=1 TWS showed as ’.’

              Toggle show visible tabs, if editor_visible_tabs=1  tabs  showed
              as ’<---->’

              Do not remove block selection after moving the cursor.

              Allow moving cursor beyond the end of line.

              enable syntax highlighting.

              show confirm dialog on save.

              to be described

              to be described

              save file position on exit.

              symbol  representation of codepage name for file (i.e. CP1251, ~
              - default).

              Search autocomplete candidates in entire of file  or  just  from
              begin of file to cursor position (0)


       You  can  use scanf search and replace to search and replace a C format
       string.  First take a look at the sscanf and sprintf man pages  to  see
       what  a  format string is and how it works.  Here’s an example: suppose
       that you want to replace all occurrences  of  an  open  bracket,  three
       comma separated numbers, and a close bracket, with the word apples, the
       third number, the word oranges and then the second number.   You  would
       fill in the Replace dialog box as follows:

       Enter search string
       Enter replace string
       apples %d oranges %d
       Enter replacement argument order

       The  last  line specifies that the third and then the second number are
       to be used in place of the first and second.

       It is advisable to use this feature with Prompt On Replace on,  because
       a  match  is thought to be found whenever the number of arguments found
       matches the number given, which is not always a real match. Scanf  also
       treats  whitespace  as being elastic.  Note that the scanf format %[ is
       very useful for scanning strings, and whitespace.

       The editor also displays non-us characters (160+).  When editing binary
       files,  you should set display bits to 7 bits in the Midnight Commander
       options menu to keep the spacing clean.



              The help file for the program.


              The default system-wide setup for GNU Midnight  Commander,  used
              only if the user’s own ~/.mc/ini file is missing.


              Global  settings  for  the Midnight Commander.  Settings in this
              file affect all users, whether they have ~/.mc/ini or not.


              The default system-wide syntax files for mcedit,  used  only  if
              the corresponding user’s own ~/.mc/cedit/ file is missing.


              User’s  own  setup.   If  this file is present then the setup is
              loaded from here instead of the system-wide setup file.


              User’s own directory where  block  commands  are  processed  and
              saved and user’s own syntax files are located.


       This  program  is distributed under the terms of the GNU General Public
       License as published by the Free Software Foundation.  See the built-in
       help  of the Midnight Commander for details on the License and the lack
       of warranty.


       The   latest   version   of   this   program   can    be    found    at


       cooledit(1), mc(1), gpm(1), terminfo(1), scanf(3).


       Paul  Sheer  (  is  the  original  author  of the
       Midnight Commander’s internal editor.


       Bugs should be reported to