1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
include <gki.h>
# GKI_EXECUTE -- Execute a metacode instruction. The instruction is decoded
# and a graphics kernel driver subroutine is called to execute the instruction.
# If the device driver does not include a procedure for the instruction the
# instruction is discarded. Integer and real parameters are unpacked from
# their short integer metacode representation. Character data is passed by
# reference, i.e., as a SHORT integer array (not EOS delimited char!!), along
# with the character count. Attribute packets are passed to the set attribute
# procedure by reference as a short integer array.
procedure gki_execute (gki, dd)
short gki[ARB] # graphics kernel instruction
int dd[ARB] # device driver
int kp # kernel procedure
int m, n, cn, fn, dummy, flags
int x, y, x1, y1, x2, y2
begin
switch (gki[GKI_HDR_OPCODE]) {
case GKI_OPENWS:
kp = dd[GKI_OPENWS]
if (kp != NULL) {
m = gki[GKI_OPENWS_M]
n = gki[GKI_OPENWS_N]
call zcall3 (kp, gki[GKI_OPENWS_D], n, m)
}
case GKI_CLOSEWS:
kp = dd[GKI_CLOSEWS]
if (kp != NULL) {
n = gki[GKI_CLOSEWS_N]
call zcall2 (kp, gki[GKI_CLOSEWS_D], n)
}
case GKI_REACTIVATEWS:
kp = dd[GKI_REACTIVATEWS]
if (kp != NULL) {
flags = gki[GKI_REACTIVATEWS_F]
call zcall1 (kp, flags)
}
case GKI_DEACTIVATEWS:
kp = dd[GKI_DEACTIVATEWS]
if (kp != NULL) {
flags = gki[GKI_DEACTIVATEWS_F]
call zcall1 (kp, flags)
}
case GKI_MFTITLE:
kp = dd[GKI_MFTITLE]
if (kp != NULL) {
n = gki[GKI_MFTITLE_N]
call zcall2 (kp, gki[GKI_MFTITLE_T], n)
}
case GKI_CLEAR:
kp = dd[GKI_CLEAR]
if (kp != NULL) {
call zcall1 (kp, dummy)
}
case GKI_CANCEL:
kp = dd[GKI_CANCEL]
if (kp != NULL) {
call zcall1 (kp, dummy)
}
case GKI_FLUSH:
kp = dd[GKI_FLUSH]
if (kp != NULL) {
call zcall1 (kp, dummy)
}
case GKI_POLYLINE:
kp = dd[GKI_POLYLINE]
if (kp != 0) {
n = gki[GKI_POLYLINE_N]
call zcall2 (kp, gki[GKI_POLYLINE_P], n)
}
case GKI_POLYMARKER:
kp = dd[GKI_POLYMARKER]
if (kp != 0) {
n = gki[GKI_POLYMARKER_N]
call zcall2 (kp, gki[GKI_POLYMARKER_P], n)
}
case GKI_TEXT:
kp = dd[GKI_TEXT]
if (kp != NULL) {
x = gki[GKI_TEXT_P]
y = gki[GKI_TEXT_P+1]
n = gki[GKI_TEXT_N]
call zcall4 (kp, x, y, gki[GKI_TEXT_T], n)
}
case GKI_FILLAREA:
kp = dd[GKI_FILLAREA]
if (kp != 0) {
n = gki[GKI_FILLAREA_N]
call zcall2 (kp, gki[GKI_FILLAREA_P], n)
}
case GKI_PUTCELLARRAY:
kp = dd[GKI_PUTCELLARRAY]
if (kp != NULL) {
x1 = gki[GKI_PUTCELLARRAY_LL]
y1 = gki[GKI_PUTCELLARRAY_LL+1]
x2 = gki[GKI_PUTCELLARRAY_UR]
y2 = gki[GKI_PUTCELLARRAY_UR+1]
m = gki[GKI_PUTCELLARRAY_NC]
n = gki[GKI_PUTCELLARRAY_NL]
call zcall7 (kp, gki[GKI_PUTCELLARRAY_P], m, n, x1,y1, x2,y2)
}
case GKI_SETCURSOR:
kp = dd[GKI_SETCURSOR]
if (kp != NULL) {
cn = gki[GKI_SETCURSOR_CN]
x = gki[GKI_SETCURSOR_POS]
y = gki[GKI_SETCURSOR_POS+1]
call zcall3 (kp, x, y, cn)
}
case GKI_PLSET:
kp = dd[GKI_PLSET]
if (kp != NULL) {
call zcall1 (kp, gki)
}
case GKI_PMSET:
kp = dd[GKI_PMSET]
if (kp != NULL) {
call zcall1 (kp, gki)
}
case GKI_TXSET:
kp = dd[GKI_TXSET]
if (kp != NULL) {
call zcall1 (kp, gki)
}
case GKI_FASET:
kp = dd[GKI_FASET]
if (kp != NULL) {
call zcall1 (kp, gki)
}
case GKI_GETCURSOR:
kp = dd[GKI_GETCURSOR]
if (kp != NULL) {
cn = gki[GKI_GETCURSOR_CN]
call zcall1 (kp, cn)
}
case GKI_GETCELLARRAY:
kp = dd[GKI_GETCELLARRAY]
if (kp != NULL) {
x1 = gki[GKI_GETCELLARRAY_LL]
y1 = gki[GKI_GETCELLARRAY_LL+1]
x2 = gki[GKI_GETCELLARRAY_UR]
y2 = gki[GKI_GETCELLARRAY_UR+1]
m = gki[GKI_GETCELLARRAY_NC]
n = gki[GKI_GETCELLARRAY_NL]
call zcall6 (kp, m, n, x1,y1, x2,y2)
}
case GKI_ESCAPE:
kp = dd[GKI_ESCAPE]
if (kp != NULL) {
fn = gki[GKI_ESCAPE_FN]
n = gki[GKI_ESCAPE_N]
call zcall3 (kp, fn, gki[GKI_ESCAPE_DC], n)
}
case GKI_SETWCS:
kp = dd[GKI_SETWCS]
if (kp != NULL) {
n = gki[GKI_SETWCS_N]
call zcall2 (kp, gki[GKI_SETWCS_WCS], n)
}
case GKI_GETWCS:
kp = dd[GKI_SETWCS]
if (kp != NULL) {
n = gki[GKI_SETWCS_N]
call zcall2 (kp, gki[GKI_SETWCS_WCS], n)
}
default:
kp = dd[GKI_UNKNOWN]
if (kp != NULL)
call zcall1 (kp, gki)
}
end
|
