X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Ftypes%2Ffloat.c;h=ee9a8318660f115d5787f94cf50becd4ab99de70;hb=d20f5e59af1c0db93913661a3daa92c087860e6e;hp=6fd0c72ef4dc97f5ce426d8a992022edbc7c16ee;hpb=7fe001942cc8ece60d945cbfbd1d135ff548dc7d;p=babeltrace.git diff --git a/formats/ctf/types/float.c b/formats/ctf/types/float.c index 6fd0c72e..ee9a8318 100644 --- a/formats/ctf/types/float.c +++ b/formats/ctf/types/float.c @@ -3,21 +3,17 @@ * * Floating point read/write functions. * - * Copyright (c) 2010 Mathieu Desnoyers + * Copyright 2010 - Mathieu Desnoyers * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. * * Reference: ISO C99 standard 5.2.4 */ @@ -36,7 +32,7 @@ /* * Aliasing float/double and unsigned long is not strictly permitted by strict - * aliasing, but in practice type prunning is well supported, and this permits + * aliasing, but in practice declaration prunning is well supported, and this permits * us to use per-word read/writes rather than per-byte. */ @@ -73,68 +69,68 @@ struct pos_len { }; void _ctf_float_copy(struct stream_pos *destp, - const struct type_class_float *dest_class, + const struct declaration_float *dest_declaration, struct stream_pos *srcp, - const struct type_class_float *src_class) + const struct declaration_float *src_declaration) { uint8_t sign; int64_t exp; uint64_t mantissa; /* Read */ - if (src->byte_order == LITTLE_ENDIAN) { - mantissa = ctf_uint_read(srcp, src_class->mantissa); - exp = ctf_int_read(srcp, src_class->exp); - sign = ctf_uint_read(srcp, src_class->sign); + if (src_declaration->byte_order == LITTLE_ENDIAN) { + mantissa = ctf_uint_read(srcp, src_declaration->mantissa); + exp = ctf_int_read(srcp, src_declaration->exp); + sign = ctf_uint_read(srcp, src_declaration->sign); } else { - sign = ctf_uint_read(srcp, src_class->sign); - exp = ctf_int_read(srcp, src_class->exp); - mantissa = ctf_uint_read(srcp, src_class->mantissa); + sign = ctf_uint_read(srcp, src_declaration->sign); + exp = ctf_int_read(srcp, src_declaration->exp); + mantissa = ctf_uint_read(srcp, src_declaration->mantissa); } /* Write */ - if (dest->byte_order == LITTLE_ENDIAN) { - ctf_uint_write(destp, dest_class->mantissa, mantissa); - ctf_int_write(destp, dest_class->exp, exp); - ctf_uint_write(destp, dest_class->sign, sign); + if (dest_declaration->byte_order == LITTLE_ENDIAN) { + ctf_uint_write(destp, dest_declaration->mantissa, mantissa); + ctf_int_write(destp, dest_declaration->exp, exp); + ctf_uint_write(destp, dest_declaration->sign, sign); } else { - ctf_uint_write(destp, dest_class->sign, sign); - ctf_int_write(destp, dest_class->exp, exp); - ctf_uint_write(destp, dest_class->mantissa, mantissa); + ctf_uint_write(destp, dest_declaration->sign, sign); + ctf_int_write(destp, dest_declaration->exp, exp); + ctf_uint_write(destp, dest_declaration->mantissa, mantissa); } } void ctf_float_copy(struct stream_pos *dest, struct stream_pos *src, - const struct type_class_float *float_class) + const struct declaration_float *float_declaration) { - align_pos(src, float_class->p.alignment); - align_pos(dest, float_class->p.alignment); - _ctf_float_copy(dest, float_class, src, float_class); + align_pos(src, float_declaration->p.alignment); + align_pos(dest, float_declaration->p.alignment); + _ctf_float_copy(dest, float_declaration, src, float_declaration); } double ctf_double_read(struct stream_pos *srcp, - const struct type_class_float *float_class) + const struct declaration_float *float_declaration) { union doubleIEEE754 u; - struct ctf_float *dest_class = float_type_new(NULL, + struct declaration_float *dest_declaration = float_declaration_new(NULL, DBL_MANT_DIG, sizeof(double) * CHAR_BIT - DBL_MANT_DIG, BYTE_ORDER, __alignof__(double)); struct stream_pos destp; - align_pos(srcp, float_class->p.alignment); - init_pos(&destp, &u.bits); - _ctf_float_copy(&destp, dest_class, srcp, float_class); - float_type_free(dest_class); + align_pos(srcp, float_declaration->p.alignment); + init_pos(&destp, (char *) u.bits); + _ctf_float_copy(&destp, dest_declaration, srcp, float_declaration); + declaration_unref(&dest_declaration->p); return u.v; } void ctf_double_write(struct stream_pos *destp, - const struct type_class_float *float_class, + const struct declaration_float *float_declaration, double v) { union doubleIEEE754 u; - struct ctf_float *src_class = float_type_new(NULL, + struct declaration_float *src_declaration = float_declaration_new(NULL, DBL_MANT_DIG, sizeof(double) * CHAR_BIT - DBL_MANT_DIG, BYTE_ORDER, @@ -142,36 +138,36 @@ void ctf_double_write(struct stream_pos *destp, struct stream_pos srcp; u.v = v; - align_pos(destp, float_class->p.alignment); - init_pos(&srcp, &u.bits); - _ctf_float_copy(destp, float_class, &srcp, src_class); - float_type_free(src_class); + align_pos(destp, float_declaration->p.alignment); + init_pos(&srcp, (char *) u.bits); + _ctf_float_copy(destp, float_declaration, &srcp, src_declaration); + declaration_unref(&src_declaration->p); } long double ctf_ldouble_read(struct stream_pos *srcp, - const struct type_class_float *float_class) + const struct declaration_float *float_declaration) { union ldoubleIEEE754 u; - struct ctf_float *dest_class = float_type_new(NULL, + struct declaration_float *dest_declaration = float_declaration_new(NULL, LDBL_MANT_DIG, sizeof(long double) * CHAR_BIT - LDBL_MANT_DIG, BYTE_ORDER, __alignof__(long double)); struct stream_pos destp; - align_pos(srcp, float_class->p.alignment); - init_pos(&destp, &u.bits); - _ctf_float_copy(&destp, dest_class, srcp, float_class); - float_type_free(dest_class); + align_pos(srcp, float_declaration->p.alignment); + init_pos(&destp, (char *) u.bits); + _ctf_float_copy(&destp, dest_declaration, srcp, float_declaration); + declaration_unref(&dest_declaration->p); return u.v; } void ctf_ldouble_write(struct stream_pos *destp, - const struct type_class_float *float_class, + const struct declaration_float *float_declaration, long double v) { union ldoubleIEEE754 u; - struct ctf_float *src_class = float_type_new(NULL, + struct declaration_float *src_declaration = float_declaration_new(NULL, LDBL_MANT_DIG, sizeof(long double) * CHAR_BIT - LDBL_MANT_DIG, BYTE_ORDER, @@ -179,8 +175,8 @@ void ctf_ldouble_write(struct stream_pos *destp, struct stream_pos srcp; u.v = v; - align_pos(destp, float_class->p.alignment); - init_pos(&srcp, &u.bits); - _ctf_float_copy(destp, float_class, &srcp, src_class); - float_type_free(src_class); + align_pos(destp, float_declaration->p.alignment); + init_pos(&srcp, (char *) u.bits); + _ctf_float_copy(destp, float_declaration, &srcp, src_declaration); + declaration_unref(&src_declaration->p); }