/src/libcbor/src/cbor/floats_ctrls.c

Source (jump to first uncovered line)
/*
 * Copyright (c) 2014-2020 Pavel Kalvoda <me@pavelkalvoda.com>
 *
 * libcbor is free software; you can redistribute it and/or modify
 * it under the terms of the MIT license. See LICENSE for details.
 */

#include "floats_ctrls.h"
#include <math.h>
#include "assert.h"

cbor_float_width cbor_float_get_width(const cbor_item_t *item) {
  CBOR_ASSERT(cbor_isa_float_ctrl(item));
  return item->metadata.float_ctrl_metadata.width;
}

uint8_t cbor_ctrl_value(const cbor_item_t *item) {
  CBOR_ASSERT(cbor_isa_float_ctrl(item));
  CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_0);
  return item->metadata.float_ctrl_metadata.ctrl;
}

bool cbor_float_ctrl_is_ctrl(const cbor_item_t *item) {
  CBOR_ASSERT(cbor_isa_float_ctrl(item));
  return cbor_float_get_width(item) == CBOR_FLOAT_0;
}

float cbor_float_get_float2(const cbor_item_t *item) {
  CBOR_ASSERT(cbor_is_float(item));
  CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_16);
  return *(float *)item->data;
}

float cbor_float_get_float4(const cbor_item_t *item) {
  CBOR_ASSERT(cbor_is_float(item));
  CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_32);
  return *(float *)item->data;
}

double cbor_float_get_float8(const cbor_item_t *item) {
  CBOR_ASSERT(cbor_is_float(item));
  CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_64);
  return *(double *)item->data;
}

double cbor_float_get_float(const cbor_item_t *item) {
  CBOR_ASSERT(cbor_is_float(item));
  // cppcheck-suppress missingReturn
  switch (cbor_float_get_width(item)) {
    case CBOR_FLOAT_0:
      return NAN;
    case CBOR_FLOAT_16:
      return cbor_float_get_float2(item);
    case CBOR_FLOAT_32:
      return cbor_float_get_float4(item);
    case CBOR_FLOAT_64:
      return cbor_float_get_float8(item);
  }
}

bool cbor_get_bool(const cbor_item_t *item) {
  CBOR_ASSERT(cbor_is_bool(item));
  return item->metadata.float_ctrl_metadata.ctrl == CBOR_CTRL_TRUE;
}

void cbor_set_float2(cbor_item_t *item, float value) {
  CBOR_ASSERT(cbor_is_float(item));
  CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_16);
  *((float *)item->data) = value;
}

void cbor_set_float4(cbor_item_t *item, float value) {
  CBOR_ASSERT(cbor_is_float(item));
  CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_32);
  *((float *)item->data) = value;
}

void cbor_set_float8(cbor_item_t *item, double value) {
  CBOR_ASSERT(cbor_is_float(item));
  CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_64);
  *((double *)item->data) = value;
}

void cbor_set_ctrl(cbor_item_t *item, uint8_t value) {
  CBOR_ASSERT(cbor_isa_float_ctrl(item));
  CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_0);
  item->metadata.float_ctrl_metadata.ctrl = value;
}

void cbor_set_bool(cbor_item_t *item, bool value) {
  CBOR_ASSERT(cbor_is_bool(item));
  item->metadata.float_ctrl_metadata.ctrl =
      value ? CBOR_CTRL_TRUE : CBOR_CTRL_FALSE;
}

cbor_item_t *cbor_new_ctrl(void) {
  cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t));
  _CBOR_NOTNULL(item);

  *item = (cbor_item_t){
      .type = CBOR_TYPE_FLOAT_CTRL,
      .data = NULL,
      .refcount = 1,
      .metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_0,
                                           .ctrl = CBOR_CTRL_NONE}}};
  return item;
}

cbor_item_t *cbor_new_float2(void) {
  cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t) + 4);
  _CBOR_NOTNULL(item);

  *item = (cbor_item_t){
      .type = CBOR_TYPE_FLOAT_CTRL,
      .data = (unsigned char *)item + sizeof(cbor_item_t),
      .refcount = 1,
      .metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_16}}};
  return item;
}

cbor_item_t *cbor_new_float4(void) {
  cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t) + 4);
  _CBOR_NOTNULL(item);

  *item = (cbor_item_t){
      .type = CBOR_TYPE_FLOAT_CTRL,
      .data = (unsigned char *)item + sizeof(cbor_item_t),
      .refcount = 1,
      .metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_32}}};
  return item;
}

cbor_item_t *cbor_new_float8(void) {
  cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t) + 8);
  _CBOR_NOTNULL(item);

  *item = (cbor_item_t){
      .type = CBOR_TYPE_FLOAT_CTRL,
      .data = (unsigned char *)item + sizeof(cbor_item_t),
      .refcount = 1,
      .metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_64}}};
  return item;
}

cbor_item_t *cbor_new_null(void) {
  cbor_item_t *item = cbor_new_ctrl();
  _CBOR_NOTNULL(item);
  cbor_set_ctrl(item, CBOR_CTRL_NULL);
  return item;
}

cbor_item_t *cbor_new_undef(void) {
  cbor_item_t *item = cbor_new_ctrl();
  _CBOR_NOTNULL(item);
  cbor_set_ctrl(item, CBOR_CTRL_UNDEF);
  return item;
}

cbor_item_t *cbor_build_bool(bool value) {
  return cbor_build_ctrl(value ? CBOR_CTRL_TRUE : CBOR_CTRL_FALSE);
}

cbor_item_t *cbor_build_float2(float value) {
  cbor_item_t *item = cbor_new_float2();
  _CBOR_NOTNULL(item);
  cbor_set_float2(item, value);
  return item;
}

cbor_item_t *cbor_build_float4(float value) {
  cbor_item_t *item = cbor_new_float4();
  _CBOR_NOTNULL(item);
  cbor_set_float4(item, value);
  return item;
}

cbor_item_t *cbor_build_float8(double value) {
  cbor_item_t *item = cbor_new_float8();
  _CBOR_NOTNULL(item);
  cbor_set_float8(item, value);
  return item;
}

cbor_item_t *cbor_build_ctrl(uint8_t value) {
  cbor_item_t *item = cbor_new_ctrl();
  _CBOR_NOTNULL(item);
  cbor_set_ctrl(item, value);
  return item;
}

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright (c) 2014-2020 Pavel Kalvoda <me@pavelkalvoda.com>
3		*
4		* libcbor is free software; you can redistribute it and/or modify
5		* it under the terms of the MIT license. See LICENSE for details.
6		*/
7
8		#include "floats_ctrls.h"
9		#include <math.h>
10		#include "assert.h"
11
12	37.6k	cbor_float_width cbor_float_get_width(const cbor_item_t *item) {
13	37.6k	CBOR_ASSERT(cbor_isa_float_ctrl(item));
14	37.6k	return item->metadata.float_ctrl_metadata.width;
15	37.6k	}
16
17	37.6k	uint8_t cbor_ctrl_value(const cbor_item_t *item) {
18	37.6k	CBOR_ASSERT(cbor_isa_float_ctrl(item));
19	37.6k	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_0);
20	37.6k	return item->metadata.float_ctrl_metadata.ctrl;
21	37.6k	}
22
23	0	bool cbor_float_ctrl_is_ctrl(const cbor_item_t *item) {
24	0	CBOR_ASSERT(cbor_isa_float_ctrl(item));
25	0	return cbor_float_get_width(item) == CBOR_FLOAT_0;
26	0	}
27
28	0	float cbor_float_get_float2(const cbor_item_t *item) {
29	0	CBOR_ASSERT(cbor_is_float(item));
30	0	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_16);
31	0	return (float )item->data;
32	0	}
33
34	0	float cbor_float_get_float4(const cbor_item_t *item) {
35	0	CBOR_ASSERT(cbor_is_float(item));
36	0	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_32);
37	0	return (float )item->data;
38	0	}
39
40	0	double cbor_float_get_float8(const cbor_item_t *item) {
41	0	CBOR_ASSERT(cbor_is_float(item));
42	0	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_64);
43	0	return (double )item->data;
44	0	}
45
46	0	double cbor_float_get_float(const cbor_item_t *item) {
47	0	CBOR_ASSERT(cbor_is_float(item));
48		// cppcheck-suppress missingReturn
49	0	switch (cbor_float_get_width(item)) {
50	0	case CBOR_FLOAT_0:
51	0	return NAN;
52	0	case CBOR_FLOAT_16:
53	0	return cbor_float_get_float2(item);
54	0	case CBOR_FLOAT_32:
55	0	return cbor_float_get_float4(item);
56	0	case CBOR_FLOAT_64:
57	0	return cbor_float_get_float8(item);
58	0	}
59	0	}
60
61	0	bool cbor_get_bool(const cbor_item_t *item) {
62	0	CBOR_ASSERT(cbor_is_bool(item));
63	0	return item->metadata.float_ctrl_metadata.ctrl == CBOR_CTRL_TRUE;
64	0	}
65
66	972	void cbor_set_float2(cbor_item_t *item, float value) {
67	972	CBOR_ASSERT(cbor_is_float(item));
68	972	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_16);
69	972	((float )item->data) = value;
70	972	}
71
72	2.19k	void cbor_set_float4(cbor_item_t *item, float value) {
73	2.19k	CBOR_ASSERT(cbor_is_float(item));
74	2.19k	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_32);
75	2.19k	((float )item->data) = value;
76	2.19k	}
77
78	565	void cbor_set_float8(cbor_item_t *item, double value) {
79	565	CBOR_ASSERT(cbor_is_float(item));
80	565	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_64);
81	565	((double )item->data) = value;
82	565	}
83
84	37.3k	void cbor_set_ctrl(cbor_item_t *item, uint8_t value) {
85	37.3k	CBOR_ASSERT(cbor_isa_float_ctrl(item));
86	37.3k	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_0);
87	37.3k	item->metadata.float_ctrl_metadata.ctrl = value;
88	37.3k	}
89
90	0	void cbor_set_bool(cbor_item_t *item, bool value) {
91	0	CBOR_ASSERT(cbor_is_bool(item));
92	0	item->metadata.float_ctrl_metadata.ctrl =
93	0	value ? CBOR_CTRL_TRUE : CBOR_CTRL_FALSE;
94	0	}
95
96	37.3k	cbor_item_t *cbor_new_ctrl(void) {
97	37.3k	cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t));
98	37.3k	_CBOR_NOTNULL(item);
99
100	37.3k	*item = (cbor_item_t){
101	37.3k	.type = CBOR_TYPE_FLOAT_CTRL,
102	37.3k	.data = NULL,
103	37.3k	.refcount = 1,
104	37.3k	.metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_0,
105	37.3k	.ctrl = CBOR_CTRL_NONE}}};
106	37.3k	return item;
107	37.3k	}
108
109	972	cbor_item_t *cbor_new_float2(void) {
110	972	cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t) + 4);
111	972	_CBOR_NOTNULL(item);
112
113	972	*item = (cbor_item_t){
114	972	.type = CBOR_TYPE_FLOAT_CTRL,
115	972	.data = (unsigned char *)item + sizeof(cbor_item_t),
116	972	.refcount = 1,
117	972	.metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_16}}};
118	972	return item;
119	972	}
120
121	2.19k	cbor_item_t *cbor_new_float4(void) {
122	2.19k	cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t) + 4);
123	2.19k	_CBOR_NOTNULL(item);
124
125	2.19k	*item = (cbor_item_t){
126	2.19k	.type = CBOR_TYPE_FLOAT_CTRL,
127	2.19k	.data = (unsigned char *)item + sizeof(cbor_item_t),
128	2.19k	.refcount = 1,
129	2.19k	.metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_32}}};
130	2.19k	return item;
131	2.19k	}
132
133	565	cbor_item_t *cbor_new_float8(void) {
134	565	cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t) + 8);
135	565	_CBOR_NOTNULL(item);
136
137	565	*item = (cbor_item_t){
138	565	.type = CBOR_TYPE_FLOAT_CTRL,
139	565	.data = (unsigned char *)item + sizeof(cbor_item_t),
140	565	.refcount = 1,
141	565	.metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_64}}};
142	565	return item;
143	565	}
144
145	479	cbor_item_t *cbor_new_null(void) {
146	479	cbor_item_t *item = cbor_new_ctrl();
147	479	_CBOR_NOTNULL(item);
148	479	cbor_set_ctrl(item, CBOR_CTRL_NULL);
149	479	return item;
150	479	}
151
152	14.4k	cbor_item_t *cbor_new_undef(void) {
153	14.4k	cbor_item_t *item = cbor_new_ctrl();
154	14.4k	_CBOR_NOTNULL(item);
155	14.4k	cbor_set_ctrl(item, CBOR_CTRL_UNDEF);
156	14.4k	return item;
157	14.4k	}
158
159	22.3k	cbor_item_t *cbor_build_bool(bool value) {
160	22.3k	return cbor_build_ctrl(value ? CBOR_CTRL_TRUE : CBOR_CTRL_FALSE);
161	22.3k	}
162
163	0	cbor_item_t *cbor_build_float2(float value) {
164	0	cbor_item_t *item = cbor_new_float2();
165	0	_CBOR_NOTNULL(item);
166	0	cbor_set_float2(item, value);
167	0	return item;
168	0	}
169
170	0	cbor_item_t *cbor_build_float4(float value) {
171	0	cbor_item_t *item = cbor_new_float4();
172	0	_CBOR_NOTNULL(item);
173	0	cbor_set_float4(item, value);
174	0	return item;
175	0	}
176
177	0	cbor_item_t *cbor_build_float8(double value) {
178	0	cbor_item_t *item = cbor_new_float8();
179	0	_CBOR_NOTNULL(item);
180	0	cbor_set_float8(item, value);
181	0	return item;
182	0	}
183
184	22.3k	cbor_item_t *cbor_build_ctrl(uint8_t value) {
185	22.3k	cbor_item_t *item = cbor_new_ctrl();
186	22.3k	_CBOR_NOTNULL(item);
187	22.3k	cbor_set_ctrl(item, value);
188	22.3k	return item;
189	22.3k	}

Coverage Report

Created: 2025-06-22 06:29