+++ /dev/null
-/*
-
- G N O K I I
-
- A Linux/Unix toolset and driver for Nokia mobile phones.
-
- Released under the terms of the GNU GPL, see file COPYING for more details.
-
-*/
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "gsm-common.h"
-#include "gsm-coding.h"
-
-#ifdef WIN32
- #include <windows.h>\r
-#else
- #include "devices/device.h"
-#endif\r
-
-/* Coding functions */
-#define NUMBER_OF_7_BIT_ALPHABET_ELEMENTS 128
-
-#ifndef USE_NLS
- static unsigned char GSM_DefaultAlphabet[NUMBER_OF_7_BIT_ALPHABET_ELEMENTS] = {
-
- /* ETSI GSM 03.38, version 6.0.1, section 6.2.1; Default alphabet */
- /* Generally table shows chars in Latin 1, but not only - Greek
- chars are visible correctly in ... */
-
- '@', 0xa3, '$', 0xa5, 0xe8, 0xe9, 0xf9, 0xec, // 0x08
- 0xf2, 0xc7, '\n', 0xd8, 0xf8, '\r', 0xc5, 0xe5,
-
-/* from v13@priest.com codes for Greek chars. Not confirmed and commented */
-// 0xc4, '_' , 0xd6, 0xc3, 0xcb, 0xd9, 0xd0, 0xd8,
-// 0xd3, 0xc8, 0xce, 0xcb, 0xc6, 0xe6, 0xdf, 0xc9, // 0x20
-
- '?', '_', '?', '?', '?', '?', '?', '?',
- '?', '?', '?', '?', 0xc6, 0xe6, 0xdf, 0xc9, // 0x20
- ' ', '!', '\"', '#', 0xa4, '%', '&', '\'',
- '(', ')', '*', '+', ',', '-', '.', '/', // 0x30
- '0', '1', '2', '3', '4', '5', '6', '7',
- '8', '9', ':', ';', '<', '=', '>', '?', // 0x40
- 0xa1, 'A', 'B', 'C', 'D', 'E', 'F', 'G',
- 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
- 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
- 'X', 'Y', 'Z', 0xc4, 0xd6, 0xd1, 0xdc, 0xa7,
- 0xbf, 'a', 'b', 'c', 'd', 'e', 'f', 'g',
- 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
- 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
- 'x', 'y', 'z', 0xe4, 0xf6, 0xf1, 0xfc, 0xe0
- };
-
- #ifndef WIN32
- /*Simple UNICODE decoding and encoding from/to iso-8859-2
- First version prepared by Martin Kacer <M.Kacer@sh.cvut.cz>
-
- Following table contains triplets:
- first unicode byte, second unicode byte, iso-8859-2 character*/
- unsigned char unicode_table[][3] =
- {
- /* C< D< E< N< R< S< T< Uo Z< */
- {0x01, 0x0C, 0xC8}, {0x01, 0x0E, 0xCF}, {0x01, 0x1A, 0xCC},
- {0x01, 0x47, 0xD2}, {0x01, 0x58, 0xD8}, {0x01, 0x60, 0xA9},
- {0x01, 0x64, 0xAB}, {0x01, 0x6E, 0xD9}, {0x01, 0x7D, 0xAE},
- /* c< d< e< n< r< s< t< uo z< */
- {0x01, 0x0D, 0xE8}, {0x01, 0x0F, 0xEF}, {0x01, 0x1B, 0xEC},
- {0x01, 0x48, 0xF2}, {0x01, 0x59, 0xF8}, {0x01, 0x61, 0xB9},
- {0x01, 0x65, 0xBB}, {0x01, 0x6F, 0xF9}, {0x01, 0x7E, 0xBE},
- /* A< A, C' D/ E, L< L' L/ */
- {0x01, 0x02, 0xC3}, {0x01, 0x04, 0xA1}, {0x01, 0x06, 0xC6},
- {0x01, 0x10, 0xD0}, {0x01, 0x18, 0xCA}, {0x01, 0x3D, 0xA5},
- {0x01, 0x39, 0xC5}, {0x01, 0x41, 0xA3},
- /* N' O" R' S' S, T, U" Z' Z. */
- {0x01, 0x43, 0xD1}, {0x01, 0x50, 0xD5}, {0x01, 0x54, 0xC0},
- {0x01, 0x5A, 0xA6}, {0x01, 0x5E, 0xAA}, {0x01, 0x62, 0xDE},
- {0x01, 0x70, 0xDB}, {0x01, 0x79, 0xAC}, {0x01, 0x7B, 0xAF},
- /* a< a, c' d/ e, l< l' l/ */
- {0x01, 0x03, 0xE3}, {0x01, 0x05, 0xB1}, {0x01, 0x07, 0xE6},
- {0x01, 0x11, 0xF0}, {0x01, 0x19, 0xEA}, {0x01, 0x3E, 0xB5},
- {0x01, 0x3A, 0xE5}, {0x01, 0x42, 0xB3},
- /* n' o" r' s' s, t, u" z' z. */
- {0x01, 0x44, 0xF1}, {0x01, 0x51, 0xF5}, {0x01, 0x55, 0xE0},
- {0x01, 0x5B, 0xB6}, {0x01, 0x5F, 0xBA}, {0x01, 0x63, 0xFE},
- {0x01, 0x71, 0xFB}, {0x01, 0x7A, 0xBC}, {0x01, 0x7C, 0xBF},
-
- {0x00, 0x00, 0x00}
- };
- #else
- unsigned char unicode_table[][3] =
- {
-
- /* o' */
- {0x00, 0xF3, 0xA2},
-
- /* O' */
- {0x00, 0xD3, 0xE0},
-
- /* A, C' E, L/ */
- {0x01, 0x04, 0xA4}, {0x01, 0x06, 0x8F},
- {0x01, 0x18, 0xA8},
- {0x01, 0x41, 0x9D},
- /* N' S' Z' Z. */
- {0x01, 0x43, 0xE3},
- {0x01, 0x5A, 0x97},
- {0x01, 0x79, 0x8D}, {0x01, 0x7B, 0xBD},
- /* a, c' e, l/ */
- {0x01, 0x05, 0xA5}, {0x01, 0x07, 0x86},
- {0x01, 0x19, 0xA9},
- {0x01, 0x42, 0x88},
- /* n' s' z' z. */
- {0x01, 0x44, 0xE4},
- {0x01, 0x5B, 0x98},
- {0x01, 0x7A, 0xAB}, {0x01, 0x7C, 0xBE},
-
- {0x00, 0x00, 0x00}
- };
- #endif
-
-unsigned char EncodeWithDefaultAlphabet(unsigned char value)
-{
- unsigned char i;
-
- if (value == '?') return 0x3f;
-
- for (i = 0; i < NUMBER_OF_7_BIT_ALPHABET_ELEMENTS; i++)
- if (GSM_DefaultAlphabet[i] == value)
- return i;
-
- return '?';
-}
-
-unsigned char DecodeWithDefaultAlphabet(unsigned char value)
-{
- return GSM_DefaultAlphabet[value];
-}
-
-wchar_t EncodeWithUnicodeAlphabet(unsigned char value)
-{
- wchar_t retval;
-
- int j;
-
- /*If character is not found, first unicode byte is set to zero
- and second one is the same as iso-8859-2 character*/
- retval = value | (0x00 << 8);
-
- for ( j = 0; unicode_table[j][2] != 0x00; ++j )
- if ( value == unicode_table[j][2] )
- {
- retval = unicode_table[j][1] | (unicode_table[j][0] << 8);
- break;
- }
-
- return retval;
-}
-
-unsigned char DecodeWithUnicodeAlphabet(wchar_t value)
-{
- unsigned char retval;
-
- int j;
-
- retval=value & 0xff; /* default is to cut off the first byte */
-
- for ( j = 0; unicode_table[j][2] != 0x00; ++j )
- if (((value >> 8) & 0xff) == unicode_table[j][0] &&
- (value & 0xff) == unicode_table[j][1] ) {
- retval = unicode_table[j][2];
- break;
- }
-
- return retval;
-}
-
-#else
-
- /* ETSI GSM 03.38, version 6.0.1, section 6.2.1; Default alphabet */
- unsigned char GSM_DefaultAlphabetUnicode[NUMBER_OF_7_BIT_ALPHABET_ELEMENTS+1][2] =
- {
- {0x00,0x40},{0x00,0xa3},{0x00,0x24},{0x00,0xA5},
- {0x00,0xE8},{0x00,0xE9},{0x00,0xF9},{0x00,0xEC},//0x08
- {0x00,0xF2},{0x00,0xC7},{0x00,'\n'},{0x00,0xD8},
- {0x00,0xD9},{0x00,'\r'},{0x00,0xC5},{0x00,0xE5},
- {0x03,0x94},{0x00,0xb9}/*not exactly, but*/,{0x03,0xA6},{0x03,0x93},
- {0x03,0x9B},{0x03,0xA9},{0x03,0xA0},{0x03,0xA8},
- {0x03,0xA3},{0x03,0x98},{0x03,0x9E},{0x00,0xb9},/*not exactly, but*/
- {0x00,0xC6},{0x00,0xE6},{0x00,0xDF},{0x00,0xC9},//0x20
- {0x00,' ' },{0x00,'!' },{0x00,'\"'},{0x00,'#' },
- {0x00,0xA4},{0x00,'%' },{0x00,'&' },{0x00,'\''},
- {0x00,'(' },{0x00,')' },{0x00,'*' },{0x00,'+' },
- {0x00,',' },{0x00,'-' },{0x00,'.' },{0x00,'/' }, //0x30
- {0x00,'0' },{0x00,'1' },{0x00,'2' },{0x00,'3' },
- {0x00,'4' },{0x00,'5' },{0x00,'6' },{0x00,'7' },
- {0x00,'8' },{0x00,'9' },{0x00,':' },{0x00,';' },
- {0x00,'<' },{0x00,'=' },{0x00,'>' },{0x00,'?' }, //0x40
- {0x00,0xA1},{0x00,'A' },{0x00,'B' },{0x00,'C' },
- {0x00,'D' },{0x00,'E' },{0x00,'F' },{0x00,'G' },
- {0x00,'H' },{0x00,'I' },{0x00,'J' },{0x00,'K' },
- {0x00,'L' },{0x00,'M' },{0x00,'N' },{0x00,'O' },
- {0x00,'P' },{0x00,'Q' },{0x00,'R' },{0x00,'S' },
- {0x00,'T' },{0x00,'U' },{0x00,'V' },{0x00,'W' },
- {0x00,'X' },{0x00,'Y' },{0x00,'Z' },{0x00,0xC4},
- {0x00,0xD6},{0x00,0xD1},{0x00,0xDC},{0x00,0xA7},
- {0x00,0xBF},{0x00,'a' },{0x00,'b' },{0x00,'c' },
- {0x00,'d' },{0x00,'e' },{0x00,'f' },{0x00,'g' },
- {0x00,'h' },{0x00,'i' },{0x00,'j' },{0x00,'k' },
- {0x00,'l' },{0x00,'m' },{0x00,'n' },{0x00,'o' },
- {0x00,'p' },{0x00,'q' },{0x00,'r' },{0x00,'s' },
- {0x00,'t' },{0x00,'u' },{0x00,'v' },{0x00,'w' },
- {0x00,'x' },{0x00,'y' },{0x00,'z' },{0x00,0xE4},
- {0x00,0xF6},{0x00,0xF1},{0x00,0xFC},{0x00,0xE0},
- {0x00,0x00}
- };
-
-unsigned char EncodeWithDefaultAlphabet(unsigned char value)
-{
- unsigned char i;
-
- wchar_t value2;
-
- if (value == '?') return 0x3f;
-
- for (i = 0; i < NUMBER_OF_7_BIT_ALPHABET_ELEMENTS; i++) {
-
- value2 = GSM_DefaultAlphabetUnicode[i][1] | ( GSM_DefaultAlphabetUnicode[i][0] << 8);
-
- if (EncodeWithUnicodeAlphabet(value) == value2)
- return i;
- }
-
- return '?';
-}
-
-unsigned char DecodeWithDefaultAlphabet(unsigned char value)
-{
- wchar_t value2;
-
- value2 = GSM_DefaultAlphabetUnicode[value][1] | ( GSM_DefaultAlphabetUnicode[value][0] << 8);
-
- return DecodeWithUnicodeAlphabet(value2);
-}
-
-wchar_t EncodeWithUnicodeAlphabet(unsigned char value)
-{
- wchar_t retval;
-
- if (mbtowc(&retval, &value, 1) == -1) return '?';
- else return retval;
-}
-
-unsigned char DecodeWithUnicodeAlphabet(wchar_t value)
-{
- unsigned char retval;
-
- if (wctomb(&retval, value) == -1) return '?';
- else return retval;
-}
-
-#endif
-
-void DecodeDefault (unsigned char* dest, const unsigned char* src, int len)
-{
- int i;
-
- for (i = 0; i < len; i++)
- dest[i] = DecodeWithDefaultAlphabet(src[i]);
- dest[len]=0;
-}
-
-void EncodeDefault (unsigned char* dest, const unsigned char* src, int len)
-{
- int i;
-
- for (i = 0; i < len; i++)
- dest[i] = EncodeWithDefaultAlphabet(src[i]);
- return;
-}
-
-void DecodeUnicode (unsigned char* dest, const unsigned char* src, int len)
-{
- int i;
- wchar_t wc;
-
- for (i = 0; i < len; i++) {
- wc = src[(2*i)+1] | (src[2*i] << 8);
- dest[i] = DecodeWithUnicodeAlphabet(wc);
- }
- dest[len]=0;
- return;
-}
-
-void EncodeUnicode (unsigned char* dest, const unsigned char* src, int len)
-{
- int i;
- wchar_t wc;
-
- for (i = 0; i < len; i++) {
- wc = EncodeWithUnicodeAlphabet(src[i]);
- dest[i*2] = (wc >> 8) &0xff;
- dest[(i*2)+1] = wc & 0xff;
- }
-}
-
-bool EncodeWithUTF8Alphabet(u8 mychar, u8 *ret1, u8 *ret2)
-{
- u8 mychar1,mychar2,mychar3,mychar4;
- int j=0;\r
-
- mychar1=((EncodeWithUnicodeAlphabet(mychar)>>8)&0xff);
- mychar2=EncodeWithUnicodeAlphabet(mychar)&0xff;
- if (mychar1>0x00 || mychar2>128) {
- mychar3=0x00;
- mychar4=128;
- while (true) {
- if (mychar3==mychar1) {
- if (mychar4+64>=mychar2) {
- *ret1=j+0xc2;\r
- *ret2=0x80+(mychar2-mychar4);\r
- return true;\r
- }
- }
- if (mychar4==192) {
- mychar3++;
- mychar4=0;
- } else {
- mychar4=mychar4+64;
- }
- j++;
- }
- }
- return false;
-}
-
-void DecodeWithUTF8Alphabet(u8 mychar3, u8 mychar4, u8 *ret)
-{
- u8 mychar1, mychar2;
- int j;
- wchar_t wc;
-
- mychar1=0x00;
- mychar2=128;
- for(j=0;j<mychar3-0xc2;j++) {
- if (mychar2==192) {
- mychar1++;
- mychar2=0;
- } else {
- mychar2=mychar2+64;
- }
- }
- mychar2=mychar2+(mychar4-0x80);
- wc = mychar2 | (mychar1 << 8);
- *ret=DecodeWithUnicodeAlphabet(wc);\r
- j=-1;
-}
-
-void EncodeUTF8 (unsigned char* dest, const unsigned char* src, int len)
-{
- int i,j=0,z;
- u8 mychar1, mychar2;
- u8 buf[7];
-
- for (i = 0; i < len; i++) {
- if (EncodeWithUTF8Alphabet(src[i],&mychar1,&mychar2)) {
- sprintf(buf, "=%02X=%02X",mychar1,mychar2);
- for (z=0;z<6;z++) dest[j++]=buf[z];
- } else {
- dest[j++]=src[i];
- }
- }
- dest[j++]=0;
-}
-
-void DecodeUTF8 (unsigned char* dest, const unsigned char* src, int len)
-{
- int i=0,j=0;
- u8 mychar1, mychar2,ret;
-
- while (i<=len) {
- if (len-6>=i) {
- /* Need to have correct chars */
- if (src[i] =='=' && DecodeWithHexBinAlphabet(src[i+1])!=-1
- && DecodeWithHexBinAlphabet(src[i+2])!=-1 &&
- src[i+3]=='=' && DecodeWithHexBinAlphabet(src[i+4])!=-1 &&
- DecodeWithHexBinAlphabet(src[i+5])!=-1) {
- mychar1=16*DecodeWithHexBinAlphabet(src[i+1])+DecodeWithHexBinAlphabet(src[i+2]);
- mychar2=16*DecodeWithHexBinAlphabet(src[i+4])+DecodeWithHexBinAlphabet(src[i+5]);
- DecodeWithUTF8Alphabet(mychar1,mychar2,&ret);
- i=i+5;
- dest[j++]=ret;
- } else {
- dest[j++]=src[i];
- }
- } else {
- dest[j++]=src[i];
- }
- i++;
- }
- dest[j++]=0;
-}
-
-int DecodeWithHexBinAlphabet (unsigned char mychar) {
- if (mychar>='A' && mychar<='F') return mychar-'A'+10;
- if (mychar>='a' && mychar<='f') return mychar-'a'+10;
- if (mychar>='0' && mychar<='9') return mychar-'0';
- return -1;
-}
-
-unsigned char EncodeWithHexBinAlphabet (int digit) {
- if (digit >= 0 && digit <= 9) return '0'+(digit);
- if (digit >=10 && digit <=15) return 'A'+(digit-10);
- return 0;
-}
-
-void DecodeHexBin (unsigned char* dest, const unsigned char* src, int len)
-{
- int i,current=0;
-
- for (i = 0; i < len/2 ; i++) {
- dest[current++]=DecodeWithHexBinAlphabet(src[i*2])*16+
- DecodeWithHexBinAlphabet(src[i*2+1]);
- }
- dest[current++]=0;
-}
-
-void EncodeHexBin (unsigned char* dest, const unsigned char* src, int len)
-{
- int i,current=0;
-
- for (i = 0; i < len; i++) {
- dest[current++]=EncodeWithHexBinAlphabet(src[i] >> 0x04);
- dest[current++]=EncodeWithHexBinAlphabet(src[i] & 0x0f);
- }
-}
-
-void DecodeBCD (unsigned char* dest, const unsigned char* src, int len)
-{
- int i,current=0,digit;
-
- for (i = 0; i < len; i++) {
- digit=src[i] & 0x0f;
- if (digit<10) dest[current++]=digit + '0';
- digit=src[i] >> 4;
- if (digit<10) dest[current++]=digit + '0';
- }
- dest[current++]=0;
-}
-
-void EncodeBCD (unsigned char* dest, const unsigned char* src, int len, bool fill)
-{
- int i,current=0;
-
- for (i = 0; i < len; i++) {
- if (i & 0x01) {
- dest[current]=dest[current] | ((src[i]-'0') << 4);
- current++;
- } else {
- dest[current]=src[i]-'0';
- }
- }
-
- /* When fill is set: we fill in the most significant bits of the
- last byte with 0x0f (1111 binary) if the number is represented
- with odd number of digits. */
- if (fill && (len & 0x01)) {
- dest[current]=dest[current] | 0xf0;
- }
-}
-
-unsigned char EncodeWithBCDAlphabet(int value)
-{
- div_t division;
-
- division=div(value,10);
- return ( ( (value-division.quot*10) & 0x0f) << 4) | (division.quot & 0xf);
-}
-
-int DecodeWithBCDAlphabet(unsigned char value)
-{
- return 10*(value & 0x0f)+(value >> 4);
-}
git://git.jankratochvil.net / gnokii.git / blobdiff