Changeset 1414


Ignore:
Timestamp:
May 1, 2004, 6:31:59 AM (21 years ago)
Author:
bird
Message:

cleanup.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/gcc/gcc/config/i386/xm-emx.h

    • Property cvs2svn:cvs-rev changed from 1.8 to 1.9
    r1413 r1414  
    66/* Directories in path environment variables are separated by semicolons. */
    77#undef PATH_SEPARATOR
    8 #define PATH_SEPARATOR          ';'
     8#define PATH_SEPARATOR          ';'
    99
    1010/* OS/2 executables ends with '.exe' */
    1111#undef HOST_EXECUTABLE_SUFFIX
    12 #define HOST_EXECUTABLE_SUFFIX ".exe"
     12#define HOST_EXECUTABLE_SUFFIX  ".exe"
    1313
    1414/* Pathname components are separated by '/' or '\\'. */
    1515#undef DIR_SEPARATOR
    16 #define DIR_SEPARATOR           '/'
     16#define DIR_SEPARATOR           '/'
    1717#undef DIR_SEPARATOR_2
    18 #define DIR_SEPARATOR_2         '\\'
     18#define DIR_SEPARATOR_2         '\\'
    1919
    2020/* Tell GCC about OS/2's bit bucket. */
    21 
    22 #define HOST_BIT_BUCKET "NUL"
     21#define HOST_BIT_BUCKET         "NUL"
    2322
    2423/* No block device special files on OS/2 */
    25 #define S_ISBLK(x) 0
    26 
     24#ifndef S_ISBLK
     25#define S_ISBLK(x)              0
     26#endif
     27
     28       
    2729/******************************************************************************
    2830 *                             - P - A - T - H - S -
    2931 ******************************************************************************/
    3032
     33/* (The /gcc/ prefix is rewritten to the real path when initalizing GCC.) */
    3134#ifndef CROSS_COMPILE
    3235#undef LOCAL_INCLUDE_DIR
     
    3437#undef TOOL_INCLUDE_DIR
    3538#undef STANDARD_INCLUDE_DIR
    36 #define STANDARD_INCLUDE_DIR            "/gcc/include/"
    37 #define STANDARD_INCLUDE_COMPONENT      "GCC"
     39#define STANDARD_INCLUDE_DIR            "/gcc/include/"
     40#define STANDARD_INCLUDE_COMPONENT      "GCC"
    3841#undef LOCAL_INCLUDE_DIR
    3942#undef PREFIX_INCLUDE_DIR
     
    4346
    4447/* for prefix.c */
    45 #define UPDATE_PATH_HOST_CANONICALIZE(path)                                    \
    46 {                                                                              \
    47   char prefix_buffer [260 + 1], *c;                                            \
    48   _abspath (prefix_buffer, path, sizeof (prefix_buffer));                      \
    49   free (path);                                                                 \
    50   /* Way too often gcc generates double slashes, it looks bad */               \
    51   for (c = prefix_buffer; *c; c++)                                             \
    52     if ((c [0] == '/') && (c [1] == '/'))                                      \
    53       memmove (c, c + 1, strlen (c));                                          \
    54   path = xstrdup (prefix_buffer);                                              \
     48#define UPDATE_PATH_HOST_CANONICALIZE(path)                                    \
     49{                                                                              \
     50  char prefix_buffer [260 + 1], *c;                                            \
     51  _abspath (prefix_buffer, path, sizeof (prefix_buffer));                      \
     52  free (path);                                                                 \
     53  /* Way too often gcc generates double slashes, it looks bad */               \
     54  for (c = prefix_buffer; *c; c++)                                             \
     55    if ((c [0] == '/') && (c [1] == '/'))                                      \
     56      memmove (c, c + 1, strlen (c));                                          \
     57  path = xstrdup (prefix_buffer);                                              \
    5558}
    5659
    57 #define EMX_INITIALIZE_ENVIRONMENT(taildirs)                                   \
    58   /* Add the GCC_ROOT and BINUTILS_ROOT env vars if they don't exist */        \
    59   if (!getenv ("GCC_ROOT") || !getenv ("G++_ROOT") || !getenv ("BINUTILS_ROOT"))\
    60     {                                                                          \
    61       char buffer [14 + 260 + 1];                                              \
    62       if (!_execname (buffer + 14, sizeof (buffer) - 14))                      \
    63       {                                                                        \
    64         int i;                                                                 \
    65         for (i = 0; i < taildirs; i++)                                         \
    66           {                                                                    \
    67             char *name = _getname (buffer + 14);                               \
    68             if (name > buffer + 14)                                            \
    69               {                                                                \
    70                 if (i < taildirs - 1) name--;                                  \
    71                 if (*name != ':') *name = 0;                                   \
    72               }                                                                \
    73           }                                                                    \
    74         if (!getenv ("GCC_ROOT"))                                              \
    75           {                                                                    \
    76             memcpy (buffer + 5, "GCC_ROOT=", 9);                               \
    77             putenv (xstrdup (buffer + 5));                                     \
    78           }                                                                    \
    79         if (!getenv ("G++_ROOT"))                                              \
    80           {                                                                    \
    81             memcpy (buffer + 5, "G++_ROOT=", 9);                               \
    82             putenv (xstrdup (buffer + 5));                                     \
    83           }                                                                    \
    84         if (!getenv ("BINUTILS_ROOT"))                                         \
    85           {                                                                    \
    86             memcpy (buffer, "BINUTILS_ROOT=", 14);                             \
    87             putenv (xstrdup (buffer));                                         \
    88           }                                                                    \
    89       }                                                                        \
    90     }
     60                               
     61/******************************************************************************
     62 *                             - I - N - I - T -
     63 ******************************************************************************/
     64 
     65#define EMX_INITIALIZE_ENVIRONMENT(taildirs)                                   \
     66  /* Set env.vars GCC_ROOT, G++_ROOT and BINUTILS_ROOT.  */                    \
     67  {                                                                            \
     68  int fGCC = !getenv ("GCC_ROOT");                                             \
     69  int fGPP = !getenv ("G++_ROOT");                                             \
     70  int fBIN = !getenv ("BINUTILS_ROOT");                                        \
     71  if (fGCC || fGPP || fBIN)                                                    \
     72    {                                                                          \
     73      char root_path [260];                                                    \
     74      if (!_execname (root_path, sizeof (root_path)))                          \
     75      {                                                                        \
     76        int i;                                                                 \
     77        for (i = 0; i < taildirs; i++)                                         \
     78          {                                                                    \
     79            char *name = _getname (root_path);                                 \
     80            if (name > root_path)                                              \
     81              {                                                                \
     82                if (i < taildirs - 1)                                          \
     83                  name--;                                                      \
     84                if (*name != ':')                                              \
     85                  *name = '\0';                                                \
     86              }                                                                \
     87          }                                                                    \
     88        if (fGCC)                                                              \
     89          setenv ("GCC_ROOT", root_path, 1);                                   \
     90        if (fGPP)                                                              \
     91          setenv ("G++_ROOT", root_path, 1);                                   \
     92        if (fGCC)                                                              \
     93          setenv ("BINUTILS_ROOT", root_path, 1);                              \
     94      }                                                                        \
     95    }                                                                          \
     96  }
    9197
    9298/* emxomf does not understand stabs+, so for frontends we have to
     
    101107    _response (&argc, (char ***)&argv);                                        \
    102108    _wildcard (&argc, (char ***)&argv);                                        \
     109                                                                               \
    103110    /* Copy argv into a new location and modify it while copying */            \
    104111    new_argv = (const char **)malloc ((max_argc = argc) * sizeof (char *));    \
     
    106113    for (i = 1, new_argc = 1; i < argc; i++)                                   \
    107114      {                                                                        \
    108         int arg_count = 1;                                                     \
     115        int         arg_count = 1;                                             \
    109116        const char *arg [4];                                                   \
    110117        arg [0] = argv [i];                                                    \
    111118        if (!strcmp (argv [i], "-Zcrtdll"))                                    \
    112           arg [0] = "-Zcrtdll=c_dll";                                          \
    113         else if (!strcmp (argv [i], "-Zlinker"))                               \
    114           {                                                                    \
     119          arg [0] = "-Zcrtdll=c_dll";                                          \
     120        else if (!strcmp (argv [i], "-Zlinker"))                               \
     121          {                                                                    \
    115122            if (i + 1 >= argc)                                                 \
    116                 fatal ("argument to `-Zlinker' is missing");                   \
    117             arg [0] = "-Xlinker";                                              \
    118             arg [1] = "-O";                                                    \
    119             arg [2] = "-Xlinker";                                              \
    120             arg [3] = argv [++i];                                              \
    121             arg_count = 4;                                                     \
    122           }                                                                    \
     123                fatal ("argument to `-Zlinker' is missing");                   \
     124            arg [0] = "-Xlinker";                                              \
     125            arg [1] = "-O";                                                    \
     126            arg [2] = "-Xlinker";                                              \
     127            arg [3] = argv [++i];                                              \
     128            arg_count = 4;                                                     \
     129          }                                                                    \
    123130        if (new_argc + arg_count > max_argc)                                   \
    124             new_argv = (const char **)realloc (new_argv,                       \
    125                 (new_argc + arg_count) * sizeof (char *));                     \
     131            new_argv = (const char **)realloc (new_argv,                       \
     132                (new_argc + arg_count) * sizeof (char *));                     \
    126133        for (j = 0; j < arg_count; j++)                                        \
    127134            new_argv [new_argc++] = arg [j];                                   \
    128135      }                                                                        \
    129136    argv = new_argv; argc = new_argc;                                          \
    130     EMX_INITIALIZE_ENVIRONMENT(2)                                              \
     137    EMX_INITIALIZE_ENVIRONMENT(2)                                              \
    131138  }
    132139
    133140/* Do some OS/2-specific work upon initialization of all compilers */
    134141#define COMPILER_HOST_INITIALIZATION                                           \
    135   {                                                                            \
     142  {                                                                            \
    136143    /* Preload compiler if specified by GCCLOAD for faster subsequent runs */  \
    137144    _emxload_env ("GCCLOAD");                                                  \
    138145    /* Compilers don't fork (thanks God!) so we can use >32MB RAM */           \
    139     _uflags (_UF_SBRK_MODEL, _UF_SBRK_ARBITRARY);                              \
    140     EMX_INITIALIZE_ENVIRONMENT(5)                                              \
     146    /* bird: this doesn't matter really as the compiler now should use high */ \
     147    /*       memory. But we'll leave it here in case a DLL gets broken. */     \
     148    _uflags (_UF_SBRK_MODEL, _UF_SBRK_ARBITRARY);                              \
     149    EMX_INITIALIZE_ENVIRONMENT(5)                                              \
    141150  }
    142151
     152                               
     153                               
     154/******************************************************************************
     155 *                             - C - L - H  -
     156 ******************************************************************************/
     157 
    143158/* Command-line help facility support -
    144159   avoid using termcap since its not too reliable on OS/2 */
     
    147162#include <io.h>
    148163
    149 static int emx_monochrome = 0;  /* 1 for monochrome output */
    150 static int emx_textattr = 0;    /* current text attributes */
     164static int emx_monochrome = 0;  /* 1 for monochrome output */
     165static int emx_textattr = 0;    /* current text attributes */
    151166
    152167static int
     
    168183static const char *ansi_seq [] =
    169184{
    170 /*  color               monochrome */
    171     "\033[0;36m",       "\033[0m",      /* */
    172     "\033[1;36m",       "\033[1m",      /* header */
    173     "\033[1;37m",       "\033[7m",      /* option */
    174     "\033[1;37m",       "\033[7m",      /* option + header */
    175     "\033[1;37m",       "\033[1m",      /* bold */
    176     "\033[1;37m",       "\033[1m",      /* bold + header */
    177     "\033[1;37m",       "\033[7m",      /* bold + option */
    178     "\033[1;37m",       "\033[7m",      /* bold + option + header */
    179     "\033[1;32m",       "\033[1m",      /* italic */
    180     "\033[1;32m",       "\033[1m",      /* italic + header */
    181     "\033[1;32m",       "\033[1m",      /* italic + option */
    182     "\033[1;32m",       "\033[1m",      /* italic + option + header */
    183     "\033[1;32m",       "\033[1m",      /* italic + bold */
    184     "\033[1;32m",       "\033[1m",      /* italic + bold + header */
    185     "\033[1;32m",       "\033[1m",      /* italic + bold + option */
    186     "\033[1;32m",       "\033[1m",      /* italic + bold + option + header */
    187     "\033[1;33m",       "\033[4m",      /* underline */
    188     "\033[1;33m",       "\033[4m",      /* underline + header */
    189     "\033[1;37m",       "\033[4m",      /* underline + option */
    190     "\033[1;37m",       "\033[4m",      /* underline + option + header */
    191     "\033[1;37m",       "\033[4m",      /* underline + bold */
    192     "\033[1;37m",       "\033[4m",      /* underline + bold + header */
    193     "\033[1;37m",       "\033[4m",      /* underline + bold + option */
    194     "\033[1;37m",       "\033[4m",      /* underline + bold + option + header */
    195     "\033[1;33m",       "\033[4m",      /* underline + italic */
    196     "\033[1;37m",       "\033[4m",      /* underline + italic + header */
    197     "\033[1;37m",       "\033[4m",      /* underline + italic + option */
    198     "\033[1;37m",       "\033[4m",      /* underline + italic + option + header */
    199     "\033[1;37m",       "\033[4m",      /* underline + italic + bold */
    200     "\033[1;37m",       "\033[4m",      /* underline + italic + bold + header */
    201     "\033[1;37m",       "\033[4m",      /* underline + italic + bold + option */
    202     "\033[1;37m",       "\033[4m",      /* underline + italic + bold + option + header */
     185/*  color               monochrome */
     186    "\033[0;36m",       "\033[0m",      /* */
     187    "\033[1;36m",       "\033[1m",      /* header */
     188    "\033[1;37m",       "\033[7m",      /* option */
     189    "\033[1;37m",       "\033[7m",      /* option + header */
     190    "\033[1;37m",       "\033[1m",      /* bold */
     191    "\033[1;37m",       "\033[1m",      /* bold + header */
     192    "\033[1;37m",       "\033[7m",      /* bold + option */
     193    "\033[1;37m",       "\033[7m",      /* bold + option + header */
     194    "\033[1;32m",       "\033[1m",      /* italic */
     195    "\033[1;32m",       "\033[1m",      /* italic + header */
     196    "\033[1;32m",       "\033[1m",      /* italic + option */
     197    "\033[1;32m",       "\033[1m",      /* italic + option + header */
     198    "\033[1;32m",       "\033[1m",      /* italic + bold */
     199    "\033[1;32m",       "\033[1m",      /* italic + bold + header */
     200    "\033[1;32m",       "\033[1m",      /* italic + bold + option */
     201    "\033[1;32m",       "\033[1m",      /* italic + bold + option + header */
     202    "\033[1;33m",       "\033[4m",      /* underline */
     203    "\033[1;33m",       "\033[4m",      /* underline + header */
     204    "\033[1;37m",       "\033[4m",      /* underline + option */
     205    "\033[1;37m",       "\033[4m",      /* underline + option + header */
     206    "\033[1;37m",       "\033[4m",      /* underline + bold */
     207    "\033[1;37m",       "\033[4m",      /* underline + bold + header */
     208    "\033[1;37m",       "\033[4m",      /* underline + bold + option */
     209    "\033[1;37m",       "\033[4m",      /* underline + bold + option + header */
     210    "\033[1;33m",       "\033[4m",      /* underline + italic */
     211    "\033[1;37m",       "\033[4m",      /* underline + italic + header */
     212    "\033[1;37m",       "\033[4m",      /* underline + italic + option */
     213    "\033[1;37m",       "\033[4m",      /* underline + italic + option + header */
     214    "\033[1;37m",       "\033[4m",      /* underline + italic + bold */
     215    "\033[1;37m",       "\033[4m",      /* underline + italic + bold + header */
     216    "\033[1;37m",       "\033[4m",      /* underline + italic + bold + option */
     217    "\033[1;37m",       "\033[4m",      /* underline + italic + bold + option + header */
    203218};
    204219
     
    214229}
    215230
    216 #define CLH_GET_WIDTH                   emx_getwidth ()
    217 #define CLH_GET_FILE_WIDTH              emx_getwidth ()
    218 #define CLH_SET_ATTR(flags, flagmask)   emx_setattr (flags, flagmask)
    219 #define CLH_FINISH                      TERM_OUT (ansi_seq [emx_monochrome])
     231#define CLH_GET_WIDTH                   emx_getwidth ()
     232#define CLH_GET_FILE_WIDTH              emx_getwidth ()
     233#define CLH_SET_ATTR(flags, flagmask)   emx_setattr (flags, flagmask)
     234#define CLH_FINISH                      TERM_OUT (ansi_seq [emx_monochrome])
    220235
    221236#endif /* IN_CLH */
Note: See TracChangeset for help on using the changeset viewer.