?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Print nothing if FindTask() has been called with NULL argument.
[AROS.git] / workbench / system / Snoopy / patches.c
blob531cddcf84dc09640b4f63094069d3ca729c636f
1 /*
2 Copyright © 2006-2012, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #include <stdio.h>
7
8 #include <aros/debug.h>
9 #include <proto/dos.h>
10 #include <proto/exec.h>
11 #include <proto/icon.h>
12 #include <proto/intuition.h>
13 #include <proto/graphics.h>
14
15 #include "main.h"
16 #include "patches.h"
17 #include "setup.h"
18 #include "locale.h"
19
20
21 #define MAX_LOCK_LEN 100 /* Max. length of a lock string */
22 #define MAX_STR_LEN 200 /* Max. string length for misc stuff */
23
24 #define MAX(x,y) ((x) > (y) ? (x) : (y))
25 #define MIN(x,y) ((x) < (y) ? (x) : (y))
26
27 // dos.library
28 #define LVO_CreateDir ( -20 * (WORD)LIB_VECTSIZE)
29 #define LVO_CurrentDir ( -21 * (WORD)LIB_VECTSIZE)
30 #define LVO_DeleteFile ( -12 * (WORD)LIB_VECTSIZE)
31 #define LVO_DeleteVar ( -152 * (WORD)LIB_VECTSIZE)
32 #define LVO_Execute ( -37 * (WORD)LIB_VECTSIZE)
33 #define LVO_FindVar ( -153 * (WORD)LIB_VECTSIZE)
34 #define LVO_GetVar ( -151 * (WORD)LIB_VECTSIZE)
35 #define LVO_LoadSeg ( -25 * (WORD)LIB_VECTSIZE)
36 #define LVO_Lock ( -14 * (WORD)LIB_VECTSIZE)
37 #define LVO_MakeLink ( -74 * (WORD)LIB_VECTSIZE)
38 #define LVO_NewLoadSeg ( -128 * (WORD)LIB_VECTSIZE)
39 #define LVO_Open ( -5 * (WORD)LIB_VECTSIZE)
40 #define LVO_Rename ( -13 * (WORD)LIB_VECTSIZE)
41 #define LVO_RunCommand ( -84 * (WORD)LIB_VECTSIZE)
42 #define LVO_SetVar ( -150 * (WORD)LIB_VECTSIZE)
43 #define LVO_SystemTagList ( -101 * (WORD)LIB_VECTSIZE)
44
45 // exec.library
46 #define LVO_FindPort ( -65 * (WORD)LIB_VECTSIZE)
47 #define LVO_FindResident ( -16 * (WORD)LIB_VECTSIZE)
48 #define LVO_FindSemaphore ( -99 * (WORD)LIB_VECTSIZE)
49 #define LVO_FindTask ( -49 * (WORD)LIB_VECTSIZE)
50 #define LVO_OpenDevice ( -74 * (WORD)LIB_VECTSIZE)
51 #define LVO_OpenLibrary ( -92 * (WORD)LIB_VECTSIZE)
52 #define LVO_OpenResource ( -83 * (WORD)LIB_VECTSIZE)
53
54 // intuition.library
55 #define LVO_LockPubScreen ( -85 * (WORD)LIB_VECTSIZE)
56
57 // graphics.library
58 #define LVO_OpenFont ( -12 * (WORD)LIB_VECTSIZE)
59
60 // icon.library
61 #define LVO_FindToolType ( -16 * (WORD)LIB_VECTSIZE)
62 #define LVO_MatchToolValue ( -17 * (WORD)LIB_VECTSIZE)
63
64 struct Library *libbases[LIB_last];
65
66 typedef LONG (*FP)();
67
68 struct Patches
69 {
70 LONG (*oldfunc)();
71 LONG (*newfunc)();
72 LONG libidx;
73 struct Library *lib;
74 LONG lvo;
75 BOOL enabled;
76 } patches[PATCH_last] =
77 {
78 // must be in same order as in enum in patches.h
79 {NULL, NULL, LIB_Dos, 0, LVO_CreateDir, FALSE},
80 {NULL, NULL, LIB_Dos, 0, LVO_CurrentDir, FALSE},
81 {NULL, NULL, LIB_Dos, 0, LVO_DeleteFile, FALSE},
82 {NULL, NULL, LIB_Dos, 0, LVO_DeleteVar, FALSE},
83 {NULL, NULL, LIB_Dos, 0, LVO_Execute, FALSE},
84 {NULL, NULL, LIB_Dos, 0, LVO_FindVar, FALSE},
85 {NULL, NULL, LIB_Dos, 0, LVO_GetVar, FALSE},
86 {NULL, NULL, LIB_Dos, 0, LVO_LoadSeg, FALSE},
87 {NULL, NULL, LIB_Dos, 0, LVO_Lock, FALSE},
88 {NULL, NULL, LIB_Dos, 0, LVO_MakeLink, FALSE},
89 {NULL, NULL, LIB_Dos, 0, LVO_NewLoadSeg, FALSE},
90 {NULL, NULL, LIB_Dos, 0, LVO_Open, FALSE},
91 {NULL, NULL, LIB_Dos, 0, LVO_Rename, FALSE},
92 {NULL, NULL, LIB_Dos, 0, LVO_RunCommand, FALSE},
93 {NULL, NULL, LIB_Dos, 0, LVO_SetVar, FALSE},
94 {NULL, NULL, LIB_Dos, 0, LVO_SystemTagList, FALSE},
95 {NULL, NULL, LIB_Exec, 0, LVO_FindPort, FALSE},
96 {NULL, NULL, LIB_Exec, 0, LVO_FindResident, FALSE},
97 {NULL, NULL, LIB_Exec, 0, LVO_FindSemaphore, FALSE},
98 {NULL, NULL, LIB_Exec, 0, LVO_FindTask, FALSE},
99 {NULL, NULL, LIB_Exec, 0, LVO_OpenDevice, FALSE},
100 {NULL, NULL, LIB_Exec, 0, LVO_OpenLibrary, FALSE},
101 {NULL, NULL, LIB_Exec, 0, LVO_OpenResource, FALSE},
102 {NULL, NULL, LIB_Intuition, 0, LVO_LockPubScreen, FALSE},
103 {NULL, NULL, LIB_Graphics, 0, LVO_OpenFont, FALSE},
104 {NULL, NULL, LIB_Icon, 0, LVO_FindToolType, FALSE},
105 {NULL, NULL, LIB_Icon, 0, LVO_MatchToolValue, FALSE},
106 };
107
108 //static char *MyNameFromLock(BPTR lock, char *filename, char *buf, int maxlen);
109 //static void GetVolName(BPTR lock, char *buf, int maxlen);
110
111 // ----------------------------------------------------------------------------------
112
113 AROS_LH1(BPTR, New_CreateDir,
114 AROS_LHA(CONST_STRPTR, name, D1),
115 struct DosLibrary *, DOSBase, 20, Dos)
116 {
117 AROS_LIBFUNC_INIT
118
119 // result is exclusive lock or NULL
120 BPTR result = AROS_CALL1(BPTR, patches[PATCH_CreateDir].oldfunc,
121 AROS_LDA(CONST_STRPTR, name, D1),
122 struct DosLibrary *, DOSBase);
123
124 if (patches[PATCH_CreateDir].enabled)
125 {
126 main_output("CreateDir", name, 0, (IPTR)result, TRUE);
127 }
128
129 return result;
130
131 AROS_LIBFUNC_EXIT
132 }
133
134 // ----------------------------------------------------------------------------------
135
136 AROS_LH1(BPTR, New_CurrentDir,
137 AROS_LHA(BPTR, lock, D1),
138 struct DosLibrary *, DOSBase, 21, Dos)
139 {
140 AROS_LIBFUNC_INIT
141 //char lockbuf[MAX_LOCK_LEN+1];
142 char *lockpath = "?";
143
144 // returns lock to old directory, 0 means boot filesystem
145 BPTR result = AROS_CALL1(BPTR, patches[PATCH_CurrentDir].oldfunc,
146 AROS_LDA(BPTR, lock, D1),
147 struct DosLibrary *, DOSBase);
148
149 if (patches[PATCH_CurrentDir].enabled)
150 {
151 LONG err = IoErr();
152 struct FileInfoBlock *fib = NULL;
153 if (lock)
154 {
155 fib = AllocDosObject(DOS_FIB, NULL);
156 if (fib)
157 {
158 if (Examine(lock, fib))
159 {
160 lockpath = fib->fib_FileName;
161 }
162 }
163 }
164 main_output("CurrentDir", lockpath, 0, TRUE, TRUE);
165
166 if (fib) FreeDosObject(DOS_FIB, fib);
167 SetIoErr(err);
168 }
169
170 return result;
171
172 AROS_LIBFUNC_EXIT
173 }
174
175 // ----------------------------------------------------------------------------------
176
177 AROS_LH1(BOOL, New_DeleteFile,
178 AROS_LHA(CONST_STRPTR, name, D1),
179 struct DosLibrary *, DOSBase, 12, Dos)
180 {
181 AROS_LIBFUNC_INIT
182
183 // true means deleting was OK
184 BOOL result = AROS_CALL1(BOOL, patches[PATCH_DeleteFile].oldfunc,
185 AROS_LDA(CONST_STRPTR, name, D1),
186 struct DosLibrary *, DOSBase);
187
188 if (patches[PATCH_DeleteFile].enabled)
189 {
190 main_output("Delete", name, 0, result, TRUE);
191 }
192
193 return result;
194
195 AROS_LIBFUNC_EXIT
196 }
197
198 // ----------------------------------------------------------------------------------
199
200 AROS_LH2(LONG, New_DeleteVar,
201 AROS_LHA(CONST_STRPTR, name, D1),
202 AROS_LHA(ULONG , flags, D2),
203 struct DosLibrary *, DOSBase, 152, Dos)
204 {
205 AROS_LIBFUNC_INIT
206
207 // true means variable was deleted
208 LONG result = AROS_CALL2(LONG, patches[PATCH_DeleteVar].oldfunc,
209 AROS_LDA(CONST_STRPTR, name, D1),
210 AROS_LDA(ULONG , flags, D2),
211 struct DosLibrary *, DOSBase);
212
213 if (patches[PATCH_DeleteVar].enabled)
214 {
215 CONST_STRPTR opt;
216 if (flags & GVF_GLOBAL_ONLY) opt = MSG(MSG_GLOBAL);
217 else if ((flags & 7) == LV_VAR) opt = MSG(MSG_LOCAL);
218 else if ((flags & 7) == LV_ALIAS) opt = MSG(MSG_ALIAS);
219 else opt = MSG(MSG_UNKNOWN);
220
221 main_output("DeleteVar", name, opt, result, TRUE);
222 }
223
224 return result;
225
226 AROS_LIBFUNC_EXIT
227 }
228
229 // ----------------------------------------------------------------------------------
230
231 AROS_LH3(LONG, New_Execute,
232 AROS_LHA(CONST_STRPTR, string, D1),
233 AROS_LHA(BPTR , input , D2),
234 AROS_LHA(BPTR , output, D3),
235 struct DosLibrary *, DOSBase, 37, Dos)
236 {
237 AROS_LIBFUNC_INIT
238
239 // true means command could be started
240 LONG result = AROS_CALL3(LONG, patches[PATCH_Execute].oldfunc,
241 AROS_LDA(CONST_STRPTR, string, D1),
242 AROS_LDA(BPTR, input , D2),
243 AROS_LDA(BPTR, output, D3),
244 struct DosLibrary *, DOSBase);
245
246 if (patches[PATCH_Execute].enabled)
247 {
248 main_output("Execute", string ,0 , result, TRUE);
249 }
250
251 return result;
252
253 AROS_LIBFUNC_EXIT
254 }
255
256 // ----------------------------------------------------------------------------------
257
258 AROS_LH2(struct LocalVar *, New_FindVar,
259 AROS_LHA(CONST_STRPTR, name, D1),
260 AROS_LHA(ULONG , type, D2),
261 struct DosLibrary *, DOSBase, 153, Dos)
262 {
263 AROS_LIBFUNC_INIT
264
265 // NULL means variable not found
266 struct LocalVar *result = AROS_CALL2(struct LocalVar *, patches[PATCH_FindVar].oldfunc,
267 AROS_LDA(CONST_STRPTR, name, D1),
268 AROS_LDA(ULONG, type, D2),
269 struct DosLibrary *, DOSBase);
270
271 if (patches[PATCH_FindVar].enabled)
272 {
273 CONST_STRPTR opt;
274 if ((type & 7) == LV_VAR) opt = MSG(MSG_LOCAL);
275 else if ((type & 7) == LV_ALIAS) opt = MSG(MSG_ALIAS);
276 else opt = MSG(MSG_UNKNOWN);
277
278 main_output("FindVar", name, opt, (IPTR)result, TRUE);
279 }
280
281 return result;
282
283 AROS_LIBFUNC_EXIT
284 }
285
286 // ----------------------------------------------------------------------------------
287
288 AROS_LH4(LONG, New_GetVar,
289 AROS_LHA(CONST_STRPTR, name, D1),
290 AROS_LHA(STRPTR, buffer, D2),
291 AROS_LHA(LONG, size, D3),
292 AROS_LHA(LONG, flags, D4),
293 struct DosLibrary *, DOSBase, 151, Dos)
294 {
295 AROS_LIBFUNC_INIT
296
297 // -1 means variable not defined
298 LONG result = AROS_CALL4(LONG, patches[PATCH_GetVar].oldfunc,
299 AROS_LDA(CONST_STRPTR, name, D1),
300 AROS_LDA(STRPTR, buffer, D2),
301 AROS_LDA(LONG, size, D3),
302 AROS_LDA(LONG, flags, D4),
303 struct DosLibrary *, DOSBase);
304
305 if (patches[PATCH_GetVar].enabled)
306 {
307 CONST_STRPTR opt;
308 if (flags & GVF_GLOBAL_ONLY) opt = MSG(MSG_GLOBAL);
309 else if ((flags & 7) == LV_ALIAS) opt = MSG(MSG_ALIAS);
310 else if (flags & GVF_LOCAL_ONLY) opt = MSG(MSG_LOCAL);
311 else opt = MSG(MSG_ANY);
312
313 main_output("GetVar", name, opt, result != -1, TRUE);
314 }
315
316 return result;
317
318 AROS_LIBFUNC_EXIT
319 }
320
321 // ----------------------------------------------------------------------------------
322
323 AROS_LH1(BPTR, New_LoadSeg,
324 AROS_LHA(CONST_STRPTR, name, D1),
325 struct DosLibrary *, DOSBase, 25, Dos)
326 {
327 AROS_LIBFUNC_INIT
328
329 // 0 means load failed
330 BPTR result = AROS_CALL1(BPTR, patches[PATCH_LoadSeg].oldfunc,
331 AROS_LDA(CONST_STRPTR, name, D1),
332 struct DosLibrary *, DOSBase);
333
334 if (patches[PATCH_LoadSeg].enabled)
335 {
336 main_output("LoadSeg", name, 0, (IPTR)result, TRUE);
337 }
338
339 return result;
340
341 AROS_LIBFUNC_EXIT
342 }
343
344 // ----------------------------------------------------------------------------------
345
346 AROS_LH2(BPTR, New_Lock,
347 AROS_LHA(CONST_STRPTR, name, D1),
348 AROS_LHA(LONG, accessMode, D2),
349 struct DosLibrary *, DOSBase, 14, Dos)
350 {
351 AROS_LIBFUNC_INIT
352
353 // 0 means error
354 BPTR result = AROS_CALL2(BPTR, patches[PATCH_Lock].oldfunc,
355 AROS_LDA(CONST_STRPTR, name, D1),
356 AROS_LDA(LONG, accessMode, D2),
357 struct DosLibrary *, DOSBase);
358
359 if (patches[PATCH_Lock].enabled)
360 {
361 CONST_STRPTR opt;
362 if (accessMode == ACCESS_READ) opt = MSG(MSG_READ);
363 else if (accessMode == ACCESS_WRITE) opt = MSG(MSG_WRITE);
364 else opt = MSG(MSG_READ_ASK);
365
366 CONST_STRPTR curname = name;
367 if ( ! curname)
368 {
369 curname="NULL";
370 }
371 else if ( ! setup.showPaths && *curname == '\0')
372 {
373 curname = "\"\"";
374 }
375
376 main_output("Lock", curname, opt, (IPTR)result, TRUE);
377 }
378
379 return result;
380
381 AROS_LIBFUNC_EXIT
382 }
383
384 // ----------------------------------------------------------------------------------
385
386 AROS_LH3(LONG, New_MakeLink,
387 AROS_LHA(CONST_STRPTR, name, D1),
388 AROS_LHA(APTR, dest, D2),
389 AROS_LHA(LONG , soft, D3),
390 struct DosLibrary *, DOSBase, 74, Dos)
391 {
392 AROS_LIBFUNC_INIT
393
394 // result is boolean
395 LONG result = AROS_CALL3(LONG, patches[PATCH_MakeLink].oldfunc,
396 AROS_LDA(CONST_STRPTR, name, D1),
397 AROS_LDA(APTR, dest, D2),
398 AROS_LDA(LONG, soft, D3),
399 struct DosLibrary *, DOSBase);
400
401 if (patches[PATCH_MakeLink].enabled)
402 {
403 //struct Process *myproc = (struct Process *)SysBase->ThisTask;
404
405 CONST_STRPTR opt;
406 if (soft) opt = "Softlink";
407 else opt = "Hardlink";
408
409 //FIXME: MyNameFromLock crashes
410 #if 0
411
412 int len = strlen(name);
413 char namestr[MAX_STR_LEN + 1];
414 if (len >= MAX_STR_LEN) {
415 strncpy(namestr, name, MAX_STR_LEN);
416 namestr[MAX_STR_LEN] = 0;
417 } else {
418 if (setup.showPaths) {
419 strcpy(namestr, MyNameFromLock(myproc->pr_CurrentDir,
420 name, namestr, MAX_STR_LEN-2));
421 len = strlen(namestr);
422 } else
423 strcpy(namestr, name);
424
425 strcat(namestr, " --> ");
426 if (soft) {
427 strncat(namestr, (char *)dest, MAX_STR_LEN - len - 1);
428 namestr[MAX_STR_LEN] = 0;
429 } else {
430 strcat(namestr, MyNameFromLock((BPTR)dest, NULL, namestr+len+1,
431 MAX_STR_LEN-len-1));
432 }
433 }
434 #endif
435 main_output("MakeLink", name /*namestr */, opt, result, TRUE);
436 }
437
438 return result;
439
440 AROS_LIBFUNC_EXIT
441 }
442
443 // ----------------------------------------------------------------------------------
444
445 AROS_LH2(BPTR, New_NewLoadSeg,
446 AROS_LHA(CONST_STRPTR, file, D1),
447 AROS_LHA(struct TagItem *, tags, D2),
448 struct DosLibrary *, DOSBase, 128, Dos)
449 {
450 AROS_LIBFUNC_INIT
451
452 // 0 means load failed
453 BPTR result = AROS_CALL2(BPTR, patches[PATCH_NewLoadSeg].oldfunc,
454 AROS_LDA(CONST_STRPTR, file, D1),
455 AROS_LDA(struct TagItem *, tags, D2),
456 struct DosLibrary *, DOSBase);
457
458 if (patches[PATCH_NewLoadSeg].enabled)
459 {
460 main_output("NewLoadSeg", file, 0, (IPTR)result, TRUE);
461 }
462
463 return result;
464
465 AROS_LIBFUNC_EXIT
466 }
467
468 // ----------------------------------------------------------------------------------
469
470 AROS_LH2(BPTR, New_Open,
471 AROS_LHA(CONST_STRPTR, name, D1),
472 AROS_LHA(LONG, accessMode, D2),
473 struct DosLibrary *, DOSBase, 5, Dos)
474 {
475 AROS_LIBFUNC_INIT
476
477 // 0 means error
478 BPTR result = AROS_CALL2(BPTR, patches[PATCH_Open].oldfunc,
479 AROS_LDA (CONST_STRPTR, name, D1),
480 AROS_LDA (LONG, accessMode, D2),
481 struct DosLibrary *, DOSBase);
482
483 if (patches[PATCH_Open].enabled)
484 {
485 CONST_STRPTR opt = NULL;
486 char optstr[10];
487 if (accessMode == MODE_OLDFILE) opt = MSG(MSG_READ);
488 else if (accessMode == MODE_NEWFILE) opt = MSG(MSG_WRITE);
489 else if (accessMode == MODE_READWRITE) opt = MSG(MSG_MODIFY);
490 else
491 opt = MSG(MSG_UNKNOWN);
492
493 main_output("Open", name, opt ? opt : (STRPTR)optstr, (IPTR)result, TRUE);
494 }
495
496 return result;
497
498 AROS_LIBFUNC_EXIT
499 }
500
501 // ----------------------------------------------------------------------------------
502
503 AROS_LH2(LONG, New_Rename,
504 AROS_LHA(CONST_STRPTR, oldName, D1),
505 AROS_LHA(CONST_STRPTR, newName, D2),
506 struct DosLibrary *, DOSBase, 13, Dos)
507 {
508 AROS_LIBFUNC_INIT
509
510 // bool
511 LONG result = AROS_CALL2(LONG, patches[PATCH_Rename].oldfunc,
512 AROS_LDA(CONST_STRPTR, oldName, D1),
513 AROS_LDA(CONST_STRPTR, newName, D2),
514 struct DosLibrary *, DOSBase);
515
516 if (patches[PATCH_Rename].enabled)
517 {
518 main_output("Rename", oldName, 0, result, FALSE);
519 main_output("to -->", newName, 0, result, TRUE);
520 }
521
522 return result;
523
524 AROS_LIBFUNC_EXIT
525 }
526
527 // ----------------------------------------------------------------------------------
528
529 AROS_LH4(LONG, New_RunCommand,
530 AROS_LHA(BPTR, segList, D1),
531 AROS_LHA(ULONG, stacksize, D2),
532 AROS_LHA(CONST_STRPTR, argptr, D3),
533 AROS_LHA(ULONG, argsize, D4),
534 struct DosLibrary *, DOSBase, 84, Dos)
535 {
536 AROS_LIBFUNC_INIT
537
538 // -1 means error
539 LONG result = AROS_CALL4(LONG, patches[PATCH_RunCommand].oldfunc,
540 AROS_LDA(BPTR, segList, D1),
541 AROS_LDA(ULONG, stacksize, D2),
542 AROS_LDA(CONST_STRPTR, argptr, D3),
543 AROS_LDA(ULONG, argsize, D4),
544 struct DosLibrary *, DOSBase);
545
546 if (patches[PATCH_RunCommand].enabled)
547 {
548 char argstr[MAX_STR_LEN + 1];
549 int pos;
550 for (pos = 0; pos < MAX_STR_LEN && argptr[pos] != 0 ; pos++)
551 {
552 if (argptr[pos] == '\n')
553 argstr[pos] = ' ';
554 else
555 argstr[pos] = argptr[pos];
556 }
557
558 argstr[pos] = 0;
559 main_output("RunCommand", argstr, 0, result != -1, TRUE);
560 }
561
562 return result;
563
564 AROS_LIBFUNC_EXIT
565 }
566
567 // ----------------------------------------------------------------------------------
568
569 AROS_LH4(BOOL, New_SetVar,
570 AROS_LHA(CONST_STRPTR, name, D1),
571 AROS_LHA(CONST_STRPTR, buffer, D2),
572 AROS_LHA(LONG , size, D3),
573 AROS_LHA(LONG , flags, D4),
574 struct DosLibrary *, DOSBase, 150, Dos)
575 {
576 AROS_LIBFUNC_INIT
577
578 BOOL result = AROS_CALL4(BOOL, patches[PATCH_SetVar].oldfunc,
579 AROS_LDA(CONST_STRPTR, name, D1),
580 AROS_LDA(CONST_STRPTR, buffer, D2),
581 AROS_LDA(LONG, size, D3),
582 AROS_LDA(LONG, flags, D4),
583 struct DosLibrary *, DOSBase);
584
585 if (patches[PATCH_SetVar].enabled)
586 {
587 CONST_STRPTR opt;
588 char varstr[MAX_STR_LEN + 1];
589 int vlen;
590
591 if (flags & GVF_GLOBAL_ONLY) opt = MSG(MSG_GLOBAL);
592 else if ((flags & 7) == LV_VAR) opt = MSG(MSG_LOCAL);
593 else if ((flags & 7) == LV_ALIAS) opt = MSG(MSG_ALIAS);
594 else opt = MSG(MSG_UNKNOWN);
595
596 /*
597 * Now create a string that looks like "Variable=Value"
598 *
599 * We go to some pains to ensure we don't overwrite our
600 * string length
601 */
602 vlen = strlen(name);
603 if (vlen > (MAX_STR_LEN-1)) {
604 strncpy(varstr, name, MAX_STR_LEN);
605 varstr[MAX_STR_LEN] = 0;
606 } else {
607 strcpy(varstr, name);
608 strcat(varstr, "=");
609 vlen = 98 - vlen;
610 if (size != -1)
611 vlen = MIN(vlen, size);
612
613 strncat(varstr, buffer, vlen);
614 varstr[MAX_STR_LEN] = 0;
615 }
616 main_output("SetVar", varstr, opt, result, TRUE);
617 }
618
619 return result;
620
621 AROS_LIBFUNC_EXIT
622 }
623
624 // ----------------------------------------------------------------------------------
625
626 AROS_LH2(LONG, New_SystemTagList,
627 AROS_LHA(CONST_STRPTR , command, D1),
628 AROS_LHA(struct TagItem *, tags, D2),
629 struct DosLibrary *, DOSBase, 101, Dos)
630 {
631 AROS_LIBFUNC_INIT
632
633 // -1 means error
634 LONG result = AROS_CALL2(LONG, patches[PATCH_SystemTagList].oldfunc,
635 AROS_LDA(CONST_STRPTR, command, D1),
636 AROS_LDA(struct TagItem *, tags, D2),
637 struct DosLibrary *, DOSBase);
638
639 if (patches[PATCH_SystemTagList].enabled)
640 {
641 char optstr[20];
642 sprintf(optstr, "%d", (int)result);
643 main_output("SystemTagList", command, optstr, result != -1, TRUE);
644 }
645
646 return result;
647
648 AROS_LIBFUNC_EXIT
649 }
650
651 // ----------------------------------------------------------------------------------
652
653 AROS_LH1(struct MsgPort *, New_FindPort,
654 AROS_LHA(STRPTR, name, A1),
655 struct ExecBase *, SysBase, 65, Exec)
656 {
657 AROS_LIBFUNC_INIT
658
659 // NULL means error
660 struct MsgPort *result = AROS_CALL1(struct MsgPort *, patches[PATCH_FindPort].oldfunc,
661 AROS_LDA(STRPTR, name, A1),
662 struct ExecBase *, SysBase);
663
664 if (patches[PATCH_FindPort].enabled)
665 {
666 main_output("FindPort", name, 0, (IPTR)result, TRUE);
667 }
668
669 return result;
670
671 AROS_LIBFUNC_EXIT
672 }
673
674 // ----------------------------------------------------------------------------------
675
676 AROS_LH1(struct Resident *, New_FindResident,
677 AROS_LHA(const UBYTE *, name, A1),
678 struct ExecBase *, SysBase, 16, Exec)
679 {
680 AROS_LIBFUNC_INIT
681
682 // NULL means error
683 struct Resident *result = AROS_CALL1(struct Resident *, patches[PATCH_FindResident].oldfunc,
684 AROS_LDA(const UBYTE *, name, A1),
685 struct ExecBase *, SysBase);
686
687 if (patches[PATCH_FindResident].enabled)
688 {
689 main_output("FindResident", name, 0, (IPTR)result, TRUE);
690 }
691
692 return result;
693
694 AROS_LIBFUNC_EXIT
695 }
696
697 // ----------------------------------------------------------------------------------
698
699 AROS_LH1(struct SignalSemaphore *, New_FindSemaphore,
700 AROS_LHA(STRPTR, name, A1),
701 struct ExecBase *, SysBase, 99, Exec)
702 {
703 AROS_LIBFUNC_INIT
704
705 // NULL means error
706 struct SignalSemaphore *result = AROS_CALL1(struct SignalSemaphore *, patches[PATCH_FindSemaphore].oldfunc,
707 AROS_LDA(STRPTR, name, A1),
708 struct ExecBase *, SysBase);
709
710 if (patches[PATCH_FindSemaphore].enabled)
711 {
712 main_output("FindSemaphore", name, 0, (IPTR)result, TRUE);
713 }
714
715 return result;
716
717 AROS_LIBFUNC_EXIT
718 }
719
720 // ----------------------------------------------------------------------------------
721
722 AROS_LH1(struct Task *, New_FindTask,
723 AROS_LHA(STRPTR, name, A1),
724 struct ExecBase *, SysBase, 49, Exec)
725 {
726 AROS_LIBFUNC_INIT
727
728 // NULL means error
729 struct Task *result = AROS_CALL1(struct Task *, patches[PATCH_FindTask].oldfunc,
730 AROS_LDA(STRPTR, name, A1),
731 struct ExecBase *, SysBase);
732
733 if ((name != NULL) && patches[PATCH_FindTask].enabled)
734 {
735 main_output("FindTask", name, 0, (IPTR)result, TRUE);
736 }
737
738 return result;
739
740 AROS_LIBFUNC_EXIT
741 }
742
743 // ----------------------------------------------------------------------------------
744
745 AROS_LH4(LONG, New_OpenDevice,
746 AROS_LHA(CONST_STRPTR, devName, A0),
747 AROS_LHA(IPTR, unitNumber, D0),
748 AROS_LHA(struct IORequest *, iORequest, A1),
749 AROS_LHA(ULONG, flags, D1),
750 struct ExecBase *, SysBase, 74, Exec)
751 {
752 AROS_LIBFUNC_INIT
753
754 // 0 means OK
755 LONG result = AROS_CALL4(LONG, patches[PATCH_OpenDevice].oldfunc,
756 AROS_LDA(CONST_STRPTR, devName, A0),
757 AROS_LDA(IPTR, unitNumber, D0),
758 AROS_LDA(struct IORequest *, iORequest, A1),
759 AROS_LDA(ULONG, flags, D1),
760 struct ExecBase *, SysBase);
761
762 if (patches[PATCH_OpenDevice].enabled)
763 {
764 char unitstr[20];
765 // FIXME: unitNumber can be a pointer
766 sprintf(unitstr, "Unit %d", (int)unitNumber);
767 main_output("OpenDevice", devName, unitstr, !result, TRUE);
768 }
769
770 return result;
771
772 AROS_LIBFUNC_EXIT
773 }
774
775 // ----------------------------------------------------------------------------------
776
777 AROS_LH2(struct Library *, New_OpenLibrary,
778 AROS_LHA(CONST_STRPTR, libName, A1),
779 AROS_LHA(ULONG, version, D0),
780 struct ExecBase *, SysBase, 92, Exec)
781 {
782 AROS_LIBFUNC_INIT
783
784 // 0 means error
785 struct Library *result = AROS_CALL2(struct Library *, patches[PATCH_OpenLibrary].oldfunc,
786 AROS_LDA(CONST_STRPTR, libName, A1),
787 AROS_LDA(ULONG, version, D0),
788 struct ExecBase *, SysBase);
789
790 if (patches[PATCH_OpenLibrary].enabled)
791 {
792 char verstr[20];
793 sprintf(verstr, MSG(MSG_VERSION), version);
794 main_output("OpenLibrary", libName, verstr, (IPTR)result, TRUE);
795 }
796
797 return result;
798
799 AROS_LIBFUNC_EXIT
800 }
801
802 // ----------------------------------------------------------------------------------
803
804 AROS_LH1(APTR, New_OpenResource,
805 AROS_LHA(CONST_STRPTR, resName, A1),
806 struct ExecBase *, SysBase, 83, Exec)
807 {
808 AROS_LIBFUNC_INIT
809
810 // 0 means error
811 APTR result = AROS_CALL1(APTR, patches[PATCH_OpenResource].oldfunc,
812 AROS_LDA(CONST_STRPTR, resName, A1),
813 struct ExecBase *, SysBase);
814
815 if (patches[PATCH_OpenResource].enabled)
816 {
817 main_output("OpenLibrary", resName, 0, (IPTR)result, TRUE);
818 }
819
820 return result;
821
822 AROS_LIBFUNC_EXIT
823 }
824
825 // ----------------------------------------------------------------------------------
826
827 AROS_LH1(struct Screen *, New_LockPubScreen,
828 AROS_LHA(CONST_STRPTR, name, A0),
829 struct IntuitionBase *, IntuitionBase, 85, Intuition)
830 {
831 AROS_LIBFUNC_INIT
832
833 // 0 means error
834 struct Screen *result = AROS_CALL1(struct Screen *, patches[PATCH_LockPubScreen].oldfunc,
835 AROS_LDA(CONST_STRPTR, name, A0),
836 struct IntuitionBase *, IntuitionBase);
837
838 if (patches[PATCH_LockPubScreen].enabled)
839 {
840 main_output("LockPubScreen", name, 0, (IPTR)result, TRUE);
841 }
842
843 return result;
844
845 AROS_LIBFUNC_EXIT
846 }
847
848 // ----------------------------------------------------------------------------------
849
850 AROS_LH1(struct TextFont *, New_OpenFont,
851 AROS_LHA(struct TextAttr *, textAttr, A0),
852 struct GfxBase *, GfxBase, 12, Graphics)
853 {
854 AROS_LIBFUNC_INIT
855
856 // 0 means error
857 struct TextFont *result = AROS_CALL1(struct TextFont *, patches[PATCH_OpenFont].oldfunc,
858 AROS_LDA(struct TextAttr *, textAttr, A0),
859 struct GfxBase *, GfxBase);
860
861 if (patches[PATCH_OpenFont].enabled)
862 {
863 char *name;
864 char sizestr[20];
865
866 if (textAttr) {
867 sprintf(sizestr, MSG(MSG_SIZE), textAttr->ta_YSize);
868 name = textAttr->ta_Name;
869 } else {
870 *sizestr = '\0';
871 name = "\"\"";
872 }
873 main_output("OpenFont", name, sizestr, (IPTR)result, TRUE);
874 }
875
876 return result;
877
878 AROS_LIBFUNC_EXIT
879 }
880
881 // ----------------------------------------------------------------------------------
882
883 AROS_LH2(UBYTE *, New_FindToolType,
884 AROS_LHA(CONST STRPTR *, toolTypeArray, A0),
885 AROS_LHA(CONST STRPTR, typeName, A1),
886 struct Library *, IconBase, 16, Icon)
887 {
888 AROS_LIBFUNC_INIT
889
890 // 0 means error
891 UBYTE *result = AROS_CALL2(UBYTE *, patches[PATCH_FindToolType].oldfunc,
892 AROS_LDA(CONST STRPTR *, toolTypeArray, A0),
893 AROS_LDA(CONST STRPTR, typeName, A1),
894 struct Library *, IconBase);
895
896 if (patches[PATCH_FindToolType].enabled)
897 {
898 main_output("FindToolType", typeName, 0, (IPTR)result, TRUE);
899 }
900
901 return result;
902
903 AROS_LIBFUNC_EXIT
904 }
905
906 // ----------------------------------------------------------------------------------
907
908 AROS_LH2(BOOL, New_MatchToolValue,
909 AROS_LHA(UBYTE *, typeString, A0),
910 AROS_LHA(UBYTE *, value, A1),
911 struct Library *, IconBase, 17, Icon)
912 {
913 AROS_LIBFUNC_INIT
914
915 BOOL result = AROS_CALL2(BOOL, patches[PATCH_MatchToolValue].oldfunc,
916 AROS_LDA(UBYTE *, typeString, A0),
917 AROS_LDA(UBYTE *, value, A1),
918 struct Library *, IconBase);
919
920 if (patches[PATCH_MatchToolValue].enabled)
921 {
922 main_output("MatchToolValue", typeString, value, result, TRUE);
923 }
924
925 return result;
926
927 AROS_LIBFUNC_EXIT
928 }
929
930 // ----------------------------------------------------------------------------------
931
932 void patches_init(void)
933 {
934 libbases[LIB_Exec] = (struct Library*)SysBase;
935 libbases[LIB_Dos] = (struct Library*)DOSBase;
936 libbases[LIB_Icon] = IconBase;
937 libbases[LIB_Intuition] = (struct Library*)IntuitionBase;
938 libbases[LIB_Graphics] = (struct Library*)GfxBase;
939
940 patches[PATCH_CreateDir].newfunc = (FP)AROS_SLIB_ENTRY(New_CreateDir, Dos, 20);
941 patches[PATCH_CurrentDir].newfunc = (FP)AROS_SLIB_ENTRY(New_CurrentDir, Dos, 21);
942 patches[PATCH_DeleteFile].newfunc = (FP)AROS_SLIB_ENTRY(New_DeleteFile, Dos, 12);
943 patches[PATCH_DeleteVar].newfunc = (FP)AROS_SLIB_ENTRY(New_DeleteVar, Dos, 152);
944 patches[PATCH_Execute].newfunc = (FP)AROS_SLIB_ENTRY(New_Execute, Dos, 37);
945 patches[PATCH_FindVar].newfunc = (FP)AROS_SLIB_ENTRY(New_FindVar, Dos, 153);
946 patches[PATCH_GetVar].newfunc = (FP)AROS_SLIB_ENTRY(New_GetVar, Dos, 151);
947 patches[PATCH_LoadSeg].newfunc = (FP)AROS_SLIB_ENTRY(New_LoadSeg, Dos, 25);
948 patches[PATCH_Lock].newfunc = (FP)AROS_SLIB_ENTRY(New_Lock, Dos, 14);
949 patches[PATCH_MakeLink].newfunc = (FP)AROS_SLIB_ENTRY(New_MakeLink, Dos, 74);
950 patches[PATCH_NewLoadSeg].newfunc = (FP)AROS_SLIB_ENTRY(New_NewLoadSeg, Dos, 128);
951 patches[PATCH_Open].newfunc = (FP)AROS_SLIB_ENTRY(New_Open, Dos, 5);
952 patches[PATCH_Rename].newfunc = (FP)AROS_SLIB_ENTRY(New_Rename, Dos, 13);
953 patches[PATCH_RunCommand].newfunc = (FP)AROS_SLIB_ENTRY(New_RunCommand, Dos, 84);
954 patches[PATCH_SetVar].newfunc = (FP)AROS_SLIB_ENTRY(New_SetVar, Dos, 150);
955 patches[PATCH_SystemTagList].newfunc = (FP)AROS_SLIB_ENTRY(New_SystemTagList, Dos, 101);
956 patches[PATCH_FindPort].newfunc = (FP)AROS_SLIB_ENTRY(New_FindPort, Exec, 65);
957 patches[PATCH_FindResident].newfunc = (FP)AROS_SLIB_ENTRY(New_FindResident, Exec, 16);
958 patches[PATCH_FindSemaphore].newfunc = (FP)AROS_SLIB_ENTRY(New_FindSemaphore, Exec, 99);
959 patches[PATCH_FindTask].newfunc = (FP)AROS_SLIB_ENTRY(New_FindTask, Exec, 49);
960 patches[PATCH_OpenDevice].newfunc = (FP)AROS_SLIB_ENTRY(New_OpenDevice, Exec, 74);
961 patches[PATCH_OpenLibrary].newfunc = (FP)AROS_SLIB_ENTRY(New_OpenLibrary, Exec, 92);
962 patches[PATCH_OpenResource].newfunc = (FP)AROS_SLIB_ENTRY(New_OpenResource, Exec, 83);
963 patches[PATCH_LockPubScreen].newfunc = (FP)AROS_SLIB_ENTRY(New_LockPubScreen, Intuition, 85);
964 patches[PATCH_OpenFont].newfunc = (FP)AROS_SLIB_ENTRY(New_OpenFont, Graphics, 12);
965 patches[PATCH_FindToolType].newfunc = (FP)AROS_SLIB_ENTRY(New_FindToolType, Icon, 16);
966 patches[PATCH_MatchToolValue].newfunc = (FP)AROS_SLIB_ENTRY(New_MatchToolValue, Icon, 17);
967
968 patches_set();
969
970 int i;
971 for (i=0; i<PATCH_last; i++)
972 {
973 if (patches[i].newfunc);
974 {
975 Forbid();
976 patches[i].oldfunc = SetFunction(libbases[patches[i].libidx], patches[i].lvo, patches[i].newfunc);
977 Permit();
978 }
979 }
980 }
981
982 // ----------------------------------------------------------------------------------
983
984 void patches_set(void)
985 {
986 patches[PATCH_CreateDir].enabled = setup.enableMakeDir;
987 patches[PATCH_CurrentDir].enabled = setup.enableChangeDir;
988 patches[PATCH_DeleteFile].enabled = setup.enableDelete;
989 patches[PATCH_DeleteVar].enabled = setup.enableSetVar;
990 patches[PATCH_Execute].enabled = setup.enableExecute;
991 patches[PATCH_FindVar].enabled = setup.enableGetVar;
992 patches[PATCH_GetVar].enabled = setup.enableGetVar;
993 patches[PATCH_LoadSeg].enabled = setup.enableLoadSeg;
994 patches[PATCH_Lock].enabled = setup.enableLock;
995 patches[PATCH_MakeLink].enabled = setup.enableMakeLink;
996 patches[PATCH_NewLoadSeg].enabled = setup.enableLoadSeg;
997 patches[PATCH_Open].enabled = setup.enableOpen;
998 patches[PATCH_Rename].enabled = setup.enableRename;
999 patches[PATCH_RunCommand].enabled = setup.enableRunCommand;
1000 patches[PATCH_SetVar].enabled = setup.enableSetVar;
1001 patches[PATCH_SystemTagList].enabled = setup.enableSystem;
1002 patches[PATCH_FindPort].enabled = setup.enableFindPort;
1003 patches[PATCH_FindResident].enabled = setup.enableFindResident;
1004 patches[PATCH_FindSemaphore].enabled = setup.enableFindSemaphore;
1005 patches[PATCH_FindTask].enabled = setup.enableFindTask;
1006 patches[PATCH_OpenDevice].enabled = setup.enableOpenDevice;
1007 patches[PATCH_OpenLibrary].enabled = setup.enableOpenLibrary;
1008 patches[PATCH_OpenResource].enabled = setup.enableOpenResource;
1009 patches[PATCH_LockPubScreen].enabled = setup.enableLockScreen;
1010 patches[PATCH_OpenFont].enabled = setup.enableOpenFont;
1011 patches[PATCH_FindToolType].enabled = setup.enableReadToolTypes;
1012 patches[PATCH_MatchToolValue].enabled = setup.enableReadToolTypes;
1013
1014 }
1015
1016 // ----------------------------------------------------------------------------------
1017
1018 void patches_reset(void)
1019 {
1020 int i;
1021
1022 for (i=0; i<PATCH_last; i++)
1023 {
1024 patches[i].enabled = FALSE;
1025 }
1026
1027 for (i=0; i<PATCH_last; i++)
1028 {
1029 if (patches[i].oldfunc)
1030 {
1031 Forbid();
1032 SetFunction(libbases[patches[i].libidx], patches[i].lvo, patches[i].oldfunc);
1033 Permit();
1034 patches[i].oldfunc = NULL;
1035 }
1036 }
1037 }
1038
Mirror of AROS' svn.