match.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	Xorriso_pvt_match_includeD   yes

Functions
int	Xorriso_prepare_regex (struct XorrisO *xorriso, char *adr, int flag)
int	Xorriso_regexec (struct XorrisO *xorriso, char *to_match, int *failed_at, int flag)
int	Xorriso_is_in_patternlist (struct XorrisO *xorriso, struct Xorriso_lsT *patternlist, char *path, int flag)
char *	Xorriso_get_pattern (struct XorrisO *xorriso, struct Xorriso_lsT *patternlist, int index, int flag)
int	Xorriso_prepare_expansion_pattern (struct XorrisO *xorriso, char *pattern, int flag)
int	Xorriso_check_for_root_pattern (struct XorrisO *xorriso, int *filec, char **filev, int count_limit, off_t *mem, int flag)
int	Xorriso_register_matched_adr (struct XorrisO *xorriso, char *adr, int count_limit, int *filec, char **filev, off_t *mem, int flag)
int	Xorriso_eval_nonmatch (struct XorrisO *xorriso, char *pattern, int *nonconst_mismatches, off_t *mem, int flag)
int	Xorriso_check_matchcount (struct XorrisO *xorriso, int count, int nonconst_mismatches, int num_patterns, char **patterns, int flag)
int	Xorriso_no_pattern_memory (struct XorrisO *xorriso, off_t mem, int flag)
int	Xorriso_alloc_pattern_mem (struct XorrisO *xorriso, off_t mem, int count, char ***filev, int flag)
int	Xorriso_warn_of_wildcards (struct XorrisO *xorriso, char *path, int flag)
int	Xorriso_expand_disk_pattern (struct XorrisO *xorriso, int num_patterns, char **patterns, int extra_filec, int *filec, char ***filev, off_t *mem, int flag)

Macro Definition Documentation

Xorriso_pvt_match_includeD

#define Xorriso_pvt_match_includeD   yes

Definition at line 13 of file match.h.

Function Documentation

Xorriso_alloc_pattern_mem()

int Xorriso_alloc_pattern_mem	(	struct XorrisO *	xorriso,
		off_t	mem,
		int	count,
		char ***	filev,
		int	flag
	)

Definition at line 609 of file match.c.

{
 char mem_text[80], limit_text[80];
 
 Sfile_scale((double) mem, mem_text,5,1e4,0);
 sprintf(xorriso->info_text,
         "Temporary memory needed for pattern expansion : %s", mem_text);
 if(!(flag&1))
   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
 if(mem > xorriso->temp_mem_limit) {
   Sfile_scale((double) xorriso->temp_mem_limit, limit_text,5,1e4,1);
   sprintf(xorriso->info_text,
           "List of matching file addresses exceeds -temp_mem_limit (%s > %s)",
           mem_text, limit_text);
   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
   return(0);
 }
 
 (*filev)= (char **) calloc(count, sizeof(char *));
 if(*filev==NULL) {
   Xorriso_no_pattern_memory(xorriso, mem, 0);
   return(-1);
 }
 return(1);
}

References XorrisO::info_text, Sfile_scale(), XorrisO::temp_mem_limit, Xorriso_msgs_submit(), and Xorriso_no_pattern_memory().

Referenced by Xorriso_expand_disk_pattern(), and Xorriso_expand_pattern().

Xorriso_check_for_root_pattern()

int Xorriso_check_for_root_pattern	(	struct XorrisO *	xorriso,
		int *	filec,
		char **	filev,
		int	count_limit,
		off_t *	mem,
		int	flag
	)

Definition at line 364 of file match.c.

{
 if(xorriso->re_fill!=0)
   return(2);
 /* This is the empty pattern representing root */
 if(flag&1) {
   (*filec)++;
   (*mem)+= 8;
 } else {
   if(*filec >= count_limit) {
     sprintf(xorriso->info_text,
            "Number of matching files changed unexpectedly (> %d)",
             count_limit);
     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
                         (flag&2 ? "FATAL" : "WARNING"), 0);
     return(flag&2 ? -1 : 0);
   }
   filev[*filec]= strdup("/");
   if(filev[*filec]==NULL) {
     Xorriso_no_pattern_memory(xorriso, (off_t) 2, 0);
     return(-1);
   }
   (*filec)++;
 }
 return(1);
}

References XorrisO::info_text, XorrisO::re_fill, Xorriso_msgs_submit(), and Xorriso_no_pattern_memory().

Referenced by Xorriso_obtain_pattern_files_i(), and Xorriso_obtain_pattern_files_x().

Xorriso_check_matchcount()

int Xorriso_check_matchcount	(	struct XorrisO *	xorriso,
		int	count,
		int	nonconst_mismatches,
		int	num_patterns,
		char **	patterns,
		int	flag
	)

Definition at line 574 of file match.c.

{
 
 if((flag&1) && (count!=1 || nonconst_mismatches)){
   if(count-nonconst_mismatches>0)
     sprintf(xorriso->info_text,
             "Pattern match with more than one file object");
   else
     sprintf(xorriso->info_text, "No pattern match with any file object");
   if(num_patterns==1)
     sprintf(xorriso->info_text+strlen(xorriso->info_text), ": ");
   Text_shellsafe(patterns[0], xorriso->info_text, 1);
   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, 
                       (flag&2 ? "FAILURE" : "SORRY"), 0);
   return(0);
 }
 return(1);
}

References XorrisO::info_text, Text_shellsafe(), and Xorriso_msgs_submit().

Referenced by Xorriso_expand_disk_pattern(), and Xorriso_expand_pattern().

Xorriso_eval_nonmatch()

int Xorriso_eval_nonmatch	(	struct XorrisO *	xorriso,
		char *	pattern,
		int *	nonconst_mismatches,
		off_t *	mem,
		int	flag
	)

Definition at line 548 of file match.c.

{
 int k,l;
 
 /* Is this a constant pattern ? */
 for(k= 0; k<xorriso->re_fill; k++) {
   if(xorriso->re_constants[k]==NULL)
 break;
   if(xorriso->re_constants[k][0]==0)
 break;
 }
 if(k<xorriso->re_fill)
   (*nonconst_mismatches)++; /* it is not */
 
 l= strlen(pattern)+1;
 (*mem)+= sizeof(char *)+l;
 if(l % sizeof(char *))
   (*mem)+= sizeof(char *)-(l % sizeof(char *));
 return(1);
}

References XorrisO::re_constants, and XorrisO::re_fill.

Referenced by Xorriso_expand_disk_pattern(), and Xorriso_expand_pattern().

Xorriso_expand_disk_pattern()

int Xorriso_expand_disk_pattern	(	struct XorrisO *	xorriso,
		int	num_patterns,
		char **	patterns,
		int	extra_filec,
		int *	filec,
		char ***	filev,
		off_t *	mem,
		int	flag
	)

Definition at line 641 of file match.c.

{
 int ret, count= 0, abs_adr= 0, i, was_count, was_filec;
 int nonconst_mismatches= 0, dive_count= 0;
 char *dir_adr= NULL;
 
 Xorriso_alloc_meM(dir_adr, char, SfileadrL);
 
 *filec= 0;
 *filev= NULL;
 
 xorriso->search_mode= 3;
 xorriso->structured_search= 1;
 
 for(i= 0; i<num_patterns; i++) {
   abs_adr= 0;
   ret= Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 4);
   if(ret<=0)
     goto ex;
   if(ret==2)
     abs_adr= 4;
 
   if(patterns[i][0]=='/' || abs_adr) {
     strcpy(dir_adr, "/");
     abs_adr= 4;
   } else {
     strcpy(dir_adr, xorriso->wdx);
     if(dir_adr[0]==0)
       strcpy(dir_adr, "/");
     ret= Sfile_type(dir_adr, 1|4);
     if(ret!=2) {
       Xorriso_msgs_submit(xorriso, 0, dir_adr, 0, "ERRFILE", 0);
       sprintf(xorriso->info_text, "Address set by -cdx is not a directory: ");
       Text_shellsafe(dir_adr, xorriso->info_text, 1);
       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
       ret= 0; goto ex;
     }
   }
 
   /* count the matches */
   was_count= count;
   ret= Xorriso_obtain_pattern_files_x(xorriso, "", dir_adr, &count, NULL, 0,
                                       mem, &dive_count, 1 | abs_adr);
   if(ret<=0)
     goto ex;
   if(was_count==count && strcmp(patterns[i],"*")!=0 && (flag&3)!=1 &&
      !(flag & 8)) {
     count++;
     ret= Xorriso_eval_nonmatch(xorriso, patterns[i],
                                &nonconst_mismatches, mem, 0);
     if(ret<=0)
       goto ex;
   }
 }
 
 ret= Xorriso_check_matchcount(xorriso, count, nonconst_mismatches,
                               num_patterns, patterns, (flag&1)|2);
 if(ret<=0)
   goto ex;
 
 count+= extra_filec;
 (*mem)+= extra_filec * sizeof(char *);
 
 if(count<=0)
   {ret= !(flag & 8); goto ex;}
 
 ret= Xorriso_alloc_pattern_mem(xorriso, *mem, count, filev, 0);
 if(ret<=0)
   goto ex;
 
 /* now store addresses */
 for(i= 0; i<num_patterns; i++) {
   abs_adr= 0;
   ret= Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 4);
   if(ret<=0)
     goto ex;
   if(ret==2)
     abs_adr= 4;
 
   if(patterns[i][0]=='/' || abs_adr) {
     strcpy(dir_adr, "/");
     abs_adr= 4;
   } else {
     strcpy(dir_adr, xorriso->wdx);
     if(dir_adr[0]==0)
       strcpy(dir_adr, "/");
   }
 
   was_filec= *filec;
   ret= Xorriso_obtain_pattern_files_x(xorriso, "", dir_adr, filec, *filev,
                                       count, mem, &dive_count, abs_adr);
   if(ret<=0)
     goto ex;
 
   if(was_filec == *filec && strcmp(patterns[i],"*")!=0 && (flag & 3) != 1 &&
      !(flag & 8)) {
     (*filev)[*filec]= strdup(patterns[i]);
     if((*filev)[*filec]==NULL) {
       (*mem)= strlen(patterns[i])+1;
       Xorriso_no_pattern_memory(xorriso, *mem, 0);
       ret= -1; goto ex;
     }
     (*filec)++;
   } 
 }
 
 ret= 1;
ex:;
 if(ret<=0) {
   if(filev!=NULL)
     Sfile_destroy_argv(&count, filev, 0);
   *filec= 0;
 }
 Xorriso_free_meM(dir_adr);
 return(ret);
}

References XorrisO::info_text, XorrisO::search_mode, Sfile_destroy_argv(), Sfile_type(), SfileadrL, XorrisO::structured_search, Text_shellsafe(), XorrisO::wdx, Xorriso_alloc_meM, Xorriso_alloc_pattern_mem(), Xorriso_check_matchcount(), Xorriso_eval_nonmatch(), Xorriso_free_meM, Xorriso_msgs_submit(), Xorriso_no_pattern_memory(), Xorriso_obtain_pattern_files_x(), and Xorriso_prepare_expansion_pattern().

Referenced by Xorriso_opt_args(), and Xorriso_option_lsx().

Xorriso_get_pattern()

char* Xorriso_get_pattern	(	struct XorrisO *	xorriso,
		struct Xorriso_lsT *	patternlist,
		int	index,
		int	flag
	)

Definition at line 321 of file match.c.

{
 int i= 0;
 struct Xorriso_lsT *s;
 
 for(s= patternlist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
   if(i == index)
     return(Xorriso_lst_get_text(s, 0));
   i++;
 }
 return(NULL);
}

References Xorriso_lst_get_next(), and Xorriso_lst_get_text().

Referenced by Xorriso_auto_driveadr(), and Xorriso_status().

Xorriso_is_in_patternlist()

int Xorriso_is_in_patternlist	(	struct XorrisO *	xorriso,
		struct Xorriso_lsT *	patternlist,
		char *	path,
		int	flag
	)

Definition at line 297 of file match.c.

{
 int ret, failed_at, i= 0;
 struct Xorriso_lsT *s;
 
 xorriso->search_mode= 3;
 xorriso->structured_search= 1;
 
 for(s= patternlist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
   ret= Xorriso_prepare_regex(xorriso, Xorriso_lst_get_text(s, 0), 0);
   if(ret <= 0)
     return(-1);
   /* Match path or parent of path */
   ret= Xorriso_regexec(xorriso, path, &failed_at, 2);
   if(ret == 0)
     return(i + 1);
   i++;
 }
 return(0);
}

References XorrisO::search_mode, XorrisO::structured_search, Xorriso_lst_get_next(), Xorriso_lst_get_text(), Xorriso_prepare_regex(), and Xorriso_regexec().

Referenced by Xorriso_auto_driveadr().

Xorriso_no_pattern_memory()

int Xorriso_no_pattern_memory	(	struct XorrisO *	xorriso,
		off_t	mem,
		int	flag
	)

Definition at line 596 of file match.c.

{
 char mem_text[80];
 
 Sfile_scale((double) mem, mem_text,5,1e4,1);
 sprintf(xorriso->info_text,
         "Cannot allocate enough memory (%s) for pattern expansion",
         mem_text);
 Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
 return(1);
}

References XorrisO::info_text, Sfile_scale(), and Xorriso_msgs_submit().

Referenced by Xorriso_alloc_pattern_mem(), Xorriso_check_for_root_pattern(), Xorriso_expand_disk_pattern(), Xorriso_expand_pattern(), Xorriso_option_not_paths(), and Xorriso_register_matched_adr().

Xorriso_prepare_expansion_pattern()

int Xorriso_prepare_expansion_pattern	(	struct XorrisO *	xorriso,
		char *	pattern,
		int	flag
	)

Definition at line 339 of file match.c.

{
 int ret, prepwd= 0;
 
 ret= Xorriso_prepare_regex(xorriso, pattern, 1|2|(flag&4));
 if(ret==2) {
   ret= Xorriso_prepare_regex(xorriso, pattern, flag&4);
   prepwd= 1;
 }
 if(ret<=0) {
   sprintf(xorriso->info_text,
           "Cannot compile pattern to regular expression:  %s", pattern);
   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
   return(0);
 }
 return(1+prepwd);
}

References XorrisO::info_text, Xorriso_msgs_submit(), and Xorriso_prepare_regex().

Referenced by Xorriso_expand_disk_pattern(), and Xorriso_expand_pattern().

Xorriso_prepare_regex()

int Xorriso_prepare_regex	(	struct XorrisO *	xorriso,
		char *	adr,
		int	flag
	)

Definition at line 38 of file match.c.

{
 int l,ret,i,count,bonked= 0,is_constant,is_still_relative= 0, adr_size;
 char *cpt,*npt,*adr_part= NULL, *absolute_adr= NULL, *adr_start,*wd;
 
 adr_size= 2 * SfileadrL;
 Xorriso_alloc_meM(adr_part, char, adr_size);
 Xorriso_alloc_meM(absolute_adr, char, adr_size);
 
 if(flag&4)
   wd= xorriso->wdx;
 else
   wd= xorriso->wdi;
 
 if(xorriso->search_mode>=2 && xorriso->search_mode<=4) {
   if(xorriso->search_mode==3 || xorriso->search_mode==4) {
     l= strlen(adr)+strlen(wd)+1;
     if(l * 2 + 2 > ((int) sizeof(xorriso->reg_expr)) || l * 2 + 2 > adr_size){
       sprintf(xorriso->info_text,"Search pattern too long");
       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
       {ret= 0; goto ex;}
     }
   }
   Xorriso_destroy_re(xorriso,0);
   if(xorriso->structured_search && xorriso->search_mode==3) {
     if(adr[0]!='/')
       is_still_relative= 1;
     if(is_still_relative && !(flag&1)) {
       /* relative expression : prepend working directory */
       sprintf(absolute_adr,"%s/%s",wd,adr);
       adr_start= absolute_adr;
       xorriso->prepended_wd= 1;
       is_still_relative= 0;
     } else
       adr_start= adr;
     /* count slashes */;
     cpt= adr_start;
     while(*cpt=='/')
       cpt++;
     for(i= 0;1;i++) {
       cpt= strchr(cpt,'/');
       if(cpt==NULL)
     break;
       while(*cpt=='/')
         cpt++;
     }
     count= i+1;
     xorriso->re= TSOB_FELD(regex_t,count);
     if(xorriso->re==NULL)
       {ret= -1; goto ex;}
     xorriso->re_constants= TSOB_FELD(char *,count);
     if(xorriso->re_constants==NULL)
       {ret= -1; goto ex;}
     for(i= 0;i<count;i++)
       xorriso->re_constants[i]= NULL;
     xorriso->re_count= count;
     xorriso->re_fill= 0;
       
     /* loop over slash chunks*/;
     cpt= adr_start;
     xorriso->re_fill= 0;
     while(*cpt=='/')
       cpt++;
     for(i= 0;i<count;i++) {
       npt= strchr(cpt,'/');
       if(npt==NULL) {
         if((int) strlen(cpt) >= adr_size)
           {ret= -1; goto ex;}
         strcpy(adr_part,cpt);
       } else {
         if(npt-cpt >= adr_size)
           {ret= -1; goto ex;}
         strncpy(adr_part,cpt,npt-cpt);
         adr_part[npt-cpt]= 0;
       }
 
       if(adr_part[0]==0)
         goto next_adr_part;
       if(adr_part[0] == '.' && adr_part[1] == 0)
         goto next_adr_part;
       if(adr_part[0]=='.' && adr_part[1]=='.' && adr_part[2]==0) {
         /* delete previous part */
         if(xorriso->re_fill <= 0) {
           bonked= 1;
           goto next_adr_part;
         } 
         if(xorriso->re_constants[xorriso->re_fill-1]!=NULL) {
           free(xorriso->re_constants[xorriso->re_fill-1]);
           xorriso->re_constants[xorriso->re_fill-1]= NULL;
         } else
           regfree(&(xorriso->re[xorriso->re_fill-1]));
         (xorriso->re_fill)--;
         goto next_adr_part;
       }
       if(strcmp(adr_part,"*")==0) {
         adr_part[0]= 0;
         ret= 2;
       } else
         ret= Xorriso__bourne_to_reg(adr_part,xorriso->reg_expr,0);
       if(ret==2) {
         if(Sregex_string(&(xorriso->re_constants[xorriso->re_fill]),adr_part,0)
            <=0)
           {ret= -1; goto ex;}
       } else {
         if(regcomp(&(xorriso->re[xorriso->re_fill]),xorriso->reg_expr,0)!=0)
           goto cannot_compile;
       }
       xorriso->re_fill++;
next_adr_part:;
       if(i==count-1)
     break;
       cpt= npt+1;
       while(*cpt=='/')
         cpt++;
     }
     if(bonked) {
       if(flag&2)
         {ret= 2; goto ex;}
       sprintf(xorriso->info_text, "Your '..' bonked at the %s directory.",
               is_still_relative ? "working" : "root");
       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE",0);
       {ret= 0; goto ex;}
     }
     if(xorriso->re_fill == 0 && is_still_relative) {
       /* "." and its equivalents end up here */
       if(Sregex_string(&(xorriso->re_constants[0]), ".", 0) <=0)
         {ret= -1; goto ex;}  
       xorriso->re_fill= 1;
     }
 
     Xorriso__bourne_to_reg(adr_start,xorriso->reg_expr,0); /* just for show */
 
   } else { 
     is_constant= 0;
     if(strcmp(adr,"*")==0 || adr[0]==0) {
       is_constant= 1;
     } else if(xorriso->search_mode==3 || xorriso->search_mode==4) {
       ret= Xorriso__bourne_to_reg(adr,xorriso->reg_expr,0);
       is_constant= (ret==2);
     } else {
       if(strlen(adr)>=sizeof(xorriso->reg_expr))
         {ret= -1; goto ex;}
       strcpy(xorriso->reg_expr,adr);
     }
     xorriso->re_count= 0; /* tells matcher that this is not structured */
     xorriso->re_constants= TSOB_FELD(char *,1);
     if(xorriso->re_constants==NULL)
       {ret= -1; goto ex;}
     xorriso->re_constants[0]= NULL;
     if(is_constant) {
       if(strcmp(adr,"*")==0) {
         if(Sregex_string(&(xorriso->re_constants[0]),"",0)<=0)
           {ret= -1; goto ex;}
       } else {
         if(Sregex_string(&(xorriso->re_constants[0]),adr,0)<=0)
           {ret= -1; goto ex;}
       }
       xorriso->re_fill= 1;
     } else { 
       xorriso->re= TSOB_FELD(regex_t,1);
       if(xorriso->re==NULL)
         {ret= -1; goto ex;}
       if(regcomp(&(xorriso->re[0]),xorriso->reg_expr,0)!=0) {
cannot_compile:;
         sprintf(xorriso->info_text, "Cannot compile regular expression : %s",
                 xorriso->reg_expr);
         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE",0);
         {ret= 0; goto ex;}
       }
     }
 
   }
 }
 ret= 1;
ex:;
 Xorriso_free_meM(adr_part);
 Xorriso_free_meM(absolute_adr);
 return(ret);
}

References XorrisO::info_text, XorrisO::prepended_wd, XorrisO::re, XorrisO::re_constants, XorrisO::re_count, XorrisO::re_fill, XorrisO::reg_expr, XorrisO::search_mode, SfileadrL, Sregex_string(), XorrisO::structured_search, TSOB_FELD, XorrisO::wdi, XorrisO::wdx, Xorriso__bourne_to_reg(), Xorriso_alloc_meM, Xorriso_destroy_re(), Xorriso_free_meM, and Xorriso_msgs_submit().

Referenced by Xorriso_is_in_patternlist(), and Xorriso_prepare_expansion_pattern().

Xorriso_regexec()

int Xorriso_regexec	(	struct XorrisO *	xorriso,
		char *	to_match,
		int *	failed_at,
		int	flag
	)

Definition at line 225 of file match.c.

{
 int ret,i,re_start= 0,reg_nomatch= -1;
 char *cpt,*npt, *adr_part= NULL, *mpt;
 
 Xorriso_alloc_meM(adr_part, char, SfileadrL);
 
 reg_nomatch= REG_NOMATCH;
 
 *failed_at= 0;
 if(!(xorriso->structured_search && xorriso->re_count>0)) {
   if(xorriso->re_constants!=NULL)
     if(xorriso->re_constants[0]!=NULL) {
       if(xorriso->re_constants[0][0]==0)
         {ret= 0; goto ex;}
       if(strcmp(xorriso->re_constants[0],to_match)!=0)
         {ret= reg_nomatch; goto ex;}
       {ret= 0; goto ex;}
     }  
   ret= regexec(&(xorriso->re[0]),to_match,1,xorriso->match,0);
   goto ex;
 }
 
 cpt= to_match;
 while(*cpt=='/')
  cpt++;
 if(flag&4)
   re_start= xorriso->re_failed_at;
 if(re_start<0)
   re_start= 0;
 for(i= re_start;i<xorriso->re_fill;i++) {
   *failed_at= i;
   npt= strchr(cpt,'/');
   if(npt==NULL) {
     if(i<xorriso->re_fill-1 && !(flag&1)) 
       {ret= reg_nomatch; goto ex;} /* this must be the last expression part */
     mpt= cpt;
   } else {
     strncpy(adr_part,cpt,npt-cpt);
     adr_part[npt-cpt]= 0;
     mpt= adr_part;
   }
   if(xorriso->re_constants[i]!=NULL) {
     if(xorriso->re_constants[i][0]!=0) /* empty constant matches anything */
       if(strcmp(xorriso->re_constants[i],mpt)!=0)
         {ret= reg_nomatch; goto ex;}
   } else {
     ret= regexec(&(xorriso->re[i]),mpt,1,xorriso->match,0);
     if(ret!=0)
       goto ex;
   }
   if(npt==NULL) {
     if(i>=xorriso->re_fill-1)
       {ret= 0; goto ex;} /* MATCH */
     *failed_at= i+1;
     {ret= reg_nomatch; goto ex;}
   }
   cpt= npt+1;
   while(*cpt=='/')
     cpt++; 
 }
 *failed_at= xorriso->re_fill;
 if(flag & 2)
   {ret= 0; goto ex;} /* MATCH */
 ret= reg_nomatch;
ex:;
 Xorriso_free_meM(adr_part);
 return(ret);
}

References XorrisO::match, XorrisO::re, XorrisO::re_constants, XorrisO::re_count, XorrisO::re_failed_at, XorrisO::re_fill, SfileadrL, XorrisO::structured_search, Xorriso_alloc_meM, and Xorriso_free_meM.

Referenced by Xorriso_is_in_patternlist(), Xorriso_ls(), Xorriso_obtain_pattern_files_i(), Xorriso_obtain_pattern_files_x(), and Xorriso_sorted_node_array().

Xorriso_register_matched_adr()

int Xorriso_register_matched_adr	(	struct XorrisO *	xorriso,
		char *	adr,
		int	count_limit,
		int *	filec,
		char **	filev,
		off_t *	mem,
		int	flag
	)

Definition at line 396 of file match.c.

{
 int l;
 
 if(flag&1) {
   (*filec)++;
   l= strlen(adr)+1;
   (*mem)+= sizeof(char *)+l;
   if(l % sizeof(char *))
     (*mem)+= sizeof(char *)-(l % sizeof(char *));
 } else {
   if(*filec >= count_limit) {
     sprintf(xorriso->info_text,
         "Number of matching files changed unexpectedly (> %d)",
         count_limit);
     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
                         (flag&2 ? "FATAL" : "WARNING"), 0);
     return(flag&2 ? -1 : 0);
   }
   filev[*filec]= strdup(adr);
   if(filev[*filec]==NULL) {
     Xorriso_no_pattern_memory(xorriso, (off_t) (strlen(adr)+1), 0);
     return(-1);
   }
   (*filec)++;
 }
 return(1);
}

References XorrisO::info_text, Xorriso_msgs_submit(), and Xorriso_no_pattern_memory().

Referenced by Xorriso_obtain_pattern_files_i(), and Xorriso_obtain_pattern_files_x().

Xorriso_warn_of_wildcards()

int Xorriso_warn_of_wildcards	(	struct XorrisO *	xorriso,
		char *	path,
		int	flag
	)

Definition at line 764 of file match.c.

{
 static int count_iso= 0, count_disk= 0, max_iso= 3, max_disk= 3;
 
 if(strchr(path,'*')!=NULL || strchr(path,'?')!=NULL ||
    strchr(path,'[')!=NULL) {
   if(flag & 2) {
     count_disk++;
     if(count_disk > max_disk)
       return(1);
   } else {
     count_iso++;
     if(count_iso > max_iso)
       return(1);
   }
   if(flag&1) {
     sprintf(xorriso->info_text,
      "Pattern expansion of wildcards \"*?[\" does not apply to this command");
   } else {
     sprintf(xorriso->info_text,
            "Pattern expansion of wildcards \"*?[\" is disabled by command %s",
            (flag&2) ? "-disk_pattern or -pathspecs" : "-iso_rr_pattern");
   }
   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
   sprintf(xorriso->info_text,"Pattern seen: ");
   Text_shellsafe(path, xorriso->info_text, 1);
   strcat(xorriso->info_text, "\n");
   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
   return(1);
 }
 return(0);
}

References XorrisO::info_text, Text_shellsafe(), and Xorriso_msgs_submit().

Referenced by Xorriso_end_idx(), Xorriso_option_cdi(), and Xorriso_option_cdx().