/work/workdir/UnpackedTarball/fontconfig/src/fcrange.c

Source (jump to first uncovered line)
/*
 * fontconfig/src/fcrange.c
 *
 * Copyright © 2002 Keith Packard
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of the author(s) not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  The authors make no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include "fcint.h"

FcRange *
FcRangeCreateDouble (double begin, double end)
{
    FcRange *ret = malloc (sizeof (FcRange));

    if (ret) {
  ret->begin = begin;
  ret->end = end;
    }

    return ret;
}

FcRange *
FcRangeCreateInteger (FcChar32 begin, FcChar32 end)
{
    FcRange *ret = malloc (sizeof (FcRange));

    if (ret) {
  ret->begin = begin;
  ret->end = end;
    }

    return ret;
}

void
FcRangeDestroy (FcRange *range)
{
    if (range)
  free (range);
}

FcRange *
FcRangeCopy (const FcRange *range)
{
    return FcRangeCreateDouble (range->begin, range->end);
}

FcBool
FcRangeGetDouble (const FcRange *range, double *begin, double *end)
{
    if (!range)
  return FcFalse;
    if (begin)
  *begin = range->begin;
    if (end)
  *end = range->end;

    return FcTrue;
}

FcRange *
FcRangePromote (double v, FcValuePromotionBuffer *vbuf)
{
    typedef struct {
  FcRange r;
    } FcRangePromotionBuffer;
    FcRangePromotionBuffer *buf = (FcRangePromotionBuffer *)vbuf;

    FC_ASSERT_STATIC (sizeof (FcRangePromotionBuffer) <= sizeof (FcValuePromotionBuffer));
    buf->r.begin = v;
    buf->r.end = v;

    return &buf->r;
}

FcBool
FcRangeIsInRange (const FcRange *a, const FcRange *b)
{
    return a->begin >= b->begin && a->end <= b->end;
}

FcBool
FcRangeCompare (FcOp op, const FcRange *a, const FcRange *b)
{
    switch ((int)op) {
    case FcOpEqual:
  return a->begin == b->begin && a->end == b->end;
    case FcOpContains:
    case FcOpListing:
  return FcRangeIsInRange (a, b);
    case FcOpNotEqual:
  return a->begin != b->begin || a->end != b->end;
    case FcOpNotContains:
  return !FcRangeIsInRange (a, b);
    case FcOpLess:
  return a->end < b->begin;
    case FcOpLessEqual:
  return a->end <= b->begin;
    case FcOpMore:
  return a->begin > b->end;
    case FcOpMoreEqual:
  return a->begin >= b->end;
    default:
  break;
    }
    return FcFalse;
}

FcChar32
FcRangeHash (const FcRange *r)
{
    int b = (int)(r->begin * 100);
    int e = (int)(r->end * 100);

    return b ^ (b << 1) ^ (e << 9);
}

FcBool
FcRangeSerializeAlloc (FcSerialize *serialize, const FcRange *r)
{
    if (!FcSerializeAlloc (serialize, r, sizeof (FcRange)))
  return FcFalse;
    return FcTrue;
}

FcRange *
FcRangeSerialize (FcSerialize *serialize, const FcRange *r)
{
    FcRange *r_serialize = FcSerializePtr (serialize, r);

    if (!r_serialize)
  return NULL;
    memcpy (r_serialize, r, sizeof (FcRange));

    return r_serialize;
}

#define __fcrange__
#include "fcaliastail.h"
#undef __fcrange__

Line	Count	Source (jump to first uncovered line)
1		/*
2		* fontconfig/src/fcrange.c
3		*
4		* Copyright © 2002 Keith Packard
5		*
6		* Permission to use, copy, modify, distribute, and sell this software and its
7		* documentation for any purpose is hereby granted without fee, provided that
8		* the above copyright notice appear in all copies and that both that
9		* copyright notice and this permission notice appear in supporting
10		* documentation, and that the name of the author(s) not be used in
11		* advertising or publicity pertaining to distribution of the software without
12		* specific, written prior permission. The authors make no
13		* representations about the suitability of this software for any purpose. It
14		* is provided "as is" without express or implied warranty.
15		*
16		* THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17		* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18		* EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19		* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20		* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21		* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22		* PERFORMANCE OF THIS SOFTWARE.
23		*/
24
25		#include "fcint.h"
26
27		FcRange *
28		FcRangeCreateDouble (double begin, double end)
29	0	{
30	0	FcRange *ret = malloc (sizeof (FcRange));
31
32	0	if (ret) {
33	0	ret->begin = begin;
34	0	ret->end = end;
35	0	}
36
37	0	return ret;
38	0	}
39
40		FcRange *
41		FcRangeCreateInteger (FcChar32 begin, FcChar32 end)
42	0	{
43	0	FcRange *ret = malloc (sizeof (FcRange));
44
45	0	if (ret) {
46	0	ret->begin = begin;
47	0	ret->end = end;
48	0	}
49
50	0	return ret;
51	0	}
52
53		void
54		FcRangeDestroy (FcRange *range)
55	0	{
56	0	if (range)
57	0	free (range);
58	0	}
59
60		FcRange *
61		FcRangeCopy (const FcRange *range)
62	0	{
63	0	return FcRangeCreateDouble (range->begin, range->end);
64	0	}
65
66		FcBool
67		FcRangeGetDouble (const FcRange range, double begin, double *end)
68	0	{
69	0	if (!range)
70	0	return FcFalse;
71	0	if (begin)
72	0	*begin = range->begin;
73	0	if (end)
74	0	*end = range->end;
75
76	0	return FcTrue;
77	0	}
78
79		FcRange *
80		FcRangePromote (double v, FcValuePromotionBuffer *vbuf)
81	0	{
82	0	typedef struct {
83	0	FcRange r;
84	0	} FcRangePromotionBuffer;
85	0	FcRangePromotionBuffer buf = (FcRangePromotionBuffer )vbuf;
86
87	0	FC_ASSERT_STATIC (sizeof (FcRangePromotionBuffer) <= sizeof (FcValuePromotionBuffer));
88	0	buf->r.begin = v;
89	0	buf->r.end = v;
90
91	0	return &buf->r;
92	0	}
93
94		FcBool
95		FcRangeIsInRange (const FcRange a, const FcRange b)
96	0	{
97	0	return a->begin >= b->begin && a->end <= b->end;
98	0	}
99
100		FcBool
101		FcRangeCompare (FcOp op, const FcRange a, const FcRange b)
102	0	{
103	0	switch ((int)op) {
104	0	case FcOpEqual:
105	0	return a->begin == b->begin && a->end == b->end;
106	0	case FcOpContains:
107	0	case FcOpListing:
108	0	return FcRangeIsInRange (a, b);
109	0	case FcOpNotEqual:
110	0	return a->begin != b->begin \|\| a->end != b->end;
111	0	case FcOpNotContains:
112	0	return !FcRangeIsInRange (a, b);
113	0	case FcOpLess:
114	0	return a->end < b->begin;
115	0	case FcOpLessEqual:
116	0	return a->end <= b->begin;
117	0	case FcOpMore:
118	0	return a->begin > b->end;
119	0	case FcOpMoreEqual:
120	0	return a->begin >= b->end;
121	0	default:
122	0	break;
123	0	}
124	0	return FcFalse;
125	0	}
126
127		FcChar32
128		FcRangeHash (const FcRange *r)
129	0	{
130	0	int b = (int)(r->begin * 100);
131	0	int e = (int)(r->end * 100);
132
133	0	return b ^ (b << 1) ^ (e << 9);
134	0	}
135
136		FcBool
137		FcRangeSerializeAlloc (FcSerialize serialize, const FcRange r)
138	0	{
139	0	if (!FcSerializeAlloc (serialize, r, sizeof (FcRange)))
140	0	return FcFalse;
141	0	return FcTrue;
142	0	}
143
144		FcRange *
145		FcRangeSerialize (FcSerialize serialize, const FcRange r)
146	0	{
147	0	FcRange *r_serialize = FcSerializePtr (serialize, r);
148
149	0	if (!r_serialize)
150	0	return NULL;
151	0	memcpy (r_serialize, r, sizeof (FcRange));
152
153	0	return r_serialize;
154	0	}
155
156		#define __fcrange__
157		#include "fcaliastail.h"
158		#undef __fcrange__

Coverage Report

Created: 2025-07-07 10:01