splash.h

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C头文件 代码 · 共 697 行 · 第 1/2 页

/*
 * Version 1.7
 * Written by Jim Morris,  [e-mail]
 * Kudos to Larry Wall for inventing Perl
 * Copyrights only exist on the regex stuff, and all have been left intact.
 * The only thing I ask is that you let me know of any nifty fixes or
 * additions.
 * 
 * Credits:
 * I'd like to thank Michael Golan <[e-mail]> for his critiques
 * and clever suggestions. Some of which have actually been implemented
 */

#ifndef _SPLASH_H
#define _SPLASH_H

#include <string.h>
#include "regexp.h"

#if     DEBUG
#include        <stdio.h>
#endif

#define INLINE  inline

// This is the base class for SPList, it handles the underlying
// dynamic array mechanism

template<class T>
class SPListBase
{
private:
    enum{ALLOCINC=20};
    T *a;
    int cnt;
    int first;
    int allocated;
    int allocinc;
    void grow(int amnt= 0, int newcnt= -1);

protected:
    void compact(const int i);

public:
#ifdef  USLCOMPILER
    // USL 3.0 bug with enums losing the value
    SPListBase(int n= 20)
#else
    SPListBase(int n= ALLOCINC)
#endif
    {
        a= new T[n];
        cnt= 0;
        first= n>>1;
        allocated= n;
        allocinc= n;
#       ifdef   DEBUG
        fprintf(stderr, "SPListBase(int %d) a= %p\n", allocinc, a);
#       endif
    }

    SPListBase(const SPListBase<T>& n);
    SPListBase<T>& SPListBase<T>::operator=(const SPListBase<T>& n);
    virtual ~SPListBase(){
#       ifdef   DEBUG
        fprintf(stderr, "~SPListBase() a= %p, allocinc= %d\n", a, allocinc);
#       endif
        delete [] a;
        a = (T *) 0x11dddd;
    }

    INLINE T& operator[](const int i);
    INLINE const T& operator[](const int i) const;

    int count(void) const{ return cnt; }

    void add(const T& n);
    void add(const int i, const T& n);
    void erase(void){ cnt= 0; first= (allocated>>1);}
};

// SPList
class SPStringList;

template <class T>
class SPList: private SPListBase<T>
{
public:

    SPList(int sz= 10): SPListBase<T>(sz){}

    // stuff I want public to see from SPListBase
    T& operator[](const int i){return SPListBase<T>::operator[](i);}
    const T& operator[](const int i) const{return SPListBase<T>::operator[](i);}
    SPListBase<T>::count;   // some compilers don't like this

    // add perl-like synonyms
    void reset(void){ erase(); }
    int scalar(void) const { return count(); }

    operator void*() { return count()?this:0; } // so it can be used in tests
    int isempty(void) const{ return !count(); } // for those that don't like the above (hi michael)

    T pop(void)
    {
        T tmp;
        int n= count()-1;
        if(n >= 0){
            tmp= (*this)[n];
            compact(n);
        }
        return tmp;
    }

    void push(const T& a){ add(a);}
    void push(const SPList<T>& l);

    T shift(void)
    {
        T tmp= (*this)[0];
        compact(0);
        return tmp;
    }
    
    int unshift(const T& a)
    {
        add(0, a);
        return count();
    }
    
    int unshift(const SPList<T>& l);

    SPList<T> reverse(void);
    SPList<T> sort();
    
    SPList<T> splice(int offset, int len, const SPList<T>& l);
    SPList<T> splice(int offset, int len);
    SPList<T> splice(int offset);
};

// just a mechanism for self deleteing strings which can be hacked
class TempString
{
private:
    char *str;
public:
    TempString(const char *s)    
    {
        str= new char[strlen(s) + 1];
        strcpy(str, s);
    }
    
    TempString(const char *s, int len)    
    {
        str= new char[len + 1];
        if(len) strncpy(str, s, len);
        str[len]= '\0';
    }

    ~TempString(){ delete [] str; str = (char*) 0x22dddd; }

    operator char*() const { return str; }
};

/*
 * This class takes care of the mechanism behind variable length strings
 */

class VarString
{
private:
    enum{ALLOCINC=32};
    char *a;
    int len;
    int allocated;
    int allocinc;
    INLINE void grow(int n= 0);

public:
#ifdef  USLCOMPILER
    // USL 3.0 bug with enums losing the value
    INLINE VarString(int n= 32);
#else
    INLINE VarString(int n= ALLOCINC);
#endif

    INLINE VarString(const VarString& n);
    INLINE VarString(const char *);
    INLINE VarString(const char* s, int n);
    INLINE VarString(char);

    ~VarString(){
#       ifdef   DEBUG
        fprintf(stderr, "~VarString() a= %p, allocinc= %d\n", a, allocinc);
#       endif
        delete [] a;
        a = (char *) 0x33dddd;
    }

    VarString& operator=(const VarString& n);
    VarString& operator=(const char *);

    INLINE const char operator[](const int i) const;
    INLINE char& operator[](const int i);

    operator const char *() const{ return a; }

    int length(void) const{ return len; }

    void add(char);
    void add(const char *);
    void add(int, const char *);
    void remove(int, int= 1);

    void erase(void){ len= 0; }
};

class SPStringList;
//
// Implements the perl specific string functionality 
//
class SPString
{
private:
    VarString pstr;  // variable length string mechanism
    
    class substring;
public:
    
    SPString():pstr(){}
    SPString(const SPString& n) : pstr(n.pstr){}     
    SPString(const char *s) : pstr(s){}
    SPString(const char c) : pstr(c){}
    SPString(const substring& sb) : pstr(sb.pt, sb.len){}
    
    SPString& operator=(const char *s){pstr= s; return *this;}        
    SPString& operator=(const SPString& n); 
    SPString& operator=(const substring& sb);

    operator const char*() const{return pstr;}
    const char operator[](int n) const{ return pstr[n]; }

    int length(void) const{ return pstr.length(); }
    
    char chop(void);
    
    int index(const SPString& s, int offset= 0);    
    int rindex(const SPString& s, int offset= -1);
    substring substr(int offset, int len= -1);
    substring substr(const Range& r){ return substr(r.start(), r.length());}
        
    int m(const char *, const char *opts=""); // the regexp match m/.../ equiv
    int m(Regexp&);
    int m(const char *, SPStringList&, const char *opts="");
    int m(Regexp&, SPStringList&);
   
    int tr(const char *, const char *, const char *opts="");
    int s(const char *, const char *, const char *opts="");

    SPStringList split(const char *pat= "[ \t\n]+", int limit= -1);
    
    int operator<(const SPString& s) const { return (strcmp(pstr, s) < 0); }
    int operator>(const SPString& s) const { return (strcmp(pstr, s) > 0); }
    int operator<=(const SPString& s) const { return (strcmp(pstr, s) <= 0); }
    int operator>=(const SPString& s) const { return (strcmp(pstr, s) >= 0); }
    int operator==(const SPString& s) const { return (strcmp(pstr, s) == 0); }
    int operator!=(const SPString& s) const { return (strcmp(pstr, s) != 0); }
    SPString operator+(const SPString& s) const;
    SPString operator+(const char *s) const;
    SPString operator+(char c) const;
    friend SPString operator+(const char *s1, const SPString& s2);

    SPString& operator+=(const SPString& s){pstr.add(s); return *this;}
    SPString& operator+=(const char *s){pstr.add(s); return *this;}
    SPString& operator+=(char c){pstr.add(c); return *this;}
    friend class substring;

private:
    void insert(int pos, int len, const char *pt, int nlen);

    // This idea lifted from NIH class library -
    // to handle substring LHS assignment
    // Note if subclasses can't be used then take external and make
    // the constructors private, and specify friend SPString
    class substring
    {
    public:
        int pos, len;
        SPString& str;
        char *pt;
    public:
        substring(SPString& os, int p, int l) : str(os)
        {
            if(p > os.length()) p= os.length();
            if((p+l) > os.length()) l= os.length() - p;
            pos= p; len= l;
            if(p == os.length()) pt= 0; // append to end of string
            else pt= &os.pstr[p];
        }

        void operator=(const SPString& s)
        {
            if(&str == &s){ // potentially overlapping
                VarString tmp(s);
                str.insert(pos, len, tmp, strlen(tmp));
            }else str.insert(pos, len, s, s.length());
        }
        
        void operator=(const substring& s)
        {
            if(&str == &s.str){ // potentially overlapping
                VarString tmp(s.pt, s.len);
                str.insert(pos, len, tmp, strlen(tmp));
            }else str.insert(pos, len, s.pt, s.len);
        }

        void operator=(const char *s)
        {
            str.insert(pos, len, s, strlen(s));
        }
    };
};

class SPStringList: public SPList<SPString>
{
public:
    SPStringList(int sz= 6):SPList<SPString>(sz){}
    // copy lists, need to duplicate all internal strings
    SPStringList(const SPStringList& n);

    SPStringList& operator=(const SPList<SPString>& n);
 
    int split(const char *str, const char *pat= "[ \t\n]+", int limit= -1);
    SPString join(const char *pat= " ");
    int m(const char *rege, const char *targ, const char *opts=""); // makes list of sub exp matches
    SPStringList grep(const char *rege, const char *opts=""); // trys rege against elements in list
};

// This doesn't belong in any class
inline SPStringList m(const char *pat, const char *str, const char *opts="")
{
SPStringList l;
    
    l.m(pat, str, opts);
    l.shift(); // remove the first element which would be $&
    return l;
}

// Streams operators