« back to all changes in this revision
Viewing changes to terps/alan2/reverse.c
- browse files at revision 7
- compare with another revision
- download diff
- download tarball
- view history from revision 7
- Committer: Package Import Robot
- Author(s): Sylvain Beucler
- Date: 2013-07-28 13:38:56 UTC
- mfrom: (1.1.3)
- Revision ID: package-import@ubuntu.com-20130728133856-4k6uc864wzsnrx04
Tags: 2011.1a-1
* New upstream release
* Alan 2 interpreter is now Free Software, include it
* Update fonts package names in dependencies (Closes: #715160)
* Bump Standards-Version to 3.9.4
* Alan 2 interpreter is now Free Software, include it
* Update fonts package names in dependencies (Closes: #715160)
* Bump Standards-Version to 3.9.4
- files added:
- .pc/.quilt_patches
- terps/alan2
- files removed:
- .pc/dfsg_disable_alan2.patch
- .pc/dfsg_disable_alan2.patch/terps
- files modified:
- .pc/applied-patches
added
removed
terps/alan2/reverse.c
1
/*----------------------------------------------------------------------*\
2
3
reverse.c
4
5
Handles all reversing of data
6
7
\*----------------------------------------------------------------------*/
8
9
10
#include "types.h"
11
#include "main.h"
12
13
#include "reverse.h"
14
15
16
/*----------------------------------------------------------------------
17
18
reversed()
19
20
Return the reversed bytes in the Aword
21
22
*/
23
#ifdef _PROTOTYPES_
24
Aword reversed(Aword w) /* IN - The ACODE word to swap bytes of */
25
#else
26
Aword reversed(w)
27
Aword w; /* IN - The ACODE word to swap bytes of */
28
#endif
29
{
30
Aword s; /* The swapped ACODE word */
31
char *wp, *sp;
32
int i;
33
34
wp = (char *) &w;
35
sp = (char *) &s;
36
37
for (i = 0; i < sizeof(Aword); i++)
38
sp[sizeof(Aword)-1 - i] = wp[i];
39
40
return s;
41
}
42
43
44
#ifdef _PROTOTYPES_
45
void reverse(Aword *w) /* IN - The ACODE word to reverse bytes in */
46
#else
47
void reverse(w)
48
Aword *w; /* IN - The ACODE word to reverse bytes in */
49
#endif
50
{
51
*w = reversed(*w);
52
}
53
54
55
#ifdef _PROTOTYPES_
56
static void reverseTable(Aword adr, int len)
57
#else
58
static void reverseTable(adr, len)
59
Aword adr;
60
int len;
61
#endif
62
{
63
Aword *e = &memory[adr];
64
int i;
65
66
if (adr != 0)
67
while (!endOfTable(e)) {
68
for (i = 0; i < len/sizeof(Aword); i++) {
69
reverse(e);
70
e++;
71
}
72
}
73
}
74
75
76
#ifdef _PROTOTYPES_
77
static void reverseStms(Aword adr)
78
#else
79
static void reverseStms(adr)
80
Aword adr;
81
#endif
82
{
83
Aword *e = &memory[adr];
84
85
if (adr != 0)
86
while (TRUE) {
87
reverse(e);
88
if (*e == ((Aword)C_STMOP<<28|(Aword)I_RETURN)) break;
89
e++;
90
}
91
}
92
93
94
#ifdef _PROTOTYPES_
95
static void reverseMsgs(Aword adr)
96
#else
97
static void reverseMsgs(adr)
98
Aword adr;
99
#endif
100
{
101
MsgElem *e = (MsgElem *) &memory[adr];
102
103
if (adr != 0 && !endOfTable(e)) {
104
reverseTable(adr, sizeof(MsgElem));
105
while (!endOfTable(e)) {
106
reverseStms(e->stms);
107
e++;
108
}
109
}
110
}
111
112
113
#ifdef _PROTOTYPES_
114
static void reverseWrds(Aword adr)
115
#else
116
static void reverseWrds(adr)
117
Aword adr;
118
#endif
119
{
120
WrdElem *e = (WrdElem *) &memory[adr];
121
122
if (adr != 0 && !endOfTable(e)) {
123
reverseTable(adr, sizeof(WrdElem));
124
while (!endOfTable(e)) {
125
if ((e->class & (1L<<WRD_SYN)) == 0) { /* Do not do this for synonyms */
126
reverseTable(e->adjrefs, sizeof(Aword));
127
reverseTable(e->nounrefs, sizeof(Aword));
128
}
129
e++;
130
}
131
}
132
}
133
134
#ifdef _PROTOTYPES_
135
static void reverseChks(Aword adr)
136
#else
137
static void reverseChks(adr)
138
Aword adr;
139
#endif
140
{
141
ChkElem *e = (ChkElem *) &memory[adr];
142
143
if (adr != 0 && !endOfTable(e)) {
144
reverseTable(adr, sizeof(ChkElem));
145
while (!endOfTable(e)) {
146
reverseStms(e->exp);
147
reverseStms(e->stms);
148
e++;
149
}
150
}
151
}
152
153
#ifdef _PROTOTYPES_
154
static void reverseAlts(Aword adr)
155
#else
156
static void reverseAlts(adr)
157
Aword adr;
158
#endif
159
{
160
AltElem *e = (AltElem *)&memory[adr];
161
162
if (adr != 0 && !endOfTable(e) && !e->done) {
163
reverseTable(adr, sizeof(AltElem));
164
e->done = TRUE;
165
while (!endOfTable(e)) {
166
reverseChks(e->checks);
167
reverseStms(e->action);
168
e++;
169
}
170
}
171
}
172
173
174
#ifdef _PROTOTYPES_
175
static void reverseVrbs(Aword adr)
176
#else
177
static void reverseVrbs(adr)
178
Aword adr;
179
#endif
180
{
181
VrbElem *e = (VrbElem *)&memory[adr];
182
183
if (adr != 0 && !endOfTable(e)) {
184
reverseTable(adr, sizeof(VrbElem));
185
while (!endOfTable(e)) {
186
reverseAlts(e->alts);
187
e++;
188
}
189
}
190
}
191
192
193
#ifdef _PROTOTYPES_
194
static void reverseSteps(Aword adr)
195
#else
196
static void reverseSteps(adr)
197
Aword adr;
198
#endif
199
{
200
StepElem *e = (StepElem *) &memory[adr];
201
202
if (adr != 0 && !endOfTable(e)) {
203
reverseTable(adr, sizeof(StepElem));
204
while (!endOfTable(e)) {
205
reverseStms(e->exp);
206
reverseStms(e->stm);
207
e++;
208
}
209
}
210
}
211
212
213
#ifdef _PROTOTYPES_
214
static void reverseScrs(Aword adr)
215
#else
216
static void reverseScrs(adr)
217
Aword adr;
218
#endif
219
{
220
ScrElem *e = (ScrElem *) &memory[adr];
221
222
if (adr != 0 && !endOfTable(e)) {
223
reverseTable(adr, sizeof(ScrElem));
224
while (!endOfTable(e)) {
225
reverseStms(e->dscr);
226
reverseSteps(e->steps);
227
e++;
228
}
229
}
230
}
231
232
233
#ifdef _PROTOTYPES_
234
static void reverseActs(Aword adr)
235
#else
236
static void reverseActs(adr)
237
Aword adr;
238
#endif
239
{
240
ActElem *e = (ActElem *) &memory[adr];
241
242
if (adr != 0 && !endOfTable(e)) {
243
reverseTable(adr, sizeof(ActElem));
244
while (!endOfTable(e)) {
245
reverseStms(e->nam);
246
reverseTable(e->atrs, sizeof(AtrElem));
247
reverseScrs(e->scradr);
248
reverseVrbs(e->vrbs);
249
reverseStms(e->dscr);
250
e++;
251
}
252
}
253
}
254
255
#ifdef _PROTOTYPES_
256
static void reverseObjs(Aword adr, Boolean v2_5)
257
#else
258
static void reverseObjs(adr, v2_5)
259
Aword adr;
260
Boolean v2_5; /* TRUE if it's a v2.5 format game */
261
#endif
262
{
263
ObjElem *e = (ObjElem *) &memory[adr];
264
ObjElem25 *e25 = (ObjElem25 *) &memory[adr];
265
266
if (v2_5) {
267
if (adr != 0 && !endOfTable(e25)) {
268
reverseTable(adr, sizeof(ObjElem25));
269
while (!endOfTable(e25)) {
270
reverseTable(e25->atrs, sizeof(AtrElem));
271
reverseVrbs(e25->vrbs);
272
reverseStms(e25->dscr1);
273
reverseStms(e25->dscr2);
274
e25++;
275
}
276
}
277
} else {
278
if (adr != 0 && !endOfTable(e)) {
279
reverseTable(adr, sizeof(ObjElem));
280
while (!endOfTable(e)) {
281
reverseTable(e->atrs, sizeof(AtrElem));
282
reverseVrbs(e->vrbs);
283
reverseStms(e->art);
284
reverseStms(e->dscr1);
285
reverseStms(e->dscr2);
286
e++;
287
}
288
}
289
}
290
}
291
292
293
#ifdef _PROTOTYPES_
294
static void reverseExts(Aword adr)
295
#else
296
static void reverseExts(adr)
297
Aword adr;
298
#endif
299
{
300
ExtElem *e = (ExtElem *) &memory[adr];
301
302
if (adr != 0 && !endOfTable(e)) {
303
reverseTable(adr, sizeof(ExtElem));
304
while (!endOfTable(e)) {
305
if (!e->done) {
306
reverseChks(e->checks);
307
reverseStms(e->action);
308
}
309
e++;
310
}
311
}
312
}
313
314
#ifdef _PROTOTYPES_
315
static void reverseLocs(Aword adr)
316
#else
317
static void reverseLocs(adr)
318
Aword adr;
319
#endif
320
{
321
LocElem *e = (LocElem *) &memory[adr];
322
323
if (adr != 0 && !endOfTable(e)) {
324
reverseTable(adr, sizeof(LocElem));
325
while (!endOfTable(e)) {
326
reverseStms(e->nams);
327
reverseStms(e->dscr);
328
reverseStms(e->does);
329
reverseTable(e->atrs, sizeof(AtrElem));
330
reverseExts(e->exts);
331
reverseVrbs(e->vrbs);
332
e++;
333
}
334
}
335
}
336
337
338
#ifdef _PROTOTYPES_
339
static void reverseClas(Aword adr)
340
#else
341
static void reverseClas(adr)
342
Aword adr;
343
#endif
344
{
345
ClaElem *e = (ClaElem *) &memory[adr];
346
347
if (adr != 0 && !endOfTable(e)) {
348
reverseTable(adr, sizeof(ClaElem));
349
while (!endOfTable(e)) {
350
reverseStms(e->stms);
351
e++;
352
}
353
}
354
if (adr)
355
reverse(&((Aword *)e)[1]); /* The verb code is stored after the table */
356
}
357
358
359
#ifdef _PROTOTYPES_
360
static void reverseElms(Aword adr)
361
#else
362
static void reverseElms(adr)
363
Aword adr;
364
#endif
365
{
366
ElmElem *e = (ElmElem *) &memory[adr];
367
368
if (adr != 0 && !endOfTable(e)) {
369
reverseTable(adr, sizeof(ElmElem));
370
while (!endOfTable(e)) {
371
if (e->code == EOS) reverseClas(e->next);
372
else reverseElms(e->next);
373
e++;
374
}
375
}
376
}
377
378
379
#ifdef _PROTOTYPES_
380
static void reverseStxs(Aword adr)
381
#else
382
static void reverseStxs(adr)
383
Aword adr;
384
#endif
385
{
386
StxElem *e = (StxElem *) &memory[adr];
387
388
if (adr != 0 && !endOfTable(e)) {
389
reverseTable(adr, sizeof(StxElem));
390
while (!endOfTable(e)) {
391
reverseElms(e->elms);
392
e++;
393
}
394
}
395
}
396
397
#ifdef _PROTOTYPES_
398
static void reverseEvts(Aword adr)
399
#else
400
static void reverseEvts(adr)
401
Aword adr;
402
#endif
403
{
404
EvtElem *e = (EvtElem *) &memory[adr];
405
406
if (adr != 0 && !endOfTable(e)) {
407
reverseTable(adr, sizeof(EvtElem));
408
while (!endOfTable(e)) {
409
reverseStms(e->code);
410
e++;
411
}
412
}
413
}
414
415
416
417
#ifdef _PROTOTYPES_
418
static void reverseLims(Aword adr)
419
#else
420
static void reverseLims(adr)
421
Aword adr;
422
#endif
423
{
424
LimElem *e = (LimElem *) &memory[adr];
425
426
if (adr != 0 && !endOfTable(e)) {
427
reverseTable(adr, sizeof(LimElem));
428
while (!endOfTable(e)) {
429
reverseStms(e->stms);
430
e++;
431
}
432
}
433
}
434
435
436
#ifdef _PROTOTYPES_
437
static void reverseCnts(Aword adr)
438
#else
439
static void reverseCnts(adr)
440
Aword adr;
441
#endif
442
{
443
CntElem *e = (CntElem *) &memory[adr];
444
445
if (adr != 0 && !endOfTable(e)) {
446
reverseTable(adr, sizeof(CntElem));
447
while (!endOfTable(e)) {
448
reverseLims(e->lims);
449
reverseStms(e->header);
450
reverseStms(e->empty);
451
reverseStms(e->nam);
452
e++;
453
}
454
}
455
}
456
457
458
#ifdef _PROTOTYPES_
459
static void reverseRuls(Aword adr)
460
#else
461
static void reverseRuls(adr)
462
Aword adr;
463
#endif
464
{
465
RulElem *e = (RulElem *) &memory[adr];
466
467
if (adr != 0 && !endOfTable(e)) {
468
reverseTable(adr, sizeof(RulElem));
469
while (!endOfTable(e)) {
470
reverseStms(e->exp);
471
reverseStms(e->stms);
472
e++;
473
}
474
}
475
}
476
477
478
479
/*----------------------------------------------------------------------
480
481
reverseHdr()
482
483
Reverse the header structure.
484
485
*/
486
#ifdef _PROTOTYPES_
487
void reverseHdr(AcdHdr *hdr)
488
#else
489
void reverseHdr(hdr)
490
AcdHdr *hdr;
491
#endif
492
{
493
int i;
494
495
/* Reverse all words in the header except the first (version marking) */
496
for (i = 1; i < sizeof(AcdHdr)/sizeof(Aword); i++)
497
reverse(&((Aword *)hdr)[i]);
498
}
499
500
/*----------------------------------------------------------------------
501
502
reverseACD()
503
504
Traverse all the data structures and reverse all integers.
505
Only performed in architectures with reversed byte ordering, which
506
makes the .ACD files fully compatible across architectures
507
508
*/
509
#ifdef _PROTOTYPES_
510
void reverseACD(Boolean v2_5)
511
#else
512
void reverseACD(v2_5)
513
Boolean v2_5;
514
#endif
515
{
516
reverseHdr(header);
517
reverseWrds(header->dict);
518
reverseTable(header->oatrs, sizeof(AtrElem));
519
reverseTable(header->latrs, sizeof(AtrElem));
520
reverseTable(header->aatrs, sizeof(AtrElem));
521
reverseActs(header->acts);
522
reverseObjs(header->objs, v2_5);
523
reverseLocs(header->locs);
524
reverseStxs(header->stxs);
525
reverseVrbs(header->vrbs);
526
reverseEvts(header->evts);
527
reverseCnts(header->cnts);
528
reverseRuls(header->ruls);
529
reverseTable(header->init, sizeof(IniElem));
530
reverseStms(header->start);
531
reverseMsgs(header->msgs);
532
533
reverseTable(header->scores, sizeof(Aword));
534
reverseTable(header->freq, sizeof(Aword));
535
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1