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

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

编译器/解释器

开发平台：

Others

CL386.C：源码内容
  1. /*
  2.     Compile with Borland C/C++ v3.1
  3.         bcc -v- -ml cl386.c
  4.     or Compile with Watcom C/C++ v10.6
  5. wcl -y -ox -ml cl386.c
  6. */
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <dos.h>
  11. #include <process.h>
  12. #ifdef __TURBOC__
  13.   #include <dir.h>
  14. //  extern unsigned _stklen = 16*1024;
  15. #else
  16.   #include <direct.h>
  17. #endif
  20. #define VERSION "4.1m"
  21. #define TO_CURR_DIR /* define, if you want put .ASM & .OBJ file to current dir */
  23. static char usage[] = /* Usage */ 
  24. "CL386 Version " VERSION " (c) Kirill Joss. Compile " __DATE__ "n"
  25. "Usage: CL386.EXE [options] filesn"
  26. "Options:                          @fname   specify response file   n"
  27. "/l[+|-]  dump listing file        /w-xxx   disable a warning       n"
  28. "/i[+|-]  dump preprocessed file   /Dxxx    define something        n"
  29. "/e[-|+]  dump errors to file      /Ennn    max number of errors    n"
  30. "/k[+|-]  keep generate files      /Ipath   specify include path    n"
  31. "/K[+|-]  keep response files      /Lpath   specify .LIB & .OBJ dir n"
  32. "/A[+|-]  disable extensions       /Cxxx    codegen parameters      n"
  33. "/v[+|-]  debug info               /Oxxx    optimzer parameters     n"
  34. "/m[+|-]  generate .MAP file       /Tp      use TLINK & PMODE       n"
  35. "/n[+|-]  no default .LIB & .OBJ   /Tl      use TLINK & PMODE(low)  n"
  36. "/a       generate .ASM file       /Tw      use WLINK & PMODE/W     n"
  37. "/c       generate .OBJ file       /Td      use WLINK & DOS/4GW     n"
  38. "/?,/h,/H this help                /Rname   specify .EXE namen";
  40. #define FALSE 0
  41. #define TRUE  1
  43. #define _ASM ".ASM"
  44. #define _OBJ ".OBJ"
  45. #define _LIB ".LIB"
  46. #define _LSA ".LSA"
  47. #define _CFG ".CFG"
  49. #define COMPILER     "CC386.EXE"   /* Name of compiler */
  50. #define COMPILER_RSP "CC386.$$$"   /* Response file   for compiler */
  51. #define COMPILER_OPT ""            /* Default options for compiler */
  53. #define ASSEMBLER     "TASM.EXE"   /* Name of assembler */
  54. #define ASSEMBLER_RSP "TASM.$$$"   /* Response file   for assembler */
  55. #define ASSEMBLER_OPT "/t/ml/m3"   /* Default options for assembler */
  57. #define TLINK "TLINK.EXE"
  58. #define WLINK "WLINK.EXE"
  60. #define LINKER_RSP  "LINK.$$$"
  62. #define DELETE_RSP  "DELETE.$$$"
  64. #define MAX_STR 256 /* Max len of string in .CFG file */
  66. /* For error() */
  67. #define ERR_NO        0  /* no error ! */
  68. #define ERR_FATAL   128  /* fatal error */
  69. #define ERR_RUNTIME 129  /* stdlib error - see 'errno' */
  71. // is param ?
  72. #define isparam(s) ( *(s) == '-' || *(s) == '/' || *(s) == '+' )
  73. // check for NOT NULL !!!
  74. #define chkNULL(exp, msg )  if ( !(exp) ) error( ERR_FATAL, msg )
  75. // empty string ?
  76. #define empty_string(s)  ( (s) == NULL || *(s) == '' )
  78. typedef struct _Item {
  79. struct _Item *next;
  80. int temp;
  81. char data[1];
  82. } Item;
  84. Item *ItemCreate( char *dat, int tmp );
  86. #define ItemDelete(item) free(item)
  88. char *FileDisk( Item *item );
  89. char *FilePath( Item *item );
  90. char *FileName( Item *item );
  91. char *FileExt ( Item *item );
  94. typedef struct _List {
  95. Item *head;
  96. Item *tail;
  97. unsigned count;
  98. } List;
  100. void ListAdd( List *list, char *data, int temp );
  101. void ListDelete( List *list );
  103. int  ListFind( List *list, char *data );
  104. void ListIter( List *list, void (*iter)( Item *) );
  106. #define FileAdd(list, file, temp) ListAdd((list),(file),(temp))
  107. #define ParamAdd(list, param) ListAdd((list),(param), FALSE);
  109. List f_cpp; // list of .CPP files
  110. List f_asm; // list of .ASM files
  111. List f_obj; // list of .OBJ files
  112. List f_lib; // list of .LIB files
  114. List l_inc;     // list of INCLUDE path
  115. List l_def;     // list of DEFINE var
  116. List l_cc386;   // list of CC386 options
  118. char _libpath[ _MAX_PATH ]; // Path of default LIB & OBJ
  119. char _exename[ _MAX_PATH ]; // Name of .EXE file
  121. int _compile  = TRUE;  // need compile
  122. int _assemble = TRUE;  // need assemble
  123. int _link     = TRUE;  // need link
  125. int _dump_cpp = FALSE; // dump preprocessed file
  126. int _dump_err =  TRUE; // dump error file
  127. int _dump_lst = FALSE; // dump listing file
  128. int _ansi     = FALSE; // ANSI
  129. int _map_file = FALSE; // map file
  130. int _nodef_lib= FALSE; // no default lib
  131. int _debug    = FALSE; // debug info
  132. int _keep_rsp = FALSE; // keep response files
  133. int _keep_gen = FALSE; // keep generate files
  135. int _output = 'p';     // Output format, same /Tx
  138. void help( void );
  140. void get_param( char *exe_name, char *env_var, int argc, char *argv[] );
  141.  int get_param_file( char *file );
  142. void get_param_str( char *str );
  143. void get_one_param( char *param );
  145. void get_option( char *param );
  147. void get_source( char *filename );
  148. void get_one_source( char *filename );
  149. void find_source( char *fpath, char *fname );
  151. void error( int exitcode, char *msg );
  153. void response( void );
  154. void compile( void );
  155. void assemble( void );
  156. void link( void );
  157. void remove_temp( void );
  159. void DeleteList( void );
  160. void DeleteAll( void ); /* for atexit() */
  163. void main( int argc, char *argv[] ) {
  165. if ( argc == 1 )
  166. help();
  168. get_param( argv[0], "CL386", argc - 1, argv + 1 );
  170. atexit( DeleteAll );
  172. if ( f_cpp.count == 0 && f_asm.count == 0 &&
  173.   f_obj.count == 0 && f_lib.count == 0 )
  174. help();
  176. if ( f_cpp.count == 0 ) _compile = FALSE;
  177. if ( f_asm.count == 0 ) _assemble = FALSE;
  178. if ( f_obj.count == 0 && f_lib.count == 0 ) _link = FALSE;
  180. response();
  182. DeleteList();
  184. compile();
  185. assemble();
  186. link();
  188. remove_temp();
  189. }
  192. void help( void ) {
  193. printf( usage ); exit( 0 );
  194. }
  197. void get_param( char *exe_name, char *env_var, int argc, char *argv[] ) {
  198. char file[ _MAX_PATH ], disk[ _MAX_DRIVE ],
  199. path[ _MAX_DIR ], name[ _MAX_FNAME ], ext [ _MAX_EXT ];
  200. char *env;
  201. int i;
  203. _splitpath( exe_name, disk, path, name, ext );
  204. _makepath( file, NULL, NULL, name, _CFG );
  205. if ( ! get_param_file( file ) ) {
  206. _makepath( file, disk, path, name, _CFG );
  207. get_param_file( file );
  208. }
  210. if ( (env = getenv( env_var ) ) != NULL )
  211. get_param_str( env );
  213. for ( i = 0; i < argc; i++ )
  214. get_one_param( argv[ i ] );
  215. }
  218. int get_param_file( char *file ) {
  219. static char s[ MAX_STR ];
  220. FILE *f = fopen( file, "rt" );
  222. if ( f == NULL )
  223. return FALSE;
  225. while( fgets( s, MAX_STR - 1, f) != NULL )
  226. get_param_str( s );
  228. fclose( f );
  229. return TRUE;
  230. }
  233. void get_param_str( char *s ) {
  234. char arg[ MAX_STR ];
  235. int  len;
  237. for ( len = 0; *s; s++ ) {
  238. if ( *s == ' ' || *s == 't' || *s == 'n' ) {
  239. if ( len > 0 ) {
  240. arg[ len ] = '';
  241. get_one_param( arg );
  242. }
  243. arg[ len = 0 ] = '';
  244. }
  245. else {
  246. arg[ len++ ] = *s;
  247. }
  248. }
  250.     if ( len > 0 ) {
  251.         arg[ len ] = '';
  252.         get_one_param( arg );
  253.     }
  254. }
  257. void get_one_param( char *arg ) {
  258.     if ( isparam( arg ) )                 // -X , +X or /X
  259.         get_option( arg );
  260.     else if ( *arg == '@' ) {               // @filename
  261.         if ( ! get_param_file( arg + 1 )  )
  262.             error( ERR_RUNTIME, arg + 1 );
  263.     }
  264.     else
  265.         get_source( arg );             // file.ext
  266. }
  269. void error( int exitcode, char *msg ) {
  270.     switch ( exitcode ) {
  271.         case ERR_NO: break;
  273.         case ERR_FATAL: fprintf( stderr, "Fatal : %sn", msg );
  274.             break;
  276.         case ERR_RUNTIME: fprintf( stderr, "%s : %s", msg, strerror( errno ) );
  277.             break;
  279.         default: fprintf( stderr, "Program error : %s !n", msg );
  280.             break;
  281.     }
  282.     exit( exitcode );
  283. }
  286. void get_option( char *param ) {
  287. switch( param[ 1 ] ) {
  289.         case 'i' : // dump preprocessed file
  290.             if ( param[2] == '-' ) {        // -i-
  291.                 _dump_cpp = FALSE; return;
  292.             }
  293.             else if ( param[2] == '+' || param[2] == '' ) { // -i or -i+ :)
  294.                 _dump_cpp = TRUE;  return;
  295.             }
  296.             break;
  298.         case 'e' : // dump errors to file
  299.             if ( param[2] == '-' ) {        // -e-
  300.                 _dump_err = FALSE; return;
  301.             }
  302.             else if ( param[2] == '+' || param[2] == '' ) { // -e or -e+ :)
  303.                 _dump_err = TRUE; return;
  304.             }
  305.             break;
  307.  case 'l' : // dump listing file
  308. if ( param[2] == '-' ) {            // -l-
  309.                 _dump_lst = FALSE; return;
  310.             }
  311.             else if ( param[2] == '+' || param[2] == '' ) { // -l or -l+ :)
  312.                 _dump_lst = TRUE; return;
  313.             }
  314.             break;
  316.         case 'A' : // disable extensions
  317.             if ( param[2] == '-' ) { // -A-
  318.                 _ansi = FALSE; return;
  319.             }
  320.             else if ( param[2] == '+' || param[2] == '' ) { // -A or -A+
  321.                 _ansi = TRUE; return;
  322.             }
  323.             break;
  325.         case 'm' : // gen map file
  326. if ( param[2] == '-' ) { // -m-
  327. _map_file = FALSE; return;
  328. }
  329.             else if ( param[2] == '+' || param[2] == '' ) { // -m or -m+
  330.                 _map_file = TRUE; return;
  331.             }
  332.             break;
  334.         case 'n' : // no default lib
  335.             if ( param[2] == '-' ) { // -n-
  336.                 _nodef_lib = FALSE; return;
  337.             }
  338.             else if ( param[2] == '+' || param[2] == '' ) { // -n or -n+
  339.                 _nodef_lib = TRUE; return;
  340.             }
  341.             break;
  343.         case 'v' : // debug info
  344.             if ( param[2] == '-' ) { // -v-
  345.                 _debug = FALSE; return;
  346. }
  347. else if ( param[2] == '+' || param[2] == '' ) { // -v or -v+
  348. _debug = TRUE; return;
  349.             }
  350.             break;
  352.         case 'K' : // keep response files
  353.             if ( param[2] == '-' ) { // -K-
  354.                 _keep_rsp = FALSE; return;
  355.             }
  356.             else if ( param[2] == '+' || param[2] == '' ) { // -K or -K+
  357.                 _keep_rsp = TRUE; return;
  358.             }
  359.             break;
  361.         case 'k' : // keep generate files
  362.             if ( param[2] == '-' ) { // -k-
  363.                 _keep_gen = FALSE; return;
  364.             }
  365.             else if ( param[2] == '+' || param[2] == '' ) { // -k or -k+
  366. _keep_gen = TRUE; return;
  367. }
  368. break;
  370.         case 'a' :
  371.             _compile = TRUE;
  372.             _assemble = _link = FALSE;
  373.             return;
  375.         case 'c' :
  376.             _compile = _assemble = TRUE;
  377.             _link = FALSE;
  378.             return;
  380.         case '?' :
  381.         case 'h' :
  382.         case 'H' :
  383.             help(); /* Not return ! */
  385.         case 'D' : // define
  386. ParamAdd( &l_def, param + 2 );
  387. return;
  389.         case 'I' : // include path
  390.             ParamAdd( &l_inc, param + 2 );
  391.             return;
  393.         case 'L' : // lib path
  394.             strupr( strncpy( _libpath, param + 2, _MAX_PATH ) );
  395. //            ParamAdd( &l_lib, param + 2 );
  396.             return;
  398.         case 'R' : // .EXE name
  399.             strupr( strncpy( _exename, param + 2, _MAX_PATH ) );
  400.             return;
  402.         case 'w' :
  403.         case 'C' :
  404.         case 'E' :
  405.         case 'O' :
  406. ParamAdd( &l_cc386, param );
  407. return;
  409.         case 'T' :
  410.             if ( param[3] == '' )
  411.                 if ( param[2] == 'p' || param[2] == 'l' || 
  412.                 param[2] == 'w' || param[2] == 'd' ) {
  413.                     _output = param[2]; return;
  414.                 }
  415.             break;
  417.     }
  418.     fprintf( stderr, "Warning! Parameter error : %sn", param );
  419. }
  422. Item *ItemCreate( char *dat, int tmp ) {
  423.     Item *item;
  424.     int len;
  426. if ( empty_string( dat ) )
  427. return NULL;
  429.     len = strlen( dat );
  431.     if ( (item = (Item *)malloc( sizeof( Item ) + len )) != NULL ) {
  432.         item->next = NULL;
  433.         item->temp = tmp;
  434.         strcpy( item->data, dat );
  435.     }
  437.     return item;
  438. }
  441. static char disk[ _MAX_DRIVE ];
  442. static char path[ _MAX_DIR   ];
  443. static char name[ _MAX_FNAME ];
  444. static char ext [ _MAX_EXT   ];
  447. char *FileDisk( Item *item ) {
  448. _splitpath( item->data, disk, path, name, ext );
  449.     return disk;
  450. }
  453. char *FilePath( Item *item ) {
  454.     _splitpath( item->data, disk, path, name, ext );
  455.     return path;
  456. }
  459. char *FileName( Item *item ) {
  460.     _splitpath( item->data, disk, path, name, ext );
  461.     return name;
  462. }
  465. char *FileExt ( Item *item ) {
  466. _splitpath( item->data, disk, path, name, ext );
  467. return ext;
  468. }
  471. void ListDelete( List *list ) {
  472. Item *p, *q;
  474. chkNULL( list, "Pointer is NULL !" );
  476. for( p = list->head; p; p = q ) {
  477. q = p->next;
  478. free(p);
  479. }
  480. list->head = list->tail = NULL;
  481. list->count = 0;
  482. }
  485. void ListAdd( List *list, char *file, int tmp ) {
  486. Item *item;
  488. chkNULL( list, "Pointer is NULL !" );
  490. item = ItemCreate( file, tmp );
  492. chkNULL( item, "Out of memory !" );
  494. if ( list->count == 0 )
  495. list->head = list->tail = item;
  496. else {
  497. (list->tail)->next = item;
  498. list->tail = item;
  499. }
  500. list->count++;
  501. }
  504. void ListIter( List *list, void (*iter)( Item *) ) {
  505. Item *p;
  507. chkNULL( list, "Pointer is NULL !" );
  509. if ( list->count && iter ) {
  510. for ( p = list->head; p; p = p->next )
  511. (*iter)(p);
  512. }
  513. }
  516. static char *need;
  517. static int found = 0;
  520. static void find( Item *item ) {
  521. if ( strcmp( item->data, need ) == 0 )
  522. found = 1;
  523. }
  526. int  ListFind( List *list, char *data ) {
  527. found = 0;
  528. need = data;
  529. ListIter( list, find );
  530. return found;
  531. }
  534. char findpath[ _MAX_PATH ];
  535. char findname[ _MAX_PATH ];
  538. void get_source( char *filename ) {
  539. _splitpath( filename, disk, path, name, ext );
  541. if ( strchr( filename, '?' ) || strchr( filename, '*' ) ) {  /* Check for '*' and '?' */
  542. _makepath( findpath, disk, path, NULL, NULL );
  543. _makepath( findname, NULL, NULL, name, ext );
  544. find_source( findpath, findname );
  545. }
  546. else
  547. get_one_source( filename );
  548. }
  550. #ifdef __TURBOC__
  552. void find_source( char *fpath, char *fname ) {
  553. int fpath_len = strlen( fpath );
  554. struct ffblk fb;
  556. if ( !findfirst( strcat( fpath, fname), &fb, FA_ARCH) )
  557. do {
  558. fpath[ fpath_len ] = '';
  559. get_one_source( strcat( fpath, fb.ff_name) );
  560. } while (! findnext(&fb) );
  561. }
  564. #else
  567. void find_source( char *fpath, char *fname ) {
  568. int fpath_len = strlen( fpath );
  569. struct find_t fb;
  571. if (!_dos_findfirst( strcat( fpath, fname), _A_NORMAL, &fb ) )
  572. do {
  573. fpath[ fpath_len ] = '';
  574. get_one_source( strcat( fpath, fb.name) );
  575. } while( ! _dos_findnext( &fb ) );
  576. }
  578. #endif
  580. void get_one_source( char *srcfile ) {
  581.     int temp = FALSE;
  582.     static char file[ _MAX_PATH ];
  583.     static char disk[ _MAX_DRIVE ];
  584.     static char path[ _MAX_DIR ];
  585.     static char name[ _MAX_FNAME ];
  586. static char ext [ _MAX_EXT ];
  588. strncpy( file, srcfile, _MAX_PATH );
  589.     _splitpath( strupr(file) , disk, path, name, ext );
  590. //  _makepath( file, disk, path, name, ext );
  592.     if ( strcmp( ext, _ASM ) != 0 && 
  593.          strcmp( ext, _OBJ ) != 0 && strcmp( ext, _LIB ) != 0 ) {
  594.         if ( ListFind( &f_cpp, file ) )
  595.             fprintf( stderr, "Warning! File already exist : %sn", file );
  596.         else
  597.             FileAdd( &f_cpp, file, temp++ );
  598. #ifdef TO_CURR_DIR
  599. _makepath( file, disk, NULL, name, strcpy( ext, _ASM ) );
  600. #else
  601.         _makepath( file, disk, path, name, strcpy( ext, _ASM ) );
  602. #endif
  603.     }
  605.     if ( strcmp( ext, _ASM ) == 0 ) {
  606. if ( ListFind( &f_asm, file ) )
  607. fprintf( stderr, "Warning! File already exist : %sn", file );
  608. else
  609.             FileAdd( &f_asm, file, temp++ );
  610.         _makepath( file, disk, path, name, strcpy( ext, _OBJ) );
  611.     }
  613.     if ( strcmp( ext, _OBJ ) == 0 ) {
  614.         if ( ListFind( &f_obj, file ) )
  615.             fprintf( stderr, "Warning! File already exist : %sn", file );
  616.         else
  617.             FileAdd( &f_obj, file, temp++ );
  618.     }
  620.     if ( strcmp( ext, _LIB ) == 0 ) {
  621.         if ( ListFind( &f_lib, file ) )
  622.             fprintf( stderr, "Warning! File already exist : %sn", file );
  623.         else
  624.             FileAdd( &f_lib, file, 0 );
  625.     }
  626. }
  629. void DeleteList( void ) {  // delete all list from memory
  630. ListDelete( &f_cpp );
  631. ListDelete( &f_asm );
  632. ListDelete( &f_obj );
  633. ListDelete( &f_lib );
  634. ListDelete( &l_def );
  635. ListDelete( &l_inc );
  636. //    ListDelete( &l_lib );
  637. ListDelete( &l_cc386 );
  638. }
  640. void DeleteAll( void ) {   // for atexit()
  641. DeleteList();
  642. if ( !_keep_rsp ) {
  643. remove( COMPILER_RSP );
  644. remove( ASSEMBLER_RSP );
  645. remove( LINKER_RSP );
  646. remove( DELETE_RSP );
  647. }
  648. }
  650. void exec( char *prg, char *rsp ) {
  651. static char *args[3];
  652. int err;
  654. args[0] = prg;
  655. args[1] = rsp;
  656. args[2] = NULL;
  658. err = spawnvp( P_WAIT, prg, args );
  660. if ( err <  0 )
  661. error( ERR_RUNTIME, prg );
  662. else if ( err > 0 )
  663. error( err, prg );
  664. }
  667. FILE *frsp;
  670. static void compile_def  ( Item *p ) { fprintf( frsp, " /D%s", p->data ); }
  671. static void compile_inc  ( Item *p ) { fprintf( frsp, "%s;", p->data ); }
  672. static void compile_opt  ( Item *p ) { fprintf( frsp, " %s", p->data ); }
  673. static void compile_files( Item *p ) { fprintf( frsp, "n%s", p->data ); }
  675. static void compile_rsp( char *file, char *def_opt ) {
  676. frsp = fopen( file, "wt" );
  677. if ( frsp == NULL )
  678. error( ERR_RUNTIME, file );
  679. fprintf( frsp, " %s", def_opt );
  680. ListIter( &l_cc386, compile_opt );
  681. fprintf( frsp, " %ci", ( _dump_cpp ? '+' : '-' ) );
  682. fprintf( frsp, " %ce", ( _dump_err ? '+' : '-' ) );
  683. fprintf( frsp, " %cl", ( _dump_lst ? '+' : '-' ) );
  684. fprintf( frsp, " %cA", (     _ansi ? '+' : '-' ) );
  685. ListIter( &l_def, compile_def );
  686. if ( l_inc.count > 0 ) {
  687. fprintf( frsp, " /I" );
  688. ListIter( &l_inc, compile_inc );
  689. }
  690. ListIter( &f_cpp, compile_files );
  691. fprintf( frsp, "n" );
  692. fclose( frsp );
  693. }
  695. void compile( void ) {
  696. if ( _compile /* && f_cpp.count > 0 */ )
  697. {
  698. // compile_rsp( COMPILER_RSP, COMPILER_OPT );
  699. exec( COMPILER, "/f" COMPILER_RSP );
  700. if ( !_keep_rsp )
  701. remove( COMPILER_RSP );
  702. // ListDelete( &f_cpp );
  703. // ListDelete( &l_cc386 );
  704. }
  705. }
  707. static void delete_temp( Item *p ) { if ( p->temp ) remove( p->data ); }
  709. static void assemble_def( Item *p ) { fprintf( frsp, " /d%s", p->data ); }
  710. static void assemble_inc( Item *p ) { fprintf( frsp, " /i%s", p->data ); }
  712. char *asm_opt;
  714. static void gen_for_asm( Item *p ) {
  715. fprintf( frsp, " %s", asm_opt );
  716. fprintf( frsp, " /z%c", ( _debug ? 'i' : 'n' ) );
  717. ListIter( &l_inc, assemble_inc );
  718. ListIter( &l_def, assemble_def );
  719. if ( _dump_lst )
  720. fprintf( frsp, " %s,%s%s%s.OBJ,%s%s%s.LSA;n", p->data,
  721. FileDisk(p), FilePath(p), FileName(p),
  722. FileDisk(p), FilePath(p), FileName(p) );
  723. else
  724. fprintf( frsp, " %s,%s%s%s.OBJ,NUL;n", p->data,
  725. FileDisk(p), FilePath(p), FileName(p) );
  726. }
  728. void assemble_rsp( char *file, char *def_opt ) {
  729. frsp = fopen( file, "wt" );
  730. if ( frsp == NULL )
  731. error( ERR_RUNTIME, file );
  732. asm_opt = def_opt;
  733. ListIter( &f_asm, gen_for_asm );
  734. fclose( frsp );
  735. }
  737. void assemble(void) {
  738. if ( _assemble /* && f_asm.count > 0 */ )
  739. {
  740. // assemble_rsp( ASSEMBLER_RSP, ASSEMBLER_OPT );
  741. exec( ASSEMBLER, "@" ASSEMBLER_RSP );
  742. if ( !_keep_rsp )
  743. remove( ASSEMBLER_RSP );
  744. // if ( !_keep_gen )
  745. // ListIter( &f_asm, delete_temp );
  746. // ListDelete( &f_asm );
  747. // ListDelete( &l_def );
  748. // ListDelete( &l_inc );
  749. }
  750. }
  753. char *first( void ) {
  754. if ( strlen( _exename ) > 0 )
  755. return _exename;
  756. else if ( f_obj.count > 0 )
  757. return FileName( f_obj.head );
  758. else if ( f_lib.count > 0 )
  759. return FileName( f_lib.head );
  760. else
  761. return NULL;
  762. }
  764. char *libpath( char *lib ) {
  765. static char library[ _MAX_PATH ];
  766. strcpy( library, _libpath );
  767. if ( library[ strlen( library) - 1 ] != '\' )
  768. strcat( library, "\" );
  769. return strcat( library, lib );
  770. }
  772. static void out_obj( Item *p ) { fprintf( frsp, " %s", p->data ); }
  774. void tlink_rsp( char *file ) {
  775. char *name = first();
  777. frsp = fopen( file, "wt" );
  778. if ( frsp == NULL )
  779. error( ERR_RUNTIME, file );
  780. fprintf( frsp, "/3/c/d" );
  781. if ( _map_file )
  782. fprintf( frsp, "/m/l/s" );
  783. else
  784. fprintf( frsp, "/x" );
  785. if ( _debug )
  786. fprintf( frsp, "/v" );
  787. if ( !_nodef_lib ) {
  788. if ( _output == 'p' )
  789. fprintf( frsp, " %s", 
  790. libpath( ( _debug ? "C0DOSD.OBJ" : "C0DOS.OBJ" ) )  );
  791. else
  792. fprintf( frsp, " %s", 
  793. libpath( ( _debug ? "C0DOSLD.OBJ" : "C0DOSL.OBJ" ) )  );
  794. }
  795. ListIter( &f_obj, out_obj );
  796. fprintf( frsp, ",%s,%s,", name, name );
  797. if ( !_nodef_lib )
  798. fprintf( frsp, " %s", libpath( "CLDOS.LIB" )  );
  799. ListIter( &f_lib, out_obj );
  800. fprintf( frsp, "n" );
  801. fclose( frsp );
  802. }
  804. void tlink(void) {
  805. // tlink_rsp( LINKER_RSP );
  806. exec( TLINK, "@" LINKER_RSP );
  807. }
  809. static void wout_obj( Item *p) { fprintf( frsp, "file %sn", p->data ); }
  810. static void wout_lib( Item *p) { fprintf( frsp, "library %sn", p->data ); }
  812. void wlink_rsp( char *file ) {
  813. char *name = first();
  815. frsp = fopen( file, "wt" );
  816. if ( frsp == NULL )
  817. error( ERR_RUNTIME, file );
  818. fprintf( frsp, "# Generate from CL386.EXEn" );
  819. fprintf( frsp, "format os2 len" );
  820. fprintf( frsp, "option nodn" );
  821. if ( _map_file )
  822. fprintf( frsp, "option mapn" );
  823. if ( _debug )
  824. fprintf( frsp, "option symfn" );
  825. if ( _output == 'w' )
  826. fprintf( frsp, "option osname='CC386+PMODE/W'n"
  827.    "option stub=%sn", libpath( "PMODEW.EXE" ) );
  828. else
  829. fprintf( frsp, "option osname='CC386+DOS/4GW'n"
  830.    "option stub=%sn", libpath( "D4GWSTUB.EXE" ) );
  831. fprintf( frsp, "name %sn", name );
  833. if ( !_nodef_lib )
  834. fprintf( frsp, "file %sn",
  835. libpath( ( _debug ? "C0DOSWD.OBJ" : "C0DOSW.OBJ" ) )  );
  837. ListIter( &f_obj, wout_obj );
  839. if ( !_nodef_lib )
  840. fprintf( frsp, "library %s", libpath( "CLDOS.LIB" )  );
  842. ListIter( &f_lib, wout_lib );
  843. fclose( frsp );
  844. }
  846. void wlink(void) {
  847. // wlink_rsp( LINKER_RSP );
  848. exec( WLINK, "@" LINKER_RSP );
  849. }
  851. void link(void) {
  852. if ( _link /* && ( f_obj.count > 0 || f_lib.count > 0 ) */ )
  853. {
  854. if ( _output == 'p' || _output == 'l' )
  855. tlink();
  856. else if ( _output == 'w' || _output == 'd' )
  857. wlink();
  858. else
  859. printf( "Unknow link!n" );
  860. if ( !_keep_rsp )
  861. remove( LINKER_RSP );
  862. // if ( !_keep_gen )
  863. // ListIter( &f_obj, delete_temp );
  864. // ListDelete( &f_obj );
  865. // ListDelete( &f_lib );
  866. }
  867. }
  869. static void delete_file(Item *p) {
  870. if (p->temp)
  871. fprintf( frsp, "%sn", p->data );
  872. }
  874. void delete_rsp( char *file ) {
  875. frsp = fopen( file, "wt" );
  876. if ( frsp == NULL )
  877. error( ERR_RUNTIME, file );
  878. ListIter( &f_asm, delete_file );
  879. ListIter( &f_obj, delete_file );
  880. fclose( frsp );
  881. }
  883. void response( void ) {
  884. if ( _compile && f_cpp.count > 0 ) {
  885. compile_rsp( COMPILER_RSP, COMPILER_OPT );
  886. }
  887. if ( _assemble && f_asm.count > 0 ) {
  888. assemble_rsp( ASSEMBLER_RSP, ASSEMBLER_OPT );
  889. }
  890. if ( _link && ( f_obj.count > 0 || f_lib.count > 0 ) ) {
  891. if ( _output == 'p' || _output == 'l' )
  892. tlink_rsp( LINKER_RSP );
  893. else if ( _output == 'w' || _output == 'd' )
  894. wlink_rsp( LINKER_RSP );
  895. }
  896. delete_rsp( DELETE_RSP );
  897. }
  899. void remove_temp( void ) {
  900. int len;
  901. char s[ _MAX_PATH ];
  903. if ( !_keep_gen ) {
  905. frsp = fopen( DELETE_RSP, "rt" );
  906. if ( frsp == NULL )
  907. error( ERR_RUNTIME, DELETE_RSP );
  909. while( fgets( s, _MAX_PATH, frsp ) != NULL ) {
  910. len = strlen( s );
  911. if ( len > 0 && s[ len - 1] == 'n' )
  912. s[ len - 1 ] = '';
  913. remove( s );
  914. }
  915. fclose( frsp );
  916. }
  917. if ( !_keep_rsp )
  918. remove( DELETE_RSP );
  919. }