merc.h

typedef struct  alias_data              ALIAS_DATA;

struct alias_data
{
  ALIAS_DATA * next;
  char       * short_n;
  char       * long_n;
}

in the pc_data struct add : (for ch->pcdata->alias)
  ALIAS_DATA *        alias;
  sh_int              alias_count; 

/*
 * Game parameters
 */
#define MAX_ALIAS 30


/*
 * declare functions.
 */
void    alias_remove    args( ( CHAR_DATA *ch, ALIAS_DATA *ali ) );

/*
 * Global variable (for memory recycling).
 */
extern          ALIAS_DATA        *     alias_free;

some .c file (ie. handler.c)
  ALIAS_DATA * alias_free;

save.c

fread_char() in case 'A'

  if (!str_cmp(word, "Alias"))
  {
    ALIAS_DATA *ali;
                
    if (alias_free == NULL )
    {
      ali = alloc_perm(sizeof(*ali));
    }
    else
    {
      ali = alias_free;
      alias_free = alias_free->next;
    }
    ali->short_n = fread_string(fp);
    ali->long_n = fread_string(fp);
    ali->next = ch->pcdata->alias;
    ch->pcdata->alias = ali;
    ch->pcdata->alias_count++;
    fMatch = TRUE;
  }

fwrite_char()
  ALIAS_DATA *ali;

then after writing skills

  for (ali = ch->pcdata->alias; ali; ali = ali->next)
  {
    fprintf(fp, "Alias      %s~ ~%s~\n", ali->short_n, ali->long_n);
  }

db.c in free_char()
    ALIAS_DATA *ali;
    ALIAS_DATA *ali_next;

then in the pcdata section add :

  for (ali = ch->pcdata->alias; ali; ali = ali_next )
  {
    ali_next = ali->next;
    alias_remove(ch, ali); 
  }

handler.c

void alias_remove(CHAR_DATA *ch, ALIAS_DATA *ali)
{
  if (IS_NPC(ch)) return;
  if (ch->pcdata->alias == NULL)
  {
    bug( "Alias_remove: no alias.", 0 );
    return;
  }
  if (ali == ch->pcdata->alias)
  {
    ch->pcdata->alias = ali->next;
  }
  else
  {
    ALIAS_DATA *prev;

    for (prev = ch->pcdata->alias; prev; prev = prev->next)
    {
      if (prev->next == ali)
      {
        prev->next = ali->next;
        break;
      }
    }
    if (prev == NULL)   
    {
      bug( "Alias_remove: cannot find ali.", 0 );
      return;
    }
  }
  ali->next = alias_free;
  alias_free = ali;
  return;
}

  /*
   * just before we do a lookup in the command table in interpret()
   */
  if (!IS_NPC(ch))
  {
    ALIAS_DATA *ali;

    for (ali = ch->pcdata->alias; ali; ali = ali->next)
    {
      if (!str_cmp(command, ali->short_n))
      {
        sprintf(buf, "%s %s", ali->long_n, argument);
        interpret(ch, buf);
        return; 
      }
    }
  }

/*
 * define and add the three following player commands.
 */
void do_alias(CHAR_DATA *ch, char *argument)
{
  ALIAS_DATA *ali;
  char arg1[MAX_INPUT_LENGTH];

  if (IS_NPC(ch)) return;
  
  argument = one_argument(argument, arg1);
  one_argument(argument, testarg);
    
  if (ch->pcdata->alias_count >= MAX_ALIAS)
  {
    send_to_char("Sorry, you have reached the limit for aliases, you need to remove some before you can make more.\n\r",ch);
    return;
  }
  if (arg1[0] == '\0' || argument[0] == '\0')
  {
    send_to_char("Syntax : alias 'short' 'long'\n\r",ch);
    send_to_char("\n\rThe 'short' is the alias, and the 'long' is the string that the alias replaces.\n\r",ch);
    send_to_char("ie. alias tt teleport orc.\n\r",ch);
    return;
  }
  if (strlen2(argument) > 400)
  {
    send_to_char("Behave... that's way to big.\n\r",ch);
    return;
  }
  smash_tilde(arg1);
  smash_tilde(testarg);
  smash_tilde(argument);
  if (!str_cmp(arg1, testarg))
  {
    send_to_char("You cannot alias the alias.\n\r",ch);
    return;
  }
  for (ali = ch->pcdata->alias; ali; ali = ali->next)
  {
    if (!str_cmp(arg1, ali->short_n))
    {
      send_to_char("You already have such an alias.\n\r",ch);
      return;
    }
    if (!str_cmp(arg1, ali->long_n) || !str_cmp(argument, ali->short_n) || !str_cmp(argument, ali->long_n))
    {
      send_to_char("No looping aliases please.\n\r", ch);
      return;
    }
  }
  if (alias_free == NULL )
  {
    ali = alloc_perm(sizeof(*ali));
  }
  else
  {
    ali = alias_free;
    alias_free = alias_free->next;
  }
  ali->short_n = str_dup(arg1);
  ali->long_n = str_dup(argument);
  ali->next = ch->pcdata->alias;
  ch->pcdata->alias = ali; 
  ch->pcdata->alias_count++;
  send_to_char("Ok.\n\r",ch);
  return;  
}  
  
void do_showalias(CHAR_DATA *ch, char *argument)
{
  ALIAS_DATA *ali;
  bool found = FALSE;
  char buf[MAX_STRING_LENGTH];
     
  if (IS_NPC(ch)) return;
     
  for (ali = ch->pcdata->alias; ali; ali = ali->next)
  {
    found = TRUE;
    sprintf(buf, "%s '%s'\n\r", ali->short_n, ali->long_n);
    send_to_char(buf,ch); 
  }
  if (!found) send_to_char("You have no aliases.\n\r",ch);
  return;
}
   
void do_removealias(CHAR_DATA *ch, char *argument)
{
  ALIAS_DATA *ali;
  char arg[MAX_INPUT_LENGTH];  
  
  if (IS_NPC(ch)) return;
  
  one_argument(argument, arg);
  
  if (arg[0] == '\0')
  {
    send_to_char("Remove which alias?\n\r",ch);
    return;
  }
  for (ali = ch->pcdata->alias; ali; ali = ali->next)
  {
    if (!str_cmp(arg, ali->short_n))
    {
      alias_remove(ch, ali);
      ch->pcdata->alias_count--;
      send_to_char("Alias removed.\n\r",ch);
      return;
    }
  }
  send_to_char("No such alias.\n\r",ch);
  return;
}