Source code of Windows XP (NT5)
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.

495 lines
19 KiB

  1. /*
  2. ** Symbol types . . .
  3. */
  4. #define SYMV_SYMBOL 0x0001
  5. #define SYMV_RAWSYMBOL 0x0002
  6. #define SYMV_FORMAL 0x0004
  7. #define SYMV_SEGMENT 0x0008
  8. #define SYMV_FUNCTION 0x0010
  9. #define SYMV_INTRINSIC 0x0020
  10. #define SYMV_LABEL 0x0040
  11. #define SYMV_TAG 0x0080
  12. #define SYMV_MOE 0x0100
  13. #define SYMV_MEMBER 0x0200
  14. #define SYMV_FIELD 0x0400
  15. #define SYMV_OPC 0x0800
  16. #define SYMV_ABSTRSYM 0x1000
  17. #define SYM_ISSYMBOL(p) (SYM_ANYVTAG(p) & SYMV_SYMBOL)
  18. #define SYM_ISFUNCTION(p) (SYM_ANYVTAG(p) & SYMV_FUNCTION)
  19. #define SYM_ISFORMAL(p) (SYM_ANYVTAG(p) & SYMV_FORMAL)
  20. #define SYM_ISABSTRSYM(p) (SYM_ANYVTAG(p) & SYMV_ABSTRSYM)
  21. #define SYM_ISLABEL(p) (SYM_ANYVTAG(p) & SYMV_LABEL)
  22. #define SYM_ISTAG(p) (SYM_ANYVTAG(p) & SYMV_TAG)
  23. #define SYM_ISMOE(p) (SYM_ANYVTAG(p) & SYMV_MOE)
  24. #define SYM_ISMEMBER(p) (SYM_ANYVTAG(p) & SYMV_MEMBER)
  25. #define SYM_ISFIELD(p) (SYM_ANYVTAG(p) & SYMV_FIELD)
  26. #define SYM_ISINTRINSIC(p) (SYM_ANYVTAG(p) & SYMV_INTRINSIC)
  27. #define SYM_ISRAWSYMBOL(p) (SYM_ANYVTAG(p) & SYMV_RAWSYMBOL)
  28. #define SYM_ISSEGMENT(p) (SYM_ANYVTAG(p) & SYMV_SEGMENT)
  29. /*
  30. ** parameter list types
  31. */
  32. #define NO_LIST 0
  33. #define EMPTY_LIST 1
  34. #define NAME_LIST 2
  35. #define PASCAL_LIST 3
  36. #define TYPE_LIST 4
  37. /*
  38. ** symbol storage classes
  39. ** symbol adjectives, these have nothing to do with types.
  40. */
  41. #define SCundef 0
  42. #define SCauto 0x01
  43. #define SCextern 0x02
  44. #define SCregister 0x04
  45. #define SCstatic 0x08
  46. #define SCtypedef 0x10
  47. #define SCglobal 0x20
  48. #define SCabsolute 0x40
  49. #define SCreally 0x80 /* used w/ SCregister by p2 if it allocs a reg */
  50. #define SCp2stuff SCreally
  51. /*
  52. ** symbol table sizes
  53. */
  54. #define LEVEL_0 0xff
  55. #define LEVEL_N 0x0f
  56. struct s_adj {
  57. uchar_t bit_0:1;
  58. uchar_t bit_1:1;
  59. uchar_t bit_2:1;
  60. uchar_t bit_3:1;
  61. uchar_t bit_4:1;
  62. uchar_t bit_5:1;
  63. uchar_t bit_6:1;
  64. uchar_t bit_7:1;
  65. uchar_t bit_8:1;
  66. uchar_t bit_9:1;
  67. uchar_t bit_10:1;
  68. uchar_t bit_11:1;
  69. uchar_t bit_12:1;
  70. uchar_t bit_13:1;
  71. uchar_t bit_14:1;
  72. uchar_t bit_15:1;
  73. };
  74. #if VERS_DEBUG
  75. /*
  76. * d=DEFINED o=OUTPUT S=INASEGMENT n=NEAR
  77. * v=VISIBLE p=PASCAL i=INIT s=STRING
  78. * N=HASANAMELIST E=DEFNBEFOREUSE C=CODESEGNAME D=DATASEGNAME
  79. * B=ISBACKREF F=FORWARDREF
  80. */
  81. #define SYM_ADJFMT "??FBDCENsipvnSod" /* prword() fmt */
  82. #endif
  83. #define IS_INVISIBLE 0
  84. #define IS_VISIBLE 1
  85. #define SYM_ISDEFINED(s) ((SYM_ANYADJ(s)).bit_0) /* all */
  86. #define SYM_ISOUTPUT(s) ((SYM_ANYADJ(s)).bit_1) /* all */
  87. #define SYM_ISINASEGMENT(s) ((SYM_ANYADJ(s)).bit_2) /* all */
  88. #define SYM_ISNEAR(s) ((SYM_ANYADJ(s)).bit_3) /* all */
  89. #define SYM_ISVISIBLE(s) ((SYM_ANYADJ(s)).bit_4) /* all */
  90. #define SYM_ISPASCAL(s) ((SYM_ANYADJ(s)).bit_5) /* all */
  91. #define SYM_ISINITIALIZED(s) ((SYM_ANYADJ(s)).bit_6) /* symbol */
  92. #define SYM_ISSTRING(s) ((SYM_ANYADJ(s)).bit_7) /* symbol */
  93. #define SYM_HASANAMELIST(s) ((SYM_ANYADJ(s)).bit_8) /* funcs */
  94. #define SYM_DEFNBEFOREUSE(s) ((SYM_ANYADJ(s)).bit_9) /* overload for QC */
  95. #define SYM_ISCODESEGNAME(s) ((SYM_ANYADJ(s)).bit_10)/* segment */
  96. #define SYM_ISDATASEGNAME(s) ((SYM_ANYADJ(s)).bit_11)/* segment */
  97. #define SYM_ISBACKREF(s) ((SYM_ANYADJ(s)).bit_12)/* label */
  98. #define SYM_ISFORWARDREF(s) ((SYM_ANYADJ(s)).bit_13)/* label */
  99. #define SYM_ISMASM(s) ((SYM_ANYADJ(s)).bit_14)/* label */
  100. #define SYM_TOLEVEL0(s) ((SYM_ANYADJ(s)).bit_15)/* funcs moved to 0 */
  101. typedef struct sym_200 { /* for fields */
  102. uchar_t field_bitstart; /* in which bit does the field start */
  103. uchar_t field_nbits; /* number of bits in this field */
  104. } sym_200_t;
  105. typedef struct sym_190 { /* struct/union members/fields */
  106. fpsym_t member_prev; /* previous member */
  107. ushort_t member_offset; /* offset of this member in the struct */
  108. sym_200_t m200;
  109. } sym_190_t;
  110. #define SOB_sym_190 (sizeof(sym_190_t) - sizeof(sym_200_t))
  111. typedef struct sym_180 { /* struct/union/enum tags */
  112. len_t tag_size; /* sizeof the struct/union */
  113. ushort_t tag_align; /* alignment of this struct */
  114. } sym_180_t;
  115. typedef struct sym_170 { /* intrinsics */
  116. ushort_t intrin_ino; /* intrinsic number */
  117. ushort_t intrin_nparms; /* number of actuals it takes */
  118. } sym_170_t;
  119. typedef struct sym_160 { /* labels */
  120. NA_TYPE label_template; /* label template */
  121. } sym_160_t;
  122. typedef struct sym_150 { /* formals */
  123. fpsym_t formal_prev; /* ptr to previous formal */
  124. } sym_150_t;
  125. typedef struct sym_140 { /* raw symbols */
  126. hash_t raw_hash; /* the hash of this symbol */
  127. } sym_140_t;
  128. typedef union sym_135 {
  129. sym_140_t m140; /* raw symbols */
  130. sym_150_t m150; /* formals */
  131. sym_160_t m160; /* labels */
  132. } sym_135_t;
  133. typedef struct sym_130 {
  134. /*
  135. SYMV_SYMBOL
  136. SYMV_RAWSYMBOL
  137. SYMV_FORMAL
  138. SYMV_SEGMENT
  139. SYMV_FUNCTION
  140. SYMV_LABEL
  141. */
  142. fpsym_t sym_anysegment; /* ptr to segment this is alloc'd in */
  143. sym_135_t m135;
  144. } sym_130_t;
  145. #define SOB_sym_130 (sizeof(sym_130_t) - sizeof(sym_135_t))
  146. typedef union sym_125 {
  147. sym_130_t m130;
  148. sym_170_t m170;
  149. } sym_125_t;
  150. typedef struct sym_120 {
  151. /*
  152. case SYMV_SYMBOL:
  153. case SYMV_RAWSYMBOL:
  154. case SYMV_FORMAL:
  155. case SYMV_SEGMENT:
  156. case SYMV_FUNCTION:
  157. case SYMV_INTRINSIC:
  158. case SYMV_LABEL:
  159. */
  160. refcnt_t sym_anyrefcnt; /* reference count */
  161. class_t sym_anyclass; /* symbol's class */
  162. symadj_t sym_anyadj; /* adjectives */
  163. sym_125_t m125;
  164. } sym_120_t;
  165. #define SOB_sym_120 (sizeof(sym_120_t) - sizeof(sym_125_t))
  166. typedef union sym_115 {
  167. sym_120_t m120;
  168. sym_180_t m180;
  169. } sym_115_t;
  170. typedef struct sym_110 {
  171. /*
  172. case SYMV_SYMBOL:
  173. case SYMV_RAWSYMBOL:
  174. case SYMV_FORMAL:
  175. case SYMV_SEGMENT:
  176. case SYMV_FUNCTION:
  177. case SYMV_INTRINSIC:
  178. case SYMV_LABEL:
  179. case SYMV_TAG:
  180. */
  181. p1key_t sym_anykey;
  182. sym_115_t m115;
  183. } sym_110_t;
  184. #define SOB_sym_110 (sizeof(sym_110_t) - sizeof(sym_115_t))
  185. typedef union sym_105 {
  186. sym_110_t m110;
  187. sym_190_t m190;
  188. } sym_105_t;
  189. typedef struct sym_100 {
  190. ptype_t sym_anytype;
  191. sym_105_t m105;
  192. } sym_100_t;
  193. #define SOB_sym_100 (sizeof(sym_100_t) - sizeof(sym_105_t))
  194. typedef union sym_95 {
  195. long moe_value;
  196. sym_100_t m100;
  197. } sym_95_t;
  198. struct s_sym {
  199. fpsym_t sym_anynext; /* pointer to next ident */
  200. fpuchar_t sym_anyname; /* pointer to name */
  201. ushort_t sym_anyvtag; /* which variant do we have? */
  202. sym_95_t m95;
  203. };
  204. #define M95(p) ((p)->m95)
  205. #define M100(p) ((p)->m95.m100)
  206. #define M105(p) ((p)->m95.m100.m105)
  207. #define M110(p) ((p)->m95.m100.m105.m110)
  208. #define M115(p) ((p)->m95.m100.m105.m110.m115)
  209. #define M120(p) ((p)->m95.m100.m105.m110.m115.m120)
  210. #define M125(p) ((p)->m95.m100.m105.m110.m115.m120.m125)
  211. #define M130(p) ((p)->m95.m100.m105.m110.m115.m120.m125.m130)
  212. #define M135(p) (M130(p).m135)
  213. #define M140(p) (M135(p).m140)
  214. #define M150(p) (M135(p).m150)
  215. #define M160(p) (M135(p).m160)
  216. #define M170(p) ((p)->m95.m100.m105.m110.m115.m120.m125.m170)
  217. #define M180(p) ((p)->m95.m100.m105.m110.m115.m180)
  218. #define M190(p) ((p)->m95.m100.m105.m190)
  219. #define M200(p) (M190(p).m200)
  220. #define SO_BASICSYM (sizeof(sym_t) - sizeof(sym_95_t))
  221. #define SO_SYMBOL (SO_BASICSYM \
  222. + SOB_sym_100\
  223. + SOB_sym_110\
  224. + SOB_sym_120\
  225. + SOB_sym_130\
  226. )
  227. #define SO_SEGMENT (SO_SYMBOL)
  228. #define SO_FUNCTION (SO_SYMBOL)
  229. #define SO_RAWSYMBOL (SO_SYMBOL \
  230. + sizeof(sym_140_t)\
  231. )
  232. #define SO_FORMAL (SO_SYMBOL \
  233. + sizeof(sym_150_t)\
  234. )
  235. #define SO_LABEL (SO_SYMBOL \
  236. + sizeof(sym_160_t)\
  237. )
  238. #define SO_INTRINSIC (SO_BASICSYM \
  239. + SOB_sym_100\
  240. + SOB_sym_110\
  241. + SOB_sym_120\
  242. + sizeof(sym_170_t)\
  243. )
  244. #define SO_TAG (SO_BASICSYM \
  245. + SOB_sym_100\
  246. + SOB_sym_110\
  247. + sizeof(sym_180_t)\
  248. )
  249. #define SO_MEMBER (SO_BASICSYM \
  250. + SOB_sym_100\
  251. + SOB_sym_190\
  252. )
  253. #define SO_FIELD (SO_MEMBER \
  254. + sizeof(sym_200_t)\
  255. )
  256. #define SO_MOE (SO_BASICSYM + sizeof(long)) /* sizeof(moe_value) */
  257. #if 0 /* this is just a big comment */
  258. *all* use s_sym and the following parts.
  259. SYMV_SYMBOL(and SYMV_SEGMENT, SYMV_FUNCTION)
  260. uses : sym_100, sym_110, sym_120, sym_130
  261. SYMV_RAWSYMBOL uses : SYMV_SYMBOL *and* sym_140
  262. SYMV_FORMAL uses : SYMV_SYMBOL *and* sym_150
  263. SYMV_LABEL uses : SYMV_SYMBOL *and* sym_160
  264. SYMV_INTRINSIC uses : sym_100, sym_110, sym_120, sym_170
  265. SYMV_TAG uses : sym_100, sym_110, sym_180
  266. SYMV_MEMBER uses : sym_100, sym_190
  267. SYMV_FIELD uses : SYMV_MEMBER *and* sym_200
  268. SYMV_MOE uses : moe_value
  269. SYMV_OPC
  270. #endif
  271. #define SYM_ANYNEXT(p) ((p)->sym_anynext)
  272. #define SYM_ANYNAME(p) ((p)->sym_anyname)
  273. #define SYM_ANYVTAG(p) ((p)->sym_anyvtag)
  274. #define SYM_ANYTYPE(p) ((p)->m95.m100.sym_anytype)
  275. #define SYM_ANYKEY(p) ((p)->m95.m100.m105.m110.sym_anykey)
  276. #define SYM_ANYREFCNT(p) ((p)->m95.m100.m105.m110.m115.m120.sym_anyrefcnt)
  277. #define SYM_ANYCLASS(p) ((p)->m95.m100.m105.m110.m115.m120.sym_anyclass)
  278. #define SYM_ANYADJ(p) ((p)->m95.m100.m105.m110.m115.m120.sym_anyadj)
  279. #define SYM_ANYSEGMENT(p) (M130(p).sym_anysegment)
  280. #define SYM_ANYAOFF(p) (M130(p).sym_anyaoff) /* P-2 allocation offset */
  281. #define SYM_ANYAREGS(p) (M130(p).sym_anyaregs) /* P-2 allocation regs */
  282. #define SYM_ANYASEG(p) (M130(p).sym_anyaseg) /* P-2 allocation segment */
  283. #define SYM_SYNEXT(p) (SYM_ANYNEXT(p))
  284. #define SYM_SYNAME(p) (SYM_ANYNAME(p))
  285. #define SYM_SYTYPE(p) (SYM_ANYTYPE(p))
  286. #define SYM_SYKEY(p) (SYM_ANYKEY(p))
  287. #define SYM_SYREFCNT(p) (SYM_ANYREFCNT(p))
  288. #define SYM_SYCLASS(p) (SYM_ANYCLASS(p))
  289. #define SYM_SYADJ(p) (SYM_ANYADJ(p))
  290. #define SYM_SYSEGMENT(p) (SYM_ANYSEGMENT(p))
  291. #define SYM_SYAOFF(p) (SYM_ANYAOFF(p))
  292. #define SYM_SYASEG(p) (SYM_ANYASEG(p))
  293. #define SYM_SENEXT(p) (SYM_ANYNEXT(p))
  294. #define SYM_SENAME(p) (SYM_ANYNAME(p))
  295. #define SYM_SETYPE(p) (SYM_ANYTYPE(p))
  296. #define SYM_SEKEY(p) (SYM_ANYKEY(p))
  297. #define SYM_SEREFCNT(p) (SYM_ANYREFCNT(p))
  298. #define SYM_SECLASS(p) (SYM_ANYCLASS(p))
  299. #define SYM_SEADJ(p) (SYM_ANYADJ(p))
  300. #define SYM_SEAOFF(p) (SYM_ANYAOFF(p))
  301. #define SYM_RANAME(p) (SYM_ANYNAME(p))
  302. #define SYM_RATYPE(p) (SYM_ANYTYPE(p))
  303. #define SYM_RASEGMENT(p) (SYM_ANYSEGMENT(p))
  304. #define SYM_RAHASH(p) (M140(p).raw_hash)
  305. #define SYM_FUNEXT(p) (SYM_ANYNEXT(p))
  306. #define SYM_FUNAME(p) (SYM_ANYNAME(p))
  307. #define SYM_FUTYPE(p) (SYM_ANYTYPE(p))
  308. #define SYM_FUKEY(p) (SYM_ANYKEY(p))
  309. #define SYM_FUREFCNT(p) (SYM_ANYREFCNT(p))
  310. #define SYM_FUCLASS(p) (SYM_ANYCLASS(p))
  311. #define SYM_FUADJ(p) (SYM_ANYADJ(p))
  312. #define SYM_FUSEGMENT(p) (SYM_ANYSEGMENT(p))
  313. #define SYM_FUAOFF(p) (SYM_ANYAOFF(p))
  314. #define SYM_FUASEG(p) (SYM_ANYASEG(p))
  315. #define SYM_FONEXT(p) (SYM_ANYNEXT(p))
  316. #define SYM_FONAME(p) (SYM_ANYNAME(p))
  317. #define SYM_FOTYPE(p) (SYM_ANYTYPE(p))
  318. #define SYM_FOKEY(p) (SYM_ANYKEY(p))
  319. #define SYM_FOREFCNT(p) (SYM_ANYREFCNT(p))
  320. #define SYM_FOCLASS(p) (SYM_ANYCLASS(p))
  321. #define SYM_FOADJ(p) (SYM_ANYADJ(p))
  322. #define SYM_FOAOFF(p) (SYM_ANYAOFF(p))
  323. #define SYM_FOPREV(p) (M150(p).formal_prev)
  324. #define SYM_LANEXT(p) (SYM_ANYNEXT(p))
  325. #define SYM_LANAME(p) (SYM_ANYNAME(p))
  326. #define SYM_LATYPE(p) (SYM_ANYTYPE(p))
  327. #define SYM_LAKEY(p) (SYM_ANYKEY(p))
  328. #define SYM_LAREFCNT(p) (SYM_ANYREFCNT(p))
  329. #define SYM_LACLASS(p) (SYM_ANYCLASS(p))
  330. #define SYM_LAADJ(p) (SYM_ANYADJ(p))
  331. #define SYM_LAAOFF(p) (SYM_ANYAOFF(p))
  332. #define SYM_LAASEG(p) (SYM_ANYASEG(p))
  333. #define SYM_LATEMPLATE(p) (M160(p).label_template)
  334. #define SYM_INNEXT(p) (SYM_ANYNEXT(p))
  335. #define SYM_INNAME(p) (SYM_ANYNAME(p))
  336. #define SYM_INTYPE(p) (SYM_ANYTYPE(p))
  337. #define SYM_INKEY(p) (SYM_ANYKEY(p))
  338. #define SYM_INREFCNT(p) (SYM_ANYREFCNT(p))
  339. #define SYM_INCLASS(p) (SYM_ANYCLASS(p))
  340. #define SYM_INADJ(p) (SYM_ANYADJ(p))
  341. #define SYM_INNUMBER(p) (M170(p).intrin_ino)
  342. #define SYM_INNPARMS(p) (M170(p).intrin_nparms)
  343. #define SYM_TANEXT(p) (SYM_ANYNEXT(p))
  344. #define SYM_TANAME(p) (SYM_ANYNAME(p))
  345. #define SYM_TATYPE(p) (SYM_ANYTYPE(p))
  346. #define SYM_TAKEY(p) (SYM_ANYKEY(p))
  347. #define SYM_TASIZE(p) (M180(p).tag_size)
  348. #define SYM_TAALIGN(p) (M180(p).tag_align)
  349. #define SYM_MENEXT(p) (SYM_ANYNEXT(p))
  350. #define SYM_MENAME(p) (SYM_ANYNAME(p))
  351. #define SYM_METYPE(p) (SYM_ANYTYPE(p))
  352. #define SYM_MEPREV(p) (M190(p).member_prev)
  353. #define SYM_MEOFFSET(p) (M190(p).member_offset)
  354. #define SYM_MEVACCESS(p) (M190(p).member_vaccess)
  355. #define SYM_FINEXT(p) (SYM_ANYNEXT(p))
  356. #define SYM_FINAME(p) (SYM_ANYNAME(p))
  357. #define SYM_FITYPE(p) (SYM_ANYTYPE(p))
  358. #define SYM_FIPREV(p) (M190(p).member_prev)
  359. #define SYM_FIOFFSET(p) (M190(p).member_offset)
  360. #define SYM_FIVACCESS(p) (M190(p).member_vaccess)
  361. #define SYM_FIBITSTART(p) (M200(p).field_bitstart)
  362. #define SYM_FINBITS(p) (M200(p).field_nbits)
  363. #define SYM_MONEXT(p) (SYM_ANYNEXT(p))
  364. #define SYM_MONAME(p) (SYM_ANYNAME(p))
  365. #define SYM_MOVALUE(p) ((p)->m95.moe_value)
  366. /*
  367. ** macros for acessing informmation on symbols type
  368. */
  369. #define SYM_ANYBTYPE(P) (TY_BTYPE(SYM_ANYTYPE(P)))
  370. #define SYM_ANYESU(P) (TY_ESU(SYM_ANYTYPE(P)))
  371. #define SYM_ANYTINDEX(P) (TY_TINDEX(SYM_ANYTYPE(P)))
  372. #define SYM_ANYINDIR(P) (TY_INDIR(SYM_SYTYPE(P)))
  373. #define SYM_ANYISUB(P) (INDIR_ISUB(SYM_ANYINDIR(P)))
  374. #define SYM_ANYINEXT(P) (INDIR_INEXT(SYM_ANYINDIR(P)))
  375. #define SYM_ANYITYPE(P) (INDIR_ITYPE(SYM_ANYINDIR(P)))
  376. #define SYM_ANYIFORMALS(P) (INDIR_IFORMALS(SYM_ANYINDIR(P)))
  377. #define SYM_NEAR(P) (IS_NEAR(SYM_ANYBTYPE(P)))
  378. #define SYM_FAR(P) (IS_FAR(SYM_ANYBTYPE(P)))
  379. #define SYM_HUGE(P) (IS_HUGE(SYM_ANYBTYPE(P)))
  380. #define SYM_CONST(P) (IS_CONST(SYM_ANYBTYPE(P)))
  381. /*
  382. ** the symbol table
  383. */
  384. struct s_table {
  385. table_t *st_next; /* link to next */
  386. table_t *st_incl; /* block is included in block pointer */
  387. fpsym_t *st_table; /* ptr to hash table */
  388. blknum_t st_level; /* block level */
  389. uchar_t st_size; /* number of entries in hash table */
  390. };
  391. /*
  392. ** macros for accessing the symbol tables.
  393. ** `level' is the level of interest.
  394. ** `ptab' is a ptr to a symbol table
  395. */
  396. #define ST_NEXT(ptab) ((ptab)->st_next)
  397. #define ST_INCL(ptab) ((ptab)->st_incl)
  398. #define ST_SYM(ptab) ((ptab)->st_table)
  399. #define ST_LEVEL(ptab) ((ptab)->st_level)
  400. #define ST_MOD(ptab) ((ptab)->st_size)
  401. #define ST_TABLE(level) ((level) ? Table_n : Table_0)
  402. #define ST_BUCKET(ptab,hash) (((ptab)->st_table[hash & ST_MOD(ptab)]))
  403. /*
  404. ** A Hash/Length/Name string is one where the first character is the hash
  405. ** of the name. The second character is the length of the identifier
  406. ** including the hash and length characters. The name begins at the third
  407. ** character.
  408. */
  409. #define HLN_IDENT_HASH(P) (HLN_HASH(*(P)))
  410. #define HLN_IDENT_LENGTH(P) (HLN_LENGTH(*(P)))
  411. #define HLN_IDENTP_NAME(P) (HLN_NAME(*(P)))
  412. /*
  413. ** delcaration specifiers, used by to hold both the class and the type.
  414. */
  415. struct s_declspec {
  416. class_t ds_class;
  417. ptype_t ds_type;
  418. };
  419. #define DSP_CLASS(p) ((p)->ds_class)
  420. #define DSP_TYPE(p) ((p)->ds_type)
  421. #define DS_CLASS(p) ((p).ds_class)
  422. #define DS_TYPE(p) ((p).ds_type)
  423.