1998-07-24 05:32:46 +02:00
|
|
|
/*
|
|
|
|
* This file contains public functions for conversion between
|
|
|
|
* client encoding and server internal encoding.
|
|
|
|
* (currently mule internal code (mic) is used)
|
|
|
|
* Tatsuo Ishii
|
1999-07-17 22:18:55 +02:00
|
|
|
* $Id: mbutils.c,v 1.8 1999/07/17 20:18:10 momjian Exp $ */
|
1998-07-24 05:32:46 +02:00
|
|
|
|
|
|
|
|
1999-07-17 18:25:28 +02:00
|
|
|
#include "postgres.h"
|
|
|
|
#include "miscadmin.h"
|
1998-07-24 05:32:46 +02:00
|
|
|
#include "mb/pg_wchar.h"
|
|
|
|
|
1999-05-25 18:15:34 +02:00
|
|
|
static int client_encoding = -1;
|
1998-09-01 06:40:42 +02:00
|
|
|
static void (*client_to_mic) ();/* something to MIC */
|
|
|
|
static void (*client_from_mic) (); /* MIC to something */
|
|
|
|
static void (*server_to_mic) ();/* something to MIC */
|
|
|
|
static void (*server_from_mic) (); /* MIC to something */
|
1998-07-24 05:32:46 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* find encoding table entry by encoding
|
|
|
|
*/
|
1998-09-01 06:40:42 +02:00
|
|
|
static pg_encoding_conv_tbl *
|
|
|
|
get_enc_ent(int encoding)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
pg_encoding_conv_tbl *p = pg_conv_tbl;
|
|
|
|
|
|
|
|
for (; p->encoding >= 0; p++)
|
|
|
|
{
|
|
|
|
if (p->encoding == encoding)
|
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
return (0);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set the client encoding. if client/server encoding is
|
|
|
|
* not supported, returns -1
|
|
|
|
*/
|
1998-09-01 06:40:42 +02:00
|
|
|
int
|
|
|
|
pg_set_client_encoding(int encoding)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
int current_server_encoding = GetDatabaseEncoding();
|
|
|
|
|
|
|
|
client_encoding = encoding;
|
|
|
|
|
|
|
|
if (client_encoding == current_server_encoding)
|
|
|
|
{ /* server == client? */
|
|
|
|
client_to_mic = client_from_mic = 0;
|
|
|
|
server_to_mic = server_from_mic = 0;
|
|
|
|
}
|
|
|
|
else if (current_server_encoding == MULE_INTERNAL)
|
|
|
|
{ /* server == MULE_INETRNAL? */
|
|
|
|
client_to_mic = get_enc_ent(encoding)->to_mic;
|
|
|
|
client_from_mic = get_enc_ent(encoding)->from_mic;
|
|
|
|
server_to_mic = server_from_mic = 0;
|
|
|
|
if (client_to_mic == 0 || client_from_mic == 0)
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
else if (encoding == MULE_INTERNAL)
|
|
|
|
{ /* client == MULE_INETRNAL? */
|
|
|
|
client_to_mic = client_from_mic = 0;
|
|
|
|
server_to_mic = get_enc_ent(current_server_encoding)->to_mic;
|
|
|
|
server_from_mic = get_enc_ent(current_server_encoding)->from_mic;
|
|
|
|
if (server_to_mic == 0 || server_from_mic == 0)
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
client_to_mic = get_enc_ent(encoding)->to_mic;
|
|
|
|
client_from_mic = get_enc_ent(encoding)->from_mic;
|
|
|
|
server_to_mic = get_enc_ent(current_server_encoding)->to_mic;
|
|
|
|
server_from_mic = get_enc_ent(current_server_encoding)->from_mic;
|
|
|
|
if (client_to_mic == 0 || client_from_mic == 0)
|
|
|
|
return (-1);
|
|
|
|
if (server_to_mic == 0 || server_from_mic == 0)
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
return (0);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* returns the current client encoding
|
|
|
|
*/
|
1998-09-01 06:40:42 +02:00
|
|
|
int
|
|
|
|
pg_get_client_encoding()
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
if (client_encoding == -1)
|
|
|
|
{
|
|
|
|
/* this is the first time */
|
|
|
|
client_encoding = GetDatabaseEncoding();
|
|
|
|
}
|
|
|
|
return (client_encoding);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* convert client encoding to server encoding. if server_encoding ==
|
|
|
|
* client_encoding or no conversion function exists,
|
|
|
|
* returns s. So be careful.
|
|
|
|
*/
|
1998-09-01 06:40:42 +02:00
|
|
|
unsigned char *
|
|
|
|
pg_client_to_server(unsigned char *s, int len)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
static unsigned char b1[MAX_PARSE_BUFFER * 4]; /* is this enough? */
|
|
|
|
static unsigned char b2[MAX_PARSE_BUFFER * 4]; /* is this enough? */
|
|
|
|
unsigned char *p = s;
|
|
|
|
|
|
|
|
if (client_encoding == GetDatabaseEncoding())
|
|
|
|
return (p);
|
|
|
|
if (client_to_mic)
|
|
|
|
{
|
|
|
|
(*client_to_mic) (s, b1, len);
|
|
|
|
len = strlen(b1);
|
|
|
|
p = b1;
|
|
|
|
}
|
|
|
|
if (server_from_mic)
|
|
|
|
{
|
|
|
|
(*server_from_mic) (p, b2, len);
|
|
|
|
p = b2;
|
|
|
|
}
|
|
|
|
return (p);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* convert server encoding to client encoding. if server_encoding ==
|
|
|
|
* client_encoding or no conversion function exists,
|
|
|
|
* returns s. So be careful.
|
|
|
|
*/
|
1998-09-01 06:40:42 +02:00
|
|
|
unsigned char *
|
|
|
|
pg_server_to_client(unsigned char *s, int len)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
static unsigned char b1[MAX_PARSE_BUFFER * 4]; /* is this enough? */
|
|
|
|
static unsigned char b2[MAX_PARSE_BUFFER * 4]; /* is this enough? */
|
|
|
|
unsigned char *p = s;
|
|
|
|
|
|
|
|
if (client_encoding == GetDatabaseEncoding())
|
|
|
|
return (p);
|
|
|
|
if (server_to_mic)
|
|
|
|
{
|
|
|
|
(*server_to_mic) (s, b1, len);
|
|
|
|
len = strlen(b1);
|
|
|
|
p = b1;
|
|
|
|
}
|
|
|
|
if (client_from_mic)
|
|
|
|
{
|
|
|
|
(*client_from_mic) (p, b2, len);
|
|
|
|
p = b2;
|
|
|
|
}
|
|
|
|
return (p);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* convert a multi-byte string to a wchar */
|
1998-09-01 06:40:42 +02:00
|
|
|
void
|
|
|
|
pg_mb2wchar(const unsigned char *from, pg_wchar * to)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
(*pg_wchar_table[GetDatabaseEncoding()].mb2wchar_with_len) (from, to, strlen(from));
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* convert a multi-byte string to a wchar with a limited length */
|
1998-09-01 06:40:42 +02:00
|
|
|
void
|
|
|
|
pg_mb2wchar_with_len(const unsigned char *from, pg_wchar * to, int len)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
(*pg_wchar_table[GetDatabaseEncoding()].mb2wchar_with_len) (from, to, len);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* returns the byte length of a multi-byte word */
|
1998-09-01 06:40:42 +02:00
|
|
|
int
|
|
|
|
pg_mblen(const unsigned char *mbstr)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
return ((*pg_wchar_table[GetDatabaseEncoding()].mblen) (mbstr));
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* returns the length (counted as a wchar) of a multi-byte string */
|
1998-09-01 06:40:42 +02:00
|
|
|
int
|
|
|
|
pg_mbstrlen(const unsigned char *mbstr)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
while (*mbstr)
|
|
|
|
{
|
|
|
|
mbstr += pg_mblen(mbstr);
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
return (len);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
/* returns the length (counted as a wchar) of a multi-byte string
|
1998-07-24 05:32:46 +02:00
|
|
|
(not necessarily NULL terminated) */
|
1998-09-01 06:40:42 +02:00
|
|
|
int
|
|
|
|
pg_mbstrlen_with_len(const unsigned char *mbstr, int limit)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
int len = 0;
|
|
|
|
int l;
|
|
|
|
|
|
|
|
while (*mbstr && limit > 0)
|
|
|
|
{
|
|
|
|
l = pg_mblen(mbstr);
|
|
|
|
limit -= l;
|
|
|
|
mbstr += l;
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
return (len);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
1998-09-25 03:46:25 +02:00
|
|
|
/*
|
|
|
|
* returns the length of a multi-byte string
|
|
|
|
* (not necessarily NULL terminated)
|
|
|
|
* that is not longer than limit.
|
|
|
|
* this function does not break multi-byte word boundary.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
pg_mbcliplen(const unsigned char *mbstr, int len, int limit)
|
|
|
|
{
|
|
|
|
int clen = 0;
|
|
|
|
int l;
|
|
|
|
|
1999-05-25 18:15:34 +02:00
|
|
|
while (*mbstr && len > 0)
|
1998-09-25 03:46:25 +02:00
|
|
|
{
|
|
|
|
l = pg_mblen(mbstr);
|
1999-05-25 18:15:34 +02:00
|
|
|
if ((clen + l) > limit)
|
1998-09-25 03:46:25 +02:00
|
|
|
break;
|
|
|
|
clen += l;
|
1999-05-25 18:15:34 +02:00
|
|
|
if (clen == limit)
|
1998-09-25 03:46:25 +02:00
|
|
|
break;
|
|
|
|
len -= l;
|
|
|
|
mbstr += l;
|
|
|
|
}
|
|
|
|
return (clen);
|
|
|
|
}
|
|
|
|
|
1998-07-24 05:32:46 +02:00
|
|
|
/*
|
|
|
|
* fuctions for utils/init
|
|
|
|
*/
|
1998-09-01 06:40:42 +02:00
|
|
|
static int DatabaseEncoding = MULTIBYTE;
|
1998-07-24 05:32:46 +02:00
|
|
|
void
|
|
|
|
SetDatabaseEncoding(int encoding)
|
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
DatabaseEncoding = encoding;
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
GetDatabaseEncoding()
|
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
return (DatabaseEncoding);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* for builtin-function */
|
|
|
|
const char *
|
|
|
|
getdatabaseencoding()
|
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
return (pg_encoding_to_char(DatabaseEncoding));
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* set and get template1 database encoding */
|
1998-09-01 06:40:42 +02:00
|
|
|
static int templateEncoding;
|
|
|
|
void
|
|
|
|
SetTemplateEncoding(int encoding)
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
templateEncoding = encoding;
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
int
|
|
|
|
GetTemplateEncoding()
|
1998-07-24 05:32:46 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
return (templateEncoding);
|
1998-07-24 05:32:46 +02:00
|
|
|
}
|