u_code->to_x_bytes, C (clang)

Language: Layout:

//clang 3.8.0

#include  <stdio.h>
#include <string.h>

static int x0_int(char string[]){
	//function return by char, a 1-st hexadecimal value as int, or -1 if not hexadecimal

int code;										//decimal value of hex character if this is hex
	const int o = 48; 								//start offset for charcodes
	int j = 0; //first position is null
		
	switch (string[j]) {//compare charcode
		case o+0 ... o+9:  return code = string[j]-o; //break;			//0-9
		case o+17 ... o+22: return code = string[j]-o-7; //break;		//A-F
		case o+49 ... o+54: return code = string[j]-o-39; //break;		//a-f
		default: return code = -1; //break;								//else -1
	}
}

char * get_x_string(char u_code[]){ //u_code - is escaped code of unicode symbol, like "\\u1ed8"
	//function return string with x-bytes, like "\xe1\xbb\x98", by code of charcode
/*
	Number of bytes		Bits for code point		First code point	Last code point		Byte 1		Byte 2		Byte 3		Byte 4
	1					7						U+0000				U+007F				0xxxxxxx	-			-			-
	2					11						U+0080				U+07FF				110000xx	10xxxxxx	-			-
	3					16						U+0800				U+FFFF				1110xxxx	10xxxxxx	10xxxxxx	-
	4					21						U+10000				U+10FFFF			11110xxx	10xxxxxx	10xxxxxx	10xxxxxx
*/	
	//static int prefix1 = 0;   														//0 	binary (prefix for 1 bytes char)
	static int prefix2 = 6;   														//110 	binary (prefix for 2 bytes char)
	static int prefix3 = 14;   														//1110 	binary (prefix for 3 bytes char)
	static int prefix4 = 30;   														//11110 binary (prefix for 4 bytes char)
	
	static int prefix = 2;															//10	binary (static prefix for every 6 bits)
	
	unsigned int temp;																//temporary integer
	char result[256];																//result string
	char tempstring[256];															//temporary string to concatenate
	
/*
	In "\u1ed8"
	1ed8 -> 0001'1110'1101'1000 (go to 3-bytes UTF-8 sequence with 12-16 bits):
	Leading UTF-8 byte: 1110 (prefix) 0001 (first four bits).
	Continuation byte: 10 (prefix) 1110 11 (again 6 bits).
	Continuation byte: 10 (префикс) 01 1000 (again 6 bits).
	Result: 11100001, 10111011, 10011000 -> e1, bb, 98.
*/
		if(u_code[0]=='\\' && u_code[1]=='u'){										//if "\u" at beginning
		if(
			//if "\\uFFF", or "\uFFFFF"
			(
				x0_int(&u_code[2])!=-1
			&&	x0_int(&u_code[3])!=-1
			&&	x0_int(&u_code[4])!=-1
			&&  x0_int(&u_code[5])==-1
			)
			||
			(
				x0_int(&u_code[2])!=-1
			&&	x0_int(&u_code[3])!=-1
			&&	x0_int(&u_code[4])!=-1
			&&	x0_int(&u_code[5])!=-1
			&&	x0_int(&u_code[6])!=-1
			&&  x0_int(&u_code[7])==-1
			)
		)
		{//insert null at after "\\u"
			//char *u_code = "\\uFFF";					//current char
			char *s = malloc(strlen(u_code) + 1);		//temporary unicode string with not full code. length(u_code)+1
			strcpy(s, u_code);							//copy this

char null_hex_digit = '0';					//hex char for null
			int pos = 2;								//position 2, after "\\u"
			memmove(s+pos+1, s+pos, strlen(s)-pos+1);	//move string
			s[pos]=null_hex_digit;						//insert null

u_code = malloc(strlen(u_code) + 1);		//change length for u_code (+1)
			strcpy(u_code, s);							//copy code

//printf("%s", u_code);						//now this '\u0FFF'
		}

if(
				x0_int(&u_code[2])!=-1
			&&  x0_int(&u_code[3])==-1
		){
			printf("Один байт... %s, \n", u_code);
			//one byte (first byte + 7 bit)
			temp = x0_int(&u_code[2]);												//first byte as int
			printf("первый байт: %x\n", temp);										//print this
			sprintf(tempstring, "\\x%x", temp);										//write 1-st \x byte
			strcpy(result, tempstring);												//copy to result
		}
		else if(
				x0_int(&u_code[2])!=-1
			&&  x0_int(&u_code[3])!=-1
			&&  x0_int(&u_code[4])==-1
		){
			printf("Два байта... %s, \n", u_code);			
			//two bytes (first byte and one byte in unicode)
		   	temp = prefix2<<5 | x0_int(&u_code[2]);									//first byte as int
			if(temp==-1){printf("not hex char"); return 0;}							//or not
			printf("первый байт: %x\n", temp);										//print this
			sprintf(tempstring, "\\x%x", temp);										//write 1-st \x byte
			strcpy(result, tempstring);												//copy to result

temp = prefix<<6 | x0_int(&u_code[3]);									//second byte as int
			if(temp==-1){printf("not hex char"); return 0;}							//or not
			printf("второй байт: %x\n", temp);										//print this (IF THIS STRING WILL BE COMMENTED, RETURNED STRING CANNOT PRINT FULLY)
			sprintf(tempstring, "\\x%x", temp);										//write 2-nd \x byte
			strcat(result, tempstring);												//add to result
		}
		else if(
				x0_int(&u_code[2])!=-1
			&&  x0_int(&u_code[3])!=-1
			&&  x0_int(&u_code[4])!=-1
			&&  x0_int(&u_code[5])!=-1
			&&  x0_int(&u_code[6])==-1			
		){
			printf("Три байта... %s, \n", u_code);
			//three bytes (first byte and two bytes unicode)
		   	temp = prefix3<<4 | x0_int(&u_code[2]);									//first byte as int
			if(temp==-1){printf("not hex char"); return 0;}							//or not
			printf("первый байт: %x\n", temp);										//print this
			sprintf(tempstring, "\\x%x", temp);										//write 1-st \x byte
			strcpy(result, tempstring);												//copy to result

temp = prefix<<6 | x0_int(&u_code[3])<<2 | x0_int(&u_code[4])>>2;		//second byte as int
			if(temp==-1){printf("not hex char"); return 0;}							//or not
			printf("второй байт: %x\n", temp);										//print this (IF THIS STRING WILL BE COMMENTED, RETURNED STRING CANNOT PRINT FULLY)
			sprintf(tempstring, "\\x%x", temp);										//write 2-nd \x byte
			strcat(result, tempstring);												//add to result
		
			temp = prefix<<6 | x0_int(&u_code[4])%4<<4 | x0_int(&u_code[5]);		//third byte as int
			if(temp==-1){printf("not hex char"); return 0;}							//or not
			printf("третий байт: %x\n", temp);										//print this
			sprintf(tempstring, "\\x%x", temp);										//write 3-rd \x byte
			strcat(result, tempstring);												//add to result
		}
		else if(
				x0_int(&u_code[2])!=-1
			&&  x0_int(&u_code[3])!=-1
			&&  x0_int(&u_code[4])!=-1
			&&  x0_int(&u_code[5])!=-1
			&&  x0_int(&u_code[6])!=-1			  
			&&  x0_int(&u_code[7])!=-1			  
			&&  x0_int(&u_code[8])==-1			  
		){
			printf("Четыре байта... %s, \n", u_code);
			//four bytes (first byte and three bytes unicode)
		   	temp = prefix4<<3 | x0_int(&u_code[2])>>1;														//first byte as int
			if(temp==-1){printf("not hex char"); return 0;}													//or not
			printf("первый байт: %x\n", temp);																//print this
			sprintf(tempstring, "\\x%x", temp);																//write 1-st \x byte
			strcpy(result, tempstring);																		//copy to result

temp = prefix<<6 | x0_int(&u_code[2])%10 | x0_int(&u_code[3])<<1 | x0_int(&u_code[4])>>3;		//second byte as int
			if(temp==-1){printf("not hex char"); return 0;}													//or not
			printf("второй байт: %x\n", temp);																//print this (IF THIS STRING WILL BE COMMENTED, RETURNED STRING CANNOT PRINT FULLY)
			sprintf(tempstring, "\\x%x", temp);																//write 2-nd \x byte
			strcat(result, tempstring);																		//add to result
		
			temp = prefix<<6 | x0_int(&u_code[4])%8 | x0_int(&u_code[5])<<4 | x0_int(&u_code[6])>>3;		//third byte as int
			if(temp==-1){printf("not hex char"); return 0;}													//or not
			printf("третий байт: %x\n", temp);																//print this
			sprintf(tempstring, "\\x%x", temp);																//write 3-rd \x byte
			strcat(result, tempstring);																		//add to result

temp = prefix<<6 | x0_int(&u_code[6])%8 | x0_int(&u_code[7]);									//third byte as int
			if(temp==-1){printf("not hex char"); return 0;}													//or not
			printf("четвёртый байт: %x\n", temp);															//print this
			sprintf(tempstring, "\\x%x", temp);																//write 3-rd \x byte
			strcat(result, tempstring);																		//add to result
		}else{
            printf("Incorrect unicode sequence for %s\n", u_code);
            return 0;
        }
		
		printf("return this result: %s\n", result);															//print result
		return result;																						//return this
    }else{
        printf("Not \\u string. return 0;\n"); return 0;													//if not unicode char
    }
}

int main(void)
{
	char *test = "\\u1ed8";
	printf("%s", test);
	printf("\n");
	//for(int i=0;i<strlen(test);i++){printf("%x ", test[i]);}
	printf("\n");
	char *x_string;
    
    x_string = get_x_string(test);
	printf("x_string: %s", x_string);    
	printf("\n\n");
	
    x_string = get_x_string("\\u9");
	printf("x_string: %s", x_string);    
	printf("\n\n");
	
    x_string = get_x_string("\\uF");
	printf("x_string: %s", x_string);    
	printf("\n\n");
	
    x_string = get_x_string("\\uFF");
	printf("x_string: %s", x_string);    
	printf("\n\n");
	
    x_string = get_x_string("\\uFFF"); // -> "\\u0FFF"
	printf("x_string: %s", x_string);    
	printf("\n\n");
	
    x_string = get_x_string("\\uFFfF");
	printf("x_string: %s", x_string);    
	printf("\n\n");
	
    x_string = get_x_string("\\uFFfFf"); //-> "\\u0FFFFF"
	printf("x_string: %s", x_string);    
	printf("\n\n");
	
    x_string = get_x_string("\\uFFfFfF");
	printf("x_string: %s", x_string);    
	printf("\n\n");
    
    printf("print results, as chars:\n");
    printf("\xe1\xbb\x98\n");//буква
    printf("\x9\n");//таб
    printf("\xf\n");//
    printf("\xcf\x8f\n");
    printf("\xe0\xbf\xbf\n");
    printf("\xef\xbf\xbf\n");
    printf("\xf0\x9f\xf7\x8f\n");
    printf("\xf7\x9f\xf7\x8f\n");    
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.23 sec, absolute running time: 0.13 sec, cpu time: 0.07 sec, memory peak: 3 Mb, absolute service time: 0,46 sec