Refactoring: Rename CONNECTION.res_stat to .proc_stat

[ngircd-alex.git] / src / ngircd / match.c

diff --git a/src/ngircd/match.c b/src/ngircd/match.c
index 437b537ff062d72974b4c87bd8ea972a1ccb2a63..5e97e71fc15e5476b2f7935b75d2a0d4ebc35330 100644 (file)
--- a/src/ngircd/match.c
+++ b/src/ngircd/match.c
@@ -2,27 +2,28 @@
  * ngIRCd -- The Next Generation IRC Daemon
  * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
  *
- * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
- * der GNU General Public License (GPL), wie von der Free Software Foundation
- * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
- * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
- * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
- * der an ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS.
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * Please read the file COPYING, README and AUTHORS for more information.
  *
- * $Id: match.c,v 1.1 2002/06/26 15:42:58 alex Exp $
- *
- * match.c: Wildcard Pattern Matching
+ * Wildcard pattern matching
  */
 
 
 #include "portab.h"
 
+static char UNUSED id[] = "$Id: match.c,v 1.5 2006/10/06 21:23:47 fw Exp $";
+
 #include "imp.h"
 #include <assert.h>
 #include <string.h>
 
 #include "exp.h"
 #include "match.h"
+#include "defines.h"
+#include "tool.h"
 
 
 /*
@@ -33,8 +34,8 @@
  */
 
 
-LOCAL INT Matche PARAMS(( REGISTER CHAR *p, REGISTER CHAR *t ));
-LOCAL INT Matche_After_Star PARAMS(( REGISTER CHAR *p, REGISTER CHAR *t ));
+static int Matche PARAMS(( const char *p, const char *t ));
+static int Matche_After_Star PARAMS(( const char *p, const char *t ));
 
 
 #define MATCH_PATTERN  6       /* bad pattern */
@@ -45,22 +46,32 @@ LOCAL INT Matche_After_Star PARAMS(( REGISTER CHAR *p, REGISTER CHAR *t ));
 #define MATCH_VALID    1       /* valid match */
 
 
-GLOBAL BOOLEAN
-Match( CHAR *Pattern, CHAR *String )
+GLOBAL bool
+Match( const char *Pattern, const char *String )
 {
        /* Pattern mit String vergleichen */
-       if( Matche( Pattern, String ) == MATCH_VALID ) return TRUE;
-       else return FALSE;
+       if( Matche( Pattern, String ) == MATCH_VALID ) return true;
+       else return false;
 } /* Match */
 
 
-LOCAL INT
-Matche( REGISTER CHAR *p, REGISTER CHAR *t )
+GLOBAL bool
+MatchCaseInsensitive(const char *pattern, const char *searchme)
+{
+       char haystack[COMMAND_LEN];
+
+       strlcpy(haystack, searchme, sizeof(haystack));
+       return Match(pattern, ngt_LowerStr(haystack));
+} /* MatchCaseInsensitive */
+
+
+static int
+Matche( const char *p, const char *t )
 {
-       REGISTER CHAR range_start, range_end;
-       BOOLEAN invert;
-       BOOLEAN member_match;
-       BOOLEAN loop;
+       register char range_start, range_end;
+       bool invert;
+       bool member_match;
+       bool loop;
 
        for( ; *p; p++, t++ )
        {
@@ -84,25 +95,25 @@ Matche( REGISTER CHAR *p, REGISTER CHAR *t )
                                p++;
 
                                /* check if this is a member match or exclusion match */
-                               invert = FALSE;
+                               invert = false;
                                if( *p == '!' || *p == '^' )
                                {
-                                       invert = TRUE;
+                                       invert = true;
                                        p++;
                                }
 
                                /* if closing bracket here or at range start then we have a malformed pattern */
                                if ( *p == ']' ) return MATCH_PATTERN;
 
-                               member_match = FALSE;
-                               loop = TRUE;
+                               member_match = false;
+                               loop = true;
 
                                while( loop )
                                {
                                        /* if end of construct then loop is done */
                                        if( *p == ']' )
                                        {
-                                               loop = FALSE;
+                                               loop = false;
                                                continue;
                                        }
 
@@ -141,16 +152,16 @@ Matche( REGISTER CHAR *p, REGISTER CHAR *t )
                                        {
                                                if( *t >= range_start && *t <= range_end )
                                                {
-                                                       member_match = TRUE;
-                                                       loop = FALSE;
+                                                       member_match = true;
+                                                       loop = false;
                                                }
                                        }
                                        else
                                        {
                                                if( *t >= range_end && *t <= range_start )
                                                {
-                                                       member_match = TRUE;
-                                                       loop = FALSE;
+                                                       member_match = true;
+                                                       loop = false;
                                                }
                                        }
                                }
@@ -201,10 +212,10 @@ Matche( REGISTER CHAR *p, REGISTER CHAR *t )
 } /* Matche */
 
 
-LOCAL INT
-Matche_After_Star( REGISTER CHAR *p, REGISTER CHAR *t )
+static int
+Matche_After_Star( const char *p, const char *t )
 {
-       REGISTER INT nextp, match = 0;
+       register int nextp, match = 0;
 
        /* pass over existing ? and * in pattern */
        while( *p == '?' || *p == '*' )