开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
type.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：10k
源码类别：

数据库系统

开发平台：

Unix_Linux

type.c：源码内容
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  5. #include "extern.h"
  7. /* malloc + error check */
  8. void *
  9. mm_alloc(size_t size)
  10. {
  11. void    *ptr = malloc(size);
  13. if (ptr == NULL)
  14. {
  15. fprintf(stderr, "Out of memoryn");
  16. exit(OUT_OF_MEMORY);
  17. }
  19. return ptr;
  20. }
  22. /* strdup + error check */
  23. char *
  24. mm_strdup(const char *string)
  25. {
  26. char    *new = strdup(string);
  28. if (new == NULL)
  29. {
  30. fprintf(stderr, "Out of memoryn");
  31. exit(OUT_OF_MEMORY);
  32. }
  34. return new;
  35. }
  37. /* duplicate memberlist */
  38. struct ECPGstruct_member *
  39. ECPGstruct_member_dup(struct ECPGstruct_member * rm)
  40. {
  41. struct ECPGstruct_member *new = NULL;
  43. while (rm)
  44. {
  45. struct ECPGtype *type;
  47. switch (rm->typ->typ)
  48. {
  49. case ECPGt_struct:
  50. case ECPGt_union:
  51. type = ECPGmake_struct_type(rm->typ->u.members, rm->typ->typ);
  52. break;
  53. case ECPGt_array:
  54. type = ECPGmake_array_type(ECPGmake_simple_type(rm->typ->u.element->typ, rm->typ->u.element->size), rm->typ->size);
  55. break;
  56. default:
  57. type = ECPGmake_simple_type(rm->typ->typ, rm->typ->size);
  58. break;
  59. }
  61. ECPGmake_struct_member(rm->name, type, &new);
  63. rm = rm->next;
  64. }
  66. return (new);
  67. }
  69. /* The NAME argument is copied. The type argument is preserved as a pointer. */
  70. void
  71. ECPGmake_struct_member(char *name, struct ECPGtype * type, struct ECPGstruct_member ** start)
  72. {
  73. struct ECPGstruct_member *ptr,
  74.    *ne =
  75. (struct ECPGstruct_member *) mm_alloc(sizeof(struct ECPGstruct_member));
  77. ne->name = strdup(name);
  78. ne->typ = type;
  79. ne->next = NULL;
  81. for (ptr = *start; ptr && ptr->next; ptr = ptr->next);
  83. if (ptr)
  84. ptr->next = ne;
  85. else
  86. *start = ne;
  87. }
  89. struct ECPGtype *
  90. ECPGmake_simple_type(enum ECPGttype typ, long siz)
  91. {
  92. struct ECPGtype *ne = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
  94. ne->typ = typ;
  95. ne->size = siz;
  96. ne->u.element = 0;
  98. return ne;
  99. }
  101. struct ECPGtype *
  102. ECPGmake_array_type(struct ECPGtype * typ, long siz)
  103. {
  104. struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array, siz);
  106. ne->u.element = typ;
  108. return ne;
  109. }
  111. struct ECPGtype *
  112. ECPGmake_struct_type(struct ECPGstruct_member * rm, enum ECPGttype type)
  113. {
  114. struct ECPGtype *ne = ECPGmake_simple_type(type, 1);
  116. ne->u.members = ECPGstruct_member_dup(rm);
  118. return ne;
  119. }
  121. static const char *
  122. get_type(enum ECPGttype typ)
  123. {
  124. switch (typ)
  125. {
  126. case ECPGt_char:
  127. return ("ECPGt_char");
  128. break;
  129. case ECPGt_unsigned_char:
  130. return ("ECPGt_unsigned_char");
  131. break;
  132. case ECPGt_short:
  133. return ("ECPGt_short");
  134. break;
  135. case ECPGt_unsigned_short:
  136. return ("ECPGt_unsigned_short");
  137. break;
  138. case ECPGt_int:
  139. return ("ECPGt_int");
  140. break;
  141. case ECPGt_unsigned_int:
  142. return ("ECPGt_unsigned_int");
  143. break;
  144. case ECPGt_long:
  145. return ("ECPGt_long");
  146. break;
  147. case ECPGt_unsigned_long:
  148. return ("ECPGt_unsigned_int");
  149. break;
  150. case ECPGt_float:
  151. return ("ECPGt_float");
  152. break;
  153. case ECPGt_double:
  154. return ("ECPGt_double");
  155. break;
  156. case ECPGt_bool:
  157. return ("ECPGt_bool");
  158. break;
  159. case ECPGt_varchar:
  160. return ("ECPGt_varchar");
  161. case ECPGt_NO_INDICATOR: /* no indicator */
  162. return ("ECPGt_NO_INDICATOR");
  163. break;
  164. case ECPGt_char_variable: /* string that should not be
  165.  * quoted */
  166. return ("ECPGt_char_variable");
  167. break;
  168. default:
  169. sprintf(errortext, "illegal variable type %dn", typ);
  170. yyerror(errortext);
  171. }
  173. return NULL;
  174. }
  176. /* Dump a type.
  177.    The type is dumped as:
  178.    type-tag <comma>    - enum ECPGttype
  179.    reference-to-variable <comma>   - void *
  180.    size <comma>    - long size of this field (if varchar)
  181.    arrsize <comma>    - long number of elements in the arr
  182.    offset <comma>    - offset to the next element
  183.    Where:
  184.    type-tag is one of the simple types or varchar.
  185.    reference-to-variable can be a reference to a struct element.
  186.    arrsize is the size of the array in case of array fetches. Otherwise 0.
  187.    size is the maxsize in case it is a varchar. Otherwise it is the size of
  188.    the variable (required to do array fetches of structs).
  189.  */
  190. static void ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
  191.   long varcharsize,
  192.   long arrsiz, const char *siz, const char *prefix);
  193. static void ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, long arrsiz,
  194.   struct ECPGtype * typ, struct ECPGtype * ind_typ, const char *offset, const char *prefix, const char *ind_prefix);
  197. void
  198. ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * typ, const char *ind_name, struct ECPGtype * ind_typ, const char *prefix, const char *ind_prefix)
  199. {
  200. if (ind_typ == NULL)
  201. {
  202. ind_typ = &ecpg_no_indicator;
  203. ind_name = "no_indicator";
  204. }
  206. switch (typ->typ)
  207. {
  208. case ECPGt_array:
  209. switch (typ->u.element->typ)
  210. {
  211. case ECPGt_array:
  212. yyerror("No nested arrays allowed (except strings)"); /* array of array */
  213. break;
  214. case ECPGt_struct:
  215. case ECPGt_union:
  216. ECPGdump_a_struct(o, name, ind_name, typ->size, typ->u.element, ind_typ->u.element, NULL, prefix, ind_prefix);
  217. break;
  218. default:
  219. if (!IS_SIMPLE_TYPE(typ->u.element->typ))
  220. yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
  222. ECPGdump_a_simple(o, name, typ->u.element->typ,
  223.   typ->u.element->size, typ->size, NULL, prefix);
  224. if (ind_typ->typ == ECPGt_NO_INDICATOR)
  225. ECPGdump_a_simple(o, ind_name, ind_typ->typ, ind_typ->size, -1, NULL, ind_prefix);
  226. else
  227. {
  228. if (ind_typ->typ != ECPGt_array)
  229. {
  230. fprintf(stderr, "Indicator for an array has to be array too.n");
  231. exit(INDICATOR_NOT_ARRAY);
  232. }
  233. ECPGdump_a_simple(o, ind_name, ind_typ->u.element->typ,
  234.   ind_typ->u.element->size, ind_typ->size, NULL, prefix);
  235. }
  236. }
  237. break;
  238. case ECPGt_struct:
  239. ECPGdump_a_struct(o, name, ind_name, 1, typ, ind_typ, NULL, prefix, ind_prefix);
  240. break;
  241. case ECPGt_union: /* cannot dump a complete union */
  242. yyerror("Type of union has to be specified");
  243. break;
  244. case ECPGt_char_variable:
  245. ECPGdump_a_simple(o, name, typ->typ, 1, 1, NULL, prefix);
  246. ECPGdump_a_simple(o, ind_name, ind_typ->typ, ind_typ->size, -1, NULL, ind_prefix);
  247. break;
  248. default:
  249. ECPGdump_a_simple(o, name, typ->typ, typ->size, -1, NULL, prefix);
  250. ECPGdump_a_simple(o, ind_name, ind_typ->typ, ind_typ->size, -1, NULL, ind_prefix);
  251. break;
  252. }
  253. }
  256. /* If siz is NULL, then the offset is 0, if not use siz as a
  257.    string, it represents the offset needed if we are in an array of structs. */
  258. static void
  259. ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
  260.   long varcharsize,
  261.   long arrsize,
  262.   const char *siz,
  263.   const char *prefix
  264. )
  265. {
  266. if (typ == ECPGt_NO_INDICATOR)
  267. fprintf(o, "ntECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ");
  268. else
  269. {
  270. char    *variable = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 4);
  271. char    *offset = (char *) mm_alloc(strlen(name) + strlen("sizeof(struct varchar_)") + 1);
  273. /* we have to use the pointer except for arrays with given bounds */
  274. if (arrsize > 0)
  275. sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
  276. else
  277. sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
  279. switch (typ)
  280. {
  281. case ECPGt_varchar:
  282. sprintf(offset, "sizeof(struct varchar_%s)", name);
  283. break;
  284. case ECPGt_char:
  285. case ECPGt_unsigned_char:
  286. case ECPGt_char_variable:
  287. sprintf(offset, "%ld*sizeof(char)", varcharsize == 0 ? 1 : varcharsize);
  288. break;
  289. default:
  290. sprintf(offset, "sizeof(%s)", ECPGtype_name(typ));
  291. break;
  292. }
  294. if (arrsize < 0)
  295. arrsize = 1;
  297. if (siz == NULL)
  298. fprintf(o, "nt%s,%s,%ldL,%ldL,%s, ", get_type(typ), variable, varcharsize, arrsize, offset);
  299. else
  300. fprintf(o, "nt%s,%s,%ldL,%ldL,%s, ", get_type(typ), variable, varcharsize, arrsize, siz);
  302. free(variable);
  303. free(offset);
  304. }
  305. }
  308. /* Penetrate a struct and dump the contents. */
  309. static void
  310. ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, long arrsiz, struct ECPGtype * typ, struct ECPGtype * ind_typ, const char *offsetarg, const char *prefix, const char *ind_prefix)
  311. {
  313. /*
  314.  * If offset is NULL, then this is the first recursive level. If not
  315.  * then we are in a struct in a struct and the offset is used as
  316.  * offset.
  317.  */
  318. struct ECPGstruct_member *p,
  319.    *ind_p = NULL;
  320. char obuf[BUFSIZ];
  321. char pbuf[BUFSIZ],
  322. ind_pbuf[BUFSIZ];
  323. const char *offset;
  325. if (offsetarg == NULL)
  326. {
  327. sprintf(obuf, "sizeof(%s)", name);
  328. offset = obuf;
  329. }
  330. else
  331. offset = offsetarg;
  333. sprintf(pbuf, "%s%s.", prefix ? prefix : "", name);
  334. prefix = pbuf;
  336. sprintf(ind_pbuf, "%s%s.", ind_prefix ? ind_prefix : "", ind_name);
  337. ind_prefix = ind_pbuf;
  339. if (ind_typ != NULL)
  340. ind_p = ind_typ->u.members;
  341. for (p = typ->u.members; p; p = p->next)
  342. {
  343. ECPGdump_a_type(o, p->name, p->typ, (ind_p != NULL) ? ind_p->name : NULL, (ind_p != NULL) ? ind_p->typ : NULL, prefix, ind_prefix);
  344. if (ind_p != NULL)
  345. ind_p = ind_p->next;
  346. }
  347. }
  349. void
  350. ECPGfree_struct_member(struct ECPGstruct_member * rm)
  351. {
  352. while (rm)
  353. {
  354. struct ECPGstruct_member *p = rm;
  356. rm = rm->next;
  357. free(p->name);
  358. free(p->typ);
  359. free(p);
  360. }
  361. }
  363. void
  364. ECPGfree_type(struct ECPGtype * typ)
  365. {
  366. if (!IS_SIMPLE_TYPE(typ->typ))
  367. {
  368. switch (typ->typ)
  369. {
  370. case ECPGt_array:
  371. switch (typ->u.element->typ)
  372. {
  373. case ECPGt_array:
  374. yyerror("internal error, found multi-dimensional arrayn");
  375. break;
  376. case ECPGt_struct:
  377. case ECPGt_union:
  378. /* Array of structs. */
  379. ECPGfree_struct_member(typ->u.element->u.members);
  380. free(typ->u.members);
  381. break;
  382. default:
  383. if (!IS_SIMPLE_TYPE(typ->u.element->typ))
  384. yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
  386. free(typ->u.element);
  387. }
  388. break;
  389. case ECPGt_struct:
  390. case ECPGt_union:
  391. ECPGfree_struct_member(typ->u.members);
  392. free(typ->u.members);
  393. break;
  394. default:
  395. sprintf(errortext, "illegal variable type %dn", typ->typ);
  396. yyerror(errortext);
  397. break;
  398. }
  399. }
  400. free(typ);
  401. }