File: array.c

package info (click to toggle)
chrony 3.0-4+deb9u2
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 2,496 kB
  • sloc: ansic: 23,531; sh: 2,022; yacc: 866; makefile: 195
file content (135 lines) | stat: -rw-r--r-- 3,078 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/*
  chronyd/chronyc - Programs for keeping computer clocks accurate.

 **********************************************************************
 * Copyright (C) Miroslav Lichvar  2014
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 * 
 **********************************************************************

  =======================================================================

  Functions implementing an array with automatic memory allocation.

  */

#include "config.h"

#include "sysincl.h"

#include "array.h"
#include "memory.h"

struct ARR_Instance_Record {
  void *data;
  unsigned int elem_size;
  unsigned int used;
  unsigned int allocated;
};

ARR_Instance
ARR_CreateInstance(unsigned int elem_size)
{
  ARR_Instance array;

  assert(elem_size > 0);

  array = MallocNew(struct ARR_Instance_Record);

  array->data = NULL;
  array->elem_size = elem_size;
  array->used = 0;
  array->allocated = 0;

  return array;
}

void
ARR_DestroyInstance(ARR_Instance array)
{
  Free(array->data);
  Free(array);
}

static void
realloc_array(ARR_Instance array, unsigned int min_size)
{
  size_t data_size;

  assert(min_size <= 2 * min_size);
  if (array->allocated >= min_size && array->allocated <= 2 * min_size)
    return;

  if (array->allocated < min_size) {
    while (array->allocated < min_size)
      array->allocated = array->allocated ? 2 * array->allocated : 1;
  } else {
    array->allocated = min_size;
  }

  data_size = (size_t)array->elem_size * array->allocated;
  assert(data_size / array->elem_size == array->allocated);

  array->data = Realloc(array->data, data_size);
}

void *
ARR_GetNewElement(ARR_Instance array)
{
  array->used++;
  realloc_array(array, array->used);
  return ARR_GetElement(array, array->used - 1);
}

void *
ARR_GetElement(ARR_Instance array, unsigned int index)
{
  assert(index < array->used);
  return (void *)((char *)array->data + (size_t)index * array->elem_size);
}

void *
ARR_GetElements(ARR_Instance array)
{
  /* Return a non-NULL pointer when the array has zero size */
  if (!array->data) {
    assert(!array->used);
    return array;
  }

  return array->data;
}

void
ARR_AppendElement(ARR_Instance array, void *element)
{
  void *e;

  e = ARR_GetNewElement(array);
  memcpy(e, element, array->elem_size);
}

void
ARR_SetSize(ARR_Instance array, unsigned int size)
{
  realloc_array(array, size);
  array->used = size;
}

unsigned int
ARR_GetSize(ARR_Instance array)
{
  return array->used;
}