fork download
copy 
  1.  
  2. #include <malloc.h>
  3. #include <ctype.h>
  4. #include <stdbool.h>
  5. #include <string.h>
  6.  
  7. typedef struct _parse_c_ {
  8. 	char name[255];
  9. 		// including function in target
  10. 	struct _parse_c_ *icld;
  11. 	struct _parse_c_ *next;
  12. }	FUNC_LIST, *PFUNC_LIST;
  13.  
  14. typedef struct _def_arg_list_ {
  15. 	char name[10];
  16. 	int index;
  17. 	struct _def_arg_list_ *next;
  18. }	DEF_ARG_LIST, *PDEF_ARG_LIST;
  19.  
  20. typedef struct _def_macro_list_ {
  21.  
  22. 	/*
  23. 		0: Standard characters
  24. 		1: Macro Variable
  25. 		2: Pasting Function (##)
  26. 		3: Macro Variable Pasting Function ( var## )
  27. 	*/
  28. 	int processor;
  29.  
  30. 	/*
  31. 		Macro Variable index number
  32. 		(Define argument index number)
  33. 	*/
  34. 	int index;
  35.  
  36. 	struct _def_macro_list_ *next;
  37. 	char ch;
  38.  
  39. }	DEF_MACRO_LIST, *PDEF_MACRO_LIST;
  40.  
  41. typedef struct _parse_def_ {
  42. 	char name[255];
  43. 	int index;
  44. 	DEF_ARG_LIST *dal;
  45. 	DEF_MACRO_LIST *dml;
  46. 	struct _parse_def_ *next;
  47. }	DEF_LIST, *PDEF_LIST;
  48.  
  49. typedef struct _line_ {
  50. 	struct _line_ *next;
  51. 	char *pointer;
  52. }	LINE_LIST, *PLINE_LIST;
  53.  
  54. DEF_LIST *create_deflist()
  55. {
  56. 	DEF_LIST *deflist = (DEF_LIST *)malloc(sizeof(DEF_LIST));
  57. 	deflist->next = 0;
  58. 	deflist->dal = 0;
  59. 	return deflist;
  60. }
  61.  
  62. DEF_ARG_LIST *create_defarglist()
  63. {
  64. 	DEF_ARG_LIST *deflist = (DEF_ARG_LIST *)malloc(sizeof(DEF_ARG_LIST));
  65. 	deflist->index = 0;
  66. 	deflist->next = 0;
  67. 	return deflist;
  68. }
  69.  
  70. DEF_MACRO_LIST *create_macrolist()
  71. {
  72. 	DEF_MACRO_LIST *macrolist = (DEF_MACRO_LIST *)malloc(sizeof(DEF_MACRO_LIST));
  73. 	macrolist->next = 0;
  74. 	macrolist->index = 0;
  75. 	macrolist->processor = 0;
  76. 	macrolist->ch = 0;
  77. 	return macrolist;
  78. }
  79.  
  80. /*
  81. 	Parse define syntax
  82. */
  83. PDEF_LIST parse_define(PLINE_LIST lines)
  84. {
  85. 	LINE_LIST *current = lines;
  86. 	DEF_LIST *deflist = create_deflist();
  87. 	DEF_LIST *recentdef = deflist;
  88. 	char *pointerptr;
  89. 	int index = 0;
  90.  
  91. 	//
  92. 	//	Search Define Structure
  93. 	//
  94. 	do 
  95. 	{
  96. 		const char *pointer = current->pointer;
  97.  
  98. 		if (*pointer++ == '#')
  99. 		{
  100. 			const char *str_def = "define";
  101.  
  102. 			for( ; *str_def; str_def++)
  103. 			{
  104. 				if (*str_def != *pointer++)
  105. 				{
  106. 					break;
  107. 				}
  108. 			}
  109.  
  110. 			//
  111. 			//	This is not define format.
  112. 			//
  113. 			if (*str_def)
  114. 			{
  115. 				continue;
  116. 			}
  117.  
  118. 			//
  119. 			//	Skip White space
  120. 			//
  121. 			for( ; isspace(*pointer); pointer++)
  122. 				;
  123.  
  124. 			//
  125. 			//	Get name
  126. 			//
  127. 			for(pointerptr = recentdef->name ; isalnum(*pointer) ||
  128. 				   *pointer == '$'   ||
  129. 				   *pointer == '_'      ; pointer++)
  130. 			{
  131. 				*pointerptr++ = *pointer;
  132. 			}
  133.  
  134. 			*pointerptr = 0;
  135.  
  136. 			//
  137. 			//	Check macro
  138. 			//
  139. 			if (*pointer++ == '(')
  140. 			{
  141. 				DEF_ARG_LIST *dal = create_defarglist();
  142. 				DEF_ARG_LIST *recentdal = dal, *prerecentdal = 0;
  143. 				int index_dal = 0;
  144.  
  145. 				//
  146. 				//	Search argument
  147. 				//
  148. 				do
  149. 				{
  150. 					for( ; isspace(*pointer); pointer++)
  151. 						;
  152.  
  153. 					for(pointerptr = recentdal->name ; isalnum(*pointer) ||
  154. 						   *pointer == '$'   ||
  155. 						   *pointer == '_'      ; pointer++)
  156. 					{
  157. 						*pointerptr++ = *pointer;
  158. 					}
  159.  
  160. 					*pointerptr = 0;
  161.  
  162. 					for( ; isspace(*pointer); pointer++)
  163. 						;
  164.  
  165. 					if (*pointer == ',')
  166. 						pointer++;
  167.  
  168. 					recentdal->index = index_dal;
  169. 					recentdal->next = create_defarglist();
  170. 					prerecentdal = recentdal;
  171. 					recentdal = recentdal->next;
  172. 					recentdal->next = 0;
  173.  
  174. 				} while(*pointer != ')');
  175.  
  176. 				if (prerecentdal) 
  177. 				{
  178. 					free(prerecentdal->next);
  179. 					recentdal->next = 0;
  180. 					recentdef->dal = dal;
  181. 				}
  182.  
  183. 				for( ; isspace(*pointer); pointer++)
  184. 					;
  185.  
  186. 				/*
  187. 					Parsing Define Format
  188. 				*/
  189. 				{
  190. 					DEF_MACRO_LIST *dml = create_macrolist();
  191. 					DEF_MACRO_LIST *recentdml = dml, *prerecnetdml = 0;
  192. 					int index_dml = 0;
  193.  
  194. 					for( ; *pointer; pointer++)
  195. 					{
  196. 						if (isalnum(*pointer) ||
  197. 						   *pointer == '$'   ||
  198. 						   *pointer == '_'      )
  199. 						{
  200. 							char arg_search[10];
  201. 							const char *t_pointer = pointer;
  202. 							int index;
  203. 							bool is_exist = false;
  204.  
  205. 							for(pointerptr = arg_search ; isalnum(*pointer) ||
  206. 								   *pointer == '$'   ||
  207. 								   *pointer == '_'      ; pointer++)
  208. 							{
  209. 								*pointerptr++ = *pointer;
  210. 							}
  211.  
  212. 							*pointerptr = 0;
  213.  
  214. 							//
  215. 							//	Search argument
  216. 							//
  217. 							for (recentdal = dal;
  218. 								recentdal; recentdal = recentdal->next)
  219. 							{
  220. 								if (!strcmp(arg_search, recentdal->name))
  221. 								{
  222. 									is_exist = true;
  223. 									index = recentdal->index;
  224. 								}
  225. 							}
  226.  
  227. 							if (true == is_exist)
  228. 							{
  229. 								dml->index = index;
  230. 								dml->processor = 1;
  231.  
  232. 								if ( * (pointer + 0) == '#' &&
  233. 									 * (pointer + 1) == '#'    )
  234. 								{
  235. 									dml->processor = 3;
  236. 									pointer++;
  237. 								}
  238. 							}
  239. 							else
  240. 							{
  241. 								pointer = t_pointer;
  242. 								goto NON_EXIST;
  243. 							}
  244. 						}
  245. 						else if (*pointer == '#')
  246. 						{
  247. 						PASTING_PROC:
  248. 							if (* (pointer + 1) == '#')
  249. 							{
  250. 								dml->processor = 2;
  251. 								pointer++;
  252. 							}
  253. 						}
  254. 						else
  255. 						{
  256. 						NON_EXIST:
  257. 							if (isspace(*pointer))
  258. 								continue;
  259. 							recentdml->ch = *pointer;
  260. 						}
  261.  
  262. 						recentdml->index = index_dml++;
  263. 						recentdml->next = create_macrolist();
  264. 						prerecnetdml = recentdml;
  265. 						recentdml = recentdml->next;
  266. 					}
  267.  
  268. 					if (prerecnetdml)
  269. 					{
  270. 						free(prerecnetdml);
  271. 						recentdml->next = 0;
  272. 						recentdef->dml = dml;
  273. 					}
  274. 				}
  275. 			}
  276.  
  277. 			recentdef->index = index++;
  278. 			recentdef->next = create_deflist();
  279. 			recentdef = recentdef->next;
  280. 		}
  281.  
  282. 		free(recentdef->next);
  283. 		recentdef->next = 0;
  284. 		current = current->next;
  285.  
  286. 	} while (current);
  287.  
  288. 	return deflist;
  289. }
  290.  
  291. int main()
  292. {
  293. 	LINE_LIST *ll = (LINE_LIST *) malloc(sizeof(LINE_LIST));
  294. 	ll->pointer = "#define pussy_loli(asdf, abcf) abd##tfs ## abcf##dc asdf";
  295. 	ll->next = 0;
  296.  
  297. 	parse_define(ll);
  298. }
Success #stdin #stdout 0s 2240KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/9QLPBY
language:
C (gcc 8.3)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!