BattletechMUX: src/utf8.c File Reference

main ( void )

Definition at line 186 of file utf8.c.

References hellow(), LARGE_NUMBER, muxevent_add_simple_arg, muxevent_initialize(), muxevent_run(), SIMULTANEOUS_EVENTS, TEST_ITERATIONS, testStrings, and utf8_test_valid().

00187 {
00188         int i, length;
00189         for(i = 0; i < sizeof(testStrings) && testStrings[i] != NULL; i++) {
00190                 printf(" %d = %d\n", i,
00191                            utf8_test_valid(testStrings[i], strlen(testStrings[i])));
00192         }
00193 }

int utf8_test_valid	(	const unsigned char *	input,
		const unsigned int	length
	)

Definition at line 91 of file utf8.c.

Referenced by main().

00092 {
00093         int current, remaining;
00094         unsigned char mbhead;
00095 
00096         for(current = 0; current < length; current++) {
00097                 remaining = length - (current + 1);
00098                 switch (input[current]) {
00099                 case 0x00...0x7F:
00100                         break;
00101                 case 0x80...0xC1:
00102                         return 0;
00103                 case 0xC2...0xDF:
00104                         if(remaining < 1)
00105                                 return -1;
00106                         if(input[current + 1] < 0x80 || input[current + 1] > 0xBF)
00107                                 return 0;
00108                         current += 1;
00109                         break;
00110                 case 0xE0:
00111                         if(remaining < 2)
00112                                 return -(remaining);
00113                         if(input[current + 1] < 0xA0 || input[current + 1] > 0xBF)
00114                                 return 0;
00115                 case 0xE1...0xEF:
00116                         if(remaining < 2)
00117                                 return -(remaining);
00118                         if(input[current + 1] < 0x80 || input[current + 1] > 0xBF)
00119                                 return 0;
00120                         if(input[current + 2] < 0x80 || input[current + 2] > 0xBF)
00121                                 return 0;
00122                         current += 2;
00123                         break;
00124                 case 0xF0:
00125                         if(remaining < 3)
00126                                 return -(remaining);
00127                         if(input[current + 1] < 0x90 || input[current + 1] > 0xBF)
00128                                 return 0;
00129                 case 0xF1...0xF7:
00130                         if(remaining < 3)
00131                                 return -(remaining);
00132                         if(input[current + 1] < 0x80 || input[current + 1] > 0xBF)
00133                                 return 0;
00134                         if(input[current + 2] < 0x80 || input[current + 2] > 0xBF)
00135                                 return 0;
00136                         if(input[current + 3] < 0x80 || input[current + 3] > 0xBF)
00137                                 return 0;
00138                         current += 3;
00139                         break;
00140                 case 0xF8:
00141                         if(remaining < 4)
00142                                 return -(remaining);
00143                         if(input[current + 1] < 0x88 || input[current + 1] > 0xBF)
00144                                 return 0;
00145                 case 0xF9...0xFB:
00146                         if(remaining < 4)
00147                                 return -(remaining);
00148                         if(input[current + 1] < 0x80 || input[current + 1] > 0xBF)
00149                                 return 0;
00150                         if(input[current + 2] < 0x80 || input[current + 2] > 0xBF)
00151                                 return 0;
00152                         if(input[current + 3] < 0x80 || input[current + 3] > 0xBF)
00153                                 return 0;
00154                         if(input[current + 4] < 0x80 || input[current + 4] > 0xBF)
00155                                 return 0;
00156                         current += 4;
00157                         break;
00158                 case 0xFC:
00159                         if(remaining < 5)
00160                                 return -(remaining);
00161                         if(input[current + 1] < 0x84 || input[current + 1] > 0xBF)
00162                                 return 0;
00163                 case 0xFD:
00164                         if(input[current + 1] < 0x80 || input[current + 1] > 0xBF)
00165                                 return 0;
00166                         if(input[current + 2] < 0x80 || input[current + 2] > 0xBF)
00167                                 return 0;
00168                         if(input[current + 3] < 0x80 || input[current + 3] > 0xBF)
00169                                 return 0;
00170                         if(input[current + 4] < 0x80 || input[current + 4] > 0xBF)
00171                                 return 0;
00172                         if(input[current + 5] < 0x80 || input[current + 5] > 0xBF)
00173                                 return 0;
00174                         current += 5;
00175                         break;
00176                         /* multibyte */
00177                 case 0xFE...0xFF:
00178                         return 0;
00179                 default:
00180                         printf("Didn't handle %08x!\n", input[current]);
00181                 }
00182         }
00183         return 1;
00184 }


Functions
int	utf8_test_valid (const unsigned char *input, const unsigned int length)
	main ()
Variables
char *	testStrings []

src/utf8.c File Reference

Functions

Variables

Function Documentation

Variable Documentation