home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / win3 / nt / source.exe / POSIX / CC / CC.C next >
C/C++ Source or Header  |  1993-07-09  |  23KB  |  989 lines
  1. /*
  2.       File : cc.c
  3.  
  4.       Author : C S Palkar
  5.  
  6.       Function : Front end for 'cc' to be POSIX complient
  7.  
  8.       Details : The 'cc' command will be invoked it options
  9.                 scaned for validity and an equivalent command
  10.                 constructed for the native C compiler, this
  11.                 command is passed to a deamon OR if possible
  12.                 execed.
  13.  
  14.       Date : 17 June 93
  15. */
  16.  
  17. #include <sys/types.h>
  18. #include <sys/stat.h>
  19. #include <fcntl.h>
  20. #include <stdlib.h>
  21. #include <stdio.h>
  22. #include <string.h>
  23.  
  24. #define PNULL(p)          (p*)NULL
  25. #define RNULL             PNULL(rev_cell)
  26. #define NNULL             PNULL(nat_cell)
  27. #define GNULL             PNULL(gnu_cell)
  28. #define SNULL             PNULL(char)
  29.  
  30. #define OPT_TAG           '-'       /* Option tag */
  31. #define EQU               '='       /* EQU */
  32. #define NL                "\n"      /* EOL */
  33. #define OP_CHAR           '/'      /* native opt tag */
  34. #define SP_CHAR           ' '       /* native arg sep */
  35. #define CNULL             '\0'      /* string terminator */
  36.  
  37. #define VAR_SEP           ':'      /* Inc var Path seperator */
  38. #define PT_SEP            "/"      /* Path seperator */
  39. #define CWD               "cwd"     /* Delmiter for path list */
  40.  
  41. #define ST_LIST           "["       /* Trial list start */
  42. #define SP_LIST           "|"       /* Trial list end */
  43. #define ED_LIST           "]"       /* Trial list end */
  44.  
  45. #define LIB_PATH          "LIB"     /* Lib path env var */
  46. #define NO_LINK           "c"       /* Opt for no lnk */
  47.  
  48. #define LIB_PPATH         "LIB"     /* Lib path */
  49. #define INC_PATH          "POSIX_INC"     /* Env var for inc path */
  50. #define LIBST             "lib"     /* Lib name */
  51. #define LEXT              ".a"      /* Lib name */
  52. #define HOST_CC           "cl386"   /* Host 'C' complier */
  53. #define TMP_ENV           "TMP"     /* Env var for tmp dir */
  54. #define TMP_DIR           "/tmp"    /* Default tmp dir */
  55. #define option(a)   ((a) == OPT_TAG )
  56.  
  57. #ifdef DEAMON
  58. #define   D_TMP           "tmp.cc"      /* Input of deamon */
  59. #define   D_IN            "devsem.ini"  /* Input of deamon */
  60. #define   D_OUT           "devsem.out"  /* Output of deamon */
  61. #define   D_ERR           "devsem.err"  /* Error of deamon */
  62. #endif
  63.  
  64. typedef enum { FALSE , TRUE , JOIN } boolean;
  65.  
  66. typedef enum                 /* trail list flag */
  67. {
  68.    NO,                  /* No trail list */
  69.    REV,                 /* Reserved list */
  70.    OPEN,                /* Open     list */
  71.    PPATH,                /* Lib paths     */
  72.    LIBS                 /* Lib type      */
  73. } t_info;
  74.  
  75. typedef struct               /* Trail list name and it native equivalent */
  76. {
  77.    char const *gnu_name;
  78.    char const *nat_name;
  79. } rev_cell , rev_list[];
  80.  
  81. typedef struct nat_dummy
  82. {
  83.    char const *nat_name;           /* Native option name */
  84.    struct nat_dummy *after_ptr;    /* After pos for order */
  85.    rev_cell *tran_list;            /* Ptr to list of reserved opts */
  86. } nat_cell, nat_list[];
  87.  
  88. typedef struct 
  89. {
  90.    char const *opt_name;        /* Option name */
  91.    t_info     trail_info;       /* Trail flag */
  92.    rev_cell   *rev_lst;         /* Ptr to trail info */
  93.    char const *opn_lst;         /* Disc list for Usage */
  94.    nat_cell   *nat_ptr;         /* Ptr to equiv native option */
  95. } gnu_cell, gnu_list[];
  96.  
  97. #if DEAMON
  98. typedef struct
  99. {
  100.    char tmp_file[256];
  101.    char out_file[256];
  102.    FILE *de_in;
  103.    FILE *de_out;
  104.    FILE *de_err;
  105. } dm_struct;
  106. #endif
  107.  
  108. typedef struct dummy
  109. {
  110.    struct dummy *nxt;
  111.    char *token;
  112.    boolean optn;
  113. } cmd_cell, *cmd_ptr;
  114.  
  115. /*
  116.     Tables which will help translation
  117. */
  118. rev_list m_rev_lst =
  119. {
  120.     { SNULL , SNULL }
  121. };
  122.  
  123. nat_list nat_lst =
  124. {
  125.     { "P"    , NNULL , RNULL  },      /* 0 */
  126.     { "Zd"   , NNULL , RNULL  },      /* 1 */
  127.     { "c"    , NNULL , RNULL  },      /* 2 */
  128.     { "Fa"   , NNULL , RNULL  },      /* 3 */
  129.     { "Fs"   , NNULL , RNULL  },      /* 4 */
  130.     { "E"    , NNULL , RNULL  },      /* 5 */
  131.     { "Za"   , NNULL , RNULL  },      /* 6 */
  132.     { "Ox"   , NNULL , RNULL  },      /* 7 */
  133.     { "w"    , NNULL , RNULL  },      /* 8 */
  134.     { "DLL"  , NNULL , RNULL  },      /* 9 */
  135.     { "W0"   , NNULL , RNULL  },      /* 10 */
  136.     { "W1"   , NNULL , RNULL  },      /* 11 */
  137.     { "W2"   , NNULL , RNULL  },      /* 12 */
  138.     { "link" , NNULL , RNULL  },      /* 13 */
  139.     { "Fpc"  , NNULL , RNULL  },      /* 14 */
  140.     { "Gc"   , NNULL , RNULL  },      /* 15 */
  141.     { "C"    , NNULL , RNULL  },      /* 16 */
  142.     { "I"    , NNULL , RNULL  },      /* 17 */
  143.     { "X"    , NNULL , RNULL  },      /* 18 */
  144.     { "D"    , NNULL , RNULL  },      /* 19 */
  145.     { "U"    , NNULL , RNULL  },      /* 20 */
  146.         { "Fe"   , NNULL , RNULL  },      /* 21 */
  147.     { SNULL , NNULL , RNULL  }
  148. };
  149.  
  150. gnu_list gnu_lst =
  151. {
  152.     { "P"           , NO , RNULL , SNULL ,  nat_lst },
  153.     { "traditional" , NO , RNULL , SNULL ,  NNULL },
  154.     { "go"          , NO , RNULL , SNULL ,  nat_lst + 1 },
  155.     { "f"           , NO , RNULL , SNULL ,  NNULL },
  156.     { "t"           , NO , RNULL , SNULL ,  NNULL },
  157.     { "c"           , NO , RNULL , SNULL ,  nat_lst + 2 },
  158.     { "o"           , OPEN , RNULL , "<file>" ,  nat_lst + 21 },
  159.     { "S"           , NO , RNULL , SNULL ,  nat_lst + 4 },
  160.     { "E"           , NO , RNULL , SNULL ,  nat_lst + 5 },
  161.     { "v"           , NO , RNULL , SNULL ,  NNULL },
  162.     { "pipe"        , NO , RNULL , SNULL ,  NNULL },
  163.     { "B"           , OPEN , RNULL , "<path-prefix>" ,  NNULL },
  164.     { "b"           , NO , RNULL , SNULL ,  NNULL },
  165.     { "ansi"        , NO , RNULL , SNULL ,  nat_lst + 6 },
  166.     { "pedantic"    , NO , RNULL , SNULL ,  NNULL },
  167.     { "O"           , NO , RNULL , SNULL ,  nat_lst + 7 },
  168.     { "g"           , NO , RNULL , SNULL ,  nat_lst + 1 },
  169.     { "w"           , NO , RNULL , SNULL ,  nat_lst + 8 },
  170.     { "static"      , NO , RNULL , SNULL ,  nat_lst + 10 },
  171.     { "Wimplicit"   , NO , RNULL , SNULL ,  nat_lst + 12 },
  172.     { "Wrettype"    , NO , RNULL , SNULL ,  nat_lst + 12 },
  173.     { "Wunused"     , NO , RNULL , SNULL ,  NNULL },
  174.     { "Wswitch"     , NO , RNULL , SNULL ,  NNULL },
  175.     { "Wcomment"    , NO , RNULL , SNULL ,  NNULL },
  176.     { "Wtrigraph"   , NO , RNULL , SNULL ,  NNULL },
  177.     { "Wall"        , NO , RNULL , SNULL ,  nat_lst + 11 },
  178.     { "Wshadow"     , NO , RNULL , SNULL ,  NNULL },
  179.     { "Wid="        , NO , RNULL , SNULL ,  NNULL },
  180.     { "Wpointer-arith", NO , RNULL , SNULL ,  NNULL },
  181.     { "Wcast-qual", NO , RNULL , SNULL ,  NNULL },
  182.     { "Wwrite-strings", NO , RNULL , SNULL ,  NNULL },
  183.     { "p"             , NO , RNULL , SNULL ,  NNULL },
  184.     { "pg"            , NO , RNULL , SNULL ,  NNULL },
  185.     { "l"            , LIBS , RNULL , "<libname>" ,  nat_lst + 13 },
  186.     { "L"            , PPATH , RNULL , "<libpath>" ,  nat_lst },
  187.     { "nostdlib"     , NO , RNULL , SNULL ,  NNULL },
  188.     { "mmachinspec" , NO , RNULL , SNULL , NULL },
  189.     { "msoft-float" , NO , RNULL , SNULL , nat_lst + 14 },
  190.     { "mshort" , NO , RNULL , SNULL , NULL },
  191.     { "mnobitfield" , NO , RNULL , SNULL , NULL },
  192.     { "mbitfield" , NO , RNULL , SNULL , NULL },
  193.     { "mrtd" , NO , RNULL , SNULL , nat_lst + 15 },
  194.     { "munix" , NO , RNULL , SNULL , NULL },
  195.     { "mgnu" , NO , RNULL , SNULL , NULL },
  196.     { "mg" , NO , RNULL , SNULL , NULL },
  197.     { "mno-epilogue" , NO , RNULL , SNULL , NULL },
  198.     { "C" , NO , RNULL , SNULL , nat_lst + 16 },
  199.     { "I" , OPEN , RNULL , "<include-path>" , nat_lst + 17 },
  200.     { "nostatic" , NO , RNULL , SNULL , nat_lst + 18 },
  201.     { "MM" , NO , RNULL , SNULL , NNULL },
  202.     { "M" , NO , RNULL , SNULL , NNULL },
  203.     { "D" , OPEN , RNULL , "<macro>" , nat_lst + 19 },
  204.     { "U" , OPEN , RNULL , "<macro>" , nat_lst + 20 },
  205.     { SNULL , OPEN , RNULL , SNULL , NNULL }
  206. };
  207.  
  208. cmd_cell head_cell , *head_ptr , *end_ptr;
  209. cmd_cell lib_cell , *lib_ptr , *lend_ptr;
  210. cmd_cell path_cell , *path_ptr , *pend_ptr;
  211.  
  212. int chk_lnk = 1; /* Wether no link has been encountered */
  213. int no_link = 0; /* Set when -c option is encountered */
  214. int no_path = 1; /* No link path added */
  215.  
  216. char *link_opts[] = /* Default linker options */
  217. {
  218.    "link",
  219.    "subsystem:posix",
  220.    "entry:__PosixProcessStartup",
  221.    SNULL
  222. };
  223.  
  224. char *def_lib[] = /* Default library */
  225. {
  226.    "libcpsx.lib",
  227.    "psxdll.lib",
  228.    "ntdll.lib",
  229.    "psxrtl.lib",
  230.    SNULL
  231. };
  232.  
  233. /*
  234.        Function : display_rev_lst()
  235.  
  236.        Discription : To display reserved word(s) with option
  237.  
  238.        Called by : usage()
  239. */
  240. void
  241. #ifdef __STDC__
  242. display_rev_lst( rev_list *rev_lst )
  243. #else
  244. display_rev_lst( rev_lst )
  245. rev_cell *rev_lst;
  246. #endif
  247. {
  248.    fputs(ST_LIST,stderr);
  249.  
  250.    while ( rev_lst->gnu_name != ( char const * ) NULL )
  251.    {
  252.       fputs(rev_lst->gnu_name,stderr);
  253.       fputs(SP_LIST,stderr);
  254.       fputs(NL,stderr);
  255.       rev_lst++;
  256.    }
  257. }
  258.  
  259. /*
  260.  
  261.    Function : print_list()
  262.  
  263.    Discription : Initialise linked list
  264.  
  265.    Called by : main()
  266.  
  267. */
  268.  
  269. void
  270. #ifdef __STDC__
  271. print_list( cmd_ptr ptr , FILE * fp )
  272. #else
  273. print_list( ptr , fp )
  274. cmd_ptr ptr;
  275. FILE *fp;
  276. #endif
  277. {
  278.    cmd_ptr tmp;
  279.  
  280.    tmp = ptr;
  281.    
  282.    do
  283.    {
  284.       if ( ptr->optn != FALSE )
  285.          fputc( OP_CHAR , fp );
  286.       fputs(ptr->token,fp);
  287.       if ( ptr->optn == JOIN )
  288.       {
  289.          ptr = ptr->nxt;
  290.          fputs(ptr->token,fp);
  291.       }
  292.       fputs( NL , fp );
  293.       ptr = ptr->nxt;
  294.    }
  295.    while ( ptr != tmp );
  296. }
  297.  
  298.  
  299. #ifdef DEAMON
  300. /*
  301.        Function : deamon()
  302.  
  303.        Discription : To identify if deamon() is there and open associated
  304.                      files.
  305.  
  306.        Called by : main()
  307. */
  308. dm_struct
  309. #ifdef __STDC__
  310. *deamon(char const *temp_env,
  311.         char const *temp_path,
  312.         char const *de_in,
  313.         char const *de_out,
  314.         char const *de_err)
  315. #else
  316. *deamon(temp_env, temp_path, de_in, de_out, de_err,de_tmp)
  317. char const *temp_env;
  318. char const *temp_path;
  319. char const *de_in;
  320. char const *de_out;
  321. char const *de_err;
  322. #endif
  323. {
  324.    static dm_struct dm_st;
  325.    char *tmp_dir, t_buff[256];
  326.    struct stat s_buff;
  327.    int fd;
  328.  
  329.    if (( tmp_dir = getenv(temp_env)) == ( char * ) NULL )
  330.       return(( dm_struct * ) NULL );
  331.  
  332.    strcpy( t_buff , tmp_dir );
  333.    strcat( strcat ( t_buff , PT_SEP ) , de_in );
  334.    strcpy( dm_st.out_file , t_buff );
  335.  
  336.    while ( stat(t_buff,&s_buff) == 0 )  /* Wait for DEAMON to get free */
  337.      sleep(2);
  338.  
  339.    strcpy( t_buff , tmp_dir );
  340.    strcat( strcat ( t_buff , PT_SEP ) , de_tmp );
  341.    strcpy( dm_st.tmp_file , t_buff );
  342.  
  343.    if (( fd = creat( t_buff , ( mode_t ) 0777 )) != -1 )
  344.    {
  345.       close(fd);
  346.       if (( dm_st.de_in = fopen( t_buff, "w" )) != ( FILE * ) NULL )
  347.          return( &dm_st );
  348.    }
  349.    return(( dm_struct * ) NULL );
  350.  
  351. #if 0
  352.    if (( dm_st.de_in = fopen( t_buff , "w" )) == ( FILE * ) NULL )
  353.       return(( dm_struct * ) NULL );
  354.  
  355.    strcpy( t_buff , tmp_dir );
  356.    strcat( strcat ( t_buff , PT_SEP ) , de_out );
  357.  
  358.    if (( dm_st.de_out = fopen( t_buff , "r" )) == ( FILE * ) NULL )
  359.       return(( dm_struct * ) NULL );
  360.  
  361.    strcpy( t_buff , tmp_dir );
  362.    strcat( strcat ( t_buff , PT_SEP ) , de_err );
  363.  
  364.    if (( dm_st.de_err = fopen( t_buff , "r" )) == ( FILE * ) NULL )
  365.       return(( dm_struct * ) NULL );
  366.  
  367.    return( &dm_st );
  368. #endif
  369. }
  370.  
  371. /*
  372.        Function : disp_deamon()
  373.  
  374.        Discription : To display messages retunred by deamon
  375.  
  376.        Called by : main()
  377. */
  378. int
  379. #ifdef __STDC__
  380. disp_deamon(FILE *fderr)
  381. #else
  382. disp_deamon(fderr)
  383. FILE *fderr;
  384. #endif
  385. {
  386.    return 0;
  387. }
  388.  
  389. /*
  390.        Function : wait_deamon()
  391.  
  392.        Discription : To wait for deamon to finish job
  393.  
  394.        Called by : main()
  395. */
  396. int
  397. #ifdef __STDC__
  398. wait_deamon(char *fdin)
  399. #else
  400. wait_deamon(fdin)
  401. char *fdin;
  402. #endif
  403. {
  404.    FILE *fd;
  405.  
  406.    while ((fd=fopen(fdin,"r")) != ( FILE *) NULL )
  407.    {
  408.       fclose(fd);
  409.       sleep(1);
  410.    }
  411.    return 0;
  412. }
  413.  
  414. /*
  415.        Function : writ_deamon()
  416.  
  417.        Discription : To write to deamon I/P file the new command
  418.  
  419.        Called by : main()
  420. */
  421. int
  422. #ifdef __STDC__
  423. writ_deamon(cmd_cell *head_ptr, FILE *fdout)
  424. #else
  425. writ_deamon(head_ptr, fdout)
  426. cmd_cell *head_ptr;
  427. FILE *fdout;
  428. #endif
  429. {
  430.    char buff[64];
  431.    size_t i;
  432.  
  433.    if ( !no_path && !no_link )
  434.    {
  435.       fputs(LIB_PPATH,fdout);
  436.       fputs( NL , fdout );
  437.       print_list( path_ptr , fdout );
  438.    }
  439.  
  440.    fprintf(fdout,"%s\n",CWD);
  441.    i = ( size_t ) sizeof( buff );
  442.    if ( getcwd( buff , i ) == CNULL )
  443.       return 0;
  444.  
  445.    fprintf(fdout,"%s\n",buff);
  446.    print_list( head_ptr , fdout );
  447.  
  448.    if ( !no_link )
  449.    {
  450.       int i;
  451.       for ( i = 0 ; link_opts[i] != SNULL ; i++ )
  452.       {
  453.          fputc( OP_CHAR , fdout );
  454.          fputs(link_opts[i],fdout);
  455.          fputs( NL , fdout );
  456.       }
  457.       for ( i = 0 ; def_lib[i] != SNULL ; i++ )
  458.       {
  459.          fputs(def_lib[i],fdout);
  460.          fputs( NL , fdout );
  461.       }
  462.       if ( lib_ptr != ( cmd_ptr ) NULL )
  463.          print_list( lib_ptr , fdout );
  464.    }      
  465.  
  466.    fclose( fdout );
  467.    return 1;
  468. }
  469. #else
  470. /*
  471.        Function : exec_cmd()
  472.  
  473.        Discription : To exec the new command
  474.  
  475.        Called by : main()
  476. */
  477. int
  478. #ifdef __STDC__
  479. exec_cmd(cmd_cell *head_ptr)
  480. #else
  481. exec_cmd(head_ptr)
  482. cmd_cell *head_ptr;
  483. #endif
  484. {
  485.    return 0;
  486. }
  487. #endif
  488.  
  489. /*
  490.        Function : usage()
  491.  
  492.        Discription : To identify if if USAGE of command is correct
  493.  
  494.        Called by : main()
  495. */
  496. int
  497. #ifdef __STDC__
  498. usage(int argc, char *argv)
  499. #else
  500. usage(argc,argv)
  501.    int argc;
  502.    char *argv;
  503. #endif
  504. {
  505.    gnu_cell *gnu_ptr;
  506.    int new_opt;
  507.  
  508.    new_opt = TRUE;
  509.    gnu_ptr = gnu_lst;
  510.  
  511.    if ( argc > 1 )
  512.       return 0;
  513.  
  514.    fprintf(stderr,"\nUseage : %s ",argv);
  515.  
  516.    while ( gnu_ptr->opt_name != ( char const * ) NULL )
  517.    {
  518.       if ( new_opt == TRUE )
  519.       {
  520.          fputc(OPT_TAG,stderr);
  521.          new_opt = FALSE;
  522.       }
  523.       fputs(gnu_ptr->opt_name,stderr);
  524.       switch ( gnu_ptr->trail_info )
  525.       {
  526.          case NO   : new_opt = TRUE;
  527.                 break;
  528.          case REV  : display_rev_lst( gnu_ptr->rev_lst );
  529.                 new_opt = TRUE;
  530.                 break;
  531.          case LIBS  :
  532.          case PPATH :
  533.          case OPEN : fputs(gnu_ptr->opn_lst,stderr);
  534.                 new_opt = TRUE;
  535.                 break;
  536.          default   : fprintf(stderr,"ERROR : Internal error \n");
  537.                 break;
  538.       }
  539.       fputc(SP_CHAR,stderr);
  540.       gnu_ptr++;
  541.    }
  542.    fputs(NL,stderr);
  543.    return 1;
  544. }
  545.  
  546. /*
  547.  
  548.    Function : init_list()
  549.  
  550.    Discription : Initialise linked list
  551.  
  552.    Called by : main()
  553.  
  554. */
  555.  
  556. cmd_ptr
  557. #ifdef __STDC__
  558. init_list( cmd_ptr cell , char * str )
  559. #else
  560. init_list( cell , str )
  561. cmd_ptr cell;
  562. char *str;
  563. #endif
  564. {
  565.    cell->token = str;
  566.    cell->optn = FALSE;
  567.    cell->nxt = cell;
  568.    return( cell );
  569. }
  570.  
  571. /*
  572.  
  573.    Function : del_list()
  574.  
  575.    Discription : Delete list
  576.  
  577.    Called by : main()
  578.  
  579. */
  580.  
  581. void
  582. #ifdef __STDC__
  583. del_list( cmd_ptr ptr )
  584. #else
  585. del_list( ptr )
  586. cmd_ptr ptr;
  587. #endif
  588. {
  589.    cmd_ptr tmp, tmp2;
  590.  
  591.    if ( ptr == ptr->nxt )
  592.       return;
  593.  
  594.    tmp = ptr;
  595.    ptr = ptr->nxt;
  596.    
  597.    do
  598.    {
  599.       tmp2 = ptr->nxt;
  600.       free( ptr );
  601.       ptr = tmp2;
  602.    }
  603.    while ( ptr != tmp );
  604. }
  605.  
  606.  
  607. /*
  608.  
  609.    Function : new_cell()
  610.  
  611.    Discription : Create new node
  612.  
  613.    Called by : main()
  614.  
  615. */
  616.  
  617. cmd_ptr
  618. #ifdef __STDC__
  619. new_cell( char *str, boolean optn)
  620. #else
  621. new_cell( str , optn)
  622. char *str;
  623. boolean optn;
  624. #endif
  625. {
  626.    cmd_ptr ptr;
  627.  
  628.    if (( ptr = (cmd_ptr)malloc(sizeof(cmd_cell))) == (cmd_ptr) NULL )
  629.       return (( cmd_ptr ) NULL );
  630.    ptr->token = str;
  631.    ptr->optn  = optn;
  632.    return ptr;
  633. }
  634.  
  635. /*
  636.  
  637.    Function : add_list()
  638.  
  639.    Discription : Add at current pos
  640.  
  641.    Called by : main()
  642.  
  643. */
  644.  
  645. cmd_ptr
  646. #ifdef __STDC__
  647. add_list( cmd_ptr ptr , cmd_ptr node )
  648. #else
  649. add_list( ptr , node )
  650. cmd_ptr ptr, node;
  651. #endif
  652. {
  653.    node->nxt = ptr->nxt;
  654.    ptr->nxt = node;
  655.    return node;
  656. }
  657.  
  658. /*
  659.  
  660.    Function : equiv_name()
  661.  
  662.    Discription : Searchs for equivalent name for native
  663.             and returns pointer to base.
  664.  
  665.    Called by : process_opt()
  666.  
  667. */
  668.  
  669. char
  670. #ifdef __STDC__
  671. *equiv_name( rev_cell *ptr , char *str )
  672. #else
  673. *equiv_name( ptr , str )
  674. rev_cell *ptr; 
  675. char *str;
  676. #endif
  677. {
  678.    while ( ptr->gnu_name != ( char const * ) NULL )
  679.       if ( strcmp(ptr->gnu_name,str) == 0 )
  680.          return ( char * ) ptr->nat_name;
  681.       else
  682.          ptr++;
  683.  
  684.    return ( char * ) NULL;
  685. }
  686.  
  687. /*
  688.  
  689.    Function : process_opt()
  690.  
  691.    Discription : Check if equivalent option exists
  692.  
  693.    Called by : main()
  694.  
  695. */
  696.  
  697. int
  698. #ifdef __STDC__
  699. process_opt( char *ch_ptr , gnu_cell *gnu_ptr , int *arg_cnt , char **argv )
  700. #else
  701. process_opt( ch_ptr , gnu_ptr , arg_cnt , argv )
  702. char *ch_ptr;
  703. gnu_cell *gnu_ptr;
  704. int *arg_cnt;
  705. char **argv;
  706. #endif
  707. {
  708.    char *tmp_ptr;
  709.    cmd_ptr cell_ptr;
  710.    boolean b;
  711.  
  712.    if ( gnu_ptr->trail_info == PPATH )
  713.    {
  714.       if ( *( ch_ptr + 1 ) != CNULL )
  715.          ch_ptr++;
  716.       else
  717.          ch_ptr = argv[++*arg_cnt];
  718.  
  719.         if ( no_path )
  720.         {
  721.            no_path = 0;
  722.            pend_ptr = path_ptr = init_list( &path_cell , ch_ptr );
  723.         }
  724.         else
  725.         {
  726.             if (( cell_ptr = new_cell(ch_ptr, FALSE )) == ( cmd_ptr ) NULL )
  727.             {
  728.                fprintf(stderr,"ERROR : No mem!\n");
  729.                return 0;
  730.             }
  731.             pend_ptr = add_list( pend_ptr , cell_ptr );
  732.         }
  733.         return 1;
  734.     }
  735.  
  736.    if ( gnu_ptr->trail_info == LIBS )
  737.    {
  738.       if ( *( ch_ptr + 1 ) != CNULL )
  739.          ch_ptr++;
  740.       else
  741.          ch_ptr = argv[++*arg_cnt];
  742.        if (( tmp_ptr = (char *)malloc(strlen(ch_ptr) + 6)) == SNULL )
  743.        {
  744.           fprintf(stderr,"ERROR : No mem!\n");
  745.           return 0;
  746.        }
  747.        strcat(strcat(strcpy(tmp_ptr,LIBST),ch_ptr),LEXT);
  748.        ch_ptr = tmp_ptr;
  749.  
  750.        if ( lib_ptr == ( cmd_ptr ) NULL )
  751.        {
  752.           lend_ptr=lib_ptr=init_list( &lib_cell,tmp_ptr );
  753.           return 1;
  754.        }
  755.  
  756.        if (( cell_ptr = new_cell(ch_ptr, FALSE )) == ( cmd_ptr ) NULL )
  757.        {
  758.           fprintf(stderr,"ERROR : No mem!\n");
  759.           return 0;
  760.        }
  761.        else
  762.        {
  763.           lend_ptr = add_list( lend_ptr , cell_ptr );
  764.           return 1;
  765.        }
  766.    }
  767.  
  768.    b = gnu_ptr->trail_info == OPEN ? JOIN : TRUE;
  769.  
  770.    if (( cell_ptr = new_cell(gnu_ptr->nat_ptr->nat_name , b )) == ( cmd_ptr ) NULL )
  771.    {
  772.       fprintf(stderr,"ERROR : No mem!\n");
  773.       return 0;
  774.    }
  775.  
  776.    end_ptr = add_list( end_ptr , cell_ptr );
  777.  
  778.    if ( gnu_ptr->trail_info == NO )
  779.       return strlen(ch_ptr) == strlen(gnu_ptr->opt_name);
  780.  
  781.    if ( *( ch_ptr + 1 ) != CNULL )
  782.       ch_ptr++;
  783.    else
  784.       ch_ptr = argv[++*arg_cnt];
  785.  
  786.    if ( gnu_ptr->trail_info != OPEN )
  787.       if (( ch_ptr = equiv_name(gnu_ptr->rev_lst,ch_ptr)) != ( char * ) NULL )
  788.          return 0;
  789.  
  790.    if (( cell_ptr = new_cell(ch_ptr, FALSE )) == ( cmd_ptr ) NULL )
  791.    {
  792.       fprintf(stderr,"ERROR : No mem!\n");
  793.       return 0;
  794.    }
  795.    else
  796.    {
  797.       end_ptr = add_list( end_ptr , cell_ptr );
  798.       return 1;
  799.    }
  800. }
  801.  
  802. /*
  803.  
  804.    Function : do_include_path()
  805.  
  806.    Discription : To add include paths passed by env
  807.  
  808.    Called by : main()
  809.  
  810. */
  811. int
  812. #ifdef __STDC__
  813. do_include_path( char *inc_path )
  814. #else
  815. do_include_path( inc_path )
  816. char *inc_path;
  817. #endif
  818. {
  819.    char *tmp_ptr,*path;
  820.    cmd_ptr cell_ptr;
  821.    boolean exit_flg;
  822.  
  823.    if (( path = ( char * ) malloc( strlen(inc_path) + 1 )) == SNULL )
  824.    {
  825.       fprintf(stderr,"ERROR : No mem!\n");
  826.       return 0;
  827.    }
  828.  
  829.    strcpy(path,inc_path);
  830.    tmp_ptr = path;
  831.    exit_flg = !strlen(path);
  832.  
  833.    while ( !exit_flg )
  834.    {
  835.       while ( *tmp_ptr != VAR_SEP && *tmp_ptr != '\0' )
  836.           tmp_ptr++;
  837.   
  838.       exit_flg = *tmp_ptr == '\0';
  839.  
  840.       *tmp_ptr = '\0';
  841.  
  842.       if ( tmp_ptr > path )
  843.       {
  844.  
  845.          if (( cell_ptr = new_cell("I", JOIN )) == ( cmd_ptr ) NULL )
  846.          {
  847.             fprintf(stderr,"ERROR : No mem!\n");
  848.             return 0;
  849.          }
  850.       
  851.          end_ptr = add_list( end_ptr , cell_ptr );
  852.          
  853.          if (( cell_ptr = new_cell(path, FALSE )) == ( cmd_ptr ) NULL )
  854.          {
  855.             fprintf(stderr,"ERROR : No mem!\n");
  856.             return 0;
  857.          }
  858.       
  859.          end_ptr = add_list( end_ptr , cell_ptr );
  860.       }
  861.        
  862.       tmp_ptr++;
  863.       path = tmp_ptr;
  864.  
  865.    }
  866.    return 1;
  867. }
  868.  
  869.  
  870. /*
  871.  
  872.    Function : in_opt_list()
  873.  
  874.    Discription : Identify option and return ptr to table entry
  875.  
  876.    Called by : main()
  877.  
  878. */
  879.  
  880. gnu_cell 
  881. #ifdef __STDC__
  882. *in_opt_list( char *ch_ptr )
  883. #else
  884. *in_opt_list( ch_ptr )
  885. char *ch_ptr;
  886. #endif
  887. {
  888.    gnu_cell *gnu_ptr;
  889.    char *tmp_ptr;
  890.  
  891.    gnu_ptr = gnu_lst;
  892.  
  893.    while (( tmp_ptr = ( char * )gnu_ptr->opt_name ) != SNULL )
  894.    {
  895.       if ( strncmp(ch_ptr,tmp_ptr,strlen(tmp_ptr)) == 0 )
  896.       {
  897.          if ( chk_lnk && strcmp(tmp_ptr,NO_LINK) == 0 )
  898.          {
  899.             chk_lnk = 0;
  900.             no_link = 1;
  901.          }
  902.          return gnu_ptr->nat_ptr == NNULL ? GNULL : gnu_ptr ;
  903.       }
  904.       else
  905.          gnu_ptr++;
  906.    }
  907.    return GNULL;
  908. }
  909.  
  910. int
  911. #ifdef __STDC__
  912. main(int argc, char **argv)
  913. #else
  914. main(argc,argv)
  915.    int argc;
  916.    char ** argv;
  917. #endif
  918. {
  919. #ifdef DEAMON
  920.    dm_struct *dm_ptr;
  921. #endif
  922.    char *arg_ptr, *ch_ptr;
  923.    cmd_ptr tmp_ptr;
  924.    gnu_cell *gnu_ptr;
  925.    int i;
  926.  
  927.    if ( usage(argc,argv[0]))
  928.       return 0;
  929.  
  930. #if DEAMON
  931.    if((dm_ptr=deamon(TMP_ENV,TMP_DIR,D_IN,D_OUT,D_ERR,D_TMP))==(dm_struct*)NULL)
  932.    {
  933.       fprintf(stderr,"Cannot execute %s deamon missing\n",*argv[0]);
  934.       return 0;
  935.    }
  936. #endif
  937.  
  938.    end_ptr = head_ptr = init_list( &head_cell , HOST_CC );
  939.  
  940.    if (( arg_ptr = getenv(INC_PATH)) != SNULL )
  941.       do_include_path(arg_ptr);
  942.  
  943.    lib_ptr = ( cmd_ptr ) NULL;
  944.    i = 0;
  945.  
  946.    while ( ++i < argc )
  947.    {
  948.       arg_ptr = *( argv + i );
  949.  
  950.       if ( !option(*arg_ptr))
  951.       {
  952.          if (( tmp_ptr = new_cell(arg_ptr,FALSE)) == ( cmd_ptr ) NULL )
  953.          {
  954.             fprintf(stderr,"Insufficient memory EXITING!\n");
  955.             return 0;
  956.          }
  957.          end_ptr = add_list( end_ptr , tmp_ptr );
  958.       }   
  959.       else
  960.       {
  961.          ch_ptr = arg_ptr;
  962.          ch_ptr++;
  963.  
  964.          while ( *ch_ptr != ( char )NULL )
  965.          {
  966.             if (( gnu_ptr = in_opt_list(ch_ptr)) != ( gnu_cell * ) NULL )
  967.                if ( process_opt(ch_ptr,gnu_ptr,&i,argv))
  968.                   break;
  969.             ch_ptr++;
  970.          }
  971.       }
  972.    }
  973.  
  974. #if DEAMON
  975.    if ( !writ_deamon( head_ptr , dm_ptr->de_in ))
  976.    {
  977.       fprintf(stderr,"Unable to communicate with DEAMON. EXITING!\n");
  978.       return 0;
  979.    }
  980.    rename( dm_ptr->tmp_file, dm_ptr->out_file );
  981.    wait_deamon( dm_ptr->out_file );
  982.    disp_deamon( dm_ptr->de_err );
  983. #else
  984.    exec_cmd( head_ptr );
  985. #endif
  986.    del_list( head_ptr );
  987.    return 0;
  988. }
  989.