LCOV - code coverage report
Current view: top level - src/backend/utils/mb/conversion_procs/utf8_and_win - utf8_and_win.c (source / functions) Coverage Total Hit
Test: PostgreSQL 19devel Lines: 93.1 % 29 27
Test Date: 2026-03-08 06:14:55 Functions: 100.0 % 5 5
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /*-------------------------------------------------------------------------
       2              :  *
       3              :  *    WIN <--> UTF8
       4              :  *
       5              :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
       6              :  * Portions Copyright (c) 1994, Regents of the University of California
       7              :  *
       8              :  * IDENTIFICATION
       9              :  *    src/backend/utils/mb/conversion_procs/utf8_and_win/utf8_and_win.c
      10              :  *
      11              :  *-------------------------------------------------------------------------
      12              :  */
      13              : 
      14              : #include "postgres.h"
      15              : #include "fmgr.h"
      16              : #include "mb/pg_wchar.h"
      17              : #include "../../Unicode/utf8_to_win1250.map"
      18              : #include "../../Unicode/utf8_to_win1251.map"
      19              : #include "../../Unicode/utf8_to_win1252.map"
      20              : #include "../../Unicode/utf8_to_win1253.map"
      21              : #include "../../Unicode/utf8_to_win1254.map"
      22              : #include "../../Unicode/utf8_to_win1255.map"
      23              : #include "../../Unicode/utf8_to_win1256.map"
      24              : #include "../../Unicode/utf8_to_win1257.map"
      25              : #include "../../Unicode/utf8_to_win1258.map"
      26              : #include "../../Unicode/utf8_to_win866.map"
      27              : #include "../../Unicode/utf8_to_win874.map"
      28              : #include "../../Unicode/win1250_to_utf8.map"
      29              : #include "../../Unicode/win1251_to_utf8.map"
      30              : #include "../../Unicode/win1252_to_utf8.map"
      31              : #include "../../Unicode/win1253_to_utf8.map"
      32              : #include "../../Unicode/win1254_to_utf8.map"
      33              : #include "../../Unicode/win1255_to_utf8.map"
      34              : #include "../../Unicode/win1256_to_utf8.map"
      35              : #include "../../Unicode/win1257_to_utf8.map"
      36              : #include "../../Unicode/win866_to_utf8.map"
      37              : #include "../../Unicode/win874_to_utf8.map"
      38              : #include "../../Unicode/win1258_to_utf8.map"
      39              : 
      40            3 : PG_MODULE_MAGIC_EXT(
      41              :                     .name = "utf8_and_win",
      42              :                     .version = PG_VERSION
      43              : );
      44              : 
      45            3 : PG_FUNCTION_INFO_V1(win_to_utf8);
      46            3 : PG_FUNCTION_INFO_V1(utf8_to_win);
      47              : 
      48              : /* ----------
      49              :  * conv_proc(
      50              :  *      INTEGER,    -- source encoding id
      51              :  *      INTEGER,    -- destination encoding id
      52              :  *      CSTRING,    -- source string (null terminated C string)
      53              :  *      CSTRING,    -- destination string (null terminated C string)
      54              :  *      INTEGER,    -- source string length
      55              :  *      BOOL        -- if true, don't throw an error if conversion fails
      56              :  * ) returns INTEGER;
      57              :  *
      58              :  * Returns the number of bytes successfully converted.
      59              :  * ----------
      60              :  */
      61              : 
      62              : typedef struct
      63              : {
      64              :     pg_enc      encoding;
      65              :     const pg_mb_radix_tree *map1;   /* to UTF8 map name */
      66              :     const pg_mb_radix_tree *map2;   /* from UTF8 map name */
      67              : } pg_conv_map;
      68              : 
      69              : static const pg_conv_map maps[] = {
      70              :     {PG_WIN866, &win866_to_unicode_tree, &win866_from_unicode_tree},
      71              :     {PG_WIN874, &win874_to_unicode_tree, &win874_from_unicode_tree},
      72              :     {PG_WIN1250, &win1250_to_unicode_tree, &win1250_from_unicode_tree},
      73              :     {PG_WIN1251, &win1251_to_unicode_tree, &win1251_from_unicode_tree},
      74              :     {PG_WIN1252, &win1252_to_unicode_tree, &win1252_from_unicode_tree},
      75              :     {PG_WIN1253, &win1253_to_unicode_tree, &win1253_from_unicode_tree},
      76              :     {PG_WIN1254, &win1254_to_unicode_tree, &win1254_from_unicode_tree},
      77              :     {PG_WIN1255, &win1255_to_unicode_tree, &win1255_from_unicode_tree},
      78              :     {PG_WIN1256, &win1256_to_unicode_tree, &win1256_from_unicode_tree},
      79              :     {PG_WIN1257, &win1257_to_unicode_tree, &win1257_from_unicode_tree},
      80              :     {PG_WIN1258, &win1258_to_unicode_tree, &win1258_from_unicode_tree},
      81              : };
      82              : 
      83              : Datum
      84           33 : win_to_utf8(PG_FUNCTION_ARGS)
      85              : {
      86           33 :     int         encoding = PG_GETARG_INT32(0);
      87           33 :     unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
      88           33 :     unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
      89           33 :     int         len = PG_GETARG_INT32(4);
      90           33 :     bool        noError = PG_GETARG_BOOL(5);
      91              :     int         i;
      92              : 
      93           33 :     CHECK_ENCODING_CONVERSION_ARGS(-1, PG_UTF8);
      94              : 
      95          198 :     for (i = 0; i < lengthof(maps); i++)
      96              :     {
      97          198 :         if (encoding == maps[i].encoding)
      98              :         {
      99              :             int         converted;
     100              : 
     101           33 :             converted = LocalToUtf(src, len, dest,
     102           33 :                                    maps[i].map1,
     103              :                                    NULL, 0,
     104              :                                    NULL,
     105              :                                    encoding,
     106              :                                    noError);
     107           33 :             PG_RETURN_INT32(converted);
     108              :         }
     109              :     }
     110              : 
     111            0 :     ereport(ERROR,
     112              :             (errcode(ERRCODE_INTERNAL_ERROR),
     113              :              errmsg("unexpected encoding ID %d for WIN character sets",
     114              :                     encoding)));
     115              : 
     116              :     PG_RETURN_INT32(0);
     117              : }
     118              : 
     119              : Datum
     120           33 : utf8_to_win(PG_FUNCTION_ARGS)
     121              : {
     122           33 :     int         encoding = PG_GETARG_INT32(1);
     123           33 :     unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
     124           33 :     unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
     125           33 :     int         len = PG_GETARG_INT32(4);
     126           33 :     bool        noError = PG_GETARG_BOOL(5);
     127              :     int         i;
     128              : 
     129           33 :     CHECK_ENCODING_CONVERSION_ARGS(PG_UTF8, -1);
     130              : 
     131          198 :     for (i = 0; i < lengthof(maps); i++)
     132              :     {
     133          198 :         if (encoding == maps[i].encoding)
     134              :         {
     135              :             int         converted;
     136              : 
     137           33 :             converted = UtfToLocal(src, len, dest,
     138           33 :                                    maps[i].map2,
     139              :                                    NULL, 0,
     140              :                                    NULL,
     141              :                                    encoding,
     142              :                                    noError);
     143           33 :             PG_RETURN_INT32(converted);
     144              :         }
     145              :     }
     146              : 
     147            0 :     ereport(ERROR,
     148              :             (errcode(ERRCODE_INTERNAL_ERROR),
     149              :              errmsg("unexpected encoding ID %d for WIN character sets",
     150              :                     encoding)));
     151              : 
     152              :     PG_RETURN_INT32(0);
     153              : }
        

Generated by: LCOV version 2.0-1