LCOV - code coverage report
Current view: top level - common/stream - rw.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 108 187 57.8 %
Date: 2021-10-27 03:06:47 Functions: 20 27 74.1 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
       7             :  */
       8             : 
       9             : #include "monetdb_config.h"
      10             : #include "stream.h"
      11             : #include "stream_internal.h"
      12             : 
      13             : 
      14             : 
      15             : int
      16           0 : mnstr_readChr(stream *restrict s, char *restrict val)
      17             : {
      18           0 :         if (s == NULL || val == NULL)
      19             :                 return -1;
      20           0 :         return (int) s->read(s, (void *) val, sizeof(*val), 1);
      21             : }
      22             : 
      23             : int
      24         201 : mnstr_writeChr(stream *s, char val)
      25             : {
      26         201 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
      27             :                 return 0;
      28         201 :         return s->write(s, (void *) &val, sizeof(val), 1) == 1;
      29             : }
      30             : 
      31             : int
      32       54286 : mnstr_readBte(stream *restrict s, int8_t *restrict val)
      33             : {
      34       54286 :         if (s == NULL || val == NULL)
      35             :                 return -1;
      36       54286 :         return (int) s->read(s, (void *) val, sizeof(*val), 1);
      37             : }
      38             : 
      39             : int
      40       57997 : mnstr_writeBte(stream *s, int8_t val)
      41             : {
      42       57997 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
      43             :                 return 0;
      44       57997 :         return s->write(s, (void *) &val, sizeof(val), 1) == 1;
      45             : }
      46             : 
      47             : int
      48      533818 : mnstr_readSht(stream *restrict s, int16_t *restrict val)
      49             : {
      50      533818 :         if (s == NULL || val == NULL)
      51             :                 return 0;
      52      533818 :         assert(s->binary);
      53      533818 :         switch (s->read(s, val, sizeof(*val), 1)) {
      54      529213 :         case 1:
      55      529213 :                 if (s->swapbytes)
      56           0 :                         *val = short_int_SWAP(*val);
      57             :                 return 1;
      58             :         case 0:
      59             :                 return 0;
      60          17 :         default:                /* -1 */
      61          17 :                 return -1;
      62             :         }
      63             : }
      64             : 
      65             : int
      66      523952 : mnstr_writeSht(stream *s, int16_t val)
      67             : {
      68      523952 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
      69             :                 return 0;
      70      523952 :         assert(s->binary);
      71      523952 :         if (s->swapbytes)
      72           0 :                 val = short_int_SWAP(val);
      73      523952 :         return s->write(s, &val, sizeof(val), 1) == 1;
      74             : }
      75             : 
      76             : int
      77      137856 : mnstr_readInt(stream *restrict s, int *restrict val)
      78             : {
      79      137856 :         if (s == NULL || val == NULL)
      80             :                 return 0;
      81      137856 :         assert(s->binary);
      82      137856 :         switch (s->read(s, val, sizeof(*val), 1)) {
      83      137856 :         case 1:
      84      137856 :                 if (s->swapbytes)
      85           0 :                         *val = normal_int_SWAP(*val);
      86             :                 return 1;
      87             :         case 0:
      88             :                 return 0;
      89           0 :         default:                /* -1 */
      90           0 :                 return -1;
      91             :         }
      92             : }
      93             : 
      94             : int
      95      148283 : mnstr_writeInt(stream *s, int val)
      96             : {
      97      148283 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
      98             :                 return 0;
      99      148283 :         assert(s->binary);
     100      148283 :         if (s->swapbytes)
     101           0 :                 val = normal_int_SWAP(val);
     102      148283 :         return s->write(s, &val, sizeof(val), 1) == 1;
     103             : }
     104             : 
     105             : int
     106           0 : mnstr_writeStr(stream *restrict s, const char *restrict val)
     107             : {
     108           0 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
     109             :                 return 0;
     110           0 :         return s->write(s, (void *) val, strlen(val), (size_t) 1) == 1;
     111             : }
     112             : 
     113             : int
     114           0 : mnstr_readStr(stream *restrict s, char *restrict val)
     115             : {
     116           0 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
     117             :                 return 0;
     118             :         do {
     119           0 :                 if (mnstr_readChr(s, val) != 1) {
     120             :                         return -1;
     121             :                 }
     122           0 :                 val++;
     123           0 :         } while (*(val - 1) != '\0');
     124             :         return 1;
     125             : }
     126             : 
     127             : 
     128             : int
     129      215809 : mnstr_readLng(stream *restrict s, int64_t *restrict val)
     130             : {
     131      215809 :         if (s == NULL || val == NULL)
     132             :                 return 0;
     133      215809 :         assert(s->binary);
     134      215809 :         switch (s->read(s, val, sizeof(*val), 1)) {
     135      215809 :         case 1:
     136      215809 :                 if (s->swapbytes)
     137           0 :                         *val = long_int_SWAP(*val);
     138             :                 return 1;
     139             :         case 0:
     140             :                 return 0;
     141           0 :         default:                /* -1 */
     142           0 :                 return -1;
     143             :         }
     144             : }
     145             : 
     146             : int
     147      230010 : mnstr_writeLng(stream *s, int64_t val)
     148             : {
     149      230010 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
     150             :                 return 0;
     151      230010 :         assert(s->binary);
     152      230010 :         if (s->swapbytes)
     153           0 :                 val = long_int_SWAP(val);
     154      230010 :         return s->write(s, &val, sizeof(val), 1) == 1;
     155             : }
     156             : 
     157             : int
     158           0 : mnstr_writeFlt(stream *s, float val)
     159             : {
     160           0 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
     161             :                 return 0;
     162           0 :         assert(s->binary);
     163           0 :         return s->write(s, &val, sizeof(val), 1) == 1;
     164             : }
     165             : 
     166             : int
     167           0 : mnstr_writeDbl(stream *s, double val)
     168             : {
     169           0 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
     170             :                 return 0;
     171           0 :         assert(s->binary);
     172           0 :         return s->write(s, &val, sizeof(val), 1) == 1;
     173             : }
     174             : 
     175             : 
     176             : #ifdef HAVE_HGE
     177             : int
     178           0 : mnstr_readHge(stream *restrict s, hge *restrict val)
     179             : {
     180           0 :         if (s == NULL || val == NULL)
     181             :                 return 0;
     182           0 :         assert(s->binary);
     183           0 :         switch (s->read(s, val, sizeof(*val), 1)) {
     184           0 :         case 1:
     185           0 :                 if (s->swapbytes)
     186           0 :                         *val = huge_int_SWAP(*val);
     187             :                 return 1;
     188             :         case 0:
     189             :                 return 0;
     190           0 :         default:                /* -1 */
     191           0 :                 return -1;
     192             :         }
     193             : }
     194             : 
     195             : int
     196           0 : mnstr_writeHge(stream *s, hge val)
     197             : {
     198           0 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
     199             :                 return 0;
     200           0 :         assert(s->binary);
     201           0 :         if (s->swapbytes)
     202           0 :                 val = huge_int_SWAP(val);
     203           0 :         return s->write(s, &val, sizeof(val), 1) == 1;
     204             : }
     205             : #endif
     206             : 
     207             : int
     208        2971 : mnstr_readBteArray(stream *restrict s, int8_t *restrict val, size_t cnt)
     209             : {
     210        2971 :         if (s == NULL || val == NULL)
     211             :                 return 0;
     212             : 
     213        2971 :         if (s->read(s, (void *) val, sizeof(*val), cnt) < (ssize_t) cnt) {
     214           0 :                 if (s->errkind == MNSTR_NO__ERROR)
     215           0 :                         mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
     216           0 :                 return 0;
     217             :         }
     218             : 
     219             :         return 1;
     220             : }
     221             : 
     222             : int
     223        3221 : mnstr_writeBteArray(stream *restrict s, const int8_t *restrict val, size_t cnt)
     224             : {
     225        3221 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
     226             :                 return 0;
     227        3221 :         return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
     228             : }
     229             : 
     230             : int
     231        3234 : mnstr_readShtArray(stream *restrict s, int16_t *restrict val, size_t cnt)
     232             : {
     233        3234 :         if (s == NULL || val == NULL)
     234             :                 return 0;
     235        3234 :         assert(s->binary);
     236        3234 :         if (s->read(s, val, sizeof(*val), cnt) < (ssize_t) cnt) {
     237           0 :                 if (s->errkind == MNSTR_NO__ERROR)
     238           0 :                         mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
     239           0 :                 return 0;
     240             :         }
     241        3234 :         if (s->swapbytes) {
     242           0 :                 for (size_t i = 0; i < cnt; i++, val++)
     243           0 :                         *val = short_int_SWAP(*val);
     244             :         }
     245             :         return 1;
     246             : }
     247             : 
     248             : int
     249        3572 : mnstr_writeShtArray(stream *restrict s, const int16_t *restrict val, size_t cnt)
     250             : {
     251        3572 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
     252             :                 return 0;
     253        3572 :         assert(s->binary);
     254        3572 :         if (s->swapbytes) {
     255           0 :                 for (size_t i = 0; i < cnt; i++)
     256           0 :                         if (!mnstr_writeSht(s, val[i]))
     257             :                                 return 0;
     258             :                 return 1;
     259             :         }
     260        3572 :         return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
     261             : }
     262             : 
     263             : int
     264       24060 : mnstr_readIntArray(stream *restrict s, int *restrict val, size_t cnt)
     265             : {
     266       24060 :         if (s == NULL || val == NULL)
     267             :                 return 0;
     268       24060 :         assert(s->binary);
     269       24060 :         if (s->read(s, val, sizeof(*val), cnt) < (ssize_t) cnt) {
     270           0 :                 if (s->errkind == MNSTR_NO__ERROR)
     271           0 :                         mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
     272           0 :                 return 0;
     273             :         }
     274       24060 :         if (s->swapbytes) {
     275           0 :                 for (size_t i = 0; i < cnt; i++, val++)
     276           0 :                         *val = normal_int_SWAP(*val);
     277             :         }
     278             :         return 1;
     279             : }
     280             : 
     281             : int
     282       25347 : mnstr_writeIntArray(stream *restrict s, const int *restrict val, size_t cnt)
     283             : {
     284       25347 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
     285             :                 return 0;
     286       25347 :         assert(s->binary);
     287       25347 :         if (s->swapbytes) {
     288           0 :                 for (size_t i = 0; i < cnt; i++)
     289           0 :                         if (!mnstr_writeInt(s, val[i]))
     290             :                                 return 0;
     291             :                 return 1;
     292             :         }
     293       25347 :         return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
     294             : }
     295             : 
     296             : int
     297       14668 : mnstr_readLngArray(stream *restrict s, int64_t *restrict val, size_t cnt)
     298             : {
     299       14668 :         if (s == NULL || val == NULL)
     300             :                 return 0;
     301       14668 :         assert(s->binary);
     302       14668 :         if (s->read(s, val, sizeof(*val), cnt) < (ssize_t) cnt) {
     303           0 :                 if (s->errkind == MNSTR_NO__ERROR)
     304           0 :                         mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
     305           0 :                 return 0;
     306             :         }
     307       14668 :         if (s->swapbytes) {
     308           0 :                 for (size_t i = 0; i < cnt; i++, val++)
     309           0 :                         *val = long_int_SWAP(*val);
     310             :         }
     311             :         return 1;
     312             : }
     313             : 
     314             : int
     315        2079 : mnstr_writeLngArray(stream *restrict s, const int64_t *restrict val, size_t cnt)
     316             : {
     317        2079 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
     318             :                 return 0;
     319        2079 :         assert(s->binary);
     320        2079 :         if (s->swapbytes) {
     321           0 :                 for (size_t i = 0; i < cnt; i++)
     322           0 :                         if (!mnstr_writeLng(s, val[i]))
     323             :                                 return 0;
     324             :                 return 1;
     325             :         }
     326        2079 :         return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
     327             : }
     328             : 
     329             : #ifdef HAVE_HGE
     330             : int
     331         485 : mnstr_readHgeArray(stream *restrict s, hge *restrict val, size_t cnt)
     332             : {
     333         485 :         if (s == NULL || val == NULL)
     334             :                 return 0;
     335         485 :         assert(s->binary);
     336         485 :         if (s->read(s, val, sizeof(*val), cnt) < (ssize_t) cnt) {
     337           0 :                 if (s->errkind == MNSTR_NO__ERROR)
     338           0 :                         mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
     339           0 :                 return 0;
     340             :         }
     341         485 :         if (s->swapbytes) {
     342           0 :                 for (size_t i = 0; i < cnt; i++, val++)
     343           0 :                         *val = huge_int_SWAP(*val);
     344             :         }
     345             :         return 1;
     346             : }
     347             : 
     348             : int
     349         489 : mnstr_writeHgeArray(stream *restrict s, const hge *restrict val, size_t cnt)
     350             : {
     351         489 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
     352             :                 return 0;
     353         489 :         assert(s->binary);
     354         489 :         if (s->swapbytes) {
     355           0 :                 for (size_t i = 0; i < cnt; i++)
     356           0 :                         if (!mnstr_writeHge(s, val[i]))
     357             :                                 return 0;
     358             :                 return 1;
     359             :         }
     360         489 :         return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
     361             : }
     362             : #endif
     363             : 
     364             : int
     365     9448466 : mnstr_printf(stream *restrict s, const char *restrict format, ...)
     366             : {
     367             :         char buf[512], *bf = buf;
     368             :         int i = 0;
     369             :         size_t bfsz = sizeof(buf);
     370             :         va_list ap;
     371             : 
     372     9448466 :         if (s == NULL || s->errkind != MNSTR_NO__ERROR)
     373             :                 return -1;
     374             : 
     375     9448426 :         va_start(ap, format);
     376     9448426 :         i = vsnprintf(bf, bfsz, format, ap);
     377     9448426 :         va_end(ap);
     378     9448786 :         while (i < 0 || (size_t) i >= bfsz) {
     379         360 :                 if (i >= 0)  /* glibc 2.1 */
     380         360 :                         bfsz = (size_t) i + 1;  /* precisely what is needed */
     381             :                 else            /* glibc 2.0 */
     382           0 :                         bfsz *= 2;      /* twice the old size */
     383         360 :                 if (bf != buf)
     384           0 :                         free(bf);
     385         360 :                 bf = malloc(bfsz);
     386         360 :                 if (bf == NULL) {
     387           0 :                         mnstr_set_error(s, MNSTR_WRITE_ERROR, "malloc failed");
     388           0 :                         return -1;
     389             :                 }
     390         360 :                 va_start(ap, format);
     391         360 :                 i = vsnprintf(bf, bfsz, format, ap);
     392         360 :                 va_end(ap);
     393             :         }
     394     9448426 :         s->write(s, (void *) bf, (size_t) i, (size_t) 1);
     395     9448426 :         if (bf != buf)
     396         360 :                 free(bf);
     397     9448426 :         return s->errkind == MNSTR_NO__ERROR ? i : -1;
     398             : }
     399             : 

Generated by: LCOV version 1.14