ermyth/src/tokenize.C

/*
 * tokenize.C: Tokenization routines.
 *
 * Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
 * Rights to this code are as documented in COPYING.
 *
 *
 * Portions of this file were derived from sources bearing the following license:
 * Rights to this code are documented in doc/pod/license.pod.
 * Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
 */

static char const rcsid[] = "$Id: tokenize.C,v 1.5 2007-08-28 17:08:12 pippijn Exp $";

#include "atheme.h"
#include "pmodule.h"

int
sjtoken (char *message, char delimiter, char **parv, int limit)
{
  char *next;
  int count;

  if (!message)
    return 0;

  /* now we take the beginning of the message and find all the spaces...
   * set them to \0 and use 'next' to go through the string
   */
  next = message;

  /* eat any additional delimiters */
  while (*next == delimiter)
    next++;

  parv[0] = next;
  count = 1;

  while (*next)
    {
      /* this is fine here, since we don't have a :delimited
       * parameter like tokenize
       */

      if (count == limit)
        {
          /* we've reached our limit */
          if (count == 256)
            slog (LG_DEBUG, "sjtoken(): reached param limit");
          return count;
        }

      if (*next == delimiter)
        {
          *next = '\0';
          next++;
          /* eat any additional delimiters */
          while (*next == delimiter)
            next++;
          /* if it's the end of the string, it's simply
           ** an extra space at the end.  here we break.
           */
          if (*next == '\0')
            break;

          /* if it happens to be a stray \r, break too */
          if (*next == '\r')
            break;

          parv[count] = next;
          count++;
        }
      else
        next++;
    }

  return count;
}

/* this splits apart a message with origin and command picked off already */
int
tokenize (char *message, char **parv)
{
  char *pos = NULL;
  char *next;
  unsigned int count = 0;

  if (!message)
    return -1;

  /* first we fid out of there's a : in the message, save that string
   * somewhere so we can set it to the last param in parv
   * also make sure there's a space before it... if not then we're screwed
   */
  pos = message;
  while (true)
    {
      if ((pos = strchr (pos, ':')))
        {
          pos--;
          if (*pos != ' ')
            {
              pos += 2;
              continue;
            }
          *pos = '\0';
          pos++;
          *pos = '\0';
          pos++;
          break;
        }
      else
        break;
    }

  /* now we take the beginning of the message and find all the spaces...
   * set them to \0 and use 'next' to go through the string
   */

  next = message;
  parv[0] = message;
  count = 1;

  while (*next)
    {
      if (count == MAXPARC)
        {
          /* we've reached one less than our max limit
           * to handle the parameter we already ripped off
           */
          slog (LG_DEBUG, "tokenize(): reached para limit");
          return count;
        }
      if (*next == ' ')
        {
          *next = '\0';
          next++;
          /* eat any additional spaces */
          while (*next == ' ')
            next++;
          /* if it's the end of the string, it's simply
           * an extra space before the :parameter. break.
           */
          if (*next == '\0')
            break;
          parv[count] = next;
          count++;
        }
      else
        next++;
    }

  if (pos)
    {
      parv[count] = pos;
      count++;
    }

  return count;
}
Revision:	1.6
Committed:	Sun Sep 16 18:54:45 2007 UTC (16 years, 8 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.5:	+7 -2 lines
Log Message:	#defines to enum
#	Content
1	/*
2	* tokenize.C: Tokenization routines.
3	*
4	* Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
5	* Rights to this code are as documented in COPYING.
6	*
7	*
8	* Portions of this file were derived from sources bearing the following license:
9	* Rights to this code are documented in doc/pod/license.pod.
10	* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
11	*/
12
13	static char const rcsid[] = "$Id: tokenize.C,v 1.5 2007-08-28 17:08:12 pippijn Exp $";
14
15	#include "atheme.h"
16	#include "pmodule.h"
17
18	int
19	sjtoken (char message, char delimiter, char *parv, int limit)
20	{
21	char *next;
22	int count;
23
24	if (!message)
25	return 0;
26
27	/* now we take the beginning of the message and find all the spaces...
28	* set them to \0 and use 'next' to go through the string
29	*/
30	next = message;
31
32	/* eat any additional delimiters */
33	while (*next == delimiter)
34	next++;
35
36	parv[0] = next;
37	count = 1;
38
39	while (*next)
40	{
41	/* this is fine here, since we don't have a :delimited
42	* parameter like tokenize
43	*/
44
45	if (count == limit)
46	{
47	/* we've reached our limit */
48	if (count == 256)
49	slog (LG_DEBUG, "sjtoken(): reached param limit");
50	return count;
51	}
52
53	if (*next == delimiter)
54	{
55	*next = '\0';
56	next++;
57	/* eat any additional delimiters */
58	while (*next == delimiter)
59	next++;
60	/* if it's the end of the string, it's simply
61	** an extra space at the end. here we break.
62	*/
63	if (*next == '\0')
64	break;
65
66	/* if it happens to be a stray \r, break too */
67	if (*next == '\r')
68	break;
69
70	parv[count] = next;
71	count++;
72	}
73	else
74	next++;
75	}
76
77	return count;
78	}
79
80	/* this splits apart a message with origin and command picked off already */
81	int
82	tokenize (char message, char *parv)
83	{
84	char *pos = NULL;
85	char *next;
86	unsigned int count = 0;
87
88	if (!message)
89	return -1;
90
91	/* first we fid out of there's a : in the message, save that string
92	* somewhere so we can set it to the last param in parv
93	* also make sure there's a space before it... if not then we're screwed
94	*/
95	pos = message;
96	while (true)
97	{
98	if ((pos = strchr (pos, ':')))
99	{
100	pos--;
101	if (*pos != ' ')
102	{
103	pos += 2;
104	continue;
105	}
106	*pos = '\0';
107	pos++;
108	*pos = '\0';
109	pos++;
110	break;
111	}
112	else
113	break;
114	}
115
116	/* now we take the beginning of the message and find all the spaces...
117	* set them to \0 and use 'next' to go through the string
118	*/
119
120	next = message;
121	parv[0] = message;
122	count = 1;
123
124	while (*next)
125	{
126	if (count == MAXPARC)
127	{
128	/* we've reached one less than our max limit
129	* to handle the parameter we already ripped off
130	*/
131	slog (LG_DEBUG, "tokenize(): reached para limit");
132	return count;
133	}
134	if (*next == ' ')
135	{
136	*next = '\0';
137	next++;
138	/* eat any additional spaces */
139	while (*next == ' ')
140	next++;
141	/* if it's the end of the string, it's simply
142	* an extra space before the :parameter. break.
143	*/
144	if (*next == '\0')
145	break;
146	parv[count] = next;
147	count++;
148	}
149	else
150	next++;
151	}
152
153	if (pos)
154	{
155	parv[count] = pos;
156	count++;
157	}
158
159	return count;
160	}