Ye_Ol_Pi_Shack
/
CppCMS
2
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 1 Wiki Activity
ChipMaster's trial hacks on C++CMS starting with v1.2.1. Not sure I'll follow on with the v2 since it looks to be breaking and mostly frivolous.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1320 Commits
2 Branches
13 MiB
 
 
 
 
 
 
Branch: yops
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'yops'
${ noResults }
CppCMS/private/encoding_validators.h

405 lines
7.4 KiB
Raw Permalink Blame History 

  1. ///////////////////////////////////////////////////////////////////////////////

  2. //                                                                             

  3. //  Copyright (C) 2008-2012  Artyom Beilis (Tonkikh) <artyomtnk@yahoo.com>     

  4. //                                                                             

  5. //  See accompanying file COPYING.TXT file for licensing details.

  6. //

  7. ///////////////////////////////////////////////////////////////////////////////

  8. #ifndef CPPCMS_ENCODING_VALIDATORS_H

  9. #define CPPCMS_ENCODING_VALIDATORS_H

  10. 

  11. #include "utf_iterator.h"

  12. 

  13. namespace cppcms { namespace encoding {

  14. 

  15. 	template<typename Iterator>

  16. 	bool utf8_valid(Iterator p,Iterator e,size_t &count)

  17. 	{

  18. 		return utf8::validate(p,e,count,true);

  19. 	}

  20. 

  21. 	template<typename Iterator>

  22. 	bool ascii_valid(Iterator p,Iterator e,size_t &count)

  23. 	{

  24. 		while(p!=e) {

  25. 			count++;

  26. 			unsigned c=(unsigned char)*p++;

  27. 			if(c==0x09 || c==0xA || c==0xD)

  28. 				continue;

  29. 			if(c<0x20 || 0x7E < c)

  30. 				return false;

  31. 		}

  32. 		return true;

  33. 	}

  34. 	template<typename Iterator>

  35. 	bool iso_8859_1_2_4_5_9_10_13_14_15_16_valid(Iterator p,Iterator e,size_t &count)

  36. 	{

  37. 		while(p!=e) {

  38. 			count++;

  39. 			unsigned c=(unsigned char)*p++;

  40. 			if(c==0x09 || c==0xA || c==0xD)

  41. 				continue;

  42. 			if(c<0x20 || (0x7F<=c && c<0xA0))

  43. 				return false;

  44. 		}

  45. 		return true;

  46. 	}

  47. 	template<typename Iterator>

  48. 	bool iso_8859_3_valid(Iterator p,Iterator e,size_t &count)

  49. 	{

  50. 		while(p!=e) {

  51. 			count++;

  52. 			unsigned c=(unsigned char)*p++;

  53. 			if(c==0x09 || c==0xA || c==0xD)

  54. 				continue;

  55. 			if(c<0x20 || (0x7F<=c && c<0xA0))

  56. 				return false;

  57. 			switch(c) {

  58. 			case 0xA5:

  59. 			case 0xAE:

  60. 			case 0xBE:

  61. 			case 0xC3:

  62. 			case 0xD0:

  63. 			case 0xE3:

  64. 			case 0xF0:

  65. 				return false;

  66. 			}

  67. 		}

  68. 		return true;

  69. 	}

  70. 	template<typename Iterator>

  71. 	bool iso_8859_6_valid(Iterator p,Iterator e,size_t &count)

  72. 	{

  73. 		while(p!=e) {

  74. 			count++;

  75. 			unsigned c=(unsigned char)*p++;

  76. 			if(c==0x09 || c==0xA || c==0xD)

  77. 				continue;

  78. 			if(c<0x20 || (0x7F<=c && c<0xA0))

  79. 				return false;

  80. 			if(	(0xA1<=c && c<=0xA3) ||

  81. 			 	(0xA5 <=c && c<= 0xAB) || 

  82. 				(0xAE <=c && c<= 0xBA) ||

  83. 				(0xBC <=c && c<= 0xBE) ||

  84. 				 0xC0 == c		||

  85. 				(0xDB <=c && c<= 0xDF) ||

  86. 				(0xF3 <=c && c<= 0xFF))

  87. 			{

  88. 				return false;

  89. 			}

  90. 		}

  91. 		return true;

  92. 	}

  93. 

  94. 	template<typename Iterator>

  95. 	bool iso_8859_7_valid(Iterator p,Iterator e,size_t &count)

  96. 	{

  97. 		while(p!=e) {

  98. 			count++;

  99. 			unsigned c=(unsigned char)*p++;

  100. 			if(c==0x09 || c==0xA || c==0xD)

  101. 				continue;

  102. 			if(c<0x20 || (0x7F<=c && c<0xA0))

  103. 				return false;

  104. 			switch(c) {

  105. 			case 0xAE:

  106. 			case 0xD2:

  107. 			case 0xFF:

  108. 				return false;

  109. 			}

  110. 		}

  111. 		return true;

  112. 	}

  113. 

  114. 	template<typename Iterator>

  115. 	bool iso_8859_8_valid(Iterator p,Iterator e,size_t &count)

  116. 	{

  117. 		while(p!=e) {

  118. 			count++;

  119. 			unsigned c=(unsigned char)*p++;

  120. 			if(c==0x09 || c==0xA || c==0xD)

  121. 				continue;

  122. 			if(c<0x20 || (0x7F<=c && c<0xA0))

  123. 				return false;

  124. 			switch(c) {

  125. 			case 0xA1:

  126. 			case 0xFB:

  127. 			case 0xFC:

  128. 			case 0xFF:

  129. 				return false;

  130. 			}

  131. 			if(0xBF <=c && c<=0xDE)

  132. 				return false;

  133. 		}

  134. 		return true;

  135. 	}

  136. 

  137. 	template<typename Iterator>

  138. 	bool iso_8859_11_valid(Iterator p,Iterator e,size_t &count)

  139. 	{

  140. 		while(p!=e) {

  141. 			count++;

  142. 			unsigned c=(unsigned char)*p++;

  143. 			if(c==0x09 || c==0xA || c==0xD)

  144. 				continue;

  145. 			if(c<0x20 || (0x7F<=c && c<0xA0))

  146. 				return false;

  147. 			switch(c) {

  148. 			case 0xDB:

  149. 			case 0xDC:

  150. 			case 0xDD:

  151. 			case 0xDE:

  152. 			case 0xFC:

  153. 			case 0xFD:

  154. 			case 0xFE:

  155. 			case 0xFF:

  156. 				return false;

  157. 			}

  158. 		}

  159. 		return true;

  160. 	}

  161. 

  162. 	template<typename Iterator>

  163. 	bool windows_1250_valid(Iterator p,Iterator e,size_t &count)

  164. 	{

  165. 		while(p!=e) {

  166. 			count++;

  167. 			unsigned c=(unsigned char)*p++;

  168. 			if(c==0x09 || c==0xA || c==0xD)

  169. 				continue;

  170. 			if(c<0x20 || 0x7F==c)

  171. 				return false;

  172. 			switch(c) {

  173. 			case 0x81:

  174. 			case 0x83:

  175. 			case 0x88:

  176. 			case 0x90:

  177. 			case 0x98:

  178. 				return false;

  179. 			}

  180. 		}

  181. 		return true;

  182. 	}

  183. 	template<typename Iterator>

  184. 	bool windows_1251_valid(Iterator p,Iterator e,size_t &count)

  185. 	{

  186. 		while(p!=e) {

  187. 			count++;

  188. 			unsigned c=(unsigned char)*p++;

  189. 			if(c==0x09 || c==0xA || c==0xD)

  190. 				continue;

  191. 			if(c<0x20 || 0x7F==c || c==152)

  192. 				return false;

  193. 		}

  194. 		return true;

  195. 	}

  196. 	template<typename Iterator>

  197. 	bool windows_1252_valid(Iterator p,Iterator e,size_t &count)

  198. 	{

  199. 		while(p!=e) {

  200. 			count++;

  201. 			unsigned c=(unsigned char)*p++;

  202. 			if(c==0x09 || c==0xA || c==0xD)

  203. 				continue;

  204. 			if(c<0x20 || 0x7F==c)

  205. 				return false;

  206. 			switch(c) {

  207. 			case 0x81:

  208. 			case 0x8D:

  209. 			case 0x8F:

  210. 			case 0x90:

  211. 			case 0x9D:

  212. 				return false;

  213. 			}

  214. 		}

  215. 		return true;

  216. 	}

  217. 	template<typename Iterator>

  218. 	bool windows_1253_valid(Iterator p,Iterator e,size_t &count)

  219. 	{

  220. 		while(p!=e) {

  221. 			count++;

  222. 			unsigned c=(unsigned char)*p++;

  223. 			if(c==0x09 || c==0xA || c==0xD)

  224. 				continue;

  225. 			if(c<0x20 || 0x7F==c)

  226. 				return false;

  227. 			switch(c) {

  228. 			case 0x81:

  229. 			case 0x88:

  230. 			case 0x8A:

  231. 			case 0x8C:

  232. 			case 0x8D:

  233. 			case 0x8E:

  234. 			case 0x8F:

  235. 			case 0x90:

  236. 			case 0x98:

  237. 			case 0x9A:

  238. 			case 0x9C:

  239. 			case 0x9D:

  240. 			case 0x9E:

  241. 			case 0x9F:

  242. 			case 0xAA:

  243. 			case 0xD2:

  244. 			case 0xFF:

  245. 				return false;

  246. 			}

  247. 		}

  248. 		return true;

  249. 	}

  250. 

  251. 	template<typename Iterator>

  252. 	bool windows_1254_valid(Iterator p,Iterator e,size_t &count)

  253. 	{

  254. 		while(p!=e) {

  255. 			count++;

  256. 			unsigned c=(unsigned char)*p++;

  257. 			if(c==0x09 || c==0xA || c==0xD)

  258. 				continue;

  259. 			if(c<0x20 || 0x7F==c)

  260. 				return false;

  261. 			switch(c) {

  262. 			case 0x81:

  263. 			case 0x8D:

  264. 			case 0x8E:

  265. 			case 0x8F:

  266. 			case 0x90:

  267. 			case 0x9D:

  268. 			case 0x9E:

  269. 				return false;

  270. 			}

  271. 		}

  272. 		return true;

  273. 	}

  274. 

  275. 	template<typename Iterator>

  276. 	bool windows_1255_valid(Iterator p,Iterator e,size_t &count)

  277. 	{

  278. 		while(p!=e) {

  279. 			count++;

  280. 			unsigned c=(unsigned char)*p++;

  281. 			if(c==0x09 || c==0xA || c==0xD)

  282. 				continue;

  283. 			if(c<0x20 || 0x7F==c)

  284. 				return false;

  285. 			switch(c) {

  286. 			case 0x81:

  287. 			case 0x8A:

  288. 			case 0x8C:

  289. 			case 0x8D:

  290. 			case 0x8E:

  291. 			case 0x8F:

  292. 			

  293. 			case 0x90:

  294. 			case 0x9A:

  295. 			case 0x9C:

  296. 			case 0x9D:

  297. 			case 0x9E:

  298. 			case 0x9F:

  299. 

  300. 			case 0xD9:

  301. 			case 0xDA:

  302. 			case 0xDB:

  303. 			case 0xDC:

  304. 			case 0xDD:

  305. 			case 0xDE:

  306. 			case 0xDF:

  307. 

  308. 			case 0xCA:

  309. 			case 0xFB:

  310. 			case 0xFC:

  311. 			case 0xFF:

  312. 				return false;

  313. 			}

  314. 		}

  315. 		return true;

  316. 	}

  317. 

  318. 	template<typename Iterator>

  319. 	bool windows_1256_valid(Iterator p,Iterator e,size_t &count)

  320. 	{

  321. 		while(p!=e) {

  322. 			count++;

  323. 			unsigned c=(unsigned char)*p++;

  324. 			if(c==0x09 || c==0xA || c==0xD)

  325. 				continue;

  326. 			if(c<0x20 || 0x7F==c)

  327. 				return false;

  328. 		}

  329. 		return true;

  330. 	}

  331. 	template<typename Iterator>

  332. 	bool windows_1257_valid(Iterator p,Iterator e,size_t &count)

  333. 	{

  334. 		while(p!=e) {

  335. 			count++;

  336. 			unsigned c=(unsigned char)*p++;

  337. 			if(c==0x09 || c==0xA || c==0xD)

  338. 				continue;

  339. 			if(c<0x20 || 0x7F==c)

  340. 				return false;

  341. 			switch(c) {

  342. 			case 0x81:

  343. 			case 0x83:

  344. 			case 0x88:

  345. 			case 0x8A:

  346. 			case 0x8C:

  347. 			case 0x90:

  348. 			case 0x98:

  349. 			case 0x9A:

  350. 			case 0x9C:

  351. 			case 0x9F:

  352. 			case 0xA1:

  353. 			case 0xA5:

  354. 				return false;

  355. 			}

  356. 		}

  357. 		return true;

  358. 	}

  359. 

  360. 	template<typename Iterator>

  361. 	bool windows_1258_valid(Iterator p,Iterator e,size_t &count)

  362. 	{

  363. 		while(p!=e) {

  364. 			count++;

  365. 			unsigned c=(unsigned char)*p++;

  366. 			if(c==0x09 || c==0xA || c==0xD)

  367. 				continue;

  368. 			if(c<0x20 || c==0x7F)

  369. 				return false;

  370. 			switch(c) {

  371. 			case 0x81:

  372. 			case 0x8A:

  373. 			case 0x8D:

  374. 			case 0x8E:

  375. 			case 0x8F:

  376. 			case 0x90:

  377. 			case 0x9A:

  378. 			case 0x9D:

  379. 			case 0x9E:

  380. 				return false;

  381. 			}

  382. 		}

  383. 		return true;

  384. 	}

  385. 	template<typename Iterator>

  386. 	bool koi8_valid(Iterator p,Iterator e,size_t &count)

  387. 	{

  388. 		while(p!=e) {

  389. 			count++;

  390. 			unsigned c=(unsigned char)*p++;

  391. 			if(c==0x09 || c==0xA || c==0xD)

  392. 				continue;

  393. 			if(c<0x20 || 0x7F==c)

  394. 				return false;

  395. 		}

  396. 		return true;

  397. 	}

  398. 

  399. 	// ISO 

  400. 

  401. 

  402. } /* validator */ } // cppcms

  403. 

  404. #endif