From 3c9817f94592907c8c19a8b8f97af87dad3dceaf Mon Sep 17 00:00:00 2001
From: John Denker <jsd@av8n.com>
Date: Thu, 22 Nov 2012 16:01:04 -0800
Subject: move case-insensitive string stuff to utils.h
---
tools/mail-scan.c | 54 ------------------------------------------------------
tools/skrewt.c | 54 ------------------------------------------------------
tools/utils.c | 28 ++++++++++++++++++++++++++++
tools/utils.h | 29 +++++++++++++++++++++++++++++
tools/ward.c | 54 ------------------------------------------------------
5 files changed, 57 insertions(+), 162 deletions(-)
(limited to 'tools')
diff --git a/tools/mail-scan.c b/tools/mail-scan.c
index 058caed..3100ab6 100644
--- a/tools/mail-scan.c
+++ b/tools/mail-scan.c
@@ -61,49 +61,6 @@ const int sa_good(0);
const int sa_spam(1);
const int sa_usage(64);
-/////////////////////////////////////////////////////////
-// Case insensitive comparison of strings
-
-class lessthan_foldcase{
-public:
- bool operator() (const std::string& a, const std::string& b) const {
- size_t a_len = a.length();
- size_t b_len = b.length();
-
- size_t lim = a_len < b_len ? a_len : b_len;
-
- for (size_t i=0; i<lim; ++i)
- {
- char cha = toupper(a[i]);
- char chb = toupper(b[i]);
-
- if (cha < chb) return true;
- if (cha > chb) return false;
- }
- // here if one is an extension of the other
- if ( a_len < b_len ) return true;
- return false;
- }
-};
-
-
-// Returns negative if a is less than b in alphabetical order
-// returns 0 if they are the same, or positive if a is greater.
-// Like perl cmp operator, but ignores case.
-int cmp_casefold(const std::string& a, const std::string& b) {
- string::const_iterator aa, bb;
- aa = a.begin();
- bb = b.begin();
- while (aa != a.end() && bb != b.end()){
- char ca = tolower(*aa++);
- char cb = tolower(*bb++);
- if (ca != cb) return ca < cb ? -2 : 2;
- }
- if (aa != a.end()) return 1; // a is longer
- if (bb != b.end()) return -1; // b is longer
- return 0;
-}
-
void exeunt(const int sts){
if (sts == sa_good) exit(sts);
@@ -158,17 +115,6 @@ public:
}
};
-string noCR(const string bar){
- string foo(bar);
- int len = foo.length();
- if (len){
- if (foo[len-1] == '\r') {
- foo.erase(len-1);
- }
- }
- return foo;
-}
-
////////////////////////////////////////////////////////////
int main(int _argc, const char** _argv){
//// pid_t pid = getpid();
diff --git a/tools/skrewt.c b/tools/skrewt.c
index 70265da..540b1cf 100644
--- a/tools/skrewt.c
+++ b/tools/skrewt.c
@@ -41,60 +41,6 @@ void usage(const int sts){
#include "utils.h"
#include "sepofra.h"
-/////////////////////////////////////////////////////////
-// Case insensitive comparison of strings
-
-class lessthan_foldcase{
-public:
- bool operator() (const std::string& a, const std::string& b) const {
- size_t a_len = a.length();
- size_t b_len = b.length();
-
- size_t lim = a_len < b_len ? a_len : b_len;
-
- for (size_t i=0; i<lim; ++i)
- {
- char cha = toupper(a[i]);
- char chb = toupper(b[i]);
-
- if (cha < chb) return true;
- if (cha > chb) return false;
- }
- // here if one is an extension of the other
- if ( a_len < b_len ) return true;
- return false;
- }
-};
-
-
-// Returns negative if a is less than b in alphabetical order
-// returns 0 if they are the same, or positive if a is greater.
-// Like perl cmp operator, but ignores case.
-int cmp_casefold(const std::string& a, const std::string& b) {
- string::const_iterator aa, bb;
- aa = a.begin();
- bb = b.begin();
- while (aa != a.end() && bb != b.end()){
- char ca = tolower(*aa++);
- char cb = tolower(*bb++);
- if (ca != cb) return ca < cb ? -2 : 2;
- }
- if (aa != a.end()) return 1; // a is longer
- if (bb != b.end()) return -1; // b is longer
- return 0;
-}
-
-string noCR(const string bar){
- string foo(bar);
- int len = foo.length();
- if (len){
- if (foo[len-1] == '\r') {
- foo.erase(len-1);
- }
- }
- return foo;
-}
-
void maybe_exeunt(const int sts, const int really){
if (!really) return;
if (sts == ex_good) exit(sts);
diff --git a/tools/utils.c b/tools/utils.c
index a7c2878..6dbbff4 100644
--- a/tools/utils.c
+++ b/tools/utils.c
@@ -87,3 +87,31 @@ string purify(const string arg){
}
return rslt;
}
+
+// Returns negative if a is less than b in alphabetical order
+// returns 0 if they are the same, or positive if a is greater.
+// Like perl cmp operator, but ignores case.
+int cmp_casefold(const std::string& a, const std::string& b) {
+ string::const_iterator aa, bb;
+ aa = a.begin();
+ bb = b.begin();
+ while (aa != a.end() && bb != b.end()){
+ char ca = tolower(*aa++);
+ char cb = tolower(*bb++);
+ if (ca != cb) return ca < cb ? -2 : 2;
+ }
+ if (aa != a.end()) return 1; // a is longer
+ if (bb != b.end()) return -1; // b is longer
+ return 0;
+}
+
+string noCR(const string bar){
+ string foo(bar);
+ int len = foo.length();
+ if (len){
+ if (foo[len-1] == '\r') {
+ foo.erase(len-1);
+ }
+ }
+ return foo;
+}
diff --git a/tools/utils.h b/tools/utils.h
index 4f5418f..77cff5e 100644
--- a/tools/utils.h
+++ b/tools/utils.h
@@ -1,6 +1,35 @@
#include <string>
#include <list>
+std::string noCR(const std::string bar);
+int cmp_casefold(const std::string& a, const std::string& b);
+
+/////////////////////////////////////////////////////////
+// Case insensitive comparison of strings
+
+class lessthan_foldcase{
+public:
+ bool operator() (const std::string& a, const std::string& b) const {
+ size_t a_len = a.length();
+ size_t b_len = b.length();
+
+ size_t lim = a_len < b_len ? a_len : b_len;
+
+ for (size_t i=0; i<lim; ++i)
+ {
+ char cha = toupper(a[i]);
+ char chb = toupper(b[i]);
+
+ if (cha < chb) return true;
+ if (cha > chb) return false;
+ }
+ // here if one is an extension of the other
+ if ( a_len < b_len ) return true;
+ return false;
+ }
+};
+
+
std::string basename(const std::string path);
int prefix(const std::string shorter, const std::string longer);
std::string time_out(const int _ttt);
diff --git a/tools/ward.c b/tools/ward.c
index 70265da..540b1cf 100644
--- a/tools/ward.c
+++ b/tools/ward.c
@@ -41,60 +41,6 @@ void usage(const int sts){
#include "utils.h"
#include "sepofra.h"
-/////////////////////////////////////////////////////////
-// Case insensitive comparison of strings
-
-class lessthan_foldcase{
-public:
- bool operator() (const std::string& a, const std::string& b) const {
- size_t a_len = a.length();
- size_t b_len = b.length();
-
- size_t lim = a_len < b_len ? a_len : b_len;
-
- for (size_t i=0; i<lim; ++i)
- {
- char cha = toupper(a[i]);
- char chb = toupper(b[i]);
-
- if (cha < chb) return true;
- if (cha > chb) return false;
- }
- // here if one is an extension of the other
- if ( a_len < b_len ) return true;
- return false;
- }
-};
-
-
-// Returns negative if a is less than b in alphabetical order
-// returns 0 if they are the same, or positive if a is greater.
-// Like perl cmp operator, but ignores case.
-int cmp_casefold(const std::string& a, const std::string& b) {
- string::const_iterator aa, bb;
- aa = a.begin();
- bb = b.begin();
- while (aa != a.end() && bb != b.end()){
- char ca = tolower(*aa++);
- char cb = tolower(*bb++);
- if (ca != cb) return ca < cb ? -2 : 2;
- }
- if (aa != a.end()) return 1; // a is longer
- if (bb != b.end()) return -1; // b is longer
- return 0;
-}
-
-string noCR(const string bar){
- string foo(bar);
- int len = foo.length();
- if (len){
- if (foo[len-1] == '\r') {
- foo.erase(len-1);
- }
- }
- return foo;
-}
-
void maybe_exeunt(const int sts, const int really){
if (!really) return;
if (sts == ex_good) exit(sts);
--
cgit v1.2.3