/*

 * lftp - file transfer program

 *

 * Copyright (c) 1996-2017 by Alexander V. Lukyanov (lav@yars.free.net)

 *

 * 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 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef XSTRING_H

#define XSTRING_H

/* Declare string and memory handling routines.  Take care that an ANSI

   string.h and pre-ANSI memory.h might conflict, and that memory.h and

   strings.h conflict on some systems.  */

#if STDC_HEADERS || HAVE_STRING_H

# include <string.h>

# if !STDC_HEADERS && HAVE_MEMORY_H

#  include <memory.h>

# endif

#else

# include <strings.h>

# ifndef strchr

#  define strchr index

# endif

# ifndef strrchr

#  define strrchr rindex

# endif

# ifndef memcpy

#  define memcpy(Dst, Src, Num) bcopy (Src, Dst, Num)

# endif

# ifndef memcmp

#  define memcmp(Src1, Src2, Num) bcmp (Src1, Src2, Num)

# endif

#endif

#include <stdarg.h>

#include <unistd.h>

#define string_alloca(len)      ((char*)alloca((len)))

#if !HAVE_DECL_STRCASECMP

CDECL int strcasecmp(const char *s1,const char *s2);

CDECL int strncasecmp(const char *s1,const char *s2,size_t n);

#endif

#if !HAVE_DECL_VSNPRINTF

CDECL int vsnprintf(char *,size_t,const char *,va_list);

#endif

#if !HAVE_DECL_SNPRINTF

CDECL int snprintf(char *,size_t,const char *,...);

#endif

static inline int xstrcmp(const char *s1,const char *s2)

{

   if(s1==s2)

      return 0;

   if(s1==0 || s2==0)

      return 1;

   return strcmp(s1,s2);

}

static inline int xstrncmp(const char *s1,const char *s2,size_t len)

{

   if(s1==s2 || len==0)

      return 0;

   if(s1==0 || s2==0)

      return 1;

   return strncmp(s1,s2,len);

}

static inline int xstrcasecmp(const char *s1,const char *s2)

{

   if(s1==s2)

      return 0;

   if(s1==0 || s2==0)

      return 1;

   return strcasecmp(s1,s2);

}

static inline size_t xstrlen(const char *s)

{

   if(s==0)

      return 0;

   return strlen(s);

}

#include <stdarg.h>

#include "xmalloc.h"

/* this is a small and fast dynamic string class */

/* mostly used as xstrdup/xfree replacement */

enum { URL_DECODE_PLUS=1, URL_ALLOW_8BIT=2 };

class xstring0 // base class

{

protected:

   char *buf;

   xstring0() {}

   xstring0(const xstring0&); // disable cloning

   int _url_decode(size_t len,int flags);

   int _hex_decode(size_t len);

public:

   ~xstring0() { xfree(buf); }

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

   const char *get() const { return buf; }

   char *get_non_const() { return buf; }

   void _clear() { buf=0; }

};

// compact variant

class xstring_c : public xstring0

{

   // make xstring_c = xstrdup() fail:

   xstring_c& operator=(char *);

   const char *operator=(const char *s);

   const char *operator=(const xstring_c& s);

   xstring_c(const xstring_c&); // disable cloning

public:

   xstring_c() { buf=0; }

   xstring_c(const char *s) { _set(s); }

   const char *set(const char *s) { return xstrset(buf,s); }

   const char *nset(const char *s,int n) { return xstrset(buf,s,n); }

   const char *set_allocated(char *s) { xfree(buf); return buf=s; }

   template<class STR> const char *move_here(STR& s) { return set_allocated(s.borrow()); }

   const char *vset(...) ATTRIBUTE_SENTINEL;

   void truncate(size_t n=0) { if(buf) buf[n]=0; }

   char *borrow() { return replace_value(buf,(char*)0); }

   bool begins_with(const char *s) const { return !strncmp(buf,s,strlen(s)); };

   bool prefixes(const char *s) const { return !strncmp(buf,s,length()); };

   bool eq(const char *s) const { return !xstrcmp(buf,s); }

   bool ne(const char *s) const { return !eq(s); }

   bool eq_nc(const char *s) const { return !xstrcasecmp(buf,s); }

   size_t length() const { return xstrlen(buf); }

   void set_length(size_t n) { if(buf) buf[n]=0; }

   char last_char() const { size_t len=length(); return len>0?buf[len-1]:0; }

   void unset() { xfree(buf); buf=0; }

   void _set(const char *s) { buf=xstrdup(s); }

   char **buf_ptr() { unset(); return &buf; }

   xstring_c& url_decode(int flags=0);

   static const xstring_c null;

};

class xstring_ca : public xstring_c

{

   xstring_ca& operator=(const xstring_ca& s); // disable assigning

   xstring_ca(const xstring_ca&); // disable cloning

public:

   xstring_ca(char *s) { buf=s; }

};

class xstring_clonable;

// full implementation

class xstring : public xstring0

{

   size_t size;

   size_t len;

   void init() { buf=0; size=len=0; }

   void init(const char *s,int l);

   void init(const char *s);

   // make xstring = xstrdup() fail:

   xstring& operator=(char *);

   const char *operator=(const char *s) { return set(s); }

   const char *operator=(const xstring& s) { return set(s); }

   xstring(const xstring&); // disable cloning

public:

   xstring() { init(); }

   xstring(const char *s) { init(s); }

   xstring(const char *s,int l) { init(s,l); }

   // explicit cloning

   xstring(const xstring_clonable& c);

   const xstring_clonable& copy() const { return *(xstring_clonable*)(this); }

   void get_space(size_t s);

   void get_space2(size_t s,size_t g);

   void shrink_space();

   char *add_space(size_t s);

   void add_commit(int new_len) { len+=new_len; }

   size_t length() const { return len; }

   xstring& set(const xstring &s) { return nset(s,s.length()); }

   xstring& set(const char *s);

   xstring& nset(const char *s,int len);

   xstring& set_allocated(char *s);

   xstring& move_here(xstring&);

   xstring& move_here(xstring_c& s) { return set_allocated(s.borrow()); }

   void swap(xstring& o);

   xstring& set_substr(int start,size_t sublen,const char *,size_t);

   xstring& set_substr(int start,size_t sublen,const char *);

   xstring& set_substr(int start,size_t sublen,const xstring &s) { return set_substr(start,sublen,s.get(),s.length()); }

   xstring& prepend(const char *s,size_t len) { return set_substr(0,0,s,len); }

   xstring& prepend(const xstring &s) { return prepend(s.get(),s.length()); }

   xstring& prepend(char c) { return prepend(&c,1); }

   xstring& append(const char *s);

   xstring& append(char c);

   xstring& append(const char *s,size_t len);

   xstring& append(const xstring &s) { return append(s.get(),s.length()); }

   xstring& append_padding(int len,char ch);

   xstring& vappend(va_list);

   xstring& vappend(...) ATTRIBUTE_SENTINEL;

   xstring& vset(...) ATTRIBUTE_SENTINEL;

   xstring& vsetf(const char *fmt, va_list ap) { truncate(0); return vappendf(fmt,ap); }

   xstring& setf(const char *fmt,...) PRINTF_LIKE(2,3);

   xstring& vappendf(const char *fmt, va_list ap);

   xstring& appendf(const char *fmt,...) PRINTF_LIKE(2,3);

   static xstring& get_tmp();

   static xstring& get_tmp(const char *s) { return get_tmp().set(s); }

   static xstring& get_tmp(const char *s,int n) { return get_tmp().nset(s,n); }

   static char *tmp_buf(int n);

   static xstring& vformat(const char *fmt,va_list ap) { return get_tmp().vsetf(fmt,ap); }

   static xstring& format(const char *fmt,...) PRINTF_LIKE(1,2);

   static xstring& cat(const char *first,...) ATTRIBUTE_SENTINEL;

   static xstring& join(const char *sep,int n,...);

   void truncate() { set_length(0); }

   void truncate(size_t n);

   void truncate_at(char c);

   /* set_length can be used to extend the string, e.g. after modification

      with get_space+get_non_const. */

   void set_length(size_t n) { if(buf) buf[len=n]=0; }

   void set_length_no_z(size_t n) { len=n; }

   char *borrow() { size=len=0; return replace_value(buf,(char*)0); }

   bool begins_with(const char *o_buf,size_t o_len) const;

   bool begins_with(const char *s) const { return begins_with(s,strlen(s)); };

   bool ends_with(const char *o_buf,size_t o_len) const;

   bool ends_with(const char *s) const { return ends_with(s,strlen(s)); };

   bool prefixes(const char *s) const { return !strncmp(buf,s,length()); };

   bool eq(const char *o_buf,size_t o_len) const;

   bool eq(const char *s) const { return eq(s,strlen(s)); }

   bool eq(const xstring&o) const { return eq(o.get(),o.length()); }

   bool ne(const xstring&o) const { return !eq(o); }

   int cmp(const char *o_buf,size_t o_len) const;

   int cmp(const xstring&o) const { return cmp(o.get(),o.length()); }

   bool eq_nc(const char *o_buf,size_t o_len) const;

   bool eq_nc(const char *s) const { return eq_nc(s,strlen(s)); }

   bool eq_nc(const xstring&o) const { return eq_nc(o.get(),o.length()); }

   bool chomp(char c='\n');

   void rtrim(char c=' ');

   char last_char() const { return len>0?buf[len-1]:0; }

   unsigned skip_all(unsigned i,char c) const;

   int instr(char c) const;

   void _clear() { init(); }

   void _set(const char *s) { init(s); }

   void unset() { xfree(buf); _clear(); }

   bool is_binary() const;

   const char *dump_to(xstring &out) const;

   const char *dump() const;

   const char *hexdump_to(xstring &out) const;

   const char *hexdump() const;

   xstring& url_decode(int flags=0);

   xstring& append_url_encoded(const char *s,int len,const char *unsafe,unsigned flags=0);

   xstring& append_url_encoded(const char *s,const char *unsafe,unsigned flags=0) { return append_url_encoded(s,strlen(s),unsafe,flags); }

   xstring& append_url_encoded(const xstring& s,const char *unsafe,unsigned flags=0) { return append_url_encoded(s,s.length(),unsafe,flags); }

   xstring& append_quoted(const char *s,int len);

   xstring& append_quoted(const char *s) { return append_quoted(s,strlen(s)); }

   xstring& hex_decode();

   xstring& c_lc();

   xstring& c_ucfirst();

   static const xstring null;

};

class xstring_clonable : public xstring {};

static inline size_t strlen(const xstring& s) { return s.length(); }

static inline size_t xstrlen(const xstring& s) { return s.length(); }

#endif//XSTRING_H