PageRenderTime 46ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/user/games/xmame/xmame-0.106/mess/systems/pdp1.c

https://bitbucket.org/thelearninglabs/uclinux-distro-tll-public
C | 512 lines | 320 code | 67 blank | 125 comment | 1 complexity | 0042919aa0750c3aec0e1d4f82358f56 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, MPL-2.0-no-copyleft-exception, LGPL-3.0, Unlicense, GPL-2.0, GPL-3.0, CC-BY-SA-3.0, AGPL-1.0, ISC, MIT, 0BSD, LGPL-2.0 
    

  1. /*
    2. 

    3. 

  3. Driver for a PDP1 emulator.
    4. 

    5. 

  5. 	Digital Equipment Corporation
    6. 

  6. 	Brian Silverman (original Java Source)
    7. 

  7. 	Vadim Gerasimov (original Java Source)
    8. 

  8. 	Chris Salomon (MESS driver)
    9. 

  9. 	Raphael Nabet (MESS driver)
    10. 

    11. 

  11. Initially, this was a conversion of a JAVA emulator
    12. 

  12. (although code has been edited extensively ever since).
    13. 

  13. I have tried contacting the author, but heard as yet nothing of him,
    14. 

  14. so I don't know if it all right with him, but after all -> he did
    15. 

  15. release the source, so hopefully everything will be fine (no his
    16. 

  16. name is not Marat).
    17. 

    18. 

  18. Note: naturally I have no PDP1, I have never seen one, nor have I any
    19. 

  19. programs for it.
    20. 

    21. 

  21. The first supported program was:
    22. 

    23. 

  23. SPACEWAR!
    24. 

    25. 

  25. The first Videogame EVER!
    26. 

    27. 

  27. When I saw the java emulator, running that game I was quite intrigued to
    28. 

  28. include a driver for MESS.
    29. 

  29. I think the historical value of SPACEWAR! is enormous.
    30. 

    31. 

  31. Two other programs are supported: Munching squares and LISP.
    32. 

    33. 

  33. Added Debugging and Disassembler...
    34. 

    35. 

    36. 

  36. Also:
    37. 

  37. ftp://minnie.cs.adfa.oz.au/pub/PDP-11/Sims/Supnik_2.3/software/lispswre.tar.gz
    38. 

  38. Is a packet which includes the original LISP as source and
    39. 

  39. binary form plus a makro assembler for PDP1 programs.
    40. 

    41. 

  41. For more documentation look at the source for the driver,
    42. 

  42. and the cpu/pdp1/pdp1.c file (information about the whereabouts of information
    43. 

  43. and the java source).
    44. 

    45. 

  45. */
    46. 

  46. 

  47. #include <math.h>
    48. 

  48. 

  49. #include "driver.h"
    50. 

  50. 

  51. #include "cpu/pdp1/pdp1.h"
    52. 

  52. #include "includes/pdp1.h"
    53. 

  53. #include "vidhrdw/crt.h"
    54. 

  54. 

  55. /*
    56. 

  56.  *
    57. 

  57.  * The loading storing OS... is not emulated (I haven't a clue where to
    58. 

  58.  * get programs for the machine)
    59. 

  59.  *
    60. 

  60.  */
    61. 

  61. 

  62. 

  63. 

  64. 

  65. 

  66. /* every memory handler is the same for now */
    67. 

  67. 

  68. /* note: MEMORY HANDLERS used everywhere, since we don't need bytes, we
    69. 

  69.  * need 18 bit words, the handler functions return integers, so it should
    70. 

  70.  * be all right to use them.
    71. 

  71.  * This gives sometimes IO warnings!
    72. 

  72.  */
    73. 

  73. #ifdef SUPPORT_ODD_WORD_SIZES
    74. 

  74. #define pdp1_read_mem MRA32_RAM
    75. 

  75. #define pdp1_write_mem MWA32_RAM
    76. 

  76. #endif
    77. 

  77. static ADDRESS_MAP_START(pdp1_map, ADDRESS_SPACE_PROGRAM, 32)
    78. 

  78. #if 0
    79. 

  79. 	AM_RANGE(0x0000, 0xffff) AM_READWRITE(pdp1_read_mem, pdp1_write_mem)
    80. 

  80. #else
    81. 

  81. 	AM_RANGE(0x00000, 0x3ffff) AM_READWRITE(pdp1_read_mem, pdp1_write_mem)
    82. 

  82. #endif
    83. 

  83. ADDRESS_MAP_END
    84. 

  84. 

  85. 

  86. INPUT_PORTS_START( pdp1 )
    87. 

  87. 

  88.     PORT_START		/* 0: spacewar controllers */
    89. 

  89. 	PORT_BIT( ROTATE_LEFT_PLAYER1, IP_ACTIVE_HIGH, IPT_JOYSTICK_LEFT) PORT_NAME("Spin Left Player 1") PORT_CODE(KEYCODE_A) PORT_CODE(JOYCODE_1_LEFT)
    90. 

  90. 	PORT_BIT( ROTATE_RIGHT_PLAYER1, IP_ACTIVE_HIGH, IPT_JOYSTICK_RIGHT) PORT_NAME("Spin Right Player 1") PORT_CODE(KEYCODE_S) PORT_CODE(JOYCODE_1_RIGHT)
    91. 

  91. 	PORT_BIT( THRUST_PLAYER1, IP_ACTIVE_HIGH, IPT_BUTTON1) PORT_NAME("Thrust Player 1") PORT_CODE(KEYCODE_D) PORT_CODE(JOYCODE_1_BUTTON1)
    92. 

  92. 	PORT_BIT( FIRE_PLAYER1, IP_ACTIVE_HIGH, IPT_BUTTON2) PORT_NAME("Fire Player 1") PORT_CODE(KEYCODE_F) PORT_CODE(JOYCODE_1_BUTTON2)
    93. 

  93. 	PORT_BIT( ROTATE_LEFT_PLAYER2, IP_ACTIVE_HIGH, IPT_JOYSTICK_LEFT) PORT_NAME("Spin Left Player 2") PORT_CODE(KEYCODE_LEFT) PORT_CODE(JOYCODE_2_LEFT ) PORT_PLAYER(2)
    94. 

  94. 	PORT_BIT( ROTATE_RIGHT_PLAYER2, IP_ACTIVE_HIGH, IPT_JOYSTICK_RIGHT) PORT_NAME("Spin Right Player 2") PORT_CODE(KEYCODE_RIGHT) PORT_CODE(JOYCODE_2_RIGHT ) PORT_PLAYER(2)
    95. 

  95. 	PORT_BIT( THRUST_PLAYER2, IP_ACTIVE_HIGH, IPT_BUTTON1) PORT_NAME("Thrust Player 2") PORT_CODE(KEYCODE_UP) PORT_CODE(JOYCODE_2_BUTTON1 ) PORT_PLAYER(2)
    96. 

  96. 	PORT_BIT( FIRE_PLAYER2, IP_ACTIVE_HIGH, IPT_BUTTON2) PORT_NAME("Fire Player 2") PORT_CODE(KEYCODE_DOWN) PORT_CODE(JOYCODE_2_BUTTON2 ) PORT_PLAYER(2)
    97. 

  97. 	PORT_BIT( HSPACE_PLAYER1, IP_ACTIVE_HIGH, IPT_BUTTON3) PORT_NAME("Hyperspace Player 1") PORT_CODE(KEYCODE_Z) PORT_CODE(JOYCODE_1_BUTTON3)
    98. 

  98. 	PORT_BIT( HSPACE_PLAYER2, IP_ACTIVE_HIGH, IPT_BUTTON3) PORT_NAME("Hyperspace Player 2") PORT_CODE(KEYCODE_SLASH) PORT_CODE(JOYCODE_2_BUTTON3 ) PORT_PLAYER(2)
    99. 

  99. 

  100. 	PORT_START		/* 1: various pdp1 operator control panel switches */
    101. 

  101. 	PORT_BIT(pdp1_control, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("control panel key") PORT_CODE(KEYCODE_LCONTROL)
    102. 

  102. 	PORT_BIT(pdp1_extend, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("extend") PORT_CODE(KEYCODE_TILDE)
    103. 

  103. 	PORT_BIT(pdp1_start_nobrk, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("start (sequence break disabled)") PORT_CODE(KEYCODE_U)
    104. 

  104. 	PORT_BIT(pdp1_start_brk, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("start (sequence break enabled)") PORT_CODE(KEYCODE_I)
    105. 

  105. 	PORT_BIT(pdp1_stop, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("stop") PORT_CODE(KEYCODE_O)
    106. 

  106. 	PORT_BIT(pdp1_continue, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("continue") PORT_CODE(KEYCODE_P)
    107. 

  107. 	PORT_BIT(pdp1_examine, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("examine") PORT_CODE(KEYCODE_OPENBRACE)
    108. 

  108. 	PORT_BIT(pdp1_deposit, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("deposit") PORT_CODE(KEYCODE_CLOSEBRACE)
    109. 

  109. 	PORT_BIT(pdp1_read_in, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("read in") PORT_CODE(KEYCODE_ENTER)
    110. 

  110. 	PORT_BIT(pdp1_reader, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("reader")
    111. 

  111. 	PORT_BIT(pdp1_tape_feed, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("tape feed")
    112. 

  112. 	PORT_BIT(pdp1_single_step, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("single step") PORT_CODE(KEYCODE_STOP)
    113. 

  113. 	PORT_BIT(pdp1_single_inst, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("single inst") PORT_CODE(KEYCODE_SLASH)
    114. 

  114. 

  115.     PORT_START		/* 2: operator control panel sense switches */
    116. 

  116. 	PORT_DIPNAME(	  040, 000, "Sense Switch 1") PORT_CODE(KEYCODE_1_PAD)
    117. 

  117.     PORT_DIPSETTING(    000, DEF_STR( Off ) )
    118. 

  118.     PORT_DIPSETTING(    040, DEF_STR( On ) )
    119. 

  119. 	PORT_DIPNAME(	  020, 000, "Sense Switch 2") PORT_CODE(KEYCODE_2_PAD)
    120. 

  120.     PORT_DIPSETTING(    000, DEF_STR( Off ) )
    121. 

  121.     PORT_DIPSETTING(    020, DEF_STR( On ) )
    122. 

  122. 	PORT_DIPNAME(	  010, 000, "Sense Switch 3") PORT_CODE(KEYCODE_3_PAD)
    123. 

  123.     PORT_DIPSETTING(    000, DEF_STR( Off ) )
    124. 

  124.     PORT_DIPSETTING(    010, DEF_STR( On ) )
    125. 

  125. 	PORT_DIPNAME(	  004, 000, "Sense Switch 4") PORT_CODE(KEYCODE_4_PAD)
    126. 

  126.     PORT_DIPSETTING(    000, DEF_STR( Off ) )
    127. 

  127.     PORT_DIPSETTING(    004, DEF_STR( On ) )
    128. 

  128. 	PORT_DIPNAME(	  002, 002, "Sense Switch 5") PORT_CODE(KEYCODE_5_PAD)
    129. 

  129.     PORT_DIPSETTING(    000, DEF_STR( Off ) )
    130. 

  130.     PORT_DIPSETTING(    002, DEF_STR( On ) )
    131. 

  131. 	PORT_DIPNAME(	  001, 000, "Sense Switch 6") PORT_CODE(KEYCODE_6_PAD)
    132. 

  132.     PORT_DIPSETTING(    000, DEF_STR( Off ) )
    133. 

  133.     PORT_DIPSETTING(    001, DEF_STR( On ) )
    134. 

  134. 

  135.     PORT_START		/* 3: operator control panel test address switches */
    136. 

  136. 	PORT_BIT( 0100000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Extension Test Address Switch 3") PORT_CODE(KEYCODE_1)
    137. 

  137. 	PORT_BIT( 0040000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Extension Test Address Switch 4") PORT_CODE(KEYCODE_2)
    138. 

  138. 	PORT_BIT( 0020000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Extension Test Address Switch 5") PORT_CODE(KEYCODE_3)
    139. 

  139. 	PORT_BIT( 0010000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Extension Test Address Switch 6") PORT_CODE(KEYCODE_4)
    140. 

  140. 	PORT_BIT( 0004000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 7") PORT_CODE(KEYCODE_5)
    141. 

  141. 	PORT_BIT( 0002000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 8") PORT_CODE(KEYCODE_6)
    142. 

  142. 	PORT_BIT( 0001000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 9") PORT_CODE(KEYCODE_7)
    143. 

  143. 	PORT_BIT( 0000400, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 10") PORT_CODE(KEYCODE_8)
    144. 

  144. 	PORT_BIT( 0000200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 11") PORT_CODE(KEYCODE_9)
    145. 

  145. 	PORT_BIT( 0000100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 12") PORT_CODE(KEYCODE_0)
    146. 

  146. 	PORT_BIT( 0000040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 13") PORT_CODE(KEYCODE_MINUS)
    147. 

  147. 	PORT_BIT( 0000020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 14") PORT_CODE(KEYCODE_EQUALS)
    148. 

  148. 	PORT_BIT( 0000010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 15") PORT_CODE(KEYCODE_Q)
    149. 

  149. 	PORT_BIT( 0000004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 16") PORT_CODE(KEYCODE_W)
    150. 

  150.    	PORT_BIT( 0000002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 17") PORT_CODE(KEYCODE_E)
    151. 

  151.    	PORT_BIT( 0000001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Address Switch 18") PORT_CODE(KEYCODE_R)
    152. 

  152. 

  153.     PORT_START		/* 4: operator control panel test word switches MSB */
    154. 

  154. 	PORT_BIT(    0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 1") PORT_CODE(KEYCODE_A)
    155. 

  155. 	PORT_BIT(    0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 2") PORT_CODE(KEYCODE_S)
    156. 

  156. 

  157.     PORT_START		/* 5: operator control panel test word switches LSB */
    158. 

  158. 	PORT_BIT( 0100000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 3") PORT_CODE(KEYCODE_D)
    159. 

  159. 	PORT_BIT( 0040000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 4") PORT_CODE(KEYCODE_F)
    160. 

  160. 	PORT_BIT( 0020000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 5") PORT_CODE(KEYCODE_G)
    161. 

  161. 	PORT_BIT( 0010000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 6") PORT_CODE(KEYCODE_H)
    162. 

  162. 	PORT_BIT( 0004000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 7") PORT_CODE(KEYCODE_J)
    163. 

  163. 	PORT_BIT( 0002000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 8") PORT_CODE(KEYCODE_K)
    164. 

  164. 	PORT_BIT( 0001000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 9") PORT_CODE(KEYCODE_L)
    165. 

  165. 	PORT_BIT( 0000400, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 10") PORT_CODE(KEYCODE_COLON)
    166. 

  166. 	PORT_BIT( 0000200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 11") PORT_CODE(KEYCODE_QUOTE)
    167. 

  167. 	PORT_BIT( 0000100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 12") PORT_CODE(KEYCODE_BACKSLASH)
    168. 

  168. 	PORT_BIT( 0000040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 13") PORT_CODE(KEYCODE_Z)
    169. 

  169. 	PORT_BIT( 0000020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 14") PORT_CODE(KEYCODE_X)
    170. 

  170. 	PORT_BIT( 0000010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 15") PORT_CODE(KEYCODE_C)
    171. 

  171. 	PORT_BIT( 0000004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 16") PORT_CODE(KEYCODE_V)
    172. 

  172.    	PORT_BIT( 0000002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 17") PORT_CODE(KEYCODE_B)
    173. 

  173.    	PORT_BIT( 0000001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Test Word Switch 18") PORT_CODE(KEYCODE_N)
    174. 

  174. 

  175. 	/*
    176. 

  176. 		Note that I can see 2 additional keys whose purpose is unknown to me.
    177. 

  177. 		The caps look like "MAR REL" for the leftmost one and "MAR SET" for
    178. 

  178. 		rightmost one: maybe they were used to set the margin (I don't have the
    179. 

  179. 		manual for the typewriter).
    180. 

  180. 	*/
    181. 

  181.     PORT_START		/* 6: typewriter codes 00-17 */
    182. 

  182. 	PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("(Space)") PORT_CODE(KEYCODE_SPACE)
    183. 

  183. 	PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("1 \"") PORT_CODE(KEYCODE_1)
    184. 

  184. 	PORT_BIT(0x0004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("2 '") PORT_CODE(KEYCODE_2)
    185. 

  185. 	PORT_BIT(0x0008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("3 ~") PORT_CODE(KEYCODE_3)
    186. 

  186. 	PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("4 (implies)") PORT_CODE(KEYCODE_4)
    187. 

  187. 	PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("5 (or)") PORT_CODE(KEYCODE_5)
    188. 

  188. 	PORT_BIT(0x0040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("6 (and)") PORT_CODE(KEYCODE_6)
    189. 

  189. 	PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("7 <") PORT_CODE(KEYCODE_7)
    190. 

  190. 	PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("8 >") PORT_CODE(KEYCODE_8)
    191. 

  191. 	PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("9 (up arrow)") PORT_CODE(KEYCODE_9)
    192. 

  192. 

  193.     PORT_START		/* 7: typewriter codes 20-37 */
    194. 

  194. 	PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("0 (right arrow)") PORT_CODE(KEYCODE_0)
    195. 

  195. 	PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("/ ?") PORT_CODE(KEYCODE_SLASH)
    196. 

  196. 	PORT_BIT(0x0004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("S") PORT_CODE(KEYCODE_S)
    197. 

  197. 	PORT_BIT(0x0008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("T") PORT_CODE(KEYCODE_T)
    198. 

  198. 	PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("U") PORT_CODE(KEYCODE_U)
    199. 

  199. 	PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("V") PORT_CODE(KEYCODE_V)
    200. 

  200. 	PORT_BIT(0x0040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("W") PORT_CODE(KEYCODE_W)
    201. 

  201. 	PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("X") PORT_CODE(KEYCODE_X)
    202. 

  202. 	PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Y") PORT_CODE(KEYCODE_Y)
    203. 

  203. 	PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Z") PORT_CODE(KEYCODE_Z)
    204. 

  204. 	PORT_BIT(0x0800, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(", =") PORT_CODE(KEYCODE_COMMA)
    205. 

  205. 	PORT_BIT(0x4000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Tab Key") PORT_CODE(KEYCODE_TAB)
    206. 

  206. 

  207.     PORT_START		/* 8: typewriter codes 40-57 */
    208. 

  208. 	PORT_BIT(0x0001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("(non-spacing middle dot) _") PORT_CODE(KEYCODE_QUOTE)
    209. 

  209. 	PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("J") PORT_CODE(KEYCODE_J)
    210. 

  210. 	PORT_BIT(0x0004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("K") PORT_CODE(KEYCODE_K)
    211. 

  211. 	PORT_BIT(0x0008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("L") PORT_CODE(KEYCODE_L)
    212. 

  212. 	PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("M") PORT_CODE(KEYCODE_M)
    213. 

  213. 	PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("N") PORT_CODE(KEYCODE_N)
    214. 

  214. 	PORT_BIT(0x0040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("O") PORT_CODE(KEYCODE_O)
    215. 

  215. 	PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("P") PORT_CODE(KEYCODE_P)
    216. 

  216. 	PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Q") PORT_CODE(KEYCODE_Q)
    217. 

  217. 	PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("R") PORT_CODE(KEYCODE_R)
    218. 

  218. 	PORT_BIT(0x1000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("- +") PORT_CODE(KEYCODE_COLON)
    219. 

  219. 	PORT_BIT(0x2000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(") ]") PORT_CODE(KEYCODE_EQUALS)
    220. 

  220. 	PORT_BIT(0x4000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("(non-spacing overstrike) |") PORT_CODE(KEYCODE_OPENBRACE)
    221. 

  221. 	PORT_BIT(0x8000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("( [") PORT_CODE(KEYCODE_MINUS)
    222. 

  222. 

  223.     PORT_START		/* 9: typewriter codes 60-77 */
    224. 

  224. 	PORT_BIT(0x0002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("A") PORT_CODE(KEYCODE_A)
    225. 

  225. 	PORT_BIT(0x0004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("B") PORT_CODE(KEYCODE_B)
    226. 

  226. 	PORT_BIT(0x0008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("C") PORT_CODE(KEYCODE_C)
    227. 

  227. 	PORT_BIT(0x0010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("D") PORT_CODE(KEYCODE_D)
    228. 

  228. 	PORT_BIT(0x0020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("E") PORT_CODE(KEYCODE_E)
    229. 

  229. 	PORT_BIT(0x0040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("F") PORT_CODE(KEYCODE_F)
    230. 

  230. 	PORT_BIT(0x0080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("G") PORT_CODE(KEYCODE_G)
    231. 

  231. 	PORT_BIT(0x0100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("H") PORT_CODE(KEYCODE_H)
    232. 

  232. 	PORT_BIT(0x0200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("I") PORT_CODE(KEYCODE_I)
    233. 

  233. 	PORT_BIT(0x0400, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Lower Case") PORT_CODE(KEYCODE_LSHIFT)
    234. 

  234. 	PORT_BIT(0x0800, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(". (multiply)") PORT_CODE(KEYCODE_STOP)
    235. 

  235. 	PORT_BIT(0x1000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Upper case") PORT_CODE(KEYCODE_RSHIFT)
    236. 

  236. 	/* hack to support my macintosh which does not differentiate the  Right Shift key */
    237. 

  237. 	PORT_BIT(0x1000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Upper case") PORT_CODE(KEYCODE_CAPSLOCK)
    238. 

  238. 	PORT_BIT(0x2000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Backspace") PORT_CODE(KEYCODE_BACKSPACE)
    239. 

  239. 	PORT_BIT(0x8000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Return") PORT_CODE(KEYCODE_ENTER)
    240. 

  240. 

  241. 	PORT_START		/* 10: pseudo-input port with config */
    242. 

  242. 	PORT_BIT( 0x0003, 0x0002, IPT_DIPSWITCH_NAME) PORT_NAME("RAM size")
    243. 

  243.     PORT_DIPSETTING(   0x0000, "4kw" )
    244. 

  244.     PORT_DIPSETTING(   0x0001, "32kw")
    245. 

  245.     PORT_DIPSETTING(   0x0002, "64kw")
    246. 

  246. 	PORT_BIT( 0x0004, 0x0000, IPT_DIPSWITCH_NAME) PORT_NAME("Hardware multiply")
    247. 

  247.     PORT_DIPSETTING(   0x0000, DEF_STR( Off ) )
    248. 

  248.     PORT_DIPSETTING(   0x0004, DEF_STR( On ) )
    249. 

  249. 	PORT_BIT( 0x0008, 0x0000, IPT_DIPSWITCH_NAME) PORT_NAME("Hardware divide")
    250. 

  250.     PORT_DIPSETTING(   0x0000, DEF_STR( Off ) )
    251. 

  251.     PORT_DIPSETTING(   0x0008, DEF_STR( On ) )
    252. 

  252. 	PORT_BIT( 0x0010, 0x0000, IPT_DIPSWITCH_NAME) PORT_NAME("Type 20 sequence break system")
    253. 

  253.     PORT_DIPSETTING(   0x0000, DEF_STR( Off ) )
    254. 

  254.     PORT_DIPSETTING(   0x0010, DEF_STR( On ) )
    255. 

  255. 	PORT_DIPNAME( 0x0020, 0x0000, "Type 32 light pen") PORT_CODE(KEYCODE_ENTER_PAD)
    256. 

  256.     PORT_DIPSETTING(   0x0000, DEF_STR( Off ) )
    257. 

  257.     PORT_DIPSETTING(   0x0020, DEF_STR( On ) )
    258. 

  258. 

  259. 	PORT_START	/* 11: pseudo-input port with lightpen status */
    260. 

  260. 	PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("select larger light pen tip") PORT_CODE(KEYCODE_PLUS_PAD)
    261. 

  261. 	PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("select smaller light pen tip") PORT_CODE(KEYCODE_MINUS_PAD)
    262. 

  262. 	PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_BUTTON1) PORT_NAME("light pen down")
    263. 

  263. 

  264. 	PORT_START /* 12: lightpen - X AXIS */
    265. 

  265. 	PORT_BIT( 0xff, 0x00, IPT_TRACKBALL_X) PORT_SENSITIVITY(100) PORT_KEYDELTA(0) PORT_MINMAX(0,0) PORT_PLAYER(1) PORT_RESET
    266. 

  266. 

  267. 	PORT_START /* 13: lightpen - Y AXIS */
    268. 

  268. 	PORT_BIT( 0xff, 0x00, IPT_TRACKBALL_Y) PORT_SENSITIVITY(100) PORT_KEYDELTA(0) PORT_MINMAX(0,0) PORT_PLAYER(1) PORT_RESET
    269. 

  269. 

  270. 

  271. INPUT_PORTS_END
    272. 

  272. 

  273. 

  274. static gfx_layout fontlayout =
    275. 

  275. {
    276. 

  276. 	6, 8,			/* 6*8 characters */
    277. 

  277. 	pdp1_charnum,	/* 96+4 characters */
    278. 

  278. 	1,				/* 1 bit per pixel */
    279. 

  279. 	{ 0 },
    280. 

  280. 	{ 0, 1, 2, 3, 4, 5, 6, 7 }, /* straightforward layout */
    281. 

  281. 	{ 0*8, 1*8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8 },
    282. 

  282. 	8*8 /* every char takes 8 consecutive bytes */
    283. 

  283. };
    284. 

  284. 

  285. static gfx_decode gfxdecodeinfo[] =
    286. 

  286. {
    287. 

  287. 	{ REGION_GFX1, 0, &fontlayout, 0, 3 },
    288. 

  288. 	{ -1 }	/* end of array */
    289. 

  289. };
    290. 

  290. 

  291. 

  292. /*
    293. 

  293. 	The static palette only includes the pens for the control panel and
    294. 

  294. 	the typewriter, as the CRT palette is generated dynamically.
    295. 

    296. 

  296. 	The CRT palette defines various levels of intensity between white and
    297. 

  297. 	black.  Grey levels follow an exponential law, so that decrementing the
    298. 

  298. 	color index periodically will simulate the remanence of a cathode ray tube.
    299. 

  299. */
    300. 

  300. static const UINT8 palette[] =
    301. 

  301. {
    302. 

  302. 	0xFF,0xFF,0xFF,	/* white */
    303. 

  303. 	0x00,0xFF,0x00,	/* green */
    304. 

  304. 	0x00,0x40,0x00,	/* dark green */
    305. 

  305. 	0xFF,0x00,0x00,	/* red */
    306. 

  306. 	0x80,0x80,0x80	/* light gray */
    307. 

  307. };
    308. 

  308. 

  309. static const UINT16 colortable[] =
    310. 

  310. {
    311. 

  311. 	pen_panel_bg, pen_panel_caption,
    312. 

  312. 	pen_typewriter_bg, pen_black,
    313. 

  313. 	pen_typewriter_bg, pen_red
    314. 

  314. };
    315. 

  315. 

  316. /* Initialise the palette */
    317. 

  317. static void palette_init_pdp1(unsigned short *sys_colortable, const unsigned char *dummy)
    318. 

  318. {
    319. 

  319. 	/* rgb components for the two color emissions */
    320. 

  320. 	const double r1 = .1, g1 = .1, b1 = .924, r2 = .7, g2 = .7, b2 = .076;
    321. 

  321. 	/* half period in seconds for the two color emissions */
    322. 

  322. 	const double half_period_1 = .05, half_period_2 = .20;
    323. 

  323. 	/* refresh period in seconds */
    324. 

  324. 	const double update_period = 1./refresh_rate;
    325. 

  325. 	double decay_1, decay_2;
    326. 

  326. 	double cur_level_1, cur_level_2;
    327. 

  327. 	int i;
    328. 

  328. 	int r, g, b;
    329. 

  329. 

  330. 

  331. 	/* initialize CRT palette */
    332. 

  332. 

  333. 	/* compute the decay factor per refresh frame */
    334. 

  334. 	decay_1 = pow(.5, update_period / half_period_1);
    335. 

  335. 	decay_2 = pow(.5, update_period / half_period_2);
    336. 

  336. 

  337. 	cur_level_1 = cur_level_2 = 255.;	/* start with maximum level */
    338. 

  338. 

  339. 	for (i=pen_crt_max_intensity; i>0; i--)
    340. 

  340. 	{
    341. 

  341. 		/* compute the current color */
    342. 

  342. 		r = (int) ((r1*cur_level_1 + r2*cur_level_2) + .5);
    343. 

  343. 		g = (int) ((g1*cur_level_1 + g2*cur_level_2) + .5);
    344. 

  344. 		b = (int) ((b1*cur_level_1 + b2*cur_level_2) + .5);
    345. 

  345. 		/* write color in palette */
    346. 

  346. 		palette_set_color(i, r, g, b);
    347. 

  347. 		/* apply decay for next iteration */
    348. 

  348. 		cur_level_1 *= decay_1;
    349. 

  349. 		cur_level_2 *= decay_2;
    350. 

  350. 	}
    351. 

  351. 

  352. 	palette_set_color(0, 0, 0, 0);
    353. 

  353. 

  354. 	/* load static palette */
    355. 

  355. 	palette_set_colors(pen_crt_num_levels, palette, sizeof(palette) / sizeof(palette[0]) / 3);
    356. 

  356. 

  357. 	memcpy(sys_colortable, colortable, sizeof(colortable));
    358. 

  358. }
    359. 

  359. 

  360. 

  361. pdp1_reset_param_t pdp1_reset_param =
    362. 

  362. {
    363. 

  363. 	{	/* external iot handlers.  NULL means that the iot is unimplemented, unless there are
    364. 

  364. 		parentheses around the iot name, in which case the iot is internal to the cpu core. */
    365. 

  365. 		/* I put a ? when the source is the handbook, since a) I have used the maintainance manual
    366. 

  366. 		as the primary source (as it goes more into details) b) the handbook and the maintainance
    367. 

  367. 		manual occasionnally contradict each other. */
    368. 

  368. 		/* dia, dba, dcc, dra are documented in MIT PDP-1 COMPUTER MODIFICATION
    369. 

  369. 		BULLETIN no. 2 (drumInstrWriteup.bin/drumInstrWriteup.txt), and are
    370. 

  370. 		similar to IOT documented in Parallel Drum Type 23 Instruction Manual. */
    371. 

  371. 	/*	(iot)		rpa			rpb			tyo			tyi			ppa			ppb			dpy */
    372. 

  372. 		NULL,		iot_rpa,	iot_rpb,	iot_tyo,	iot_tyi,	iot_ppa,	iot_ppb,	iot_dpy,
    373. 

  373. 	/*				spacewar																 */
    374. 

  374. 		NULL,		iot_011,	NULL,		NULL,		NULL,		NULL,		NULL,		NULL,
    375. 

  375. 	/*							lag												glf?/jsp?	gpl?/gpr?/gcf? */
    376. 

  376. 		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,
    377. 

  377. 	/*	rrb			rcb?		rcc?		cks			mcs			mes			mel			 */
    378. 

  378. 		iot_rrb,	NULL,		NULL,		iot_cks,	NULL,		NULL,		NULL,		NULL,
    379. 

  379. 	/*	cad?		rac?		rbc?		pac						lpr/lfb/lsp swc/sci/sdf?/shr?	scv? */
    380. 

  380. 		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,
    381. 

  381. 	/*	(dsc)		(asc)		(isb)		(cac)		(lsm)		(esm)		(cbs)		 */
    382. 

  382. 		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,
    383. 

  383. 	/*	icv?		dia			dba			dcc			dra						mri|rlc?	mrf/inr?/ccr? */
    384. 

  384. 		NULL,		iot_dia,	iot_dba,	iot_dcc,	iot_dra,	NULL,		NULL,		NULL,
    385. 

  385. 	/*	mcb|dur?	mwc|mtf?	mrc|sfc?...	msm|cgo?	(eem/lem)	mic			muf			 */
    386. 

  386. 		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,		NULL,
    387. 

  387. 	},
    388. 

  388. 	pdp1_tape_read_binary,
    389. 

  389. 	pdp1_io_sc_callback,
    390. 

  390. 	0,	/* extend mode support defined in input ports and pdp1_init_machine */
    391. 

  391. 	0,	/* hardware multiply/divide support defined in input ports and pdp1_init_machine */
    392. 

  392. 	0	/* type 20 sequence break system support defined in input ports and pdp1_init_machine */
    393. 

  393. };
    394. 

  394. 

  395. 

  396. static MACHINE_DRIVER_START(pdp1)
    397. 

  397. 

  398. 	/* basic machine hardware */
    399. 

  399. 	/* PDP1 CPU @ 200 kHz (no master clock, but the instruction and memory rate is 200 kHz) */
    400. 

  400. 	MDRV_CPU_ADD(PDP1, 1000000/*the CPU core uses microsecond counts*/)
    401. 

  401. 	MDRV_CPU_CONFIG(pdp1_reset_param)
    402. 

  402. 	MDRV_CPU_PROGRAM_MAP(pdp1_map, 0)
    403. 

  403. 	MDRV_CPU_VBLANK_INT(pdp1_interrupt, 1)	/* dummy interrupt: handles input */
    404. 

  404. 

  405. 	MDRV_FRAMES_PER_SECOND(refresh_rate)
    406. 

  406. 	MDRV_VBLANK_DURATION(DEFAULT_REAL_60HZ_VBLANK_DURATION)
    407. 

  407. 

  408. 	MDRV_MACHINE_START( pdp1 )
    409. 

  409. 

  410. 	/* video hardware (includes the control panel and typewriter output) */
    411. 

  411. 	MDRV_VIDEO_ATTRIBUTES(VIDEO_TYPE_RASTER)
    412. 

  412. 	MDRV_SCREEN_SIZE(virtual_width, virtual_height)
    413. 

  413. 	MDRV_VISIBLE_AREA(0, virtual_width-1, 0, virtual_height-1)
    414. 

  414. 

  415. 	MDRV_GFXDECODE(gfxdecodeinfo)
    416. 

  416. 	MDRV_PALETTE_LENGTH(pen_crt_num_levels + (sizeof(palette) / sizeof(palette[0]) / 3))
    417. 

  417. 	MDRV_COLORTABLE_LENGTH(sizeof(colortable) / sizeof(colortable[0]))
    418. 

  418. 

  419. 	MDRV_PALETTE_INIT(pdp1)
    420. 

  420. 	MDRV_VIDEO_START(pdp1)
    421. 

  421. 	MDRV_VIDEO_EOF(crt)
    422. 

  422. 	MDRV_VIDEO_UPDATE(pdp1)
    423. 

  423. MACHINE_DRIVER_END
    424. 

  424. 

  425. /*
    426. 

  426. 	pdp1 can address up to 65336 18 bit words when extended (4096 otherwise).
    427. 

  427. */
    428. 

  428. ROM_START(pdp1)
    429. 

  429. 	ROM_REGION(pdp1_fontdata_size, REGION_GFX1, 0)
    430. 

  430. 		/* space filled with our font */
    431. 

  431. ROM_END
    432. 

  432. 

  433. static void pdp1_punchtape_getinfo(const device_class *devclass, UINT32 state, union devinfo *info)
    434. 

  434. {
    435. 

  435. 	/* punchtape */
    436. 

  436. 	switch(state)
    437. 

  437. 	{
    438. 

  438. 		/* --- the following bits of info are returned as 64-bit signed integers --- */
    439. 

  439. 		case DEVINFO_INT_TYPE:							info->i = IO_PUNCHTAPE; break;
    440. 

  440. 		case DEVINFO_INT_COUNT:							info->i = 2; break;
    441. 

  441. 

  442. 		/* --- the following bits of info are returned as pointers to data or functions --- */
    443. 

  443. 		case DEVINFO_PTR_INIT:							info->init = device_init_pdp1_tape; break;
    444. 

  444. 		case DEVINFO_PTR_LOAD:							info->load = device_load_pdp1_tape; break;
    445. 

  445. 		case DEVINFO_PTR_UNLOAD:						info->unload = device_unload_pdp1_tape; break;
    446. 

  446. 		case DEVINFO_PTR_GET_DISPOSITIONS:				info->getdispositions = pdp1_get_open_mode; break;
    447. 

  447. 

  448. 		/* --- the following bits of info are returned as NULL-terminated strings --- */
    449. 

  449. 		case DEVINFO_STR_FILE_EXTENSIONS:				strcpy(info->s = device_temp_str(), "tap,rim"); break;
    450. 

  450. 	}
    451. 

  451. }
    452. 

  452. 

  453. static void pdp1_printer_getinfo(const device_class *devclass, UINT32 state, union devinfo *info)
    454. 

  454. {
    455. 

  455. 	/* printer */
    456. 

  456. 	switch(state)
    457. 

  457. 	{
    458. 

  458. 		/* --- the following bits of info are returned as 64-bit signed integers --- */
    459. 

  459. 		case DEVINFO_INT_TYPE:							info->i = IO_PRINTER; break;
    460. 

  460. 		case DEVINFO_INT_READABLE:						info->i = 0; break;
    461. 

  461. 		case DEVINFO_INT_WRITEABLE:						info->i = 1; break;
    462. 

  462. 		case DEVINFO_INT_CREATABLE:						info->i = 1; break;
    463. 

  463. 		case DEVINFO_INT_COUNT:							info->i = 1; break;
    464. 

  464. 

  465. 		/* --- the following bits of info are returned as pointers to data or functions --- */
    466. 

  466. 		case DEVINFO_PTR_LOAD:							info->load = device_load_pdp1_typewriter; break;
    467. 

  467. 		case DEVINFO_PTR_UNLOAD:						info->unload = device_unload_pdp1_typewriter; break;
    468. 

  468. 

  469. 		/* --- the following bits of info are returned as NULL-terminated strings --- */
    470. 

  470. 		case DEVINFO_STR_FILE_EXTENSIONS:				strcpy(info->s = device_temp_str(), "typ"); break;
    471. 

  471. 	}
    472. 

  472. }
    473. 

  473. 

  474. static void pdp1_cylinder_getinfo(const device_class *devclass, UINT32 state, union devinfo *info)
    475. 

  475. {
    476. 

  476. 	/* cylinder */
    477. 

  477. 	switch(state)
    478. 

  478. 	{
    479. 

  479. 		/* --- the following bits of info are returned as 64-bit signed integers --- */
    480. 

  480. 		case DEVINFO_INT_TYPE:							info->i = IO_CYLINDER; break;
    481. 

  481. 		case DEVINFO_INT_READABLE:						info->i = 1; break;
    482. 

  482. 		case DEVINFO_INT_WRITEABLE:						info->i = 1; break;
    483. 

  483. 		case DEVINFO_INT_CREATABLE:						info->i = 0; break;
    484. 

  484. 		case DEVINFO_INT_COUNT:							info->i = 1; break;
    485. 

  485. 

  486. 		/* --- the following bits of info are returned as pointers to data or functions --- */
    487. 

  487. 		case DEVINFO_PTR_LOAD:							info->load = device_load_pdp1_drum; break;
    488. 

  488. 		case DEVINFO_PTR_UNLOAD:						info->unload = device_unload_pdp1_drum; break;
    489. 

  489. 

  490. 		/* --- the following bits of info are returned as NULL-terminated strings --- */
    491. 

  491. 		case DEVINFO_STR_FILE_EXTENSIONS:				strcpy(info->s = device_temp_str(), "drm"); break;
    492. 

  492. 	}
    493. 

  493. }
    494. 

  494. 

  495. SYSTEM_CONFIG_START(pdp1)
    496. 

  496. 	/*CONFIG_RAM_DEFAULT(4 * 1024)
    497. 

  497. 	CONFIG_RAM(32 * 1024)
    498. 

  498. 	CONFIG_RAM(64 * 1024)*/
    499. 

  499. 	CONFIG_DEVICE(pdp1_punchtape_getinfo)
    500. 

  500. 	CONFIG_DEVICE(pdp1_printer_getinfo)
    501. 

  501. 	CONFIG_DEVICE(pdp1_cylinder_getinfo)
    502. 

  502. SYSTEM_CONFIG_END
    503. 

  503. 

  504. 

  505. /***************************************************************************
    506. 

    507. 

  507.   Game driver(s)
    508. 

    509. 

  509. ***************************************************************************/
    510. 

  510. 

  511. /*	  YEAR	NAME	  PARENT	COMPAT	MACHINE   INPUT 	INIT	CONFIG	COMPANY	FULLNAME */
    512. 

  512. COMP( 1961, pdp1,	  0, 		0,		pdp1,	  pdp1, 	0,		pdp1,	"Digital Equipment Corporation",  "PDP-1" , 0)
    513. 

  513.