← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/ut0mem.h

  • Committer: Monty Taylor
  • Date: 2008-11-16 23:47:43 UTC
  • mto: (584.1.10 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116234743-c38gmv0pa2kdefaj
Broke out cached_item.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/ut0mem.h
 
1
/***********************************************************************
 
2
Memory primitives
 
3
 
 
4
(c) 1994, 1995 Innobase Oy
 
5
 
 
6
Created 5/30/1994 Heikki Tuuri
 
7
************************************************************************/
 
8
 
 
9
#ifndef ut0mem_h
 
10
#define ut0mem_h
 
11
 
 
12
#include "univ.i"
 
13
#include <string.h>
 
14
#include <stdlib.h>
 
15
 
 
16
/* The total amount of memory currently allocated from the OS with malloc */
 
17
extern ulint    ut_total_allocated_memory;
 
18
 
 
19
UNIV_INLINE
 
20
void*
 
21
ut_memcpy(void* dest, const void* sour, ulint n);
 
22
 
 
23
UNIV_INLINE
 
24
void*
 
25
ut_memmove(void* dest, const void* sour, ulint n);
 
26
 
 
27
UNIV_INLINE
 
28
int
 
29
ut_memcmp(const void* str1, const void* str2, ulint n);
 
30
 
 
31
 
 
32
/**************************************************************************
 
33
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
 
34
defined and set_to_zero is TRUE. */
 
35
UNIV_INTERN
 
36
void*
 
37
ut_malloc_low(
 
38
/*==========*/
 
39
                                        /* out, own: allocated memory */
 
40
        ulint   n,                      /* in: number of bytes to allocate */
 
41
        ibool   set_to_zero,            /* in: TRUE if allocated memory
 
42
                                        should be set to zero if
 
43
                                        UNIV_SET_MEM_TO_ZERO is defined */
 
44
        ibool   assert_on_error);       /* in: if TRUE, we crash mysqld if
 
45
                                        the memory cannot be allocated */
 
46
/**************************************************************************
 
47
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
 
48
defined. */
 
49
UNIV_INTERN
 
50
void*
 
51
ut_malloc(
 
52
/*======*/
 
53
                        /* out, own: allocated memory */
 
54
        ulint   n);     /* in: number of bytes to allocate */
 
55
/**************************************************************************
 
56
Tests if malloc of n bytes would succeed. ut_malloc() asserts if memory runs
 
57
out. It cannot be used if we want to return an error message. Prints to
 
58
stderr a message if fails. */
 
59
UNIV_INTERN
 
60
ibool
 
61
ut_test_malloc(
 
62
/*===========*/
 
63
                        /* out: TRUE if succeeded */
 
64
        ulint   n);     /* in: try to allocate this many bytes */
 
65
/**************************************************************************
 
66
Frees a memory block allocated with ut_malloc. */
 
67
UNIV_INTERN
 
68
void
 
69
ut_free(
 
70
/*====*/
 
71
        void* ptr);  /* in, own: memory block */
 
72
/**************************************************************************
 
73
Implements realloc. This is needed by /pars/lexyy.c. Otherwise, you should not
 
74
use this function because the allocation functions in mem0mem.h are the
 
75
recommended ones in InnoDB.
 
76
 
 
77
man realloc in Linux, 2004:
 
78
 
 
79
       realloc()  changes the size of the memory block pointed to
 
80
       by ptr to size bytes.  The contents will be  unchanged  to
 
81
       the minimum of the old and new sizes; newly allocated mem�
 
82
       ory will be uninitialized.  If ptr is NULL,  the  call  is
 
83
       equivalent  to malloc(size); if size is equal to zero, the
 
84
       call is equivalent to free(ptr).  Unless ptr is  NULL,  it
 
85
       must  have  been  returned by an earlier call to malloc(),
 
86
       calloc() or realloc().
 
87
 
 
88
RETURN VALUE
 
89
       realloc() returns a pointer to the newly allocated memory,
 
90
       which is suitably aligned for any kind of variable and may
 
91
       be different from ptr, or NULL if the  request  fails.  If
 
92
       size  was equal to 0, either NULL or a pointer suitable to
 
93
       be passed to free() is returned.  If realloc()  fails  the
 
94
       original  block  is  left  untouched  - it is not freed or
 
95
       moved. */
 
96
UNIV_INTERN
 
97
void*
 
98
ut_realloc(
 
99
/*=======*/
 
100
                        /* out, own: pointer to new mem block or NULL */
 
101
        void*   ptr,    /* in: pointer to old block or NULL */
 
102
        ulint   size);  /* in: desired size */
 
103
/**************************************************************************
 
104
Frees in shutdown all allocated memory not freed yet. */
 
105
UNIV_INTERN
 
106
void
 
107
ut_free_all_mem(void);
 
108
/*=================*/
 
109
 
 
110
UNIV_INLINE
 
111
char*
 
112
ut_strcpy(char* dest, const char* sour);
 
113
 
 
114
UNIV_INLINE
 
115
ulint
 
116
ut_strlen(const char* str);
 
117
 
 
118
UNIV_INLINE
 
119
int
 
120
ut_strcmp(const char* str1, const char* str2);
 
121
 
 
122
/**************************************************************************
 
123
Copies up to size - 1 characters from the NUL-terminated string src to
 
124
dst, NUL-terminating the result. Returns strlen(src), so truncation
 
125
occurred if the return value >= size. */
 
126
UNIV_INTERN
 
127
ulint
 
128
ut_strlcpy(
 
129
/*=======*/
 
130
                                /* out: strlen(src) */
 
131
        char*           dst,    /* in: destination buffer */
 
132
        const char*     src,    /* in: source buffer */
 
133
        ulint           size);  /* in: size of destination buffer */
 
134
 
 
135
/**************************************************************************
 
136
Like ut_strlcpy, but if src doesn't fit in dst completely, copies the last
 
137
(size - 1) bytes of src, not the first. */
 
138
UNIV_INTERN
 
139
ulint
 
140
ut_strlcpy_rev(
 
141
/*===========*/
 
142
                                /* out: strlen(src) */
 
143
        char*           dst,    /* in: destination buffer */
 
144
        const char*     src,    /* in: source buffer */
 
145
        ulint           size);  /* in: size of destination buffer */
 
146
 
 
147
/**************************************************************************
 
148
Compute strlen(ut_strcpyq(str, q)). */
 
149
UNIV_INLINE
 
150
ulint
 
151
ut_strlenq(
 
152
/*=======*/
 
153
                                /* out: length of the string when quoted */
 
154
        const char*     str,    /* in: null-terminated string */
 
155
        char            q);     /* in: the quote character */
 
156
 
 
157
/**************************************************************************
 
158
Make a quoted copy of a NUL-terminated string.  Leading and trailing
 
159
quotes will not be included; only embedded quotes will be escaped.
 
160
See also ut_strlenq() and ut_memcpyq(). */
 
161
UNIV_INTERN
 
162
char*
 
163
ut_strcpyq(
 
164
/*=======*/
 
165
                                /* out: pointer to end of dest */
 
166
        char*           dest,   /* in: output buffer */
 
167
        char            q,      /* in: the quote character */
 
168
        const char*     src);   /* in: null-terminated string */
 
169
 
 
170
/**************************************************************************
 
171
Make a quoted copy of a fixed-length string.  Leading and trailing
 
172
quotes will not be included; only embedded quotes will be escaped.
 
173
See also ut_strlenq() and ut_strcpyq(). */
 
174
UNIV_INTERN
 
175
char*
 
176
ut_memcpyq(
 
177
/*=======*/
 
178
                                /* out: pointer to end of dest */
 
179
        char*           dest,   /* in: output buffer */
 
180
        char            q,      /* in: the quote character */
 
181
        const char*     src,    /* in: string to be quoted */
 
182
        ulint           len);   /* in: length of src */
 
183
 
 
184
/**************************************************************************
 
185
Return the number of times s2 occurs in s1. Overlapping instances of s2
 
186
are only counted once. */
 
187
UNIV_INTERN
 
188
ulint
 
189
ut_strcount(
 
190
/*========*/
 
191
                                /* out: the number of times s2 occurs in s1 */
 
192
        const char*     s1,     /* in: string to search in */
 
193
        const char*     s2);    /* in: string to search for */
 
194
 
 
195
/**************************************************************************
 
196
Replace every occurrence of s1 in str with s2. Overlapping instances of s1
 
197
are only replaced once. */
 
198
UNIV_INTERN
 
199
char*
 
200
ut_strreplace(
 
201
/*==========*/
 
202
                                /* out, own: modified string, must be
 
203
                                freed with mem_free() */
 
204
        const char*     str,    /* in: string to operate on */
 
205
        const char*     s1,     /* in: string to replace */
 
206
        const char*     s2);    /* in: string to replace s1 with */
 
207
 
 
208
/**************************************************************************
 
209
Converts a raw binary data to a '\0'-terminated hex string. The output is
 
210
truncated if there is not enough space in "hex", make sure "hex_size" is at
 
211
least (2 * raw_size + 1) if you do not want this to happen. Returns the
 
212
actual number of characters written to "hex" (including the '\0'). */
 
213
UNIV_INLINE
 
214
ulint
 
215
ut_raw_to_hex(
 
216
/*==========*/
 
217
                                        /* out: number of chars written */
 
218
        const void*     raw,            /* in: raw data */
 
219
        ulint           raw_size,       /* in: "raw" length in bytes */
 
220
        char*           hex,            /* out: hex string */
 
221
        ulint           hex_size);      /* in: "hex" size in bytes */
 
222
 
 
223
/***********************************************************************
 
224
Adds single quotes to the start and end of string and escapes any quotes
 
225
by doubling them. Returns the number of bytes that were written to "buf"
 
226
(including the terminating '\0'). If buf_size is too small then the
 
227
trailing bytes from "str" are discarded. */
 
228
UNIV_INLINE
 
229
ulint
 
230
ut_str_sql_format(
 
231
/*==============*/
 
232
                                        /* out: number of bytes
 
233
                                        that were written */
 
234
        const char*     str,            /* in: string */
 
235
        ulint           str_len,        /* in: string length in bytes */
 
236
        char*           buf,            /* out: output buffer */
 
237
        ulint           buf_size);      /* in: output buffer size
 
238
                                        in bytes */
 
239
 
 
240
#ifndef UNIV_NONINL
 
241
#include "ut0mem.ic"
 
242
#endif
 
243
 
 
244
#endif