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

Source
/*
 * 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
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	49.5k	cbor_float_width cbor_float_get_width(const cbor_item_t *item) {
13	49.5k	CBOR_ASSERT(cbor_isa_float_ctrl(item));
14	49.5k	return item->metadata.float_ctrl_metadata.width;
15	49.5k	}
16
17	49.5k	uint8_t cbor_ctrl_value(const cbor_item_t *item) {
18	49.5k	CBOR_ASSERT(cbor_isa_float_ctrl(item));
19	49.5k	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_0);
20	49.5k	return item->metadata.float_ctrl_metadata.ctrl;
21	49.5k	}
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	8.08k	void cbor_set_float2(cbor_item_t *item, float value) {
67	8.08k	CBOR_ASSERT(cbor_is_float(item));
68	8.08k	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_16);
69	8.08k	((float )item->data) = value;
70	8.08k	}
71
72	6.68k	void cbor_set_float4(cbor_item_t *item, float value) {
73	6.68k	CBOR_ASSERT(cbor_is_float(item));
74	6.68k	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_32);
75	6.68k	((float )item->data) = value;
76	6.68k	}
77
78	5.11k	void cbor_set_float8(cbor_item_t *item, double value) {
79	5.11k	CBOR_ASSERT(cbor_is_float(item));
80	5.11k	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_64);
81	5.11k	((double )item->data) = value;
82	5.11k	}
83
84	78.2k	void cbor_set_ctrl(cbor_item_t *item, uint8_t value) {
85	78.2k	CBOR_ASSERT(cbor_isa_float_ctrl(item));
86	78.2k	CBOR_ASSERT(cbor_float_get_width(item) == CBOR_FLOAT_0);
87	78.2k	item->metadata.float_ctrl_metadata.ctrl = value;
88	78.2k	}
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	78.2k	cbor_item_t *cbor_new_ctrl(void) {
97	78.2k	cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t));
98	78.2k	_CBOR_NOTNULL(item);
99
100	78.2k	*item = (cbor_item_t){
101	78.2k	.type = CBOR_TYPE_FLOAT_CTRL,
102	78.2k	.data = NULL,
103	78.2k	.refcount = 1,
104	78.2k	.metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_0,
105	78.2k	.ctrl = CBOR_CTRL_NONE}}};
106	78.2k	return item;
107	78.2k	}
108
109	8.08k	cbor_item_t *cbor_new_float2(void) {
110	8.08k	cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t) + 4);
111	8.08k	_CBOR_NOTNULL(item);
112
113	8.08k	*item = (cbor_item_t){
114	8.08k	.type = CBOR_TYPE_FLOAT_CTRL,
115	8.08k	.data = (unsigned char *)item + sizeof(cbor_item_t),
116	8.08k	.refcount = 1,
117	8.08k	.metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_16}}};
118	8.08k	return item;
119	8.08k	}
120
121	6.68k	cbor_item_t *cbor_new_float4(void) {
122	6.68k	cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t) + 4);
123	6.68k	_CBOR_NOTNULL(item);
124
125	6.68k	*item = (cbor_item_t){
126	6.68k	.type = CBOR_TYPE_FLOAT_CTRL,
127	6.68k	.data = (unsigned char *)item + sizeof(cbor_item_t),
128	6.68k	.refcount = 1,
129	6.68k	.metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_32}}};
130	6.68k	return item;
131	6.68k	}
132
133	5.11k	cbor_item_t *cbor_new_float8(void) {
134	5.11k	cbor_item_t *item = _cbor_malloc(sizeof(cbor_item_t) + 8);
135	5.11k	_CBOR_NOTNULL(item);
136
137	5.11k	*item = (cbor_item_t){
138	5.11k	.type = CBOR_TYPE_FLOAT_CTRL,
139	5.11k	.data = (unsigned char *)item + sizeof(cbor_item_t),
140	5.11k	.refcount = 1,
141	5.11k	.metadata = {.float_ctrl_metadata = {.width = CBOR_FLOAT_64}}};
142	5.11k	return item;
143	5.11k	}
144
145	4.62k	cbor_item_t *cbor_new_null(void) {
146	4.62k	cbor_item_t *item = cbor_new_ctrl();
147	4.62k	_CBOR_NOTNULL(item);
148	4.62k	cbor_set_ctrl(item, CBOR_CTRL_NULL);
149	4.62k	return item;
150	4.62k	}
151
152	30.0k	cbor_item_t *cbor_new_undef(void) {
153	30.0k	cbor_item_t *item = cbor_new_ctrl();
154	30.0k	_CBOR_NOTNULL(item);
155	30.0k	cbor_set_ctrl(item, CBOR_CTRL_UNDEF);
156	30.0k	return item;
157	30.0k	}
158
159	43.5k	cbor_item_t *cbor_build_bool(bool value) {
160	43.5k	return cbor_build_ctrl(value ? CBOR_CTRL_TRUE : CBOR_CTRL_FALSE);
161	43.5k	}
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	43.5k	cbor_item_t *cbor_build_ctrl(uint8_t value) {
185	43.5k	cbor_item_t *item = cbor_new_ctrl();
186	43.5k	_CBOR_NOTNULL(item);
187	43.5k	cbor_set_ctrl(item, value);
188	43.5k	return item;
189	43.5k	}

Coverage Report

Created: 2026-02-26 06:27