alias.c

P2P NAP的C实现 P2P在网络应用中越来越流行

  
  st = (char *)malloc(bp+strlen(n)+strlen(m+ep)+1);
  memset(st, 0, bp+strlen(n)+strlen(m+ep)+1);
  
  strncpy(st, m, bp);
  sprintf(st, "%s%s%s", st, n, m+ep);
  
  return(st);
}

/* tok is a NULL-terminated list of tokens. Print them to wchan (the
   main window), enclosed in |..|. Currently unused. */
void prt(char **tok)
{
  int i;
  char buf[1024];
  
  memset(buf, 0, sizeof(buf));

  for (i=0;tok[i];i++)
  {
    strcat(buf, tok[i]);
    strcat(buf, " ");
  }
  
  buf[strlen(buf)-1] = 0;
  
  wp(wchan, "|%s|\n", buf);
  drw(wchan);
}

unsigned char *dovars(unsigned char *nm)
{
  unsigned char *r=NULL, *t;
  char **vtok=NULL, b[512], **tok;
  int i, j, vcnt=0, cnt, x, y;
  
  if (findset(nm))
    r = strdup(getval(nm));
  
  if (strchr(nm, '('))
  {
    memset(b, 0, sizeof(b));
    strcpy(b, strchr(nm, '(')+1);
    b[strlen(b)-1] = 0;
    vtok = form_vtoks(b, &vcnt);
  }
  
  if (!vtok)
  {
    for (i=0;i<vcnt;i++)
    {
      if (*vtok[i] == '$')
      {
        t = dovars(vtok[i]+1);
        if (t)
        {
          free(vtok[i]);
          vtok[i] = t;
        }
      }
    }
  }
  else
  {
    for (i=0;i<vcnt;i++)
    {
      tok = form_toks(vtok[i], &cnt);
      tok = fxv(tok, cnt, &cnt);
      for (j=0;j<cnt;j++)
      {
        if (*tok[j] == '$' && !isdigit(tok[j][1]) && tok[j][1] != '+')
        {
          t = dovars(tok[j]+1);
          if (t)
          {
            free(tok[j]);
            tok[j] = t;
          }
        }
      }
      for (j=0;tok[j];j++)
      {
        if (*tok[j] == '$' && tok[j][1] == '+' && !tok[j][2])
        {
          if (j > 0 && tok[j+1] && tok[j-1])
          {
            for (x=1;tok[j-x]&&!(*tok[j-x]);x++);
            for (y=1;tok[j+y]&&!(*tok[j+y]);y++);
            if (!tok[j-x])
              x--;
            if (!tok[j+y])
              y--;
            tok[j] = (char *)realloc(tok[j], strlen(tok[j-x])+strlen(tok[j+y])+1);
            if (strcmp(tok[j-x], "$+"))
              strcpy(tok[j], tok[j-x]);
            else
              *tok[j] = 0;
            if (strcmp(tok[j+y], "$+"))
              strcat(tok[j], tok[j+y]);
            *tok[j-x] = 0;
            *tok[j+y] = 0;
          }
          else
            *tok[j] = 0;
        }
      }
      
      vtok[i] = (char *)realloc(vtok[i], 2048);
      memset(vtok[i], 0, 2048);
      for (j=0;tok[j];j++)
      {
        if (*tok[j])
        {
          strcat(vtok[i], tok[j]);
          strcat(vtok[i], " ");
        }
        free(tok[j]);
      }
      free(tok);
      vtok[i][strlen(vtok[i])-1] = 0;
      vtok[i] = (char *)realloc(vtok[i], strlen(vtok[i])+1);
    }
  }
  
  memset(b, 0, sizeof(b));
  for (i=0;nm[i]&&nm[i]!='(';i++)
    b[i] = nm[i];
  
  for (i=0;;i++)
  {
    if (!vars[i].nm)
    {
      if (vtok)
      {
        for (j=0;j<vcnt;j++)
          free(vtok[j]);
        free(vtok);
      }
      break;
    }
    if (!strcasecmp(vars[i].nm, b))
    {
      r = vars[i].func(vtok, vcnt);
      if (vtok)
      {
        for (j=0;j<vcnt;j++)
          free(vtok[j]);
        free(vtok);
      }
      break;
    }
  }
  
  if (!r)
    return(strdup(""));
  else  
    return(r);
}

/* tokenize a string t of the form " x1, x2, ..., xn" into the tokens
   x1 through xn. Here x1...xn are well-balanced strings (with respect
   to '(' and ')'). Notes: x1...xn may contain additional commas
   inside parentheses.  Whitespace is skipped at the beginning and after
   commas, but not before commas. The behavior is undefined (messy) if
   x1...xn are not well-balanced. Some tokens may be the empty string;
   this also happens if t consist of one or more spaces only.
   Returns: NULL-terminated array of tokens and number of tokens in
   n. */

char **form_vtoks(char *t, int *n)
{
  int i, j, k, c=0;
  char **ret;
  
  if (!strlen(t))
  {
    *n = 0;
    return(NULL);
  }
  
  ret = (char **)malloc(4096);
  
  for (i=0,j=0;;i++)  /* i=token number, j=character number in t. */
  {
    ret[i] = (char *)malloc(1024);
    memset(ret[i], 0, 1024);
    while (t[j] && isspace(t[j]))
      j++;
    for (k=0,c=0;t[j];k++,j++) /* k=char. number in ret[i], c=nesting level */
    {
      if (t[j] == ',' && !c)
        break;
      if (c < 0)
        c = 0;
      if (t[j] == '(')
        c++;
      else if (t[j] == ')')
        c--;
      ret[i][k] = t[j];
    }
    ret[i] = (char *)realloc(ret[i], strlen(ret[i])+1);
    if (!t[j])
      break;
    j++;
  }
  
  ret[i+1] = NULL;
  *n = i+1;
  
  return(ret);
}

unsigned char *doalias(alias_t *al, char **tok, int cnt)
{
  char *ret, echr;
  char **atok, p[16], pt[2048], tb[2048], *t;
  int i, j, acnt, n, l, c;
  
  t = strdup(al->args);
  
  for (i=0;al->args[i]&&al->args[i] == ' ';i++);
  
  if (al->args[i] == '{')
  {
    for (i=0,c=0;t[i];i++)
    {
      if (c < 0)
        c = 0;
      if (t[i] == '{' && !c)
      {
        t[i] = ' ';
        c++;
      }
      else if (t[i] == '{')
        c++;
      else if (t[i] == '}' && c == 1)
      {
        t[i] = ' ';
        c--;
      }
      else if (t[i] == '}')
        c--;
    }
  }
  
  if (t[strlen(t)-1] == '|' || t[strlen(t)-1] == '\n')
    t[strlen(t)-1] = 0;
  
  memset(pt, 0, sizeof(pt));
  strcpy(pt, t);
  free(t);
  
  for (i=0;pt[i];i++)
  {
    if (pt[i] == '$' || pt[i] == '?')
    {
      for (j=i,echr=0;;j++)
      {
        if (!pt[j] || pt[j] == ',' || pt[j] == ' ' || pt[j] == '=' || pt[j] == '!' || pt[j] == '>' || pt[j] == '<')
        {
          echr = pt[j];
          break;
        }
      }
      if (i > 0 && (pt[i-1] == '(' || pt[i-1] == ')' || pt[i-1] == ',' || pt[i-1] == '=' || pt[i-1] == '!' || pt[i-1] == '<' || pt[i-1] == '>' || pt[i-1] == ' '))
      {
        if (pt[i-1] != ' ')
        {
          memset(tb, 0, sizeof(tb));
          strcpy(tb, pt+i);
          strcpy(pt+i+1, tb);
          pt[i] = ' ';
        }
        else
          j--;
        if (echr && echr != ' ')
        {
          memset(tb, 0, sizeof(tb));
          strcpy(tb, pt+j+1);
          strcpy(pt+j+2, tb);
          pt[j+1] = ' ';
        }
      }
    }
  }
  
  t = strdup(pt);
  
  atok = form_tokso(t, &acnt);
  free(t);
  
  for (i=0,j=0;i<acnt;i++)
    if (*atok[i] == '$' && atok[i][1])
      if (atoi(atok[i]+1) > j)
        j = atoi(atok[i]+1);

  if ((cnt-1) < j) {
    for (i=0; i<acnt; i++) {
      free(atok[i]);
    }
    free(atok);
    return(NULL);
  }  

  for (i=0;atok[i];i++)
  {
    if (*atok[i] == '?' && isdigit(atok[i][1]))
    {
      if (atoi(atok[i]+1) <= (cnt-1))
        *atok[i] = '$';
      else
      {
        for (j=1;;j++)
        {
          if (!isdigit(atok[i][j]) && atok[i][j] != '-')
          {
            memset(tb, 0, sizeof(tb));
            strcpy(tb, atok[i]+j);
            strcpy(atok[i], tb);
            break;
          }
        }
      }
    }
  }
  
  for (i=0,l=0;atok[i];i++)
  {
    if (*atok[i] == '$' && isdigit(atok[i][1]) && !strchr(atok[i], '-'))
    {
      n = atoi(atok[i]+1);
      memset(tb, 0, sizeof(tb));
      for (j=1;atok[i][j];j++)
        if (!isdigit(atok[i][j]))
          break;
      strcpy(tb, atok[i]+j);
      atok[i] = (char *)realloc(atok[i], strlen(tok[n])+strlen(tb)+1);
      strcpy(atok[i], tok[n]);
      strcat(atok[i], tb);
    }
    else if (*atok[i] == '$' && isdigit(atok[i][1]))
    {
      memset(p, 0, sizeof(p));
      for (j=1;;j++)
      {
        if (!isdigit(atok[i][j]) && atok[i][j] != '-')
        {
          memset(tb, 0, sizeof(tb));
          strcpy(tb, atok[i]+j);
          strcpy(atok[i], tb);
          break;
        }
        if (atok[i][j] != '-')
          p[j-1] = atok[i][j];
      }
      n = atoi(p);
      memset(pt, 0, sizeof(pt));
      for (j=n;tok[j];j++)
      {
        strcat(pt, tok[j]);
        strcat(pt, " ");
      }
      pt[strlen(pt)-1] = 0;
      atok[i] = (char *)realloc(atok[i], strlen(pt)+strlen(tb)+1);
      strcpy(atok[i], pt);
      strcat(atok[i], tb);
    }
    else if (*atok[i] == '$' && !strcasecmp(atok[i]+1, "num"))
    {
      free(atok[i]);
      atok[i] = NULL;
      msprintf(&atok[i], "%i", cnt-1);
    }
    else if (*atok[i] == '$' && !strcasecmp(atok[i]+1, "str"))
    {
      free(atok[i]);
      atok[i] = (char *)malloc(4096);
      memset(atok[i], 0, 4096);
      for (j=0;tok[j];j++)
      {
        if (*tok[j])
        {
          strcat(atok[i], tok[j]);
          strcat(atok[i], " ");
        }
      }
      atok[i][strlen(atok[i])-1] = 0;
      atok[i] = (char *)realloc(atok[i], strlen(atok[i])+1);
    }
    l+=strlen(atok[i])+1;
  }

  ret = (char *)malloc(4096);
  memset(ret, 0, 4096);
  
  for (i=0;atok[i];i++)
  {
    if (*atok[i])
    {
      strcat(ret, atok[i]);
      strcat(ret, " ");
    }
    free(atok[i]);
  }
  
  free(atok);
  
  ret[strlen(ret)-1] = 0;
  ret = (char *)realloc(ret, strlen(ret)+1);
  
  return((unsigned char *)ret);
}

/* save alias list to named file */
int savealiases(char *fn)
{
  FILE *f;
  alias_t *cur;
  
  f = fopen(fn, "w");
  if (!f)
    return(-1);
  
  for (cur=alhead;cur;cur=cur->next)
    fprintf(f, "%s %s\n", cur->nm, cur->args);
  
  fclose(f);
  
  return(1);
}

/* load aliases from named file and append to alias list. The format
   is ad hoc. */
int loadaliases(char *fn)
{
  FILE *f;
  alias_t *cur;
  char buf[4096], tb[4096];
  int i, c, j;
  char *p;
  
  f = fopen(fn, "r");
  if (!f)
    return(-1);
  
  while (1)
  {
    if (fgets(buf, sizeof(buf), f) == NULL)
      break;
    if (*buf == '#')   /* skip comments in column 0 */
      continue;
    if (buf[strlen(buf)-1] == '\n')
      buf[strlen(buf)-1] = 0;
    for (i=0,c=0;buf[i];i++)  /* find the first space, if any */
    {
      if (isspace(buf[i]))
      {
        c = 1;
        break;
      }
    }
    /* no space found; continue on next line. Note: no comment allowed
       here.  */

    if (!c)
    {
      buf[strlen(buf)] = ' ';
      fgets(buf+strlen(buf), sizeof(buf)-strlen(buf), f);
      if (buf[strlen(buf)-1] == '\n')
        buf[strlen(buf)-1] = 0;
    }
    
    buf[strlen(buf)] = '\n';
    
    for (c=0,i=0;;i++)