home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / amiga / programm / utility / bmake15.lzh / pattern.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-19  |  3.8 KB  |  180 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 )
  24.         delim++;
  25.     if( !*delim )
  26.         return( stricmp( pattern, cmpstr ) ? 0 : 1 );
  27.     prelen = (int)(delim - pattern);
  28.     postlen = strlen( delim + 1 );
  29.     if( prelen + postlen > complen ||
  30.         strnicmp( pattern, cmpstr, prelen ) ||
  31.         stricmp( delim + 1, cmpstr + complen - postlen ))
  32.         return( 0 );
  33.     return( 1 ); /* match */
  34. }
  35.  
  36. static struct patternrule *
  37. find_patternrule( char *dep_pat, char *tar_pat )
  38. {
  39.     struct patternrule *sr = NULL;
  40.  
  41.     for( struct patternrule *ln = Global.patternlist.lh_Head; ln->node.ln_Succ;
  42.         ln = ln->node.ln_Succ ) {
  43.         if( !stricmp( dep_pat, ln->dep_pat ) &&
  44.             !stricmp( tar_pat, ln->tar_pat )) {
  45.             sr = ln;
  46.             break;
  47.         }
  48.     }
  49.  
  50.     return( sr );
  51. }
  52.  
  53. struct patternrule *
  54. new_patternrule( char *dep_pat, char *tar_pat )
  55. {
  56.     int found_flag = 0;
  57.     long size = sizeof(struct patternrule);
  58.     struct patternrule *new = find_patternrule( dep_pat, tar_pat );
  59.     if( new )
  60.         found_flag = 1;
  61.     else
  62.         new = (struct patternrule *)malloc( size );
  63.  
  64.     if( new ) {
  65.         strcpy( new->tar_pat, tar_pat );
  66.         if( dep_pat )
  67.             strcpy( new->dep_pat, dep_pat );
  68.         else
  69.             *new->dep_pat = (char)0;
  70.         if( !found_flag )
  71.             AddTail( &Global.patternlist, &new->node );
  72.     }
  73.     return( new );
  74. }
  75.  
  76. int
  77. delete_patternrule( struct patternrule *rule )
  78. {
  79.     free( rule );
  80.     return( 0 );
  81. }
  82.  
  83. void
  84. delete_patternlist( struct List *list )
  85. {
  86.     for_list( list, delete_patternrule );
  87. }
  88.  
  89. struct patternrule *
  90. add_pattern_rule( struct target *tar )
  91. {
  92.     struct patternrule *sr = NULL;
  93.     struct depend *dep = (struct depend *)tar->dependlist.lh_Head;
  94.     char *depname;
  95.     depname = (dep) ? (dep->name) : NULL;
  96.     sr = new_patternrule( depname, tar->name );
  97.     if( sr ) {
  98.         sr->targ = tar;
  99.         if( tar->flags & TF_ADDED )
  100.             Remove( &tar->node );
  101.         tar->flags |= (TF_PATTERN | TF_ADDED);
  102.         AddTail( &Global.speciallist, &tar->node );
  103.     }
  104.     return( sr );
  105. }
  106.  
  107. struct patternrule *
  108. add_suffix_targets( char *suf )
  109. {
  110.     char *next, tar_pat[ MAXSUFFIX+2 ], dep_pat[ MAXSUFFIX+2 ];    
  111.     struct patternrule *sr, *first = NULL;
  112.     struct target *ln, *succ;
  113.  
  114.     for( ln = (struct target *)Global.targetlist.lh_Head;
  115.         ln->node.ln_Succ; ln = succ ) {
  116.         succ = ln->node.ln_Succ;
  117.  
  118.         next = ln->name;
  119.         *dep_pat = (char)0; /* default to match nothing */
  120.         strcpy( tar_pat, "%." );
  121.  
  122.         if( *next++ == '.' ) {
  123.             next = parse_strtok( tar_pat+2, next, sizeof(suf)-1, isnotsuf );
  124.             if( *next++ == '.' ) {
  125.                 strcpy( dep_pat, tar_pat ); /* double-suffix */
  126.                 next = parse_strtok( tar_pat+2, next, sizeof(suf)-1, isnotsuf );
  127.             }
  128.         }
  129.         if( !stricmp( suf, tar_pat+2 )) {
  130.             /* transform a target rule into a suffix rule */
  131.             sr = new_patternrule( dep_pat, tar_pat );
  132.             if( sr ) {
  133.                 sr->targ = ln;
  134.                 ln->flags |= TF_PATTERN;
  135.                 Remove( &ln->node );
  136.                 AddTail( &Global.speciallist, &ln->node );
  137.             }
  138.             else
  139.                 return( first ); /* error */
  140.             if( !first )
  141.                 first = sr;
  142.         }
  143.     }
  144.  
  145.     return( first );
  146. }
  147.  
  148. int
  149. map_to_pattern( char *name, char *from_pat, char *to_pat, char *string )
  150. {
  151.     char *f_delim = from_pat;
  152.     char *t_delim = to_pat;
  153.     int len, prelen;
  154.  
  155.     while( *f_delim && *f_delim != PATMATCH_CHAR ) f_delim++;
  156.     while( *t_delim && *t_delim != PATMATCH_CHAR ) t_delim++;
  157.     if( !*f_delim )
  158.         return( 1 );
  159.     if( !*t_delim ) {
  160.         strcpy( name, to_pat );
  161.         return( 0 );
  162.     }
  163.  
  164.     len = (int)(t_delim - to_pat );
  165.     if( len > 0 ) {
  166.         strncpy( name, to_pat, len );
  167.         name += len;
  168.     }
  169.  
  170.     prelen = (int)(f_delim - from_pat);
  171.     len = strlen( string ) - strlen( f_delim + 1 ) - prelen;
  172.  
  173.     if( len > 0 ) {
  174.         strncpy( name, string + prelen, len );
  175.         name += len;
  176.     }
  177.     strcpy( name, t_delim + 1 );
  178.     return( 0 );
  179. }
  180.