Annotation of embedaddon/php/ext/xmlrpc/libxmlrpc/simplestring.c, revision 1.1.1.2
1.1 misho 1: /*
2: This file is part of libXMLRPC - a C library for xml-encoded function calls.
3:
4: Author: Dan Libby (dan@libby.com)
5: Epinions.com may be contacted at feedback@epinions-inc.com
6: */
7:
8: /*
9: Copyright 2000 Epinions, Inc.
10:
11: Subject to the following 3 conditions, Epinions, Inc. permits you, free
12: of charge, to (a) use, copy, distribute, modify, perform and display this
13: software and associated documentation files (the "Software"), and (b)
14: permit others to whom the Software is furnished to do so as well.
15:
16: 1) The above copyright notice and this permission notice shall be included
17: without modification in all copies or substantial portions of the
18: Software.
19:
20: 2) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT ANY WARRANTY OR CONDITION OF
21: ANY KIND, EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION ANY
22: IMPLIED WARRANTIES OF ACCURACY, MERCHANTABILITY, FITNESS FOR A PARTICULAR
23: PURPOSE OR NONINFRINGEMENT.
24:
25: 3) IN NO EVENT SHALL EPINIONS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT,
26: SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT
27: OF OR IN CONNECTION WITH THE SOFTWARE (HOWEVER ARISING, INCLUDING
28: NEGLIGENCE), EVEN IF EPINIONS, INC. IS AWARE OF THE POSSIBILITY OF SUCH
29: DAMAGES.
30:
31: */
32:
33:
1.1.1.2 ! misho 34: static const char rcsid[] = "#(@) $Id$";
1.1 misho 35:
36:
37: #define SIMPLESTRING_INCR 32
38:
39: /****h* ABOUT/simplestring
40: * NAME
41: * simplestring
42: * AUTHOR
43: * Dan Libby, aka danda (dan@libby.com)
44: * CREATION DATE
45: * 06/2000
46: * HISTORY
47: * $Log$
48: * Revision 1.3 2002/08/22 01:25:50 sniper
49: * kill some compile warnings
50: *
51: * Revision 1.2 2002/07/05 04:43:53 danda
52: * merged in updates from SF project. bring php repository up to date with xmlrpc-epi version 0.51
53: *
54: * Revision 1.4 2002/02/13 20:58:50 danda
55: * patch to make source more windows friendly, contributed by Jeff Lawson
56: *
57: * Revision 1.3 2001/09/29 21:58:05 danda
58: * adding cvs log to history section
59: *
60: * 10/15/2000 -- danda -- adding robodoc documentation
61: * PORTABILITY
62: * Coded on RedHat Linux 6.2. Builds on Solaris x86. Should build on just
63: * about anything with minor mods.
64: * NOTES
65: * This code was written primarily for xmlrpc, but has found some other uses.
66: *
67: * simplestring is, as the name implies, a simple API for dealing with C strings.
68: * Why would I write yet another string API? Because I couldn't find any that were
69: * a) free / GPL, b) simple/lightweight, c) fast, not doing unneccesary strlens all
70: * over the place. So. It is simple, and it seems to work, and it is pretty fast.
71: *
72: * Oh, and it is also binary safe, ie it can handle strings with embedded NULLs,
73: * so long as the real length is passed in.
74: *
75: * And the masses rejoiced.
76: *
77: * BUGS
78: * there must be some.
79: ******/
80:
81: #include <stdlib.h>
82: #include <string.h>
83: #include "simplestring.h"
84:
85: #define my_free(thing) if(thing) {free(thing); thing = 0;}
86:
87: /*----------------------**
88: * Begin String Functions *
89: *-----------------------*/
90:
91: /****f* FUNC/simplestring_init
92: * NAME
93: * simplestring_init
94: * SYNOPSIS
95: * void simplestring_init(simplestring* string)
96: * FUNCTION
97: * initialize string
98: * INPUTS
99: * string - pointer to a simplestring struct that will be initialized
100: * RESULT
101: * void
102: * NOTES
103: * SEE ALSO
104: * simplestring_free ()
105: * simplestring_clear ()
106: * SOURCE
107: */
108: void simplestring_init(simplestring* string) {
109: memset(string, 0, sizeof(simplestring));
110: }
111: /******/
112:
113: static void simplestring_init_str(simplestring* string) {
114: string->str = (char*)malloc(SIMPLESTRING_INCR);
115: if(string->str) {
116: string->str[0] = 0;
117: string->len = 0;
118: string->size = SIMPLESTRING_INCR;
119: }
120: else {
121: string->size = 0;
122: }
123: }
124:
125: /****f* FUNC/simplestring_clear
126: * NAME
127: * simplestring_clear
128: * SYNOPSIS
129: * void simplestring_clear(simplestring* string)
130: * FUNCTION
131: * clears contents of a string
132: * INPUTS
133: * string - the string value to clear
134: * RESULT
135: * void
136: * NOTES
137: * This function is very fast as it does not de-allocate any memory.
138: * SEE ALSO
139: *
140: * SOURCE
141: */
142: void simplestring_clear(simplestring* string) {
143: if(string->str) {
144: string->str[0] = 0;
145: }
146: string->len = 0;
147: }
148: /******/
149:
150: /****f* FUNC/simplestring_free
151: * NAME
152: * simplestring_free
153: * SYNOPSIS
154: * void simplestring_free(simplestring* string)
155: * FUNCTION
156: * frees contents of a string, if any. Does *not* free the simplestring struct itself.
157: * INPUTS
158: * string - value containing string to be free'd
159: * RESULT
160: * void
161: * NOTES
162: * caller is responsible for allocating and freeing simplestring* struct itself.
163: * SEE ALSO
164: * simplestring_init ()
165: * SOURCE
166: */
167: void simplestring_free(simplestring* string) {
168: if(string && string->str) {
169: my_free(string->str);
170: string->len = 0;
171: }
172: }
173: /******/
174:
175: /****f* FUNC/simplestring_addn
176: * NAME
177: * simplestring_addn
178: * SYNOPSIS
179: * void simplestring_addn(simplestring* string, const char* add, int add_len)
180: * FUNCTION
181: * copies n characters from source to target string
182: * INPUTS
183: * target - target string
184: * source - source string
185: * add_len - number of characters to copy
186: * RESULT
187: * void
188: * NOTES
189: * SEE ALSO
190: * simplestring_add ()
191: * SOURCE
192: */
193: void simplestring_addn(simplestring* target, const char* source, int add_len) {
194: if(target && source) {
195: if(!target->str) {
196: simplestring_init_str(target);
197: }
198: if(target->len + add_len + 1 > target->size) {
199: /* newsize is current length + new length */
200: int newsize = target->len + add_len + 1;
201: int incr = target->size * 2;
202:
203: /* align to SIMPLESTRING_INCR increments */
204: newsize = newsize - (newsize % incr) + incr;
205: target->str = (char*)realloc(target->str, newsize);
206:
207: target->size = target->str ? newsize : 0;
208: }
209:
210: if(target->str) {
211: if(add_len) {
212: memcpy(target->str + target->len, source, add_len);
213: }
214: target->len += add_len;
215: target->str[target->len] = 0; /* null terminate */
216: }
217: }
218: }
219: /******/
220:
221: /****f* FUNC/simplestring_add
222: * NAME
223: * simplestring_add
224: * SYNOPSIS
225: * void simplestring_add(simplestring* string, const char* add)
226: * FUNCTION
227: * appends a string of unknown length from source to target
228: * INPUTS
229: * target - the target string to append to
230: * source - the source string of unknown length
231: * RESULT
232: * void
233: * NOTES
234: * SEE ALSO
235: * simplestring_addn ()
236: * SOURCE
237: */
238: void simplestring_add(simplestring* target, const char* source) {
239: if(target && source) {
240: simplestring_addn(target, source, strlen(source));
241: }
242: }
243: /******/
244:
245:
246: /*----------------------
247: * End String Functions *
248: *--------------------**/
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to simplestring.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / xmlrpc / libxmlrpc