home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d5xx / d523 / bmake.lha / BMake / source.lzh / pattern.c < prev    next >
C/C++ Source or Header  |  1991-07-20  |  4KB  |  169 lines
  1. /*    pattern.c
  2.  *    (c) Copyright 1991 by Ben Eng, All Rights Reserved
  3.  *
  4.  */
  5.  
  6. #include <string.h>
  7. #include <ctype.h>
  8. #include <fcntl.h>
  9.  
  10. #include <clib/exec_protos.h>
  11. #include <clib/dos_protos.h>
  12.  
  13. #include "make.h"
  14. #include "depend.h"
  15.  
  16.  
  17. int
  18. pattern_match( char *pattern, char *cmpstr )
  19. {
  20.     char *delim = pattern;
  21.     int prelen, postlen, complen = strlen( cmpstr);
  22.  
  23.     while( *delim && *delim != PATMATCH_CHAR ) delim++;
  24.     if( !*delim ) return( stricmp( pattern, cmpstr ) ? 0 : 1 );
  25.     prelen = (int)(delim - pattern);
  26.     postlen = strlen( delim + 1 );
  27.     if( prelen + postlen > complen ||
  28.         strncmp( pattern, cmpstr, prelen ) ||
  29.         stricmp( delim + 1, cmpstr + complen - postlen ))
  30.         return( 0 );
  31.     return( 1 ); /* match */
  32. }
  33.  
  34. struct patternrule *
  35. find_patternrule( char *dep_pat, char *tar_pat )
  36. {
  37.     struct patternrule *sr = NULL;
  38.  
  39.     for( struct patternrule *ln = Global.patternlist.lh_Head; ln->node.ln_Succ;
  40.         ln = ln->node.ln_Succ ) {
  41.         if( !stricmp( dep_pat, ln->dep_pat ) &&
  42.             !stricmp( tar_pat, ln->tar_pat )) {
  43.             sr = ln;
  44.             break;
  45.         }
  46.     }
  47.  
  48.     return( sr );
  49. }
  50.  
  51. struct patternrule *
  52. new_patternrule( char *dep_pat, char *tar_pat )
  53. {
  54.     int found_flag = 0;
  55.     long size = sizeof(struct patternrule);
  56.     struct patternrule *new = find_patternrule( dep_pat, tar_pat );
  57.     if( new ) found_flag = 1;
  58.     else new = (struct patternrule *)malloc( size );
  59.  
  60.     if( new ) {
  61.         strcpy( new->tar_pat, tar_pat );
  62.         if( dep_pat ) strcpy( new->dep_pat, dep_pat );
  63.         else *new->dep_pat = (char)0;
  64.         if( !found_flag ) AddTail( &Global.patternlist, &new->node );
  65.     }
  66.     return( new );
  67. }
  68.  
  69. int
  70. delete_patternrule( struct patternrule *rule )
  71. {
  72.     free( rule );
  73.     return( 0 );
  74. }
  75.  
  76. void
  77. delete_patternlist( struct List *list )
  78. {
  79.     for_list( list, delete_patternrule );
  80. }
  81.  
  82. struct patternrule *
  83. add_pattern_rule( struct target *tar )
  84. {
  85.     struct patternrule *sr = NULL;
  86.     struct depend *dep = (struct depend *)tar->dependlist.lh_Head;
  87.     char *depname;
  88.     depname = (dep) ? (dep->name) : NULL;
  89.     sr = new_patternrule( depname, tar->name );
  90.     if( sr ) {
  91.         sr->targ = tar;
  92.         if( tar->flags & TF_ADDED ) Remove( &tar->node );
  93.         tar->flags |= (TF_PATTERN | TF_ADDED);
  94.         AddTail( &Global.speciallist, &tar->node );
  95.     }
  96.     return( sr );
  97. }
  98.  
  99. struct patternrule *
  100. add_suffix_targets( char *suf )
  101. {
  102.     char *next, tar_pat[ MAXSUFFIX+2 ], dep_pat[ MAXSUFFIX+2 ];    
  103.     struct patternrule *sr, *first = NULL;
  104.     struct target *ln, *succ;
  105.  
  106.     for( ln = (struct target *)Global.targetlist.lh_Head;
  107.         ln->node.ln_Succ; ln = succ ) {
  108.         succ = ln->node.ln_Succ;
  109.  
  110.         next = ln->name;
  111.         *dep_pat = (char)0; /* default to match nothing */
  112.         strcpy( tar_pat, "%." );
  113.  
  114.         if( *next++ == '.' ) {
  115.             next = parse_strtok( tar_pat+2, next, sizeof(suf)-1, isnotsuf );
  116.             if( *next++ == '.' ) {
  117.                 strcpy( dep_pat, tar_pat ); /* double-suffix */
  118.                 next = parse_strtok( tar_pat+2, next, sizeof(suf)-1, isnotsuf );
  119.             }
  120.         }
  121.         if( !stricmp( suf, tar_pat+2 )) {
  122.             /* transform a target rule into a suffix rule */
  123.             sr = new_patternrule( dep_pat, tar_pat );
  124.             if( sr ) {
  125.                 sr->targ = ln;
  126.                 ln->flags |= TF_PATTERN;
  127.                 Remove( &ln->node );
  128.                 AddTail( &Global.speciallist, &ln->node );
  129.             }
  130.             else return( first ); /* error */
  131.             if( !first ) first = sr;
  132.         }
  133.     }
  134.  
  135.     return( first );
  136. }
  137.  
  138. int
  139. map_to_pattern( char *name, char *from_pat, char *to_pat, char *string )
  140. {
  141.     char *f_delim = from_pat;
  142.     char *t_delim = to_pat;
  143.     int len, prelen;
  144.  
  145.     while( *f_delim && *f_delim != PATMATCH_CHAR ) f_delim++;
  146.     while( *t_delim && *t_delim != PATMATCH_CHAR ) t_delim++;
  147.     if( !*f_delim ) return( 1 );
  148.     if( !*t_delim ) {
  149.         strcpy( name, to_pat );
  150.         return( 0 );
  151.     }
  152.  
  153.     len = (int)(t_delim - to_pat );
  154.     if( len > 0 ) {
  155.         strncpy( name, to_pat, len );
  156.         name += len;
  157.     }
  158.  
  159.     prelen = (int)(f_delim - from_pat);
  160.     len = strlen( string ) - strlen( f_delim + 1 ) - prelen;
  161.  
  162.     if( len > 0 ) {
  163.         strncpy( name, string + prelen, len );
  164.         name += len;
  165.     }
  166.     strcpy( name, t_delim + 1 );
  167.     return( 0 );
  168. }
  169.