1mem.h(3)                   Library Functions Manual                   mem.h(3)
2
3
4

NAME

6       mem.h - Управление памятью
7
8

SYNOPSIS

10       #include <memory.h>
11       #include <string.h>
12       #include 'bee2/defs.h'
13       #include 'bee2/core/safe.h'
14
15
16   Макросы
17       #define memCopyIf(dest,  src,  count)        ((dest) && (src) ?
18           memCopy(dest, src, count) : 0)
19       #define memSetZero(buf,  count)   memSet(buf, 0, count)
20       #define memIsNullOrValid(buf,  count)        ((buf) == 0 ||
21           memIsValid(buf, count))
22           Нулевой указатель или корректный буфер памяти?
23
24   Функции
25       void memCopy (void *dest, const void *src, size_t count)
26           Копировать буфер памяти
27       void memMove (void *dest, const void *src, size_t count)
28           Переместить буфер памяти
29       void memSet (void *buf, octet c, size_t count)
30           Заполнить буфер памяти
31       void memNeg (void *buf, size_t count)
32           Инвертировать буфер памяти
33       void * memAlloc (size_t count)
34           Выделение блока памяти Выделяется блок динамической памяти из count
35           октетов.
36       void * memRealloc (void *buf, size_t count)
37           Изменение размера блока памяти Размер блока динамической памяти buf
38           устанавливается равным count. При необходимости блок перемещается в
39           памяти. Содержимое блока максимально сохраняется.
40       void memFree (void *buf)
41           Освобождение блока памяти
42       bool_t memIsValid (const void *buf, size_t count)
43           Корректный буфер памяти?
44       bool_t memIsAligned (const void *buf, size_t size)
45           Буфер выровнен на границу?
46       bool_t memEq (const void *buf1, const void *buf2, size_t count)
47           Проверка совпадения
48       int memCmp (const void *buf1, const void *buf2, size_t count)
49           Сравнение
50       int memCmpRev (const void *buf1, const void *buf2, size_t count)
51           Обратное сравнение
52       void memWipe (void *buf, size_t count)
53           Очистить буфер памяти
54       bool_t memIsZero (const void *buf, size_t count)
55           Нулевой буфер памяти?
56       size_t memNonZeroSize (const void *buf, size_t count)
57           Размер значащей части буфера
58       bool_t memIsRep (const void *buf, size_t count, octet o)
59           Повтор октета?
60       void memJoin (void *dest, const void *src1, size_t count1, const void
61           *src2, size_t count2)
62           Объединение двух буферов
63       bool_t memIsDisjoint (const void *buf1, const void *buf2, size_t count)
64           Буферы одинакового размера не пересекаются?
65       bool_t memIsSameOrDisjoint (const void *buf1, const void *buf2, size_t
66           count)
67           Буферы совпадают или не пересекаются?
68       bool_t memIsDisjoint2 (const void *buf1, size_t count1, const void
69           *buf2, size_t count2)
70           Два буфера не пересекаются?
71       bool_t memIsDisjoint3 (const void *buf1, size_t count1, const void
72           *buf2, size_t count2, const void *buf3, size_t count3)
73           Три буфера не пересекаются?
74       bool_t memIsDisjoint4 (const void *buf1, size_t count1, const void
75           *buf2, size_t count2, const void *buf3, size_t count3, const void
76           *buf4, size_t count4)
77           Четыре буфера не пересекаются?
78       void memXor (void *dest, const void *src1, const void *src2, size_t
79           count)
80           Cложение октетов памяти по модулю 2.
81       void memXor2 (void *dest, const void *src, size_t count)
82           Добавление октетов памяти по модулю 2.
83       void memSwap (void *buf1, void *buf2, size_t count)
84           Перестановка октетов памяти
85       void memRev (void *buf, size_t count)
86           Реверс октетов
87

Подробное описание

89       Реализованы или переопределены манипуляции над буферами памяти, которые
90       интерпретируются как строки октетов.
91
92       Функции xxTo и xxFrom выполняют преобразования между буферами памяти и
93       другими структурами данных. Могут быть функции двух типов: простые и
94       сложные. В простых функциях объем памяти для размещения преобразованных
95       данных сразу известен. В простые функции передается корректный
96       указатель на буфер-назначение, простые функции не возвращают никаких
97       значений. В сложных функциях объем выходных данных рассчитывается по
98       входным и возвращается как выходное значение. В сложную функцию можно
99       передать нулевой указатель на буфер-назначение, получить требуемый
100       объем буфера, зарезервировать буфер и обратиться к функции еще один
101       раз.
102
103       Буфер памяти может представлять массив слов u16, u32, u64, word.
104       Стандартными считаются соглашения LITTLE_ENDIAN (см. defs.h). Поэтому
105       на платформах с соглашениями BIG_ENDIAN при загрузке слова из памяти и,
106       наоборот, при сохранении слова в памяти выполняется реверс октетов
107       слова.
108
109       Предусловие
110           В функции передаются корректные буферы памяти.
111

Макросы

113   #define memCopyIf(dest, src, count)     ((dest) && (src) ? memCopy(dest,
114       src, count) : 0)
115       Копировать [count]src в [count]dest, если указатели src и dest
116       ненулевые.
117
118   #define memSetZero(buf, count)   memSet(buf, 0, count)
119       Буфер [count]buf обнуляется.
120

Функции

122   void * memAlloc (size_t count)
123       Возвращает
124           Указатель на блок памяти или 0, если памяти не хватает.
125
126       Прим.
127           Блок выделяется, даже если count == 0.
128
129       Аргументы
130           count размер блока
131
132   int memCmp (const void * buf1, const void * buf2, size_t count)
133       Буферы [count]buf1 и [count]buf2 сравниваются лексикографически.
134
135       Возвращает
136           < 0, если [count]buf1 < [count]buf2, 0, если [count]buf1 ==
137           [count]buf2,
138
139               0, если [count]buf1 > [count]buf2.
140
141       Прим.
142           Октеты буферов сравниваются последовательно, от первого к
143           последнему. Первое несовпадение задает соотношение между буферами.
144
145       Регулярность
146           Имеется ускоренная нерегулярная редакция.
147
148       Прим.
149           Повторяется логика сравнения стандартной функции memcmp().
150
151       Аргументы
152           buf1 первый буфер
153           buf2 второй буфер
154           count размер буферов
155
156   int memCmpRev (const void * buf1, const void * buf2, size_t count)
157       Буферы [count]buf1 и [count]buf2 сравниваются
158       обратно-лексикографически.
159
160       Возвращает
161           < 0, если [count]buf1 < [count]buf2, 0, если [count]buf1 ==
162           [count]buf2,
163
164               0, если [count]buf1 > [count]buf2.
165
166       Прим.
167           Октеты буферов сравниваются последовательно, от последнего к
168           первому. Первое несовпадение задает соотношение между буферами.
169
170       Регулярность
171           Имеется ускоренная нерегулярная редакция.
172
173       Аргументы
174           buf1 первый буфер
175           buf2 второй буфер
176           count размер буферов
177
178   void memCopy (void * dest, const void * src, size_t count)
179       Октеты буфера [count]src переписываются в буфер [count]dest.
180
181       Предусловие
182           Буферы src и dest не пересекаются.
183
184   bool_t memEq (const void * buf1, const void * buf2, size_t count)
185       Проверяется, что содержимое буферов [count]buf1 и [count]buf2
186       совпадает.
187
188       Возвращает
189           Признак совпадения.
190
191       Регулярность
192           Имеется ускоренная нерегулярная редакция.
193
194       Аргументы
195           buf1 первый буфер
196           buf2 второй буфер
197           count размер буферов
198
199   void memFree (void * buf)
200       Освобождается блок динамической памяти buf.
201
202       Предусловие
203           buf выделен с помощью memAlloc() или memRealloc().
204
205       Аргументы
206           buf буфер
207
208   bool_t memIsAligned (const void * buf, size_t size)
209       Проверяется, что buf выровнен на границу size-байтового блока.
210
211       Возвращает
212           Проверяемый признак.
213
214       Аргументы
215           buf буфер
216           size длина блока
217
218   bool_t memIsDisjoint (const void * buf1, const void * buf2, size_t count)
219       Проверяется, что буфер [count]buf1 не пересекается с буфером
220       [count]buf2.
221
222       Возвращает
223           Проверяемый признак.
224
225       Предусловие
226           Буферы buf1 и buf2 корректны.
227
228       Аргументы
229           buf1 первый буфер
230           buf2 второй буфер
231           count размер буферов
232
233   bool_t memIsDisjoint2 (const void * buf1, size_t count1, const void * buf2,
234       size_t count2)
235       Проверяется, что буфер [count1]buf1 не пересекается с буфером
236       [count2]buf2.
237
238       Возвращает
239           Проверяемый признак.
240
241       Предусловие
242           Буферы buf1 и buf2 корректны.
243
244       Аргументы
245           buf1 первый буфер
246           count1 размер buf1
247           buf2 второй буфер
248           count2 размер buf2
249
250   bool_t memIsDisjoint3 (const void * buf1, size_t count1, const void * buf2,
251       size_t count2, const void * buf3, size_t count3)
252       Проверяется, что буферы [count1]buf1, [count2]buf2 и [count3]buf3
253       попарно не пересекаются.
254
255       Возвращает
256           Проверяемый признак.
257
258       Предусловие
259           Буферы buf1, buf2 и buf3 корректны.
260
261       Аргументы
262           buf1 первый буфер
263           count1 размер buf1
264           buf2 второй буфер
265           count2 размер buf2
266           buf3 третий буфер
267           count3 размер buf3
268
269   bool_t memIsDisjoint4 (const void * buf1, size_t count1, const void * buf2,
270       size_t count2, const void * buf3, size_t count3, const void * buf4,
271       size_t count4)
272       Проверяется, что буферы [count1]buf1, [count2]buf2, [count3]buf3 и
273       [count4]buf4 попарно не пересекаются.
274
275       Возвращает
276           Проверяемый признак.
277
278       Предусловие
279           Буферы buf1, buf2, buf3 и buf4 корректны.
280
281       Аргументы
282           buf1 первый буфер
283           count1 размер buf1
284           buf2 второй буфер
285           count2 размер buf2
286           buf3 третий буфер
287           count3 размер buf3
288           buf4 четвертый буфер
289           count4 размер buf4
290
291   bool_t memIsRep (const void * buf, size_t count, octet o)
292       Проверяется, что [count]buf заполнен октетом o.
293
294       Прим.
295           Считается, что в пустом буфере (count == 0) повторяется значение 0.
296
297       Возвращает
298           Признак успеха.
299
300       Регулярность
301           Имеется ускоренная нерегулярная редакция.
302
303       Аргументы
304           buf буфер
305           count размер буфера
306           o значение
307
308   bool_t memIsSameOrDisjoint (const void * buf1, const void * buf2, size_t
309       count)
310       Проверяется, что буфер [count]buf1 совпадает или не пересекается с
311       буфером [count]buf2.
312
313       Возвращает
314           Проверяемый признак.
315
316       Предусловие
317           Буферы buf1 и buf2 корректны.
318
319       Аргументы
320           buf1 первый буфер
321           buf2 второй буфер
322           count размер буферов
323
324   bool_t memIsValid (const void * buf, size_t count)
325       Проверяется, что [count]buf является корректным буфером.
326
327       Возвращает
328           Проверяемый признак.
329
330       Прим.
331           Нулевой указатель buf является корректным, если count == 0.
332
333       Аргументы
334           buf буфер
335           count размер буфера
336
337   bool_t memIsZero (const void * buf, size_t count)
338       Проверяется, что буфер [count]buf является нулевым.
339
340       Возвращает
341           Проверяемый признак.
342
343       Регулярность
344           Имеется ускоренная нерегулярная редакция.
345
346       Аргументы
347           buf буфер
348           count размер буфера
349
350   void memJoin (void * dest, const void * src1, size_t count1, const void *
351       src2, size_t count2)
352       В dest записывается блок [count1]src1 || [count2]src2.
353
354       Предусловие
355           По адресам src1, src2, dest зарезервировано count1, count2 и count1
356           + count2 октетов памяти соответственно.
357
358       Прим.
359           Буферы src1, src2 и dest могут пересекаться.
360
361       Аргументы
362           dest назначение
363           src1 первый источник
364           count1 число октетов src1
365           src2 второй источник
366           count2 число октетов src2
367
368   void memMove (void * dest, const void * src, size_t count)
369       Октеты буфера [count]src перемещаются в буфер [count]dest.
370
371       Предусловие
372           Буферы src и dest могут пересекаться.
373
374   void memNeg (void * buf, size_t count)
375       Все биты буфера [count]buf инвертируются.
376
377   size_t memNonZeroSize (const void * buf, size_t count)
378       Определяется размер значащей части буфера [count]buf. Незначащими
379       считаются последние нулевые октеты буфера вплоть до первого ненулевого.
380
381       Возвращает
382           Размер значащей части в октетах.
383
384       Регулярность
385           Функция нерегулярна: время выполнения зависит от заполнения buf.
386
387       Аргументы
388           buf буфер
389           count размер буфера
390
391   void * memRealloc (void * buf, size_t count)
392       Возвращает
393           Указатель на блок памяти с новым размером или 0, если count == 0
394           или памяти не хватает.
395
396       Прим.
397           memRealloc(buf, 0) равносильно memFree(buf).
398
399       Аргументы
400           buf блок памяти
401           count размер блока
402
403   void memRev (void * buf, size_t count)
404       Октеты буфера [count]buf записываются в обратном порядке.
405
406       Аргументы
407           buf буфер
408           count размер буфера
409
410   void memSet (void * buf, octet c, size_t count)
411       Буфер [count]buf заполняется октетом c.
412
413   void memSwap (void * buf1, void * buf2, size_t count)
414       Октеты буферов [count]buf1 и [count]buf2 меняются местами.
415
416       Предусловие
417           Буферы buf1 и buf2 не пересекаются.
418
419       Аргументы
420           buf1 первый буфер
421           buf2 второй буфер
422           count число октетов
423
424   void memWipe (void * buf, size_t count)
425       Буфер [count]buf очищается -- в него записываются произвольные октеты.
426
427       Прим.
428           Запись выполняется всегда, даже если buf в дальнейшем не
429           используется и включена оптимизация компиляции.
430
431       Аргументы
432           buf буфер
433           count размер буфера
434
435   void memXor (void * dest, const void * src1, const void * src2, size_t
436       count)
437       В буфер [count]dest записывается поразрядная по модулю 2 сумма октетов
438       октетов буферов [count]src1 и [count]src2.
439
440       Предусловие
441           Буфер dest либо не пересекается, либо совпадает с каждым из буферов
442           src1, src2.
443
444       Аргументы
445           dest сумма
446           src1 первое слагаемое
447           src2 второе слагаемое
448           count число октетов
449
450   void memXor2 (void * dest, const void * src, size_t count)
451       К октетам буфера [count]dest добавляются октеты буфера [count]src.
452       Сложение выполняется поразрядно по модулю 2.
453
454       Предусловие
455           Буфер dest либо не пересекается, либо совпадает с буфером src.
456
457       Аргументы
458           dest второе слагаемое / сумма
459           src первое слагаемое
460           count число октетов
461

Автор

463       Автоматически создано Doxygen для Библиотека Bee2 из исходного текста.
464
465
466
467Библиотека Bee2                 Пт 23 Июн 2023                        mem.h(3)
Impressum