/* This software is Copyright 1989, 1990, 1992, 1993 by various individuals.
   Please see the accompanying file COPYRIGHT for details. */

#include <string.h>
#include <stdlib.h>
#include <limits.h>

#include "prims.h"
#include "ctype.h"
#include "config.h"
#include "externs.h"
#include "property.h"
#include "interface.h"

unsigned long int crctable[1<<CHAR_BIT] = {
#include "crctable"
};

char downcase(char x)
{
 return(DOWNCASE(x));
}

int string_compare(register const char *s1, register const char *s2)
{
 while (*s1 && *s2 && (DOWNCASE(*s1) == DOWNCASE(*s2)))
  { s1++;
    s2++;
  }
 return(DOWNCASE(*s1)-DOWNCASE(*s2));
}

int string_n_compare(register const char *s1, register const char *s2, register int n)
{
 register int rv;

 while (*s1 && *s2 && (n > 0))
  { rv = DOWNCASE(*s1) - DOWNCASE(*s2);
    if (rv) return(rv);
    s1 ++;
    s2 ++;
  }
 return(0);
}

int cibcmp(const void *as1, const void *as2, register int n)
{
 register const char *s1;
 register const char *s2;

 for (s1=as1,s2=as2;n>0;n--,s1++,s2++) if (DOWNCASE(*s1) != DOWNCASE(*s2)) return(1);
 return(0);
}

int string_prefix(register const char *string, register const char *prefix)
{
  while(*string && *prefix && DOWNCASE(*string) == DOWNCASE(*prefix))
    string++, prefix++;
  return *prefix == '\0';
}

/* accepts only nonempty matches starting at the beginning of a word */
const char *string_match(register const char *src, register const char *sub)
{
  if(*sub != '\0') {
    while(*src) {
      if(string_prefix(src, sub)) return src;
      /* else scan to beginning of next word */
      while(*src && Cisalnum(*src)) src++;
      while(*src && !Cisalnum(*src)) src++;
    }
  }

  return 0;
}

/*
 * pronoun_substitute()
 *
 * %-type substitutions for pronouns
 *
 * %a/%A for absolute possessive (his/hers/its, His/Hers/Its)
 * %s/%S for subjective pronouns (he/she/it, He/She/It)
 * %o/%O for objective pronouns (him/her/it, Him/Her/It)
 * %p/%P for possessive pronouns (his/her/its, His/Her/Its)
 * %r/%R for reflexive pronouns (himself/herself/itself,
 *                                Himself/Herself/Itself)
 * %n    for the player's name.
 */
char *pronoun_substitute(dbref player, const char *str)
{
 char c;
 char prn[3];
 char *tmp;
 char *result;
 char *self_sub;               /* self substitution code */
 int lngth_sofar = 0;
 int gender;
 struct propref *pr;
 static char buf[BUFFER_LEN+1];
 static char tmp_buf[BUFFER_LEN];

 prn[0] = '%';
 prn[2] = '\0';
 tmp = &tmp_buf[0];
 strcpy(tmp,str);
 result = &buf[0];
 while (*tmp && (lngth_sofar < BUFFER_LEN-1))
  { lngth_sofar ++;
    if ((*tmp == '%') && tmp[1])
     { *result = '\0';
       c = *++tmp;
       prn[1] = c;
       self_sub = 0;
       pr = lookup_property(player,prn,0);
       if (pr)
	{ if ((propref_get_attr(pr) & PATTR_TYPE) == PTYPE_STRING)
	   { self_sub = propref_get_string(pr);
	   }
	  propref_done(pr);
	}
       if (self_sub)
	{ lngth_sofar += strlen(self_sub);
	  if (lngth_sofar < BUFFER_LEN) strcpy(result,self_sub);
          if (Cisupper(prn[1])) *result = Ctoupper(*result);
	  result += strlen(result);
	  tmp ++;
	  free(self_sub);
	}
       else
	{ gender = genderof(player);
	  if (gender == GENDER_UNASSIGNED)
	   { switch (c)
	      { case 'n': case 'N':
		case 'o': case 'O':
		case 's': case 'S':
		case 'r': case 'R':
		   lngth_sofar += strlen(NAME(player));
		   if (lngth_sofar < BUFFER_LEN) strcpy(result,NAME(player));
		   break;
		case 'a': case 'A':
		case 'p': case 'P':
		   lngth_sofar += strlen(NAME(player)) + 2;
		   if (lngth_sofar < BUFFER_LEN) sprintf(result,"%s's",NAME(player));
		   break;
		default:
		   result[0] = c;
		   result[1] = 0;
		   break;
	      }
	   }
	  else
	   { const char **s;
	     static const char *subjective[4] = { "", "it", "she", "he" };
	     static const char *possessive[4] = { "", "its", "her", "his" };
	     static const char *objective[4] = { "", "it", "her", "him" };
	     static const char *reflexive[4] = { "", "itself", "herself", "himself" };
	     static const char *absolute[4] = { "", "its", "hers", "his" };
	     switch (c)
	      {          case 'a': case 'A': s = absolute;
		if (0) { case 's': case 'S': s = subjective; }
		if (0) { case 'p': case 'P': s = possessive; }
		if (0) { case 'o': case 'O': s = objective;  }
		if (0) { case 'r': case 'R': s = reflexive;  }
		   lngth_sofar += strlen(s[gender]);
		   if (lngth_sofar < BUFFER_LEN) strcpy(result,s[gender]);
		   break;
		case 'n': case 'N':
		   lngth_sofar += strlen(NAME(player));
		   if (lngth_sofar < BUFFER_LEN) strcpy(result,NAME(player));
		   break;
		default:
		   *result = *tmp;
		   result[1] = '\0';
		   break;
	      }
	     if (Cisupper(c) && Cislower(*result)) *result = Ctoupper(*result);
	   }
	  result += strlen(result);
	  tmp ++;
	}
     }
    else
     { *result++ = *tmp++;
     }
  }
 *result = '\0';
 return(&buf[0]);
}

char *pronoun_substitute_str(dbref player, STR s)
{
 char *t;
 char *rv;

 t = fetch_str(s);
 rv = pronoun_substitute(player,t);
 free(t);
 return(rv);
}

char *dup_string_(const char *string, const char *file, int line)
{
 char *s;

 /* NULL, "" -> NULL */
 if ((string == 0) || (*string == '\0')) return(0);
 s = muck_malloc(strlen(string)+1,file,line);
 if (s == 0) abort();
 strcpy(s,string);
 return(s);
}

void lowerstring(char *string)
{
  while (*string)
  {
    *string = (Cisupper(*string)) ? Ctolower (*string) : *string;
    string++;
  }
}

void upperstring(char *string)
{
  while (*string)
  {
    *string = (Cislower(*string)) ? Ctoupper (*string) : *string;
    string++;
  }
}

char *splitstring(char *string, char splittoken)
{
  char *ret;

  ret = strchr(string, splittoken);
  if (ret)
  {
    *(ret++) = '\0';
    while (*ret == ' ') ret++;
  }

  return ret;
}

unsigned long int strhash(const char *s)
{
 unsigned long int crc;
 const unsigned char *cp;

 crc = 0;
 for (cp=(const unsigned char *)s;*cp;cp++)
  { crc = (crc >> CHAR_BIT) ^ crctable[(crc^*cp)&~((~0UL)<<CHAR_BIT)];
  }
 return(crc);
}

MUFQUAD str_to_mufquad(const char *s)
{
 MUFQUAD q;
 int d;

 if (!s || !*s) return(0);
 q = 0;
 while (1)
  { switch (*s++)
     { case '0': d = 0; break;
       case '1': d = 1; break;
       case '2': d = 2; break;
       case '3': d = 3; break;
       case '4': d = 4; break;
       case '5': d = 5; break;
       case '6': d = 6; break;
       case '7': d = 7; break;
       case '8': d = 8; break;
       case '9': d = 9; break;
       case 'a': case 'A': d = 10; break;
       case 'b': case 'B': d = 11; break;
       case 'c': case 'C': d = 12; break;
       case 'd': case 'D': d = 13; break;
       case 'e': case 'E': d = 14; break;
       case 'f': case 'F': d = 15; break;
       default: return(q); break;
     }
    q = (q << 4) | d;
  }
}

const char *mufquad_to_str(MUFQUAD q)
{
 static char buf[((sizeof(MUFQUAD)*CHAR_BIT)/4)+2];
 char *bp;

 bp = &buf[sizeof(buf)-1];
 *--bp = '\0';
 while (q)
  { *--bp = "0123456789abcdef"[q&0xf];
    q >>= 4;
  }
 return(bp);
}