home *** CD-ROM | disk | FTP | other *** search
/ vim.ftp.fu-berlin.de / 2015-02-03.vim.ftp.fu-berlin.de.tar / vim.ftp.fu-berlin.de / amiga / vim46src.lha / vim-4.6 / src / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-11  |  29.8 KB  |  1,129 lines
  1. /* vi:set ts=4 sw=4:
  2.  *
  3.  * VIM - Vi IMproved        by Bram Moolenaar
  4.  *
  5.  * Do ":help uganda"  in Vim to read copying and usage conditions.
  6.  * Do ":help credits" in Vim to see a list of people who contributed.
  7.  */
  8.  
  9. #define EXTERN
  10. #include "vim.h"
  11. #include "globals.h"
  12. #include "proto.h"
  13. #include "option.h"
  14.  
  15. #ifdef SPAWNO
  16. # include <spawno.h>            /* special MSDOS swapping library */
  17. #endif
  18.  
  19. static void usage __PARMS((int, char_u *));
  20. static int stdout_notty = FALSE;            /* is stdout not a terminal? */
  21.  
  22. /*
  23.  * Types of usage message required.  These must match the array of error
  24.  * messages in usage().
  25.  */
  26. #define USAGE_UNKNOWN_OPTION    0
  27. #define USAGE_TOO_MANY_ARGS        1
  28. #define USAGE_ARG_MISSING        2
  29. #define USAGE_GARBAGE            3
  30.  
  31.     static void
  32. usage(n, str)
  33.     int        n;
  34.     char_u    *str;
  35. {
  36.     register int i;
  37.     static char_u *(use[]) = {(char_u *)"[file ..]",
  38.                             (char_u *)"-t tag",
  39.                             (char_u *)"-e [errorfile]"};
  40.     static char_u *(errors[]) =  {(char_u *)"Unknown option",
  41.                                 (char_u *)"Too many arguments",
  42.                                 (char_u *)"Argument missing after",
  43.                                 (char_u *)"Garbage after option",
  44.                                 };
  45.  
  46. #if defined(UNIX) || defined(__EMX__)
  47.     reset_signals();        /* kill us with CTRL-C here, if you like */
  48. #endif
  49.  
  50.     fprintf(stderr, longVersion);
  51.     fprintf(stderr, "\n");
  52.     fprintf(stderr, (char *)errors[n]);
  53.     if (str != NULL)
  54.         fprintf(stderr, ": \"%s\"", str);
  55.     fprintf(stderr, "\nusage:");
  56.     for (i = 0; ; ++i)
  57.     {
  58.         fprintf(stderr, " vim [options] ");
  59.         fprintf(stderr, (char *)use[i]);
  60.         if (i == (sizeof(use) / sizeof(char_u *)) - 1)
  61.             break;
  62.         fprintf(stderr, "\n   or:");
  63.     }
  64.  
  65.     fprintf(stderr, "\n\nOptions:\n");
  66. #ifdef USE_GUI
  67.     fprintf(stderr, "   -g\t\t\tRun using GUI\n");
  68.     fprintf(stderr, "   -f\t\t\tForeground: Don't fork when starting GUI\n");
  69. #endif
  70.     fprintf(stderr, "   -R  or  -v\t\tReadonly mode (view mode)\n");
  71.     fprintf(stderr, "   -b\t\t\tBinary mode\n");
  72.     fprintf(stderr, "   -l\t\t\tLisp mode\n");
  73.     fprintf(stderr, "   -n\t\t\tNo swap file, use memory only\n");
  74.     fprintf(stderr, "   -r\t\t\tList swap files\n");
  75.     fprintf(stderr, "   -r (with file name)\tRecover crashed session\n");
  76.     fprintf(stderr, "   -L\t\t\tSame as -r\n");
  77. #ifdef AMIGA
  78.     fprintf(stderr, "   -x\t\t\tDon't use newcli to open window\n");
  79.     fprintf(stderr, "   -d <device>\t\tUse <device> for I/O\n");
  80. #endif
  81. #ifdef RIGHTLEFT
  82.     fprintf(stderr, "   -H\t\t\tstart in Hebrew mode\n");
  83. #endif
  84.     fprintf(stderr, "   -T <terminal>\tSet terminal type to <terminal>\n");
  85.     fprintf(stderr, "   -o[N]\t\tOpen N windows (default: one for each file)\n");
  86.     fprintf(stderr, "   +\t\t\tStart at end of file\n");
  87.     fprintf(stderr, "   +<lnum>\t\tStart at line <lnum>\n");
  88.     fprintf(stderr, "   -c <command>\t\tExecute <command> first\n");
  89.     fprintf(stderr, "   -s <scriptin>\tRead commands from script file <scriptin>\n");
  90.     fprintf(stderr, "   -w <scriptout>\tAppend commands to script file <scriptout>\n");
  91.     fprintf(stderr, "   -W <scriptout>\tWrite commands to script file <scriptout>\n");
  92.     fprintf(stderr, "   -u <vimrc>\t\tUse <vimrc> instead of any .vimrc\n");
  93.     fprintf(stderr, "   -i <viminfo>\t\tUse <viminfo> instead of .viminfo\n");
  94.     fprintf(stderr, "   --\t\t\tEnd of options\n");
  95.  
  96. #ifdef USE_GUI_X11
  97. # ifdef USE_GUI_MOTIF
  98.     fprintf(stderr, "\nOptions recognised by gvim (Motif version):\n");
  99. # else
  100. #  ifdef USE_GUI_ATHENA
  101.     fprintf(stderr, "\nOptions recognised by gvim (Athena version):\n");
  102. #  endif /* USE_GUI_ATHENA */
  103. # endif /* USE_GUI_MOTIF */
  104.     fprintf(stderr, "   -display <display>\tRun vim on <display>\n");
  105.     fprintf(stderr, "   -iconic\t\tStart vim iconified\n");
  106. # if 0
  107.     fprintf(stderr, "   -name <name>\t\tUse resource as if vim was <name>\n");
  108.     fprintf(stderr, "\t\t\t  (Unimplemented)\n");
  109. # endif
  110.     fprintf(stderr, "   -background <color>\tUse <color> for the background (also: -bg)\n");
  111.     fprintf(stderr, "   -foreground <color>\tUse <color> for normal text (also: -fg)\n");
  112.     fprintf(stderr, "   -bold <color>\tUse <color> for bold text\n");
  113.     fprintf(stderr, "   -italic <color>\tUse <color> for italic text\n");
  114.     fprintf(stderr, "   -underline <color>\tUse <color> for underlined text (also: -ul)\n");
  115.     fprintf(stderr, "   -cursor <color>\tUse <color> for cursor\n");
  116.     fprintf(stderr, "   -font <font>\t\tUse <font> for normal text (also: -fn)\n");
  117.     fprintf(stderr, "   -boldfont <font>\tUse <font> for bold text\n");
  118.     fprintf(stderr, "   -italicfont <font>\tUse <font> for italic text\n");
  119.     fprintf(stderr, "   -geometry <geom>\tUse <geom> for initial geometry (also: -geom)\n");
  120.     fprintf(stderr, "   -borderwidth <width>\tUse a border width of <width> (also: -bw)\n");
  121.     fprintf(stderr, "   -scrollbarwidth <width>\tUse a scrollbar width of <width> (also: -sw)\n");
  122.     fprintf(stderr, "   -menuheight <height>\tUse a menu bar height of <height> (also: -mh)\n");
  123.     fprintf(stderr, "   -reverse\t\tUse reverse video (also: -rv)\n");
  124.     fprintf(stderr, "   +reverse\t\tDon't use reverse video (also: +rv)\n");
  125.     fprintf(stderr, "   -xrm <resource>\tSet the specified resource\n");
  126. #endif /* USE_GUI_X11 */
  127.  
  128.     mch_windexit(1);
  129. }
  130.  
  131. #ifdef HAVE_LOCALE_H
  132. # include <locale.h>
  133. #endif
  134.  
  135.     void
  136. main(argc, argv)
  137.     int                argc;
  138.     char          **argv;
  139. {
  140.     char_u           *initstr;        /* init string from the environment */
  141.     char_u           *term = NULL;    /* specified terminal name */
  142.     char_u           *fname = NULL;    /* file name from command line */
  143.     char_u           *command = NULL;    /* command from + or -c option */
  144.     char_u           *tagname = NULL;    /* tag from -t option */
  145.     char_u           *use_vimrc = NULL;    /* vimrc from -u option */
  146.     int             c;
  147.     int                doqf = 0;
  148.     int                i;
  149.     int                bin_mode = FALSE;        /* -b option used */
  150.     int                window_count = 1;        /* number of windows to use */
  151.     int                arg_idx = 0;            /* index for arg_files[] */
  152.     int                check_version = FALSE;    /* check .vimrc version number */
  153.     int                argv_idx;                /* index in argv[n][] */
  154.  
  155. #if defined(MSDOS) || defined(WIN32) || defined(OS2)
  156.     static struct initmap
  157.     {
  158.         char_u        *arg;
  159.         int            mode;
  160.     } initmappings[] =
  161.     {
  162.         /* normal and visual mode */
  163. #ifdef MSDOS
  164.         {(char_u *)"\316w H", NORMAL+VISUAL},        /* CTRL-HOME is 'H' */
  165.         {(char_u *)"\316u L", NORMAL+VISUAL},        /* CTRL-END is 'L' */
  166.         {(char_u *)"\316\204 1G", NORMAL+VISUAL},    /* CTRL-PageUp is '1G' */
  167.         {(char_u *)"\316v G", NORMAL+VISUAL},        /* CTRL-PageDown is 'G' */
  168. #else /* WIN32 */
  169.         /* Use the Windows (CUA) keybindings */
  170.         {(char_u *)"\316w 1G", NORMAL+VISUAL},        /* CTRL-HOME is '1G' */
  171.         {(char_u *)"\316u G$", NORMAL+VISUAL},        /* CTRL-END is 'G$' */
  172.         {(char_u *)"\316\204 H", NORMAL+VISUAL},    /* CTRL-PageUp is 'H' */
  173.         {(char_u *)"\316v L$", NORMAL+VISUAL},        /* CTRL-PageDown is 'L$' */
  174.         {(char_u *)"\316s B", NORMAL+VISUAL},        /* CTRL-Left is 'B' */
  175.         {(char_u *)"\316t W", NORMAL+VISUAL},        /* CTRL-Right is 'W' */
  176. #endif /* WIN32 */
  177.  
  178.         /* insert mode */
  179. #ifdef MSDOS
  180.         {(char_u *)"\316w \017H", INSERT},            /* CTRL-HOME is '^OH' */
  181.         {(char_u *)"\316u \017L", INSERT},            /* CTRL-END is '^OL' */
  182.         {(char_u *)"\316\204 \017\061G", INSERT},    /* CTRL-PageUp is '^O1G' */
  183.         {(char_u *)"\316v \017G", INSERT},            /* CTRL-PageDown is '^OG' */
  184. #else /* WIN32 */
  185.         /* Use the Windows (CUA) keybindings */
  186.         {(char_u *)"\316w \017\061G", INSERT},        /* CTRL-HOME is '^O1G' */
  187.         {(char_u *)"\316u \017G\017$", INSERT},        /* CTRL-END is '^OG^O$' */
  188.         {(char_u *)"\316\204 \017H",INSERT},        /* CTRL-PageUp is '^OH'*/
  189.         {(char_u *)"\316v \017L\017$", INSERT},        /* CTRL-PageDown ='^OL^O$'*/
  190.         {(char_u *)"\316s \017B", INSERT},            /* CTRL-Left is '^OB' */
  191.         {(char_u *)"\316t \017W", INSERT},            /* CTRL-Right is '^OW' */
  192. #endif /* WIN32 */
  193.     };
  194. #endif
  195.  
  196. #ifdef __EMX__
  197.     _wildcard(&argc, &argv);
  198. #endif
  199.  
  200. #ifdef HAVE_LOCALE_H
  201.     setlocale(LC_ALL, "");        /* for ctype() and the like */
  202. #endif
  203.  
  204. #ifdef USE_GUI
  205.     gui_prepare(&argc, argv);    /* Prepare for possibly starting GUI sometime */
  206. #endif
  207.  
  208. /*
  209.  * Check if we have an interactive window.
  210.  * On the Amiga: If there is no window, we open one with a newcli command
  211.  * (needed for :! to * work). mch_check_win() will also handle the -d argument.
  212.  */
  213.     stdout_notty = (mch_check_win(argc, argv) == FAIL);
  214.  
  215. /*
  216.  * allocate the first window and buffer. Can't do anything without it
  217.  */
  218.     if ((curwin = win_alloc(NULL)) == NULL ||
  219.                         (curbuf = buflist_new(NULL, NULL, 1L, FALSE)) == NULL)
  220.         mch_windexit(0);
  221.     curwin->w_buffer = curbuf;
  222.     screen_start();                    /* don't know where cursor is yet */
  223.  
  224. /*
  225.  * Allocate space for the generic buffers (needed for set_init_1()).
  226.  */
  227.     if ((IObuff = alloc(IOSIZE)) == NULL ||
  228.                             (NameBuff = alloc(MAXPATHL)) == NULL)
  229.         mch_windexit(0);
  230.  
  231. /*
  232.  * Set the default values for the options.
  233.  * First find out the home directory, needed to expand "~" in options.
  234.  */
  235.     init_homedir();                /* find real value of $HOME */
  236.     set_init_1();
  237.  
  238. /*
  239.  * If the executable is called "view" we start in readonly mode.
  240.  */
  241.     if (STRCMP(gettail((char_u *)argv[0]), (char_u *)"view") == 0)
  242.     {
  243.         readonlymode = TRUE;
  244.         curbuf->b_p_ro = TRUE;
  245.         if (p_uc)                    /* if we are doing any updating.. */
  246.             p_uc = 10000;            /* ..don't update very often */
  247.     }
  248.  
  249. /*
  250.  * If the executable is called "gvim" we run the GUI version.
  251.  */
  252.     if (STRCMP(gettail((char_u *)argv[0]), (char_u *)"gvim") == 0)
  253.     {
  254. #ifdef USE_GUI
  255.         gui.starting = TRUE;
  256. #else
  257.         fprintf(stderr, (char *)e_nogvim);
  258.         mch_windexit(2);
  259. #endif
  260.     }
  261.  
  262.     ++argv;
  263.     /*
  264.      * Process the command line arguments
  265.      *        '+{command}'    execute command
  266.      *        '-b'            binary
  267.      *        '-c {command}'    execute command
  268.      *        '-d {device}'    device (for Amiga)
  269.      *        '-f'            Don't fork when starging GUI. (if USE_GUI defined)
  270.       *        '-g'            Run with GUI. (if USE_GUI defined)
  271.      *        '-H'            Start in right-left mode
  272.      *        '-i viminfo'    use instead of p_viminfo
  273.      *        '-n'            no .vim file
  274.      *        '-o[N]'            open N windows (default: number of files)
  275.      *        '-r'            recovery mode
  276.      *        '-L'            recovery mode
  277.      *         '-s scriptin'    read from script file
  278.      *        '-T terminal'    terminal name
  279.      *        '-u vimrc'        read initializations from a file
  280.      *        '-v'             view or Readonly mode
  281.      *        '-R'            view or Readonly mode
  282.      *        '-w scriptout'    write to script file (append)
  283.      *        '-W scriptout'    write to script file (overwrite)
  284.      *        '-x'            open window directly, not with newcli
  285.      */
  286.     argv_idx = 1;            /* active option letter is argv[0][argv_idx] */
  287.  
  288.     while (argc > 1 && ((c = argv[0][0]) == '+' || (c == '-' &&
  289.                                    vim_strchr((char_u *)"bcdfgHilLnorRsTuvwWx",
  290.                                              c = argv[0][argv_idx]) != NULL)))
  291.     {
  292.         ++argv_idx;            /* advance to next option letter by default */
  293.         switch (c)
  294.         {
  295.         case '+':             /* + or +{number} or +/{pat} or +{command} */
  296.             argv_idx = -1;            /* skip to next argument */
  297.             if (argv[0][1] == NUL)
  298.                 command = (char_u *)"$";
  299.             else
  300.                 command = (char_u *)&(argv[0][1]);
  301.             break;
  302.  
  303.         case 'b':
  304.             bin_mode = TRUE;        /* postpone to after reading .exrc files */
  305.             break;
  306.  
  307. #ifdef USE_GUI
  308.         case 'f':
  309.             gui.dofork = FALSE;        /* don't fork() when starting GUI */
  310.             break;
  311. #endif
  312.  
  313.         case 'g':
  314. #ifdef USE_GUI
  315.             gui.starting = TRUE;    /* start GUI a bit later */
  316. #else
  317.             fprintf(stderr, (char *)e_nogvim);
  318.             mch_windexit(2);
  319. #endif
  320.             break;
  321.  
  322.         case 'H':                /* start in Hebrew mode: rl + hkmap set */
  323. #ifdef RIGHTLEFT
  324.             curwin->w_p_rl = p_hkmap = TRUE;
  325. #else
  326.             fprintf(stderr, (char *)e_nohebrew);
  327.             mch_windexit(2);
  328. #endif
  329.             break;
  330.  
  331.         case 'l':            /* -l: lisp mode, 'lisp' and 'showmatch' on */
  332.             curbuf->b_p_lisp = TRUE;
  333.             p_sm = TRUE;
  334.             break;
  335.  
  336.         case 'n':
  337.             p_uc = 0;
  338.             break;
  339.  
  340.         case 'o':
  341.             window_count = 0;        /* default: open window for each file */
  342.             if (isdigit(argv[0][argv_idx]))
  343.             {
  344.                 window_count = atoi(&(argv[0][argv_idx]));
  345.                 while (isdigit(argv[0][argv_idx]))
  346.                     ++argv_idx;
  347.             }
  348.             break;
  349.  
  350.         case 'r':
  351.         case 'L':
  352.             recoverymode = 1;
  353.             break;
  354.         
  355.         case 'v':
  356.         case 'R':
  357.             readonlymode = TRUE;
  358.             curbuf->b_p_ro = TRUE;
  359.             if (p_uc)                    /* if we are doing any updating.. */
  360.                 p_uc = 10000;            /* ..don't update very often */
  361.             break;
  362.  
  363.         case 'x':
  364.             break;    /* This is ignored as it is handled in mch_check_win() */
  365.  
  366.  
  367.         case 'w':
  368.             if (isdigit(argv[0][argv_idx]))    /* -w{number}; set window height */
  369.             {
  370.                 argv_idx = -1;
  371.                 break;                        /* not implemented, ignored */
  372.             }
  373.             /* FALLTHROUGH */
  374.  
  375.         default:    /* options with argument */
  376.             /*
  377.              * Check there's no garbage immediately after the option letter.
  378.              */
  379.             if (argv[0][argv_idx] != NUL)
  380.                 usage(USAGE_GARBAGE, (char_u *)argv[0]);
  381.  
  382.             --argc;
  383.             if (argc < 2)
  384.                 usage(USAGE_ARG_MISSING, (char_u *)argv[0]);
  385.             ++argv;
  386.             argv_idx = -1;
  387.  
  388.             switch (c)
  389.             {
  390.             case 'c':            /* -c {command} */
  391.                 command = (char_u *)argv[0];
  392.                 break;
  393.  
  394.         /*    case 'd':    This is ignored as it is handled in mch_check_win() */
  395.  
  396.             case 'i':            /* -i {viminfo} */
  397.                 use_viminfo = (char_u *)argv[0];
  398.                 break;
  399.             
  400.             case 's':            /* -s {scriptin} */
  401.                 if (scriptin[0] != NULL)
  402.                 {
  403.                     fprintf(stderr,
  404.                             "Attempt to open script file again: \"%s %s\"\n",
  405.                             argv[-1], argv[0]);
  406.                     mch_windexit(2);
  407.                 }
  408.                 if ((scriptin[0] = fopen(argv[0], READBIN)) == NULL)
  409.                 {
  410.                     fprintf(stderr, "Cannot open \"%s\" for reading\n", argv[0]);
  411.                     mch_windexit(2);
  412.                 }
  413.                 break;
  414.             
  415. /*
  416.  * The -T term option is always available and when HAVE_TERMLIB is supported
  417.  * it overrides the environment variable TERM.
  418.  */
  419.             case 'T':            /* -T {terminal} */
  420.                 term = (char_u *)argv[0];
  421.                 break;
  422.             
  423.             case 'u':            /* -u {vimrc} */
  424.                 use_vimrc = (char_u *)argv[0];
  425.                 break;
  426.             
  427.             case 'w':            /* -w {scriptout} (append) */
  428.             case 'W':            /* -W {scriptout} (overwrite) */
  429.                 if (scriptout != NULL)
  430.                 {
  431.                     fprintf(stderr,
  432.                             "Attempt to open script file again: \"%s %s\"\n",
  433.                             argv[-1], argv[0]);
  434.                     mch_windexit(2);
  435.                 }
  436.                 if ((scriptout = fopen(argv[0],
  437.                                     c == 'w' ? APPENDBIN : WRITEBIN)) == NULL)
  438.                 {
  439.                     fprintf(stderr, "cannot open \"%s\" for output\n", argv[0]);
  440.                     mch_windexit(2);
  441.                 }
  442.                 break;
  443.             }
  444.         }
  445.         /*
  446.          * If there are no more letters after the current "-", go to next
  447.          * argument.  argv_idx is set to -1 when the current argument is to be
  448.          * skipped.
  449.          */
  450.         if (argv_idx <= 0 || argv[0][argv_idx] == NUL)
  451.         {
  452.             --argc;
  453.             ++argv;
  454.             argv_idx = 1;
  455.         }
  456.     }
  457.  
  458.     /*
  459.      * Process the other command line arguments.
  460.      * -e[errorfile]    quickfix mode
  461.      * -t[tagname]        jump to tag
  462.      * [--] [file ..]    file names
  463.      */
  464.     if (argc > 1)
  465.     {
  466.         if (argv[0][0] == '-' && (argv[0][1] != '-' || argv[0][2] != NUL))
  467.         {
  468.             switch (argv[0][1])
  469.             {
  470.               case 'e':            /* -e QuickFix mode */
  471.                 switch (argc)
  472.                 {
  473.                     case 2:
  474.                             if (argv[0][2])    /* -eerrorfile */
  475.                                 p_ef = (char_u *)argv[0] + 2;
  476.                             break;                /* -e */
  477.  
  478.                     case 3:                    /* -e errorfile */
  479.                             if (argv[0][2] != NUL)
  480.                                 usage(USAGE_GARBAGE, (char_u *)argv[0]);
  481.                             ++argv;
  482.                             p_ef = (char_u *)argv[0];
  483.                             break;
  484.  
  485.                     default:                /* argc > 3: too many arguments */
  486.                             usage(USAGE_TOO_MANY_ARGS, NULL);
  487.                 }
  488.                 doqf = 1;
  489.                 break;
  490.  
  491.             case 't':            /* -t tag  or -ttag */
  492.                 switch (argc)
  493.                 {
  494.                     case 2:
  495.                             if (argv[0][2])        /* -ttag */
  496.                             {
  497.                                 tagname = (char_u *)argv[0] + 2;
  498.                                 break;
  499.                             }
  500.                             usage(USAGE_ARG_MISSING, (char_u *)argv[0]);
  501.                             break;
  502.  
  503.                     case 3:                        /* -t tag */
  504.                             if (argv[0][2] != NUL)    /* also -ttag?! */
  505.                                 usage(USAGE_GARBAGE, (char_u *)argv[0]);
  506.                             ++argv;
  507.                             tagname = (char_u *)argv[0];
  508.                             break;
  509.  
  510.                     default:                /* argc > 3: too many arguments */
  511.                             usage(USAGE_TOO_MANY_ARGS, NULL);
  512.                 }
  513.                 break;
  514.  
  515.             default:
  516.                 usage(USAGE_UNKNOWN_OPTION, (char_u *)argv[0]);
  517.             }
  518.         }
  519.         else                /* must be a file name */
  520.         {
  521.             /*
  522.              * Skip a single "--" argument, used in front of a file name that
  523.              * starts with '-'.
  524.              */
  525.             if (argc > 2 && STRCMP(argv[0], "--") == 0)
  526.             {
  527.                 ++argv;
  528.                 --argc;
  529.             }
  530.  
  531. #if (!defined(UNIX) && !defined(__EMX__)) || defined(ARCHIE)
  532.             if (ExpandWildCards(argc - 1, (char_u **)argv, &arg_count,
  533.                     &arg_files, TRUE, TRUE) == OK && arg_count != 0)
  534.             {
  535.                 fname = arg_files[0];
  536.                 arg_exp = TRUE;
  537.             }
  538. #else
  539.             arg_files = (char_u **)argv;
  540.             arg_count = argc - 1;
  541.             fname = (char_u *)argv[0];
  542. #endif
  543.             if (arg_count > 1)
  544.             {
  545.                 printf("%d files to edit\n", arg_count);
  546.                 screen_start();            /* don't know where cursor is now */
  547.             }
  548.         }
  549.     }
  550.  
  551.     RedrawingDisabled = TRUE;
  552.  
  553.     /*
  554.      * When listing swap file names, don't do cursor positioning et. al.
  555.      */
  556.     if (recoverymode && fname == NULL)
  557.         full_screen = FALSE;
  558.  
  559. #ifdef USE_GUI
  560.     /*
  561.      * We don't want to open the GUI window until after we've read .vimrc,
  562.      * otherwise we don't know what font we will use, and hence we don't know
  563.      * what size the window should be.  So if there are errors in the .vimrc
  564.      * file, they will have to go to the terminal -- webb
  565.      */
  566.     if (gui.starting)
  567.         full_screen = FALSE;
  568. #endif
  569.  
  570.     /*
  571.      * mch_windinit() sets up the terminal (window) for use.  This must be
  572.      * done after resetting full_screen, otherwise it may move the cursor
  573.      * (MSDOS).
  574.      * Note that we may use mch_windexit() before mch_windinit()!
  575.      */
  576.     mch_windinit();                /* inits Rows and Columns */
  577.  
  578.     /*
  579.      * Set the default values for the options that use Rows and Columns.
  580.      */
  581.     set_init_2();
  582.  
  583.     firstwin->w_height = Rows - 1;
  584.     cmdline_row = Rows - 1;
  585.  
  586.     /*
  587.      * Now print a warning if stdout is not a terminal.
  588.      */
  589.     if (full_screen && (stdout_notty || mch_check_input() == FAIL))
  590.     {
  591.         if (stdout_notty)
  592.             fprintf(stderr, "Vim: Warning: Output is not to a terminal\n");
  593.         if (mch_check_input() == FAIL)
  594.             fprintf(stderr, "Vim: Warning: Input is not from a terminal\n");
  595.         mch_delay(2000L, TRUE);
  596.         screen_start();            /* don't know where cursor is now */
  597.     }
  598.  
  599.     curbuf->b_nwindows = 1;        /* there is one window */
  600.     win_init(curwin);            /* init current window */
  601.     init_yank();                /* init yank buffers */
  602.     if (full_screen)
  603.         termcapinit(term);        /* set terminal name and get terminal
  604.                                    capabilities */
  605.     screenclear();                /* clear screen (just inits screen structures,
  606.                                     because starting is TRUE) */
  607.  
  608.     if (full_screen)
  609.         msg_start();        /* in case a mapping or error message is printed */
  610.     msg_scroll = TRUE;
  611.     no_wait_return = TRUE;
  612.  
  613. #if defined(MSDOS) || defined(WIN32) || defined(OS2)
  614. /*
  615.  * Default mapping for some often used keys.
  616.  * Need to put string in allocated memory, because do_map() will modify it.
  617.  */
  618.     for (i = 0; i < sizeof(initmappings) / sizeof(struct initmap); ++i)
  619.     {
  620.         initstr = strsave(initmappings[i].arg);
  621.         if (initstr != NULL)
  622.         {
  623.             do_map(0, initstr, initmappings[i].mode);
  624.             vim_free(initstr);
  625.         }
  626.     }
  627. #endif
  628.  
  629. /*
  630.  * If -u option give, use only the initializations from that file and nothing
  631.  * else.
  632.  */
  633.     if (use_vimrc != NULL)
  634.     {
  635.         if (STRCMP(use_vimrc, "NONE") != 0)
  636.         {
  637.             if (do_source(use_vimrc, FALSE) == OK)
  638.                 check_version = TRUE;
  639.             else
  640.                 EMSG2("Cannot read from \"%s\"", use_vimrc);
  641.         }
  642.     }
  643.     else
  644.     {
  645.  
  646.     /*
  647.      * get system wide defaults (for unix)
  648.      */
  649. #if defined(HAVE_CONFIG_H) || defined(OS2)
  650.         if (do_source(sys_vimrc_fname, TRUE) == OK)
  651.             check_version = TRUE;
  652. #endif
  653.  
  654.     /*
  655.      * Try to read initialization commands from the following places:
  656.      * - environment variable VIMINIT
  657.      * - user vimrc file (s:.vimrc for Amiga, ~/.vimrc for Unix)
  658.      * - environment variable EXINIT
  659.      * - user exrc file (s:.exrc for Amiga, ~/.exrc for Unix)
  660.      * The first that exists is used, the rest is ignored.
  661.      */
  662.         if ((initstr = vim_getenv((char_u *)"VIMINIT")) != NULL &&
  663.                                                         *initstr != NUL)
  664.         {
  665.             sourcing_name = (char_u *)"VIMINIT";
  666.             do_cmdline(initstr, TRUE, TRUE);
  667.             sourcing_name = NULL;
  668.         }
  669.         else if (do_source((char_u *)USR_VIMRC_FILE, TRUE) == FAIL)
  670.         {
  671.             if ((initstr = vim_getenv((char_u *)"EXINIT")) != NULL)
  672.             {
  673.                 sourcing_name = (char_u *)"EXINIT";
  674.                 do_cmdline(initstr, TRUE, TRUE);
  675.                 sourcing_name = NULL;
  676.             }
  677.             else
  678.                 (void)do_source((char_u *)USR_EXRC_FILE, FALSE);
  679.         }
  680.         else
  681.             check_version = TRUE;
  682.  
  683.     /*
  684.      * Read initialization commands from ".vimrc" or ".exrc" in current
  685.      * directory.  This is only done if the 'exrc' option is set.
  686.      * Because of security reasons we disallow shell and write commands now,
  687.      * except for unix if the file is owned by the user or 'secure' option has
  688.      * been reset in environmet of global ".exrc" or ".vimrc".
  689.      * Only do this if VIMRC_FILE is not the same as USR_VIMRC_FILE or
  690.      * sys_vimrc_fname.
  691.      */
  692.         if (p_exrc)
  693.         {
  694. #ifdef UNIX
  695.             {
  696.                 struct stat s;
  697.  
  698.                 /* if ".vimrc" file is not owned by user, set 'secure' mode */
  699.                 if (stat(VIMRC_FILE, &s) || s.st_uid != getuid())
  700.                     secure = p_secure;
  701.             }
  702. #else
  703.             secure = p_secure;
  704. #endif
  705.  
  706.             i = FAIL;
  707.             if (fullpathcmp((char_u *)USR_VIMRC_FILE,
  708.                                              (char_u *)VIMRC_FILE) != FPC_SAME
  709. #if defined(HAVE_CONFIG_H) || defined(OS2)
  710.                     && fullpathcmp(sys_vimrc_fname,
  711.                                              (char_u *)VIMRC_FILE) != FPC_SAME
  712. #endif
  713.                     )
  714.                 i = do_source((char_u *)VIMRC_FILE, TRUE);
  715.  
  716.             if (i != FAIL)
  717.                 check_version = TRUE;
  718. #ifdef UNIX
  719.             else
  720.             {
  721.                 struct stat s;
  722.  
  723.                     /* if ".exrc" is not owned by user set 'secure' mode */
  724.                 if (stat(EXRC_FILE, &s) || s.st_uid != getuid())
  725.                     secure = p_secure;
  726.                 else
  727.                     secure = 0;
  728.             }
  729. #endif
  730.             if (i == FAIL && fullpathcmp((char_u *)USR_EXRC_FILE,
  731.                                              (char_u *)EXRC_FILE) != FPC_SAME)
  732.                 (void)do_source((char_u *)EXRC_FILE, FALSE);
  733.         }
  734.         if (secure == 2)
  735.             need_wait_return = TRUE;
  736.         secure = 0;
  737.     }
  738.  
  739.     /*
  740.      * Recovery mode without a file name: List swap files.
  741.      * This uses the 'dir' option, therefore it must be after the
  742.      * initializations.
  743.      */
  744.     if (recoverymode && fname == NULL)
  745.     {
  746.         recover_names(NULL, TRUE, 0);
  747.         mch_windexit(0);
  748.     }
  749.  
  750.     /*
  751.      * Set a few option defaults after reading .vimrc files:
  752.      * 'title' and 'icon', Unix: 'shellpipe' and 'shellredir'.
  753.      */
  754.     set_init_3();
  755.  
  756. #ifdef USE_GUI
  757.     if (gui.starting)
  758.         gui_start();            /* will set full_screen to TRUE */
  759. #endif
  760.  
  761.     /*
  762.      * If we read a .vimrc but it does not contain a "version 4.0" command,
  763.      * give the user a pointer to the help for the new version.
  764.      */
  765.     if (check_version && found_version == 0)
  766.     {
  767.         smsg((char_u *)"This is Vim version %s.", Version);
  768.         MSG("No \":version 4.x\" command found in any .vimrc.");
  769.         MSG("Use \":help version\" for info about this new version.");
  770.     }
  771.  
  772. #ifdef VIMINFO
  773. /*
  774.  * Read in registers, history etc, but not marks, from the viminfo file
  775.  */
  776.     if (*p_viminfo != NUL)
  777.         read_viminfo(NULL, TRUE, FALSE, FALSE);
  778. #endif /* VIMINFO */
  779.  
  780. #ifdef SPAWNO            /* special MSDOS swapping library */
  781.     init_SPAWNO("", SWAP_ANY);
  782. #endif
  783.  
  784.     if (bin_mode)                    /* -b option used */
  785.     {
  786.         set_options_bin(curbuf->b_p_bin, 1);
  787.         curbuf->b_p_bin = 1;        /* binary file I/O */
  788.     }
  789.  
  790. /*
  791.  * "-e errorfile": Load the error file now.
  792.  * If the error file can't be read, exit before doing anything else.
  793.  */
  794.     if (doqf && qf_init() == FAIL)        /* if reading error file fails: exit */
  795.     {
  796.         outchar('\n');
  797.         mch_windexit(3);
  798.     }
  799.  
  800.     /* Don't set the file name if there was a command in .vimrc that already
  801.      * loaded the file */
  802.     if (curbuf->b_filename == NULL)
  803.     {
  804.         (void)setfname(fname, NULL, TRUE);    /* includes maketitle() */
  805.         ++arg_idx;                            /* used first argument name */
  806.     }
  807.  
  808.     if (window_count == 0)
  809.         window_count = arg_count;
  810.     if (window_count > 1)
  811.     {
  812.         /* Don't change the windows if there was a command in .vimrc that
  813.          * already split some windows */
  814.         if (firstwin->w_next == NULL)
  815.             window_count = make_windows(window_count);
  816.         else
  817.             window_count = win_count();
  818.     }
  819.     else
  820.         window_count = 1;
  821.  
  822. /*
  823.  * Start putting things on the screen.
  824.  * Scroll screen down before drawing over it
  825.  * Clear screen now, so file message will not be cleared.
  826.  */
  827.     starting = FALSE;
  828.     no_wait_return = FALSE;
  829.     msg_scroll = FALSE;
  830. #ifdef USE_GUI
  831.     /*
  832.      * This seems to be required to make callbacks to be called now, instead
  833.      * of after things have been put on the screen, which then may be deleted
  834.      * when getting a resize callback.
  835.      */
  836.     if (gui.in_use)
  837.         gui_mch_wait_for_chars(50);
  838. #endif
  839.  
  840. /*
  841.  * When done something that is not allowed or error message call wait_return.
  842.  * This must be done before starttermcap(), because it may switch to another
  843.  * screen. It must be done after settmode(1), because we want to react on a
  844.  * single key stroke.
  845.  * Call settmode and starttermcap here, so the T_KS and T_TI may be defined
  846.  * by termcapinit and redifined in .exrc.
  847.  */
  848.     settmode(1);
  849.     if (need_wait_return || msg_didany)
  850.         wait_return(TRUE);
  851.  
  852.     starttermcap();            /* start termcap if not done by wait_return() */
  853. #ifdef USE_MOUSE
  854.     setmouse();                            /* may start using the mouse */
  855. #endif
  856.     if (scroll_region)
  857.         scroll_region_reset();            /* In case Rows changed */
  858.  
  859.     scroll_start();
  860.     screenclear();                        /* clear screen */
  861.  
  862.     no_wait_return = TRUE;
  863.  
  864.     if (recoverymode)                    /* do recover */
  865.     {
  866.         msg_scroll = TRUE;                /* scroll message up */
  867.         ml_recover();
  868.         msg_scroll = FALSE;
  869.         if (curbuf->b_ml.ml_mfp == NULL) /* failed */
  870.             getout(1);
  871.         do_modelines();                    /* do modelines */
  872.     }
  873.     else
  874.     {
  875.         /*
  876.          * Open a buffer for windows that don't have one yet.
  877.          * Commands in the .vimrc might have loaded a file or split the window.
  878.          * Watch out for autocommands that delete a window.
  879.          */
  880. #ifdef AUTOCMD
  881.         /*
  882.          * Don't execute Win/Buf Enter/Leave autocommands here
  883.          */
  884.         ++autocmd_no_enter;
  885.         ++autocmd_no_leave;
  886. #endif
  887.         for (curwin = firstwin; curwin != NULL; curwin = curwin->w_next)
  888.         {
  889.             curbuf = curwin->w_buffer;
  890.             if (curbuf->b_ml.ml_mfp == NULL)
  891.             {
  892.                 (void)open_buffer();        /* create memfile and read file */
  893. #ifdef AUTOCMD
  894.                 curwin = firstwin;            /* start again */
  895. #endif
  896.             }
  897.             mch_breakcheck();
  898.             if (got_int)
  899.             {
  900.                 (void)vgetc();    /* only break the file loading, not the rest */
  901.                 break;
  902.             }
  903.         }
  904. #ifdef AUTOCMD
  905.         --autocmd_no_enter;
  906.         --autocmd_no_leave;
  907. #endif
  908.         curwin = firstwin;
  909.         curbuf = curwin->w_buffer;
  910.     }
  911.  
  912. #ifdef AUTOCMD
  913.     apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE);
  914. #endif
  915.     setpcmark();
  916.  
  917.     /*
  918.      * When started with "-e errorfile" jump to first error now.
  919.      */
  920.     if (doqf)
  921.         qf_jump(0, 0, FALSE);
  922.  
  923.     /*
  924.      * If opened more than one window, start editing files in the other windows.
  925.      * Make_windows() has already opened the windows.
  926.      */
  927. #ifdef AUTOCMD
  928.     /*
  929.      * Don't execute Win/Buf Enter/Leave autocommands here
  930.      */
  931.     ++autocmd_no_enter;
  932.     ++autocmd_no_leave;
  933. #endif
  934.     for (i = 1; i < window_count; ++i)
  935.     {
  936.         if (curwin->w_next == NULL)            /* just checking */
  937.             break;
  938.         win_enter(curwin->w_next, FALSE);
  939.  
  940.         /* Only open the file if there is no file in this window yet (that can
  941.          * happen when .vimrc contains ":sall") */
  942.         if (curbuf == firstwin->w_buffer || curbuf->b_filename == NULL)
  943.         {
  944.             curwin->w_arg_idx = arg_idx;
  945.             /* edit file from arg list, if there is one */
  946.             (void)do_ecmd(0, arg_idx < arg_count ? arg_files[arg_idx] : NULL,
  947.                                           NULL, NULL, (linenr_t)1, ECMD_HIDE);
  948.             if (arg_idx == arg_count - 1)
  949.                 arg_had_last = TRUE;
  950.             ++arg_idx;
  951.         }
  952.         mch_breakcheck();
  953.         if (got_int)
  954.         {
  955.             (void)vgetc();        /* only break the file loading, not the rest */
  956.             break;
  957.         }
  958.     }
  959. #ifdef AUTOCMD
  960.     --autocmd_no_enter;
  961. #endif
  962.     win_enter(firstwin, FALSE);                /* back to first window */
  963. #ifdef AUTOCMD
  964.     --autocmd_no_leave;
  965. #endif
  966.     if (window_count > 1)
  967.         win_equal(curwin, FALSE);            /* adjust heights */
  968.  
  969.     /*
  970.      * If there are more file names in the argument list than windows,
  971.      * put the rest of the names in the buffer list.
  972.      */
  973.     while (arg_idx < arg_count)
  974.         (void)buflist_add(arg_files[arg_idx++]);
  975.  
  976.     /*
  977.      * Need to jump to the tag before executing the '-c command'.
  978.      * Makes "vim -c '/return' -t main" work.
  979.      */
  980.     if (tagname)
  981.     {
  982.         STRCPY(IObuff, "ta ");
  983.         STRCAT(IObuff, tagname);
  984.         do_cmdline(IObuff, TRUE, TRUE);
  985.     }
  986.  
  987.     if (command)
  988.     {
  989.         /*
  990.          * We start commands on line 0, make "vim +/pat file" match a
  991.          * pattern on line 1.
  992.          */
  993.         curwin->w_cursor.lnum = 0;
  994.         sourcing_name = (char_u *)"command line";
  995.         do_cmdline(command, TRUE, TRUE);
  996.         sourcing_name = NULL;
  997.     }
  998.  
  999.     RedrawingDisabled = FALSE;
  1000.     redraw_later(NOT_VALID);
  1001.     no_wait_return = FALSE;
  1002.  
  1003.     /* start in insert mode */
  1004.     if (p_im)
  1005.         need_start_insertmode = TRUE;
  1006.  
  1007. /*
  1008.  * main command loop
  1009.  */
  1010.     for (;;)
  1011.     {
  1012.         if (stuff_empty())
  1013.         {
  1014.             if (need_check_timestamps)
  1015.                 check_timestamps();
  1016.             if (need_wait_return)        /* if wait_return still needed ... */
  1017.                 wait_return(FALSE);        /* ... call it now */
  1018.             if (need_start_insertmode)
  1019.             {
  1020.                 need_start_insertmode = FALSE;
  1021.                 stuffReadbuff((char_u *)"i");    /* start insert mode next */
  1022.                 /* skip the fileinfo message now, because it would be shown
  1023.                  * after insert mode finishes! */
  1024.                 need_fileinfo = FALSE;
  1025.             }
  1026.         }
  1027.         dont_wait_return = FALSE;
  1028.         if (got_int && !global_busy)
  1029.         {
  1030.             (void)vgetc();                /* flush all buffers */
  1031.             got_int = FALSE;
  1032.         }
  1033.         adjust_cursor();                /* put cursor on an existing line */
  1034.         msg_scroll = FALSE;
  1035.         quit_more = FALSE;
  1036.         keep_help_flag = FALSE;
  1037.         /*
  1038.          * If skip redraw is set (for ":" in wait_return()), don't redraw now.
  1039.          * If there is nothing in the stuff_buffer or do_redraw is TRUE,
  1040.          * update cursor and redraw.
  1041.          */
  1042.         if (skip_redraw)            
  1043.             skip_redraw = FALSE;
  1044.         else if (do_redraw || stuff_empty())
  1045.         {
  1046.             cursupdate();                /* Figure out where the cursor is based
  1047.                                             on curwin->w_cursor. */
  1048. #ifdef SLEEP_IN_EMSG
  1049.             if (need_sleep)                /* sleep before redrawing */
  1050.             {
  1051.                 mch_delay(1000L, TRUE);
  1052.                 need_sleep = FALSE;
  1053.             }
  1054. #endif
  1055.             if (VIsual_active)
  1056.                 update_curbuf(INVERTED);/* update inverted part */
  1057.             if (must_redraw)
  1058.                 updateScreen(must_redraw);
  1059.             else if (redraw_cmdline)
  1060.                 showmode();
  1061.             if (keep_msg != NULL)
  1062.             {
  1063.                 if (keep_msg_highlight)
  1064.                 {
  1065.                     (void)set_highlight(keep_msg_highlight);
  1066.                     msg_highlight = TRUE;
  1067.                 }
  1068.                 msg(keep_msg);            /* display message after redraw */
  1069.             }
  1070.             if (need_fileinfo)            /* used after jumping to a tag */
  1071.             {
  1072.                 fileinfo(did_cd, TRUE, FALSE);
  1073.                 need_fileinfo = FALSE;
  1074.             }
  1075.  
  1076.             emsg_on_display = FALSE;    /* can delete error message now */
  1077.             msg_didany = FALSE;            /* reset lines_left in msg_start() */
  1078.             do_redraw = FALSE;
  1079.             showruler(FALSE);
  1080.  
  1081.             setcursor();
  1082.             cursor_on();
  1083.         }
  1084.  
  1085.         /*
  1086.          * get and execute a normal mode command
  1087.          */
  1088.         normal();
  1089.     }
  1090.     /*NOTREACHED*/
  1091. }
  1092.  
  1093.     void
  1094. getout(r)
  1095.     int             r;
  1096. {
  1097.     exiting = TRUE;
  1098.  
  1099.     /* Position the cursor on the last screen line, below all the text */
  1100. #ifdef USE_GUI
  1101.     if (!gui.in_use)
  1102. #endif
  1103.         windgoto((int)Rows - 1, 0);
  1104.  
  1105. #ifdef AUTOCMD
  1106.     apply_autocmds(EVENT_VIMLEAVE, NULL, NULL, FALSE);
  1107.  
  1108.     /* Position the cursor again, the autocommands may have moved it */
  1109. # ifdef USE_GUI
  1110.     if (!gui.in_use)
  1111. # endif
  1112.         windgoto((int)Rows - 1, 0);
  1113. #endif
  1114.  
  1115. #ifdef VIMINFO
  1116.     msg_didany = FALSE;
  1117.     /* Write out the registers, history, marks etc, to the viminfo file */
  1118.     if (*p_viminfo != NUL)
  1119.         write_viminfo(NULL, FALSE);
  1120.     if (msg_didany)                /* make the user read the error message */
  1121.     {
  1122.         no_wait_return = FALSE;
  1123.         wait_return(FALSE);
  1124.     }
  1125. #endif /* VIMINFO */
  1126.  
  1127.     mch_windexit(r);
  1128. }
  1129.