开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
MK386.C
资源名称：c_compiler.zip　[点击查看]
上传用户：hlzzc88
上传日期：2007-01-06
资源大小：220k
文件大小：23k
源码类别：

编译器/解释器

开发平台：

Others

MK386.C：源码内容
  1. //
  2. //  Compile with Borland C/C++ v3.1 : bcc -v- -ml cl386.c
  3. //  Compile with Watcom C/C++ v10.6 : wcl -y -ox -ml cl386.c
  4. //
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <dos.h>
  9. #include <process.h>
  10. #ifdef __TURBOC__
  11.   #include <dir.h>
  12. #else
  13.   #include <direct.h>
  14. #endif
  16. #define VERSION "1.0"
  18. static char usage[] = /* Usage */ 
  19. "MK386 Version " VERSION " (c) Kirill Joss. Compile " __DATE__ "n"
  20. "Usage: MK386.EXE [options] filesn"
  21. "Options:       (default parameters if first)n"
  22. "/l[-|+]  dump listing file        /w-xxx   disable a warning       n"
  23. "/i[-|+]  dump preprocessed file   /Dxxx    define something        n"
  24. "/e[+|-]  dump errors to file      /Ennn    max number of errors    n"
  25. "/k[+|-]  keep generate files      /Ipath   specify include path    n"
  26. "/K[-|+]  keep response files      /Lpath   specify .LIB & .OBJ dir n"
  27. "/A[+|-]  disable extensions       /Cxxx    codegen parameters      n"
  28. "/v[-|+]  debug info               /Oxxx    optimzer parameters     n"
  29. "/m[-|+]  generate .MAP file       /Tp      use TLINK & PMODE       n"
  30. "/n[-|+]  no default .LIB & .OBJ   /Tl      use TLINK & PMODE(low)  n"
  31. "/M[+|-]  run MAKE                 /Tw      use WLINK & PMODE/W     n"
  32. "/B[-|+]  build all                /Td      use WLINK & DOS/4GW     n"
  33. "/a       generate .ASM file       /c       generate .OBJ file      n"
  34. "/ename   set name of .EXE file    /opath   set out path .OBJ files n"
  35. "/?,/h,/H this help                @fname   specify response file   n";
  38. #define FALSE 0
  39. #define TRUE  1
  41. #define MAX_STR 256 /* Max len of string in .CFG file */
  43. // is param ?
  44. #define isparam(s) ( *(s) == '-' || *(s) == '/' || *(s) == '+' )
  45. // check for NOT NULL !!!
  46. #define chkNULL(exp, msg )  if ( !(exp) ) error( ERR_FATAL, msg )
  47. // empty string ?
  48. #define empty_string(s)  ( (s) == NULL || *(s) == '' )
  50. typedef struct _Item {
  51.     struct _Item *next;
  52.     char data[1];
  53. } Item;
  55. typedef struct _List {
  56.     Item *head;
  57.     Item *tail;
  58.     unsigned count;
  59. } List;
  61. Item *ItemCreate( char *dat );
  62. #define ItemDelete(item) free(item)
  64. void ListAdd( List *list, char *data );
  65. void ListDelete( List *list );
  66. int  ListFind( List *list, char *data );
  67. void ListIter( List *list, void (*iter)( Item *) );
  69. #define FileAdd(list, file) ListAdd((list),(file))
  70. #define ParamAdd(list, param) ListAdd((list),(param));
  72. List files; // list of all files
  74. List l_inc; // list of INCLUDE path
  75. List l_def; // list of DEFINE var
  76. List l_cc386; // list of CC386 options
  78. int _compile  = TRUE;
  79. int _assemble = TRUE;
  80. int _link     = TRUE;
  82. int _dump_cpp = FALSE; // dump preprocessed file
  83. int _dump_err =  TRUE; // dump error file
  84. int _dump_lst = FALSE; // dump listing file
  85. int _ansi     =  TRUE; // ANSI
  87. int _map_file = FALSE; // map file
  88. int _nodef_lib= FALSE; // no default lib
  89. int _debug    = FALSE; // debug info
  91. int _keep_rsp = FALSE; // keep response files
  92. int _keep_gen = TRUE;  // keep generate files
  94. int _make_run = TRUE;
  95. int _build_all = FALSE;
  97. int _output = 'p';     // Output format, same /Tx, can be 'p', 'l', 'w', 'd'
  99. char path_lib[ _MAX_PATH ]; // path for default LIB & OBJ
  100. char path_obj[ _MAX_PATH ]; // path for output .OBJ files
  101. char name_exe[ _MAX_PATH ]; // name of .EXE file
  103.  // For error()
  104. #define ERR_NO        0  /* no error ! */
  105. #define ERR_FATAL   128  /* fatal error */
  106. #define ERR_RUNTIME 129  /* stdlib error - see 'errno' */
  108.  // output errmsg & exit()
  109. void error( int exitcode, char *msg );
  110.  // output help & exit(0)
  111. void help( void );
  112.  // get parameters from <name>.CFG, CL386, cmdline ...
  113. void get_param( char *exe_name, char *env_var, int argc, char *argv[] );
  114.  // get parameters from file
  115. int get_param_file( char *file );
  116.  // get parameters from string
  117. void get_param_str( char *str );
  118.  // check ONE parameter
  119. void get_one_param( char *param );
  120.  // get ONE options
  121. void get_option( char *param );
  122.  // get ONE file ( can '*' & '?' )
  123. void get_source( char *filename );
  124.  // get ONE file without '*' & '?'
  125. void get_one_source( char *filename );
  126.  // find source files
  127. void find_source( char *fpath, char *fname );
  128.  // clear all list
  129. void cleanup( void );
  130.  // generate MAKEFILE.
  131. void gen_makefile( void );
  132.  // run overlay MAKE
  133. void make( char *maker );
  136. void main( int argc, char *argv[] ) {
  138.     if ( argc == 1 ) // no argument
  139.         help();
  140.     get_param( argv[0], "CL386", argc - 1, argv + 1 );
  141.     atexit( cleanup );  // set exit function
  142.     if ( files.count == 0 ) // no files
  143.         help();
  144.     gen_makefile();
  145.     cleanup();
  146.     if ( _make_run )
  147.         make( "MAKE.EXE" );
  148. }
  151. void help( void ) {
  152.     printf( usage ); exit( 0 );
  153. }
  156. static char _file[ _MAX_PATH  ];
  157. static char fdisk[ _MAX_DRIVE ];
  158. static char fpath[ _MAX_DIR   ];
  159. static char fname[ _MAX_FNAME ];
  160. static char fext [ _MAX_EXT   ];
  163. void get_param( char *exe_name, char *env_var, int argc, char *argv[] ) {
  164.     static char _cfg[] = ".CFG";
  165.     int i;
  166.     char *env;
  168.     _splitpath( exe_name, fdisk, fpath, fname, fext );
  169.     _makepath( _file, NULL, NULL, fname, _cfg );
  170.     if ( ! get_param_file( _file ) ) {
  171.         _makepath( _file, fdisk, fpath, fname, _cfg );
  172.         get_param_file( _file );
  173.     }
  175.     if ( (env = getenv( env_var ) ) != NULL )
  176.         get_param_str( env );
  178.     for ( i = 0; i < argc; i++ )
  179.         get_one_param( argv[ i ] );
  180. }
  183. int get_param_file( char *file ) {
  184.     static char str[ MAX_STR ];
  185.     FILE *f = fopen( file, "rt" );
  187.     if ( f == NULL )
  188.         return FALSE;
  190.     while( fgets( str, MAX_STR - 1, f) != NULL )
  191.         get_param_str( str );
  193.     fclose( f );
  194.     return TRUE;
  195. }
  198. void get_param_str( char *s ) {
  199.     char arg[ MAX_STR ];
  200.     int  len;
  202.     for ( len = 0; *s; s++ ) {
  203.         if ( *s == ' ' || *s == 't' || *s == 'n' ) {
  204.             if ( len > 0 ) {
  205.                 arg[ len ] = '';
  206.                 get_one_param( arg );
  207.             }
  208.             arg[ len = 0 ] = '';
  209.         }
  210.         else {
  211.             arg[ len++ ] = *s;
  212.         }
  213.     }
  215.     if ( len > 0 ) {
  216.         arg[ len ] = '';
  217.         get_one_param( arg );
  218.     }
  219. }
  222. void get_one_param( char *arg ) {
  223.     if ( isparam( arg ) )                 // -X , +X or /X
  224.         get_option( arg );
  225.     else if ( *arg == '@' ) {               // @filename
  226.         if ( ! get_param_file( arg + 1 )  )
  227.             error( ERR_RUNTIME, arg + 1 );
  228.     }
  229.     else
  230.         get_source( arg );             // file.ext
  231. }
  234. void error( int exitcode, char *msg ) {
  235.     switch ( exitcode ) {
  236.         case ERR_NO: break;
  238.         case ERR_FATAL: fprintf( stderr, "Fatal : %sn", msg );
  239.             break;
  241.         case ERR_RUNTIME: fprintf( stderr, "%s : %s", msg, strerror( errno ) );
  242.             break;
  244.         default: fprintf( stderr, "Program error : %s !n", msg );
  245.             break;
  246.     }
  247.     exit( exitcode );
  248. }
  251. static int setop( char *param, int *option ) {
  252.     if ( param[2] == '-' && param[3] == '' )
  253.         *option = FALSE;
  254.     else if ( ( param[2] == '+' && param[3] == '' ) || param[2] == '' )
  255.         *option = TRUE;
  256.     else
  257.         return FALSE;
  258.     return TRUE;
  259. }
  262. void get_option( char *param ) {
  263.     int len;
  265.     switch( param[ 1 ] ) {
  267.         case 'i' : // dump preprocessed file
  268.             if ( setop( param, &_dump_cpp ) )
  269.                 return;
  270.             break;
  272.         case 'e' : // dump errors to file
  273.             if ( setop( param, &_dump_err ) )
  274.                 return;
  275.             else
  276.                 strupr( strncpy( name_exe, param + 2, _MAX_PATH ) );
  277.             break;
  279.          case 'l' : // dump listing file
  280.             if ( setop( param, &_dump_lst ) )
  281.                 return;
  282.             break;
  284.         case 'A' : // disable extensions
  285.             if ( setop( param, &_ansi ) )
  286.                 return;
  287.             break;
  289.         case 'm' : // gen map file
  290.             if ( setop( param, &_map_file ) )
  291.                 return;
  292.             break;
  294.         case 'n' : // no default lib
  295.             if ( setop( param, &_nodef_lib ) )
  296.                 return;
  297.             break;
  299.         case 'v' : // debug info
  300.             if ( setop( param, &_debug ) )
  301.                 return;
  302.             break;
  304.         case 'K' : // keep response files
  305.             if ( setop( param, &_keep_rsp ) )
  306.                 return;
  307.             break;
  309.         case 'k' : // keep generate files
  310.             if ( setop( param, &_keep_gen ) )
  311.                 return;
  312.             break;
  314.         case 'B' : // building all
  315.             if ( setop( param, &_build_all ) )
  316.                 return;
  317.             break;
  319.         case 'M' : // run make, else ONLY generate MAKEFILE.
  320.             if ( setop( param, &_make_run ) )
  321.                 return;
  322.             break;
  324.         case 'a' :
  325.             if ( param[2] == '' ) {
  326.                 _compile = TRUE;
  327.                 _assemble = _link = FALSE;
  328.                 return;
  329.             }
  330.             break;
  332.         case 'c' :
  333.             if ( param[2] == '' ) {
  334.                 _compile = _assemble = TRUE;
  335.                 _link = FALSE;
  336.                 return;
  337.             }
  338.             break;
  340.         case '?' :
  341.         case 'h' :
  342.         case 'H' :
  343.             help(); /* Not return ! */
  345.         case 'D' : // define
  346.             ParamAdd( &l_def, param + 2 );
  347.             return;
  349.         case 'I' : // include path
  350.             ParamAdd( &l_inc, param + 2 );
  351.             return;
  353.         case 'L' : // lib path
  354.             strupr( strncpy( path_lib, param + 2, _MAX_PATH ) );
  355.             len = strlen( path_lib );
  356.             if ( len > 0 && path_lib[ len - 1 ] == '\' )
  357.                 path_lib[ len - 1 ] = '';
  358.             return;
  360.         case 'o' : // output obj path
  361.             strupr( strncpy( path_obj, param + 2, _MAX_PATH ) );
  362.             len = strlen( path_obj );
  363.             if ( len > 0 && path_obj[ len - 1 ] == '\' )
  364.                 path_obj[ len - 1 ] = '';
  365.             return;
  367.         case 'w' :
  368.         case 'C' :
  369.         case 'E' :
  370.         case 'O' :
  371.             ParamAdd( &l_cc386, param );
  372.             return;
  374.         case 'T' :
  375.             if ( param[3] == '' )
  376.                 if ( param[2] == 'p' || param[2] == 'l' || 
  377.                 param[2] == 'w' || param[2] == 'd' ) {
  378.                     _output = param[2]; return;
  379.                 }
  380.             break;
  382.     }
  383.     fprintf( stderr, "Warning! Parameter error : %sn", param );
  384. }
  387. Item *ItemCreate( char *dat ) {
  388.     Item *item;
  389.     int len;
  391.     if ( empty_string( dat ) )
  392.         return NULL;
  394.     len = strlen( dat );
  396.     if ( (item = (Item *)malloc( sizeof( Item ) + len )) != NULL ) {
  397.         item->next = NULL;
  398.         strcpy( item->data, dat );
  399.     }
  401.     return item;
  402. }
  405. void ListDelete( List *list ) {
  406.     Item *p, *q;
  408.     chkNULL( list, "Pointer is NULL !" );
  410.     for( p = list->head; p; p = q ) {
  411.         q = p->next;
  412.         free(p);
  413.     }
  414.     list->head = list->tail = NULL;
  415.     list->count = 0;
  416. }
  419. void ListAdd( List *list, char *file ) {
  420.     Item *item;
  422.     chkNULL( list, "Pointer is NULL !" );
  424.     item = ItemCreate( file );
  426.     chkNULL( item, "Out of memory !" );
  428.     if ( list->count == 0 )
  429.         list->head = list->tail = item;
  430.     else {
  431.         (list->tail)->next = item;
  432.         list->tail = item;
  433.     }
  434.     list->count++;
  435. }
  438. void ListIter( List *list, void (*iter)( Item *) ) {
  439.     Item *p;
  441.     chkNULL( list, "Pointer is NULL !" );
  443.     if ( list->count && iter ) {
  444.         for ( p = list->head; p; p = p->next )
  445.             (*iter)(p);
  446.     }
  447. }
  450. static char *need;
  451. static int found = 0;
  454. static void find( Item *item ) {
  455.     if ( strcmp( item->data, need ) == 0 )
  456.         found = 1;
  457. }
  460. int  ListFind( List *list, char *data ) {
  461.     found = 0;
  462.     need = data;
  463.     ListIter( list, find );
  464.     return found;
  465. }
  468. char findpath[ _MAX_PATH ];
  469. char findname[ _MAX_PATH ];
  472. void get_source( char *filename ) {
  473.     _splitpath( filename, fdisk, fpath, fname, fext );
  475.     if ( strchr( filename, '?' ) || strchr( filename, '*' ) ) {  /* Check for '*' and '?' */
  476.         _makepath( findpath, fdisk, fpath, NULL, NULL );
  477.         _makepath( findname, NULL, NULL, fname, fext );
  478.         find_source( findpath, findname );
  479.     }
  480.     else
  481.         get_one_source( filename );
  482. }
  485. #ifdef __TURBOC__
  488. void find_source( char *fpath, char *fname ) {
  489.     int fpath_len = strlen( fpath );
  490.     struct ffblk fb;
  492.     if ( !findfirst( strcat( fpath, fname), &fb, FA_ARCH) )
  493.     do {
  494.         fpath[ fpath_len ] = '';
  495.         get_one_source( strcat( fpath, fb.ff_name) );
  496.     } while (! findnext(&fb) );
  497. }
  500. #else
  503. void find_source( char *fpath, char *fname ) {
  504.     int fpath_len = strlen( fpath );
  505.     struct find_t fb;
  507.     if (!_dos_findfirst( strcat( fpath, fname), _A_NORMAL, &fb ) )
  508.     do {
  509.         fpath[ fpath_len ] = '';
  510.         get_one_source( strcat( fpath, fb.name) );
  511.     } while( ! _dos_findnext( &fb ) );
  512. }
  515. #endif
  518. void get_one_source( char *srcfile ) {
  519.     char file[ _MAX_PATH ];
  520.     strupr( strncpy( file, srcfile, _MAX_PATH ) );
  521.     FileAdd( &files, file );
  522. }
  525. void cleanup( void ) {   // for atexit()
  526.     ListDelete( &files );
  527.     ListDelete( &l_def );
  528.     ListDelete( &l_inc );
  529.     ListDelete( &l_cc386 );
  530. }
  533. #define Def(v) ( (v) ? 'D' : 'U' )
  535. void make( char *maker ) {
  536.     static char make_opt[ _MAX_PATH ];
  537. //  static char *args[3];
  538.     int err;
  540.     sprintf( make_opt,
  541. " -%cMAP -%cDEBUG -%cNODEFLIB -%cKEEP_SRC -%cKEEP_LST -%cLINK -%cASSEMBLE -%cCOMPILE",
  542.         Def( _map_file), Def( _debug), Def( _nodef_lib),
  543.         Def( _keep_gen ), Def( _dump_lst ),
  544.         Def( _link), Def( _assemble ), Def( _compile ) );
  545.     if ( _keep_rsp )
  546.         strcat( make_opt, " -K" );
  547.     if ( _build_all )
  548.         strcat( make_opt, " -B" );
  549.     printf( "%s%sn", maker, make_opt );
  550.     err = spawnlp( P_OVERLAY, maker, maker, make_opt, NULL );
  552.     if ( err <  0 )
  553.         error( ERR_RUNTIME, maker );
  554.     else if ( err > 0 )
  555.         error( err, maker );
  556. }
  558. char *name( void ) {
  559.     if ( strlen( name_exe ) > 0 )
  560.         return name_exe;
  561.     _splitpath( files.head->data, fdisk, fpath, fname, fext );
  562.     return fname;
  563. }
  565. char *libpath( char *lib ) {
  566.     if ( strlen( path_lib ) == 0 )
  567.         return lib;
  568.     strcpy( _file, path_lib );
  569.     strcat( _file, "\" );
  570.     return strcat( _file, lib );
  571. }
  573. #define L_( s ) fprintf( frsp, "t%s", (s) )
  574. #define L0( s ) fprintf( frsp, "%s", (s) )
  575. #define L1( s ) fprintf( frsp, "%sn", (s) )
  577. static FILE *frsp;
  580. static void compile_inc  ( Item *p ) { fprintf( frsp, "%s;", p->data );   }
  581. static void compile_def  ( Item *p ) { fprintf( frsp, " /D%s", p->data ); }
  582. static void compile_opt  ( Item *p ) { fprintf( frsp, " %s", p->data );   }
  584. static void assemble_def( Item *p ) { fprintf( frsp, " /d%s", p->data ); }
  585. static void assemble_inc( Item *p ) { fprintf( frsp, " /i%s", p->data ); }
  588. static void get_obj( Item *p ) {
  589.     _splitpath( p->data, fdisk, fpath, fname, fext );
  590.     if ( strcmp( fext, ".OBJ" ) == 0 )
  591.         fprintf( frsp, "%s \n", p->data );
  592.     else if ( strcmp( fext, ".ASM" ) == 0 ) {
  593.         fprintf( frsp, "$(PATH_OBJ)\%s.OBJ \n", fname );
  594.     }
  595.     else if ( strcmp( fext, ".LIB" ) != 0 ) {
  596.         fprintf( frsp, "$(PATH_OBJ)\%s.OBJ \n", fname );
  597.     }
  598. }
  600. static void get_asm( Item *p ) {
  601.     _splitpath( p->data, fdisk, fpath, fname, fext );
  602.     if ( strcmp( fext, ".OBJ" ) == 0 || strcmp( fext, ".LIB" ) == 0 )
  603.         return;
  604.     else if ( strcmp( fext, ".ASM" ) == 0 )
  605.         fprintf( frsp, "%s \n", p->data );
  606.     else
  607.         fprintf( frsp, "%s.ASM \n", fname );
  608. }
  610. static void get_lib( Item *p ) {
  611.     _splitpath( p->data, fdisk, fpath, fname, fext );
  612.     if ( strcmp( fext, ".LIB" ) == 0 ) {
  613.         fprintf( frsp, "%s \n", p->data );
  614.     }
  615. }
  617. static void get_dep( Item *p ) {
  618.     _splitpath( p->data, fdisk, fpath, fname, fext );
  619.     if ( strcmp( fext, ".LIB" ) == 0 )
  620.         return; // .LIB file
  621.     else if ( strcmp( fext, ".OBJ" ) == 0 )
  622.         return; // .OBJ file
  623.     else if ( strcmp( fext, ".ASM" ) == 0 ) {   // .ASM file
  624.         fprintf( frsp, "$(PATH_OBJ)\%s.OBJ : %sn", fname, p->data );
  625.         fprintf( frsp, "  $(AS) %s,$(PATH_OBJ)\%s.OBJ,$(PATH_OBJ)\%s.LST,NULn",
  626.             p->data, fname, fname );
  627.         fprintf( frsp, "  $(DEL_LST) $(PATH_OBJ)\%s.LSTn", fname );
  628.     }
  629.     else {  // .CPP file
  630.         fprintf( frsp, "$(PATH_OBJ)\%s.OBJ : %s.ASMn", fname, fname );
  631.         fprintf( frsp, "  $(AS) %s.ASM,$(PATH_OBJ)\%s.OBJ,$(PATH_OBJ)\%s.LST,NULn",
  632.             fname, fname, fname );
  633.         fprintf( frsp, "  $(DEL_LST) $(PATH_OBJ)\%s.LSTn", fname );
  634.         fprintf( frsp, "  $(DEL_SRC) %s.ASMn", fname );
  635.         fprintf( frsp, "%s.ASM : %sn", fname, p->data );
  636.         fprintf( frsp, "  $(CC) %sn",  p->data );
  637.     }
  638. }
  641. static void wout_obj( Item *p) {
  642.     _splitpath( p->data, fdisk, fpath, fname, fext );
  643.     if ( strcmp( fext, ".LIB" ) == 0 )
  644.         return;
  645.     else if ( strcmp( fext, ".OBJ" ) == 0 )
  646.         fprintf( frsp, "file %sn", p->data );
  647.     else if ( strcmp( fext, ".ASM" ) == 0 )
  648.         fprintf( frsp, "file $(PATH_OBJ)\%s.OBJn", fname );
  649.     else
  650.         fprintf( frsp, "file $(PATH_OBJ)\%s.OBJn", fname );
  651. }
  653. static void wout_lib( Item *p) {
  654.     _splitpath( p->data, fdisk, fpath, fname, fext );
  655.     if ( strcmp( fext, ".LIB" ) == 0 )
  656.         fprintf( frsp, "library %sn", p->data );
  657. }
  659. static void delete_obj( Item *p ) {
  660.     _splitpath( p->data, fdisk, fpath, fname, fext );
  661.     if ( strcmp( fext, ".LIB" ) == 0 || strcmp( fext, ".OBJ" ) == 0 )
  662.         return;
  663.     else
  664.         fprintf( frsp, "  $(DEL_SRC) $(PATH_OBJ)\%s.OBJn", fname );
  665. }
  667. void gen_makefile( void ) {
  668.     int tlink = ( _output == 'p' || _output == 'l' );
  670.     frsp = fopen( "MAKEFILE.", "wt" );
  671.     if ( frsp == NULL )
  672.         error( ERR_RUNTIME, "MAKEFILE." );
  674. L1( "#" );
  675. L1( "#  this MAKEFILE. generate MK386.EXE program"  );
  676. L1( "#" );
  677. L1( ".AUTODEPEND" );
  678. L1( ".SWAP" );
  679. L1( "# LINK     = # define LINK for COMPILE, ASSEMBLE & LINK" );
  680. L1( "# ASSEMBLE = # define ASSEMBLE for COMPILE & ASSEMBLE" );
  681. L1( "# COMPILE  = # define COMPILER for ONLY COMPILE" );
  682. L1( "!ifndef LINK" );
  683. L1( "!ifndef ASSEMBLE" );
  684. L1( "!ifndef COMPILE" );
  685. L1( "LINK       =" );
  686. L1( "!endif" );
  687. L1( "!endif" );
  688. L1( "!endif" );
  689. L1( "# DEBUG    = # define DEBUG for debug info and debug startup module" );
  690. L1( "# MAP      = # define MAP for generate .MAP file" );
  691. L1( "# NODEFLIB = # define NODEFLIB for NO link default .OBJ & .LIB" );
  692. L1( "# KEEP_SRC = # define KEEP_SRC for save generate .ASM & .OBJ files" );
  693. L1( "# KEEP_LST = # define KEEP_LST for save generate .LST files" );
  694. L1( "" );
  695. L1( "                                       ### name of .EXE file" );
  696. L0( "NAME = " ); L1( name() );
  697. L1( "                                       ### define tools" );
  698. L1( "CC  = CC386.EXE" );
  699. L1( "AS  = TASM.EXE" );
  700. L1( "                                       ### define options for CC" );
  701. L0( "CC_INC = " );
  702.     if ( l_inc.count > 0 ) {
  703.         L0( "/I" ); ListIter( &l_inc, compile_inc );
  704.     }
  705. L1( "" );
  706. L0( "CC_DEF = " );
  707.     ListIter( &l_def, compile_def );
  708. L1( "" );
  709. L0( "CC_OPT = " );
  710.     fprintf( frsp, "%ci %ce %cA",
  711. ( _dump_cpp ? '+' : '-' ), ( _dump_err ? '+' : '-' ), ( !_ansi ? '+' : '-' ) );
  712.     ListIter( &l_cc386, compile_opt );
  713. L1( "" );
  714. L1( "!ifdef KEEP_LST" );
  715. L1( "CC_OPT = $(CC_OPT) +l" );
  716. L1( "!endif" );
  717. L1( "" );
  718. L1( "CC = $(CC) $(CC_OPT) $(CC_DEF) $(CC_INC)" );
  719. L1( "                                       ### define options for AS" );
  720. L0( "AS_INC = " );
  721.     ListIter( &l_inc, assemble_inc );
  722. L1( "" );
  723. L0( "AS_DEF = " );
  724.     ListIter( &l_def, assemble_def );
  725. L1( "" );
  726. L1( "!ifdef DEBUG");
  727. L1( "AS_OPT = /t /m3 /ml /zi" );
  728. L1( "!else" );
  729. L1( "AS_OPT = /t /m3 /ml /zn" );
  730. L1( "!endif");
  731. L1( "!ifdef KEEP_LST" );
  732. L1( "AS_OPT = $(AS_OPT) /la" );
  733. L1( "!endif" );
  734. L1( "" );
  735. L1( "AS = $(AS) $(AS_OPT) $(AS_DEF) $(AS_INC)" );
  736. L1( "                                       ### .LIB & output .OBJ path" );
  737. L0( "PATH_LIB = " ); L1( path_lib );
  738. L0( "PATH_OBJ = " );
  739.     if ( strlen( path_obj ) > 0 )
  740.         L1( path_obj );
  741.     else
  742.         L1( "." );
  743. L1( "                                       ### default .OBJ & .LIB" );
  744. L1( "!ifdef NODEFLIB");
  745. L1( "DEFAULT_OBJS =" );
  746. L1( "DEFAULT_LIBS =" );
  747. L1( "WLINK_OBJS   =" );
  748. L1( "WLINK_LIBS   =" );
  749. L1( "!else" );
  750. L1( "DEFAULT_LIBS = $(PATH_LIB)\CLDOS.LIB" );
  751. L1( "WLINK_LIBS   = library $(DEFAULT_LIBS)" );
  752. L1( "!ifdef DEBUG" );
  753.     if ( _output == 'l' )
  754.         L1( "DEFAULT_OBJS = $(PATH_LIB)\C0DOSLD.OBJ " );
  755.     else if ( _output == 'p' )
  756.         L1( "DEFAULT_OBJS = $(PATH_LIB)\C0DOSD.OBJ " );
  757.     else
  758.         L1( "DEFAULT_OBJS = $(PATH_LIB)\C0DOSWD.OBJ " );
  759. L1( "!else" );
  760.     if ( _output == 'l' )
  761.         L1( "DEFAULT_OBJS = $(PATH_LIB)\C0DOSL.OBJ " );
  762.     else if ( _output == 'p' )
  763.         L1( "DEFAULT_OBJS = $(PATH_LIB)\C0DOS.OBJ " );
  764.     else
  765.         L1( "DEFAULT_OBJS = $(PATH_LIB)\C0DOSW.OBJ " );
  766. L1( "!endif" );
  767. L1( "WLINK_OBJS   = file $(DEFAULT_OBJS)" );
  768. L1( "!endif" );
  769. L1( "                                       ### define macro for KEEP_SRC" );
  770. L1( "!ifdef KEEP_SRC");
  771. L1( "DEL_SRC = @rem" );
  772. L1( "!else" );
  773. L1( "DEL_SRC = -del" );
  774. L1( "!endif");
  775. L1( "                                       ### define macro for KEEP_LST" );
  776. L1( "!ifdef KEEP_LST");
  777. L1( "DEL_LST = @rem" );
  778. L1( "!else" );
  779. L1( "DEL_LST = -del" );
  780. L1( "!endif");
  781. L1( "                                       ### define macro for MAP" );
  782. L1( "!ifdef MAP");
  783. L1( "TLINK_OPT = /3/d/c/m/l/s" );
  784. L1( "WLINK_OPT = option map" );
  785. L1( "!else" );
  786. L1( "TLINK_OPT = /3/d/c/x" );
  787. L1( "WLINK_OPT = " );
  788. L1( "!endif");
  789. L1( "                                       ### define macro for DEBUG" );
  790. L1( "!ifdef DEBUG");
  791. L1( "TLINK_DBG = /v" );
  792. L1( "WLINK_DBG = debug option symf" );
  793. L1( "!else" );
  794. L1( "TLINK_DBG = " );
  795. L1( "WLINK_DBG = option quiet" );
  796. L1( "!endif");
  797. L1( "                                       ### .ASM files" );
  798.     fprintf( frsp, "ASMS = \n" );
  799.     ListIter( &files, get_asm );
  800. L1( "                                       ### .OBJ files" );
  801. fprintf( frsp, "OBJS = $(DEFAULT_OBJS) \n" );
  802. ListIter( &files, get_obj );
  803. L1( "                                       ### .LIB files" );
  804. fprintf( frsp, "LIBS = $(DEFAULT_LIBS) \n" );
  805. ListIter( &files, get_lib );
  806. L1( "                                       ###  main make depend" );
  807. L1( "!ifdef LINK" );
  808. L1( "$(NAME).EXE : $(OBJS) $(LIBS) makefile." );
  809. if ( tlink )
  810. {
  811. L1( "  TLINK.EXE @&&|" );
  812. L1( "$(TLINK_OPT) $(TLINK_DBG) $(OBJS), $(NAME), $(NAME), $(LIBS)" );
  813. }
  814. else
  815. {
  816. L1( "  WLINK.EXE @&&|" );
  817. L1( "$(WLINK_OPT) $(WLINK_DBG)" );
  818. L1( "format os2 le" );
  819. L1( "option nod" );
  820. if ( _output == 'w' ) {
  821. L1( "option osname='CC386+PMODE/W'" );
  822. L1( "option stub=$(PATH_LIB)\PMODEW.EXE" );
  823. }
  824. else {
  825. L1( "option osname='CC386+DOS/4GW'" );
  826. L1( "option stub=$(PATH_LIB)\D4GWSTUB.EXE" );
  827.         }
  828.         L1( "name $(NAME)" );
  829.         L1( "$(WLINK_OBJS)" );
  830.         ListIter( &files, wout_obj );
  831.         L1( "$(WLINK_LIBS)" );
  832.         ListIter( &files, wout_lib );
  833.     }
  834. L1( "|" );
  835.     ListIter( &files, delete_obj );
  836. L1( "!else" );
  837. L1( "!ifdef ASSEMBLE");
  838. L1( "assemble : $(OBJS) " );
  839. L1( "!else" );
  840. L1( "!ifdef COMPILE");
  841. L1( "compile : $(ASMS) " );
  842. L1( "!endif" );
  843. L1( "!endif" );
  844. L1( "!endif" );
  845. L1( "                                       ### files depend" );
  846.     ListIter( &files, get_dep );
  847.     fclose( frsp );
  848. }