1 |
edhill |
1.1 |
/* macpcstr.c -- niftyapp library pascal/C combination strings |
2 |
|
|
*/ |
3 |
|
|
/* (C) Copyright 1995 by Carnegie Mellon University |
4 |
|
|
* All Rights Reserved. |
5 |
|
|
* |
6 |
|
|
* Permission to use, copy, modify, distribute, and sell this software |
7 |
|
|
* and its documentation for any purpose is hereby granted without |
8 |
|
|
* fee, provided that the above copyright notice appear in all copies |
9 |
|
|
* and that both that copyright notice and this permission notice |
10 |
|
|
* appear in supporting documentation, and that the name of Carnegie |
11 |
|
|
* Mellon University not be used in advertising or publicity |
12 |
|
|
* pertaining to distribution of the software without specific, |
13 |
|
|
* written prior permission. Carnegie Mellon University makes no |
14 |
|
|
* representations about the suitability of this software for any |
15 |
|
|
* purpose. It is provided "as is" without express or implied |
16 |
|
|
* warranty. |
17 |
|
|
* |
18 |
|
|
* CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO |
19 |
|
|
* THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
20 |
|
|
* AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE |
21 |
|
|
* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
22 |
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN |
23 |
|
|
* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING |
24 |
|
|
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
25 |
|
|
* SOFTWARE. |
26 |
|
|
*/ |
27 |
|
|
/* (C) Copyright 1990, 1991 by Christopher J. Newman |
28 |
|
|
* All Rights Reserved. |
29 |
|
|
* |
30 |
|
|
* Permission to use, copy, modify, distribute, and sell this software and its |
31 |
|
|
* documentation for any purpose is hereby granted without fee, provided that |
32 |
|
|
* the above copyright notice appear in all copies and that both that |
33 |
|
|
* copyright notice and this permission notice appear in supporting |
34 |
|
|
* documentation, and that the name of Christopher J. Newman not be used in |
35 |
|
|
* advertising or publicity pertaining to distribution of the software without |
36 |
|
|
* specific, written prior permission. Christopher J. Newman makes no |
37 |
|
|
* representations about the suitability of this software for any purpose. It |
38 |
|
|
* is provided "as is" without express or implied warranty. |
39 |
|
|
* |
40 |
|
|
* CHRISTOPHER J. NEWMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, |
41 |
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT |
42 |
|
|
* SHALL CHRISTOPHER J. NEWMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR |
43 |
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, |
44 |
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
45 |
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE |
46 |
|
|
* OF THIS SOFTWARE. |
47 |
|
|
* |
48 |
|
|
* Author: Christopher J. Newman |
49 |
|
|
* Message: This is a nifty program. |
50 |
|
|
* |
51 |
|
|
* Created 9/1/88, Assembly Code 6/27/90 |
52 |
|
|
*/ |
53 |
|
|
|
54 |
|
|
#ifdef THINK_C |
55 |
|
|
typedef unsigned char PCstr; |
56 |
|
|
|
57 |
|
|
/* assembler function prototypes */ |
58 |
|
|
void PtoPCstrcpy(void); |
59 |
|
|
void CtoPCstrcpy(void); |
60 |
|
|
void PCtoPCstrcpy(void); |
61 |
|
|
void PtoPCstrncpy(void); |
62 |
|
|
void CtoPCstrncpy(void); |
63 |
|
|
void PtoPCstrcat(void); |
64 |
|
|
void CtoPCstrcat(void); |
65 |
|
|
PCstr *PtoPCstr(void); |
66 |
|
|
PCstr *CtoPCstr(void); |
67 |
|
|
void SetPlen(void); |
68 |
|
|
PCstr *longtoPCstr(long); /* not in assembler */ |
69 |
|
|
|
70 |
|
|
void PtoPCstrcpy( /* PCstr *dest, *src */ ) |
71 |
|
|
{ |
72 |
|
|
asm 68000 { |
73 |
|
|
movea.l 8(sp),a0 ; a0 = src |
74 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
75 |
|
|
clr.w d0 |
76 |
|
|
move.b (a0),d0 |
77 |
|
|
clr.b 1(a1,d0) |
78 |
|
|
@loop: |
79 |
|
|
move.b (a0)+,(a1)+ |
80 |
|
|
dbf.w d0,@loop |
81 |
|
|
} |
82 |
|
|
} |
83 |
|
|
|
84 |
|
|
void CtoPCstrcpy( /* PCstr *dest, char *src */) |
85 |
|
|
{ |
86 |
|
|
asm 68000 { |
87 |
|
|
movea.l 8(sp),a0 ; a0 = src |
88 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
89 |
|
|
addq.l #1,a1 |
90 |
|
|
moveq.l #-1,d0 |
91 |
|
|
@loop: |
92 |
|
|
addq.w #1,d0 |
93 |
|
|
move.b (a0)+,(a1)+ |
94 |
|
|
bne.s @loop |
95 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
96 |
|
|
move.b d0,(a1) |
97 |
|
|
} |
98 |
|
|
} |
99 |
|
|
|
100 |
|
|
void PCtoPCstrcpy( /* PCstr *dest, PCstr *src */) |
101 |
|
|
{ |
102 |
|
|
asm 68000 { |
103 |
|
|
movea.l 8(sp),a0 ; a0 = src |
104 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
105 |
|
|
move.b (a0)+,(a1)+ |
106 |
|
|
@loop: |
107 |
|
|
move.b (a0)+,(a1)+ |
108 |
|
|
bne.s @loop |
109 |
|
|
} |
110 |
|
|
} |
111 |
|
|
|
112 |
|
|
void PtoPCstrncpy( /* PCstr *dest, char *src, short n */) |
113 |
|
|
{ |
114 |
|
|
asm 68000 { |
115 |
|
|
movea.l 8(sp),a0 ; a0 = src |
116 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
117 |
|
|
move.w 12(sp),d0 ; d0 = n |
118 |
|
|
clr.w d1 |
119 |
|
|
move.b (a0)+,d1 |
120 |
|
|
cmp.w d0,d1 |
121 |
|
|
bcc.s @skip |
122 |
|
|
move.w d1,d0 |
123 |
|
|
@skip: |
124 |
|
|
move.b d0,(a1)+ |
125 |
|
|
subq.w #1,d0 |
126 |
|
|
bcs.s @exit |
127 |
|
|
@loop: |
128 |
|
|
move.b (a0)+,(a1)+ |
129 |
|
|
dbf d0,@loop |
130 |
|
|
@exit: |
131 |
|
|
} |
132 |
|
|
} |
133 |
|
|
|
134 |
|
|
void CtoPCstrncpy( /* PCstr *dest, char *src, short n */ ) |
135 |
|
|
{ |
136 |
|
|
asm 68000 { |
137 |
|
|
movea.l 8(sp),a0 ; a0 = src |
138 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
139 |
|
|
addq.l #1,a1 |
140 |
|
|
clr.w d1 |
141 |
|
|
move.w 12(sp),d0 ; d0 = n |
142 |
|
|
bra.s @skip |
143 |
|
|
@loop: |
144 |
|
|
addq.w #1,d1 |
145 |
|
|
move.b (a0)+,(a1)+ |
146 |
|
|
@skip: |
147 |
|
|
dbeq.w d0,@loop |
148 |
|
|
clr.b (a1) |
149 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
150 |
|
|
subq.w #1,d1 |
151 |
|
|
move.b d1,(a1) |
152 |
|
|
} |
153 |
|
|
} |
154 |
|
|
|
155 |
|
|
void PtoPCstrcat( /* PCstr *dest, char *src */ ) |
156 |
|
|
{ |
157 |
|
|
asm 68000 { |
158 |
|
|
movea.l 8(sp),a0 ; a0 = src |
159 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
160 |
|
|
clr.w d0 |
161 |
|
|
clr.w d1 |
162 |
|
|
move.b (a0)+,d0 |
163 |
|
|
move.b (a1),d1 |
164 |
|
|
add.b d0,(a1) |
165 |
|
|
lea.l 1(a1,d1),a1 |
166 |
|
|
bra.s @skip |
167 |
|
|
@loop: |
168 |
|
|
move.b (a0)+,(a1)+ |
169 |
|
|
@skip: |
170 |
|
|
dbf.w d0,@loop |
171 |
|
|
clr.b (a1) |
172 |
|
|
} |
173 |
|
|
} |
174 |
|
|
|
175 |
|
|
void CtoPCstrcat( /* PCstr *dest, char *src */ ) |
176 |
|
|
{ |
177 |
|
|
asm 68000 { |
178 |
|
|
movea.l 8(sp),a0 ; a0 = src |
179 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
180 |
|
|
clr.w d0 |
181 |
|
|
move.b (a1),d0 |
182 |
|
|
lea.l 1(a1,d0),a1 |
183 |
|
|
subq.w #1,d0 |
184 |
|
|
@loop: |
185 |
|
|
addq.w #1,d0 |
186 |
|
|
move.b (a0)+,(a1)+ |
187 |
|
|
bne.s @loop |
188 |
|
|
movea.l 4(sp),a1 ; a1 = dest |
189 |
|
|
move.b d0,(a1) |
190 |
|
|
} |
191 |
|
|
} |
192 |
|
|
|
193 |
|
|
PCstr *PtoPCstr( /* char *str */ ) |
194 |
|
|
{ |
195 |
|
|
asm 68000 { |
196 |
|
|
movea.l 4(sp),a0 ; a0 = str |
197 |
|
|
clr.w d0 |
198 |
|
|
move.b (a0),d0 |
199 |
|
|
clr.b 1(a0,d0) |
200 |
|
|
move.l a0,d0 |
201 |
|
|
} |
202 |
|
|
} |
203 |
|
|
|
204 |
|
|
PCstr *CtoPCstr( /* char *str */) |
205 |
|
|
{ |
206 |
|
|
asm 68000 { |
207 |
|
|
movea.l 4(sp),a0 ; a0 = str |
208 |
|
|
move.b (a0)+,d0 |
209 |
|
|
lea.l (a0),a1 |
210 |
|
|
@loop: |
211 |
|
|
move.b (a1),d1 |
212 |
|
|
move.b d0,(a1)+ |
213 |
|
|
move.b d1,d0 |
214 |
|
|
bne.s @loop |
215 |
|
|
move.b d0,(a1) |
216 |
|
|
suba.l a0,a1 |
217 |
|
|
move.l a1,d0 |
218 |
|
|
move.b d0,-(a0) |
219 |
|
|
move.l a0,d0 |
220 |
|
|
} |
221 |
|
|
} |
222 |
|
|
|
223 |
|
|
void SetPlen( /* PCstr *pcstr */ ) |
224 |
|
|
{ |
225 |
|
|
asm 68000 { |
226 |
|
|
movea.l 4(sp),a0 ; a0 = str |
227 |
|
|
lea.l 1(a0),a1 |
228 |
|
|
moveq.l #-1,d0 |
229 |
|
|
@loop: |
230 |
|
|
addq.w #1,d0 |
231 |
|
|
@skip: |
232 |
|
|
tst.b (a1)+ |
233 |
|
|
bne.s @loop |
234 |
|
|
move.b d0,(a0) |
235 |
|
|
} |
236 |
|
|
} |
237 |
|
|
#else |
238 |
|
|
/* C function prototypes in mac_napp.h */ |
239 |
|
|
#include "macnapp.h" |
240 |
|
|
|
241 |
|
|
void PtoPCstrcpy(dest, src) |
242 |
|
|
register PCstr *dest; |
243 |
|
|
register char *src; |
244 |
|
|
{ |
245 |
|
|
register short i; |
246 |
|
|
|
247 |
|
|
i = Pstrlen(src); |
248 |
|
|
C(dest)[i] = '\0'; |
249 |
|
|
do { |
250 |
|
|
*dest++ = *src++; |
251 |
|
|
} while (i--); |
252 |
|
|
} |
253 |
|
|
|
254 |
|
|
void CtoPCstrcpy(dest, src) |
255 |
|
|
register PCstr *dest; |
256 |
|
|
register char *src; |
257 |
|
|
{ |
258 |
|
|
register short i; |
259 |
|
|
register char *cpy; |
260 |
|
|
|
261 |
|
|
cpy = C(dest); |
262 |
|
|
for (i = 0; *cpy++ = *src++; i++); |
263 |
|
|
*dest = i; |
264 |
|
|
} |
265 |
|
|
|
266 |
|
|
void PCtoPCstrcpy(dest, src) |
267 |
|
|
register PCstr *dest; |
268 |
|
|
register PCstr *src; |
269 |
|
|
{ |
270 |
|
|
*dest++ = *src++; |
271 |
|
|
while (*dest++ = *src++); |
272 |
|
|
} |
273 |
|
|
|
274 |
|
|
void PtoPCstrncpy(PCstr *dest, char *src, short n) |
275 |
|
|
{ |
276 |
|
|
if (Pstrlen(src) < n) n = Pstrlen(src); |
277 |
|
|
*dest++ = n; |
278 |
|
|
src++; |
279 |
|
|
while (n--) *dest++ = *src++; |
280 |
|
|
*dest++ = '\0'; |
281 |
|
|
} |
282 |
|
|
|
283 |
|
|
void CtoPCstrncpy(PCstr *dest, char *src, short n) |
284 |
|
|
{ |
285 |
|
|
register char *tmp; |
286 |
|
|
register short i; |
287 |
|
|
|
288 |
|
|
tmp = C(dest); |
289 |
|
|
for (i = 0; n-- && (*tmp++ = *src++); i++); |
290 |
|
|
*tmp = '\0'; |
291 |
|
|
*dest = i; |
292 |
|
|
} |
293 |
|
|
|
294 |
|
|
void PtoPCstrcat(dest, src) |
295 |
|
|
register PCstr *dest; |
296 |
|
|
register char *src; |
297 |
|
|
{ |
298 |
|
|
register short i; |
299 |
|
|
register short j; |
300 |
|
|
|
301 |
|
|
i = *dest; |
302 |
|
|
*dest += (j = (unsigned char) *src++); |
303 |
|
|
dest += i + 1; |
304 |
|
|
while (j--) *dest++ = *src++; |
305 |
|
|
*dest = '\0'; |
306 |
|
|
} |
307 |
|
|
|
308 |
|
|
void CtoPCstrcat(dest, src) |
309 |
|
|
register PCstr *dest; |
310 |
|
|
register char *src; |
311 |
|
|
{ |
312 |
|
|
register short i; |
313 |
|
|
register char *tmp; |
314 |
|
|
|
315 |
|
|
tmp = (char *) dest + (i = *dest) + 1; |
316 |
|
|
while (*tmp++ = *src++) i++; |
317 |
|
|
*dest = i; |
318 |
|
|
} |
319 |
|
|
|
320 |
|
|
PCstr *PtoPCstr(str) |
321 |
|
|
register char *str; |
322 |
|
|
{ |
323 |
|
|
SetClen((PCstr*) str); |
324 |
|
|
|
325 |
|
|
return ((PCstr*) str); |
326 |
|
|
} |
327 |
|
|
|
328 |
|
|
PCstr *CtoPCstr(str) |
329 |
|
|
register char *str; |
330 |
|
|
{ |
331 |
|
|
register PCstr i; |
332 |
|
|
register char c, d; |
333 |
|
|
register char *tmp; |
334 |
|
|
|
335 |
|
|
i = 0; |
336 |
|
|
tmp = str; |
337 |
|
|
tmp++; |
338 |
|
|
c = *tmp++; |
339 |
|
|
do { |
340 |
|
|
d = *tmp; |
341 |
|
|
*tmp++ = c; |
342 |
|
|
i++; |
343 |
|
|
} while (c = d); |
344 |
|
|
(*(PCstr*)str) = i; |
345 |
|
|
|
346 |
|
|
return ((PCstr*) str); |
347 |
|
|
} |
348 |
|
|
|
349 |
|
|
void SetPlen(pcstr) |
350 |
|
|
register PCstr *pcstr; |
351 |
|
|
{ |
352 |
|
|
register short i = -1; |
353 |
|
|
register char *len = C(pcstr); |
354 |
|
|
|
355 |
|
|
do { |
356 |
|
|
i++; |
357 |
|
|
} while (*len++); |
358 |
|
|
|
359 |
|
|
*pcstr = i; |
360 |
|
|
} |
361 |
|
|
#endif |
362 |
|
|
|
363 |
|
|
/* simple procedure to convert decimal number of |
364 |
|
|
* less than 20 digits to a PC string. |
365 |
|
|
* Compiling with 68020 option makes this quite a bit more efficient. |
366 |
|
|
*/ |
367 |
|
|
PCstr *longtoPCstr(i) |
368 |
|
|
register long i; |
369 |
|
|
{ |
370 |
|
|
static PCstr sbuf[21]; |
371 |
|
|
register Boolean negflag; |
372 |
|
|
register unsigned long val, ten = 10; |
373 |
|
|
register PCstr *pos = sbuf + sizeof (sbuf) - 1; |
374 |
|
|
register PCstr *posst; |
375 |
|
|
|
376 |
|
|
*pos = '\0'; |
377 |
|
|
posst = --pos; |
378 |
|
|
negflag = false; |
379 |
|
|
val = i; |
380 |
|
|
if (i < 0) { |
381 |
|
|
negflag = true; |
382 |
|
|
val = -i; |
383 |
|
|
} |
384 |
|
|
do { |
385 |
|
|
*pos = (unsigned short) (val % ten) + '0'; |
386 |
|
|
pos--; |
387 |
|
|
} while (val /= ten); |
388 |
|
|
if (negflag) { |
389 |
|
|
*pos = '-'; |
390 |
|
|
pos--; |
391 |
|
|
} |
392 |
|
|
*pos = posst - pos; |
393 |
|
|
|
394 |
|
|
return (pos); |
395 |
|
|
} |
396 |
|
|
|