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.

476 lines
6.0 KiB

  1. /*++
  2. Copyright (c) 1993 Microsoft Corporation
  3. Module Name:
  4. regiodsc.cxx
  5. Abstract:
  6. This module contains the definitions of the member functions
  7. of IO_DESCRIPTOR class.
  8. Author:
  9. Jaime Sasson (jaimes) 02-Dec-1993
  10. Environment:
  11. ULIB, User Mode
  12. --*/
  13. // don't let ntdddisk.h (included in ulib.hxx")
  14. // redefine values
  15. #define _NTDDDISK_H_
  16. #include "ulib.hxx"
  17. #include "regiodsc.hxx"
  18. #include <ctype.h>
  19. DEFINE_CONSTRUCTOR ( IO_DESCRIPTOR, OBJECT );
  20. IO_DESCRIPTOR::~IO_DESCRIPTOR (
  21. )
  22. /*++
  23. Routine Description:
  24. Destroy a IO_DESCRIPTOR.
  25. Arguments:
  26. None.
  27. Return Value:
  28. None.
  29. --*/
  30. {
  31. }
  32. VOID
  33. IO_DESCRIPTOR::Construct (
  34. )
  35. /*++
  36. Routine Description:
  37. Construct a IO_DESCRIPTOR object.
  38. Arguments:
  39. None.
  40. Return Value:
  41. None.
  42. --*/
  43. {
  44. _Option = 0;
  45. _Type = 0;
  46. _ShareDisposition = 0;
  47. _Flags = 0;
  48. }
  49. #if DBG
  50. VOID
  51. IO_DESCRIPTOR::DbgDumpObject(
  52. )
  53. /*++
  54. Routine Description:
  55. Print a IO_DESCRIPTOR object.
  56. Arguments:
  57. None.
  58. Return Value:
  59. None.
  60. --*/
  61. {
  62. DebugPrintTrace(( "\t\tOption = %#x \n", _Option ));
  63. DebugPrintTrace(( "\t\tType = %#x \n", _Type ));
  64. DebugPrintTrace(( "\t\tShareDisposition = %#x \n", _ShareDisposition ));
  65. DebugPrintTrace(( "\t\tFlags = %x \n", _Flags ));
  66. }
  67. #endif
  68. // #include "ulib.hxx"
  69. // #include "regdesc.hxx"
  70. // extern "C" {
  71. // #include <ctype.h>
  72. // }
  73. DEFINE_CONSTRUCTOR ( IO_PORT_DESCRIPTOR, IO_DESCRIPTOR );
  74. IO_PORT_DESCRIPTOR::~IO_PORT_DESCRIPTOR (
  75. )
  76. /*++
  77. Routine Description:
  78. Destroy an IO_PORT_DESCRIPTOR.
  79. Arguments:
  80. None.
  81. Return Value:
  82. None.
  83. --*/
  84. {
  85. }
  86. VOID
  87. IO_PORT_DESCRIPTOR::Construct (
  88. )
  89. /*++
  90. Routine Description:
  91. Construct a IO_PORT_DESCRIPTOR object.
  92. Arguments:
  93. None.
  94. Return Value:
  95. None.
  96. --*/
  97. {
  98. _Length = 0;
  99. _Alignment = 0;
  100. _MinimumAddress.LowPart = 0;
  101. _MinimumAddress.HighPart = 0;
  102. _MaximumAddress.LowPart = 0;
  103. _MaximumAddress.HighPart = 0;
  104. }
  105. #if DBG
  106. VOID
  107. IO_PORT_DESCRIPTOR::DbgDumpObject(
  108. )
  109. /*++
  110. Routine Description:
  111. Print a IO_PORT_DESCRIPTOR object.
  112. Arguments:
  113. None.
  114. Return Value:
  115. None.
  116. --*/
  117. {
  118. IO_DESCRIPTOR::DbgDumpObject();
  119. DebugPrintTrace(( "\t\tLength = %#lx \n", _Length ));
  120. DebugPrintTrace(( "\t\tAlignment = %#lx \n", _Alignment ));
  121. DebugPrintTrace(( "\t\tMinimumAddress.HighPart = %#lx \n", _MinimumAddress.HighPart ));
  122. DebugPrintTrace(( "\t\tMinimumAddress.LowPart = %#lx \n", _MinimumAddress.LowPart ));
  123. DebugPrintTrace(( "\t\tMaximumAddress.HighPart = %#lx \n", _MaximumAddress.HighPart ));
  124. DebugPrintTrace(( "\t\tMaximumAddress.LowPart = %#lx \n", _MaximumAddress.LowPart ));
  125. DebugPrintTrace(( "\n" ));
  126. }
  127. #endif
  128. // #include "ulib.hxx"
  129. // #include "regdesc.hxx"
  130. // extern "C" {
  131. // #include <ctype.h>
  132. // }
  133. DEFINE_CONSTRUCTOR ( IO_INTERRUPT_DESCRIPTOR, IO_DESCRIPTOR );
  134. IO_INTERRUPT_DESCRIPTOR::~IO_INTERRUPT_DESCRIPTOR (
  135. )
  136. /*++
  137. Routine Description:
  138. Destroy an IO_INTERRUPT_DESCRIPTOR.
  139. Arguments:
  140. None.
  141. Return Value:
  142. None.
  143. --*/
  144. {
  145. }
  146. VOID
  147. IO_INTERRUPT_DESCRIPTOR::Construct (
  148. )
  149. /*++
  150. Routine Description:
  151. Construct an IO_INTERRUPT_DESCRIPTOR object.
  152. Arguments:
  153. None.
  154. Return Value:
  155. None.
  156. --*/
  157. {
  158. _MinimumVector = 0;
  159. _MaximumVector = 0;
  160. }
  161. #if DBG
  162. VOID
  163. IO_INTERRUPT_DESCRIPTOR::DbgDumpObject(
  164. )
  165. /*++
  166. Routine Description:
  167. Print an IO_INTERRUPT_DESCRIPTOR object.
  168. Arguments:
  169. None.
  170. Return Value:
  171. None.
  172. --*/
  173. {
  174. IO_DESCRIPTOR::DbgDumpObject();
  175. DebugPrintTrace(( "\t\tMinimumVector = %#lx \n", _MinimumVector ));
  176. DebugPrintTrace(( "\t\tMaximumVector = %#lx \n", _MaximumVector ));
  177. DebugPrintTrace(( "\n" ));
  178. }
  179. #endif
  180. // #include "ulib.hxx"
  181. // #include "regdesc.hxx"
  182. // extern "C" {
  183. // #include <ctype.h>
  184. // }
  185. DEFINE_CONSTRUCTOR ( IO_MEMORY_DESCRIPTOR, IO_DESCRIPTOR );
  186. IO_MEMORY_DESCRIPTOR::~IO_MEMORY_DESCRIPTOR (
  187. )
  188. /*++
  189. Routine Description:
  190. Destroy an IO_MEMORY_DESCRIPTOR.
  191. Arguments:
  192. None.
  193. Return Value:
  194. None.
  195. --*/
  196. {
  197. }
  198. VOID
  199. IO_MEMORY_DESCRIPTOR::Construct (
  200. )
  201. /*++
  202. Routine Description:
  203. Construct an IO_MEMORY_DESCRIPTOR object.
  204. Arguments:
  205. None.
  206. Return Value:
  207. None.
  208. --*/
  209. {
  210. _Length = 0;
  211. _Alignment = 0;
  212. _MinimumAddress.LowPart = 0;
  213. _MinimumAddress.HighPart = 0;
  214. _MaximumAddress.LowPart = 0;
  215. _MaximumAddress.HighPart = 0;
  216. }
  217. #if DBG
  218. VOID
  219. IO_MEMORY_DESCRIPTOR::DbgDumpObject(
  220. )
  221. /*++
  222. Routine Description:
  223. Print an IO_MEMORY_DESCRIPTOR object.
  224. Arguments:
  225. None.
  226. Return Value:
  227. None.
  228. --*/
  229. {
  230. IO_DESCRIPTOR::DbgDumpObject();
  231. DebugPrintTrace(( "\t\tLength = %#lx \n", _Length ));
  232. DebugPrintTrace(( "\t\tAlignment = %#lx \n", _Alignment ));
  233. DebugPrintTrace(( "\t\tMinimumAddress.HighPart = %#lx \n", _MinimumAddress.HighPart ));
  234. DebugPrintTrace(( "\t\tMinimumAddress.LowPart = %#lx \n", _MinimumAddress.LowPart ));
  235. DebugPrintTrace(( "\t\tMaximumAddress.HighPart = %#lx \n", _MaximumAddress.HighPart ));
  236. DebugPrintTrace(( "\t\tMaximumAddress.LowPart = %#lx \n", _MaximumAddress.LowPart ));
  237. DebugPrintTrace(( "\n" ));
  238. }
  239. #endif
  240. // #include "ulib.hxx"
  241. // #include "regdesc.hxx"
  242. // extern "C" {
  243. // #include <ctype.h>
  244. // }
  245. DEFINE_CONSTRUCTOR ( IO_DMA_DESCRIPTOR, IO_DESCRIPTOR );
  246. IO_DMA_DESCRIPTOR::~IO_DMA_DESCRIPTOR (
  247. )
  248. /*++
  249. Routine Description:
  250. Destroy a IO_DMA_DESCRIPTOR.
  251. Arguments:
  252. None.
  253. Return Value:
  254. None.
  255. --*/
  256. {
  257. }
  258. VOID
  259. IO_DMA_DESCRIPTOR::Construct (
  260. )
  261. /*++
  262. Routine Description:
  263. Construct an IO_DMA_DESCRIPTOR object.
  264. Arguments:
  265. None.
  266. Return Value:
  267. None.
  268. --*/
  269. {
  270. _MinimumChannel = 0;
  271. _MaximumChannel = 0;
  272. }
  273. #if DBG
  274. VOID
  275. IO_DMA_DESCRIPTOR::DbgDumpObject(
  276. )
  277. /*++
  278. Routine Description:
  279. Print a IO_DMA_DESCRIPTOR object.
  280. Arguments:
  281. None.
  282. Return Value:
  283. None.
  284. --*/
  285. {
  286. IO_DESCRIPTOR::DbgDumpObject();
  287. DebugPrintTrace(( "\t\tMinimumChannel = %#lx \n", _MinimumChannel ));
  288. DebugPrintTrace(( "\t\tMaximumChannel = %#lx \n", _MaximumChannel ));
  289. DebugPrintTrace(( "\n" ));
  290. }
  291. #endif