home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / apl / sharp / apdefn.h < prev    next >
Text File  |  1988-03-21  |  17KB  |  464 lines
  1. /*1854339PC360:UTIL:APDEFN.IPSA.H.12.18525. */
  2. /* ======================================= */
  3. /*                                         */
  4. /*  sharp apl pc interrupt definitions.    */
  5. /*                                         */
  6. /* ======================================= */
  7. /*                                         */
  8. #define INTSFS 96 /* file system interrupt               */
  9. #define INTSVP 97 /* shared variable processor interrupt */
  10. #define INTPOST 98 /* task post interrupt                */
  11. #define INTDISP 99 /* entry to task dispatcher from low priority
  12.                       task only */
  13. #define INTSHUT 100 /* task shutdown */
  14. /* ======================================= */
  15. /*                                         */
  16. /*  sharp apl svp/pc percmd definition     */
  17. /*                                         */
  18. /* ======================================= */
  19. /*                                         */
  20. struct percmd
  21. {
  22.  unsigned char  pccmd ; /* svp command*/
  23.  unsigned char  pcflags;/* command flags: reserved: must be 0 */
  24.  unsigned long  pcp1,pcp2,pcp3; /* major parameters and results */
  25. /*
  26.    svp percmd contents:
  27.  
  28. cmd       pcp1     pcp2    pcp3
  29.          in   out  in  out   in  out
  30.  
  31.  
  32. share    ascv  -    -   doc   -   -
  33. retract  scvpo -    -   doc   -  chron
  34. useinit  scvpo -    -   len   -   -
  35.  
  36. usedata  scvpo -   aval  -   len  -
  37. copydata scvpo -   aval  -   len  -
  38. setinit  scvpo -    -   len   -   -
  39.  
  40. setdata  scvpo -   aval  -   len  -
  41. seize    scvpo -    -   len   -   -
  42.  
  43. release  scvpo -    -    -    -   -
  44. svc      scvpo -   acv  ccv   -   -
  45.  
  46. svs      scvpo -    -   ccv   -   -
  47. scan     ascv  -    -    -    -   -
  48. signon   apcv  -    -   ppi   -   -
  49. signoff  apcv  -    -    -    -   -
  50. retrall  apcv  -    -    -    -   -
  51. setclone apcv  -   cid   -    -   -
  52.  
  53. contents of fields:
  54.  
  55. scvpo:   peroffer index, from scvpo as the result of share or scan.
  56. apcv:    mainstore address of processor control vector.
  57. ascv:    mainstore address of share control vector.
  58. asv:     access state vector.
  59. acv:     access control vector.
  60. ppi:     perproc index assigned to this processor.
  61. aval:    mainstore address of value.
  62. ccv:     combined access state vector, access control vector.
  63. cid:     new cloneid.
  64. len:     length of value in bytes. If len is a result, -1 indicates
  65.          no value available.
  66. chron:   chronology of new offer.
  67. doc:     previous degree of coupling.
  68. */
  69. } ;
  70. /*                                                                   */
  71. /*                                                                */
  72. /*       SHARED VARIABLE OPERATION CODES.                         */
  73. /*                                                                */
  74. /*                                                                */
  75.                      /* retract all variables. used only by APL   */
  76. #define SVPSVRA 2
  77.                       /* SIGN ON.                           */
  78. #define SVPON   3
  79.                       /* SIGN OFF.                          */
  80. #define SVPOFF  4
  81. /*                                                          */
  82.                     /* SCAN FOR OFFERS.                     */
  83. #define SVPSVQ  5
  84.                     /* SHARE.                               */
  85. #define SVPSVO  6
  86.                     /* RETRACT.                             */
  87. #define SVPSVR  7
  88. /*                                                          */
  89.                     /* SET ACCESS CONTROL.                  */
  90. #define SVPSVC  8
  91.                     /* RETURN ACCESS STATE (AND CONTROL VECTOR) */
  92. #define SVPSVS  9
  93. /*                                                          */
  94.                     /* USE INITIAL SELECTION.               */
  95. #define SVPUIS 10
  96.                     /* SET INITIAL SELECTION.               */
  97. #define SVPSIS 11
  98.                     /* COPY INITIAL SELECTION. (SEIZE).     */
  99. #define SVPCIS 12
  100. /*                                                          */
  101.                     /* USE DATA TRANSFER.                   */
  102. #define SVPUDT 13
  103.                     /* SET DATA TRANSFER.                   */
  104. #define SVPSDT 14
  105.                     /* COPY DATA TRANSFER.                  */
  106. #define SVPCDT 15
  107.                     /* NO DATA TRANSFER (RELEASE).          */
  108. #define SVPNDT 16
  109. /*                                                          */
  110.  
  111.                     /* SET NEW CLONEID. Used only by APL.   */
  112. #define SVPCID 17
  113.  
  114. #define SVPMAX 17   /* maximum legal svp command */
  115. /*                                                                   */
  116. /*                                                                   */
  117. /*                                                                   */
  118. /*                                                                   */
  119. /*       SHARED VARIABLE PROCESSOR RETURN CODES...                   */
  120. /*                                                                   */
  121. /*       - RETURNED TO THE CALLING PROGRAM BY THE SSVP.              */
  122. /*                                                                   */
  123.                  /* VARIABLE IS AN OFFER (NO OTHER SHARER).   */
  124. #define SVZNOS 1
  125. /*                                                                   */
  126. /*       NOTE ...        SVZNOS OCCURS IN COMBINATION WITH OTHER     */
  127. /*                       RETURN CODES, IE, IF RELEVANT IT WILL BE    */
  128. /*                       ORED WITH THE ACTUAL COMPLETION CODE.       */
  129. /*                                                                   */
  130.                   /* REJECTION BECAUSE OF ACCESS CONTROL.  */
  131. #define SVZLOCK 0
  132.                   /*TEMPORARY SETDATA REJECTION BECAUSE OF */
  133. /*                       INSUFFICIENT S.V. STORAGE. CONTROL RETAINED.*/
  134. #define SVZSVSF 2
  135.                   /*USE, SET, OR COPY DATA TRANSFER INCORRECT*/
  136. #define SVZILI 4
  137.                   /*SCAN, NO OFFERS FOUND.                   */
  138. #define SVZNOF 6
  139.                   /*NORMAL END - REQUEST COMPLETED SUCCESSFULLY.*/
  140. #define SVZNE 8
  141.                   /*PROCESSOR ID IN USE.                        */
  142. #define SVZNIU 10
  143.                   /*PROCESSOR NOT SIGNED ON TO SVP.             */
  144. #define SVZNSO 12
  145.                   /*PROCESSOR ALREADY SIGNED ON WITH SAME ID.   */
  146. #define SVZASO 14
  147.                   /*INVALID REQUEST SEQUENCE.                   */
  148. #define SVZIVS 16
  149.                   /*(USEINIT) NO VALUE AVAILABLE IN S.V.S.      */
  150. #define SVZNV 18
  151.                   /*STORAGE PROTECTION EXCEPTION.               */
  152. #define SVZSPE 20
  153.                   /*SVP NOT AVAILABLE (NOT RUNNING).              */
  154. #define SVZNA 22
  155.                   /*PERSHARE TABLE FULL.                          */
  156. #define SVZPSF 24
  157.                   /*PROCESSOR TABLE FULL.                         */
  158. #define SVZPPF 26
  159.                   /*VALUE TOO LARGE (WILL NEVER FIT).             */
  160. #define SVZVTL 28
  161.                   /*ARGUMENT ERROR DETECTED IN VALIDITY CHECK.    */
  162. #define SVZARG 30
  163.                        /*MUST BE MAX/SVZCODES.                    */
  164. #define SVZMAX SVZARG
  165.  
  166. /* SVP degrees of coupling */
  167. #define COUPLE0 0
  168. #define COUPLE1 1
  169. #define COUPLE2 2
  170.  
  171.  
  172.  
  173.  
  174.  
  175. /* ============================================= */
  176. /*                                               */
  177. /*  sharp apl svp/pc processor control vector    */
  178. /*                                               */
  179. /* ============================================= */
  180. /*                                               */
  181. struct perpcv
  182. {
  183. /* perscv and perpcv assume that id,nid come first in same format */
  184.  long  pcvid ;             /* processor id           */
  185.  long  pcvnid;             /* cloneid                */
  186.  unsigned int pcvpost;     /* reasons for post       */
  187. /*                                                   */
  188. /* extension of pcv     for task dispatcher fields.  */
  189. /*                                                   */
  190.  unsigned long  pcvtcs   ; /* cs:ip value for task dispatch*/
  191.  unsigned long  pcvtss   ; /* ss:sp value for task dispatch*/
  192.  unsigned long  pcvtds   ; /* ds:dx value for task dispatch*/
  193.  unsigned int   pcvtbp   ; /*    bp value for task dispatch*/
  194. } ;
  195.  
  196. /*  pcvpost values. */
  197.                          /* end of storage wait */
  198. #define perpwfs   1
  199.                          /* share completed     */
  200. #define perpshar  2
  201.                          /* retraction          */
  202. #define perpretr  4
  203.                          /* use data            */
  204. #define perpuse   8
  205.                          /* set data            */
  206. #define perpset  16
  207.                          /* release             */
  208. #define perprels 32
  209.                          /* set acv             */
  210. #define perpsacv 64
  211.                          /* offer received      */
  212. #define perpoffr 128
  213. /*
  214.    The next 4 bits are reserved for use by auxiliary processors.
  215.    The svp will not set these bits, not make any use of them.
  216.    They are intended for simple communication among APs.
  217. */
  218.                          /* AP post bit 0.      */
  219. #define perpap0  256
  220.                          /* AP post bit 1.      */
  221. #define perpap1  512
  222.                          /* AP post bit 2.      */
  223. #define perpap2  1024
  224.                          /* AP post bit 3.      */
  225. #define perpap3  2048
  226.                          /* AP shutdown bit.    */
  227. #define perpshut 4096
  228. /* next 3 bits are reserved for future expansion*/
  229.  
  230.  
  231.  
  232.  
  233.  
  234. /* ======================================= */
  235. /*                                         */
  236. /*  sharp apl svp/pc perscv definition     */
  237. /*                                         */
  238. /* ======================================= */
  239. /*                                         */
  240. #define MAXPSN 11
  241. struct perscv
  242. {
  243.  long  scvcount; /* byte count of value, if any        */
  244.  unsigned int scvsos; /* must be 0 or 1 */
  245.    /* if 1, a scan or share issued by
  246.       this processor will examine only offers
  247.       resulting from share, and will ignore offers
  248.       resulting from retract.
  249.       Also, this procesor will not
  250.       recouple to an offer resulting from this
  251.       processor retracting. The other processor
  252.       is not affected, and may retract and reshare,
  253.       unless it too sets scvsos. */
  254.  
  255. /* ppidsrch assumes that id,pid are identical in scv,pcv */
  256.  long  scvid  ;  /* processor id */
  257.  long  scvnid ;  /* cloneid*/
  258.  unsigned long  scvalue;  /* mainstore address of value, if any */
  259.  unsigned long  scvchron; /* chronology */
  260.  unsigned long  scvpo   ; /* peroffer associated with this perscv.*/
  261.  long  scvother; /* processor id of partner*/
  262.  long  scvnothr; /* clone id of partner */
  263.  unsigned char scvnamel; /*length of name, or longest acceptable name*/
  264.                   /* maximum identifier length */
  265.  unsigned char  scvname[MAXPSN]; /* name of shared variable. if first
  266.                     character is binary 0, any name will match.*/
  267. } ;
  268. /*APL CHARACTER EQUATES */
  269. #define QALPHA   42
  270. #define QOMEGA   46
  271. #define QA       86
  272. #define QB       87
  273. #define QC       88
  274. #define QD       89
  275. #define QE       90
  276. #define QF       91
  277. #define QG       92
  278. #define QH       93
  279. #define QI       94
  280. #define QJ       95
  281. #define QK       96
  282. #define QL       97
  283. #define QM       98
  284. #define QN       99
  285. #define QO       100
  286. #define QP       101
  287. #define QQ       102
  288. #define QR       103
  289. #define QS       104
  290. #define QT       105
  291. #define QU       106
  292. #define QV       107
  293. #define QW       108
  294. #define QX       109
  295. #define QY       110
  296. #define QZ       111
  297. #define QDELTA   112
  298.  
  299. #define QAU      113
  300. #define QBU      114
  301. #define QCU      115
  302. #define QDU      116
  303. #define QEU      117
  304. #define QFU      118
  305. #define QGU      119
  306. #define QHU      120
  307. #define QIU      121
  308. #define QJU      122
  309. #define QKU      123
  310. #define QLU      124
  311. #define QMU      125
  312. #define QNU      126
  313. #define QOU      127
  314. #define QPU      128
  315. #define QQU      129
  316. #define QRU      130
  317. #define QSU      131
  318. #define QTU      132
  319. #define QUU      133
  320. #define QVU      134
  321. #define QWU      135
  322. #define QXU      136
  323. #define QYU      137
  324. #define QZU      138
  325. #define QDELTAU  139
  326.  
  327. #define Q0       140
  328. #define Q1       141
  329. #define Q2       142
  330. #define Q3       143
  331. #define Q4       144
  332. #define Q5       145
  333. #define Q6       146
  334. #define Q7       147
  335. #define Q8       148
  336. #define Q9       149
  337. #define QBLANK   152
  338. #define QSEMIC    18
  339. /*=================================*/
  340. /*                                 */
  341. /*     asdata                      */
  342. /*     apl shared variable array   */
  343. /*                                 */
  344. /*=================================*/
  345.  
  346. /*========================================*/
  347. /*                                        */
  348. /*     apl array object definition.       */
  349. /*     all fields are 370 format.         */
  350. /*     see IBM System/370 Principles of   */
  351. /*     Operation (GA22-7000) for details. */
  352. /*                                        */
  353. /*========================================*/
  354.  
  355.  
  356. /* Note that the byte ordering of the System/370 and the 8088 are   */
  357. /* reversed from one another. The 8088 stores the low-order byte in */
  358. /* the lowest-numbered storage location, and the 370 stores the     */
  359. /* low-order byte in the the highest-numbered storage location.     */
  360. /* This means that a function must be used to reverse the order of  */
  361. /* bytes as they are stored or fetched into the asdata array.       */
  362.  
  363. struct asdata
  364.  {
  365.  char astype;           /* type of apl object */
  366.  
  367.  char mt2;              /* unused. must be 0  */
  368.  short asrank;          /* 4 * rank of object,*/
  369.                         /* byte count of shape vector which follows*/
  370.  
  371. /* for example, a scalar has asrank of 0, a vector has asrank of   */
  372. /* 4, and a rank-3 array has asrank of 12.                         */
  373.  long asshape[];        /* shape vector, data follows */
  374.  }; /* end asdata */
  375.  
  376. /* format of asdata entries:                                         */
  377.  
  378. /* values of astype and their meanings:      */
  379.  
  380. #define typb 1          /* array is boolean   */
  381. #define typi 2          /* array is integer   */
  382. #define typf 3          /* array is real      */
  383. #define typc 4          /* array is character */
  384. #define typp 5          /* array is package   */
  385. #define typa 6          /* array is enclosed  */
  386. #define typz 7          /* arrays is complex  */
  387.  
  388. /* All data elements are stored in ravel order. Each data type has   */
  389. /* a different number of bits per element:                           */
  390.  
  391. /* Data Type   Number of bits per element
  392.  
  393.    Boolean     1
  394.    Integer     32
  395.    Floating    64
  396.    Character   8
  397.    Package     indeterminate
  398.    Enclosed    indeterminate
  399.    Complex     128
  400.  
  401. All arrays are stored left-justified in the 370 word, and all byte
  402. counts must be a multiple of 4. The left-justification is only
  403. evident in Boolean and character arrays.
  404.  
  405. Boolean arrays are stored as 1 bit per element:
  406. Assume B is the boolean matrix: 3 4 reshape 1 0 1 0 1 0 1 1 1 0 1 0.
  407. B looks like:
  408.          01 00 00 08     type and rank
  409.          00 00 00 03     shape vector
  410.          00 00 00 04
  411.          AB A0 00 00     value.
  412.  
  413. Integer arrays are stored as 4 bytes per element:
  414. Assume B is the integer scalar: 272.
  415. B looks like:
  416.          02 00 00 00    type and rank
  417.          00 00 01 10    value (note no shape vector).
  418.  
  419. The array iota 0 looks like:
  420.          02 00 00 04    type and rank.
  421.          00 00 00 00    shape.
  422.                         note no value.
  423.  
  424. Floating arrays are stored as 8 bytes per element:
  425. Assume B is the floating point vector 3 .5.
  426. B is stored in 370 Double Precision floating point format,
  427. and looks like:
  428.  
  429.          03 00 00 04    type and rank
  430.          00 00 00 02    shape vector
  431.          41 30 00 00    value
  432.          00 00 00 00
  433.          40 80 00 00
  434.          00 00 00 00
  435.  
  436. Note that floating and complex values must be stored in normalized
  437. form, and that zeros must be true zeros(8 bytes of 0), or APL will
  438. produce incorrect results.
  439. Also, note that S/370 floating point is not compatible with
  440. IEEE floating point. They aren't even close.
  441.  
  442. Package and Enclosed data types are not described in this release of
  443. SHARP APL/PC.
  444.  
  445. Complex arrays are stored as 16 bytes per element, as pairs
  446. of S/370 floating point numbers, representing the real and imaginary
  447. parts, respectively.
  448. Assume B is the complex scalar (-1)*.5.
  449. B looks like:
  450.  
  451.          07 00 00 00    type and rank
  452.          00 00 00 00    value of 0J1.
  453.          00 00 00 00
  454.          41 10 00 00
  455.          00 00 00 00
  456.  
  457. Note that floating and complex values must be stored in normalized
  458. form, and that zeros must be true zeros(8 bytes of 0), or APL will
  459. produce incorrect results.
  460. Also, note that S/370 floating point is not compatible with
  461. IEEE floating point. They aren't even close.
  462.  
  463. */
  464.