?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix IO memory access .. SB128 driver makes noises in VMWare - CMI is untested (Curren...
[AROS.git] / workbench / c / AddDatatypes.c
blobea4f5516096b1747127d671407bf0e20a1075a4e
1 /*
2 Copyright © 1995-2010, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc:
6 Lang: English
7 */
8
9
10 /******************************************************************************
11
12 NAME
13
14 AddDatatypes (files) [QUIET] [REFRESH] [LIST]
15
16 SYNOPSIS
17
18 FILES/M, QUIET/S, REFRESH/S, LIST/S
19
20 LOCATION
21
22 C:
23
24 FUNCTION
25
26 AddDatatypes allows you to activate a set of specific datatypes.
27 This might be necessary if new datatypes were installed on your
28 system or were not activated on startup.
29
30 INPUTS
31
32 FILES -- The name of the file(s) of the corresponding datatype.
33 QUIET -- Won't output any messages
34 REFRESH -- Refreshes the Datatype list?
35 LIST -- This will display a list of current datatypes loaded in
36 memory
37
38 RESULT
39
40 Standard DOS error codes.
41
42 NOTES
43
44 EXAMPLE
45
46 AddDataTypes gif.datatype REFRESH
47
48 BUGS
49
50 SEE ALSO
51
52 INTERNALS
53
54 HISTORY
55
56 ******************************************************************************/
57
58 #include <aros/macros.h>
59 #include <aros/bigendianio.h>
60 #include <exec/types.h>
61 #include <exec/memory.h>
62 #include <exec/execbase.h>
63 #include <dos/dos.h>
64 #include <dos/dosasl.h>
65 #include <dos/dosextens.h>
66 #include <libraries/iffparse.h>
67 #include <utility/name.h>
68 #include <utility/hooks.h>
69 #include <workbench/startup.h>
70
71 #include <proto/exec.h>
72 #include <proto/dos.h>
73 #include <proto/utility.h>
74 #include <proto/iffparse.h>
75 #include <proto/alib.h>
76 #include <proto/arossupport.h>
77
78 #include <string.h>
79
80 #include "../libs/datatypes/datatypes_intern.h"
81 #undef DOSBase
82 #undef UtilityBase
83 #undef IFFParseBase
84 #undef LocaleBase
85 #undef DTList
86
87 /******************************** STRUCTURES *********************************/
88
89 /* same as datatypes/datatypes.h/struct DataTypeHeader, but always big endian
90 and 32 bit pointers (which in the file are actually offsets) */
91
92 struct FileDataTypeHeader
93 {
94 ULONG fdth_NameOffset; /* Name of the data type */
95 ULONG fdth_BaseNameOffset; /* Base name of the data type */
96 ULONG fdth_PatternOffset; /* File name match pattern */
97 ULONG fdth_MaskOffset; /* Comparision mask (binary) */
98 ULONG fdth_GroupID; /* DataType Group */
99 ULONG fdth_ID; /* DataType ID (same as IFF FORM type) */
100 WORD fdth_MaskLen; /* Length of the comparision mask */
101 WORD fdth_Pad; /* Unused at present (must be 0) */
102 UWORD fdth_Flags; /* Flags -- see below */
103 UWORD fdth_Priority;
104 };
105
106 #define O(x) offsetof(struct FileDataTypeHeader,x)
107
108 static const IPTR FileDataTypeHeaderDesc[] =
109 {
110 sizeof(struct FileDataTypeHeader),
111 SDM_ULONG(O(fdth_NameOffset)),
112 SDM_ULONG(O(fdth_BaseNameOffset)),
113 SDM_ULONG(O(fdth_PatternOffset)),
114 SDM_ULONG(O(fdth_MaskOffset)),
115 SDM_ULONG(O(fdth_GroupID)),
116 SDM_ULONG(O(fdth_ID)),
117 SDM_WORD(O(fdth_MaskLen)),
118 SDM_WORD(O(fdth_Pad)),
119 SDM_UWORD(O(fdth_Flags)),
120 SDM_UWORD(O(fdth_Priority)),
121 SDM_END
122 };
123
124 /******************************** PROTOTYPES *********************************/
125
126 struct StackVars; /* forward declaration */
127
128 BOOL DateScan(struct StackVars *sv);
129 void ScanDirectory(struct StackVars *sv, STRPTR pattern);
130 struct DataTypesList *CreateDTList(struct StackVars *sv);
131 struct CompoundDatatype *CreateBasicType(struct StackVars *sv,
132 struct List *list,
133 struct List *globallist, STRPTR name,
134 UWORD Flags, ULONG ID, ULONG GroupID);
135 void LoadDatatype(struct StackVars *sv, STRPTR name);
136 struct CompoundDatatype *CreateDatatype(struct StackVars *sv,
137 struct IFFHandle *iff);
138 struct CompoundDatatype *AddDatatype(struct StackVars *sv,
139 struct CompoundDatatype *cdt);
140 void DeleteDatatype(struct StackVars *sv, struct CompoundDatatype *cdt);
141 void AlphaInsert(struct StackVars *sv, struct List *list, struct Node *node);
142 void PrioInsert(struct StackVars *sv, struct List *list,
143 struct CompoundDatatype *cdt);
144 struct Node *__FindNameNoCase(struct StackVars *sv, struct List *list,
145 STRPTR name);
146
147 AROS_UFP4(LONG, AROS_SLIB_ENTRY(ReadFunc, AddDatatypes, 0),
148 AROS_UFPA(BPTR , fh , D1),
149 AROS_UFPA(void * , buf , D2),
150 AROS_UFPA(LONG , size , D3),
151 AROS_UFPA(struct DosLibrary *, DOSBase, A6));
152 AROS_UFP4(LONG, AROS_SLIB_ENTRY(SeekFunc, AddDatatypes, 0),
153 AROS_UFPA(BPTR , fh , D1),
154 AROS_UFPA(LONG , pos , D2),
155 AROS_UFPA(LONG , mode , D3),
156 AROS_UFPA(struct DosLibrary *, DOSBase, A6));
157 AROS_UFP3(UBYTE *, AROS_SLIB_ENTRY(AllocFunc, AddDatatypes, 0),
158 AROS_UFPA(ULONG, size, D0),
159 AROS_UFPA(ULONG, req, D1),
160 AROS_UFPA(struct DosLibrary *, DOSBase, A6));
161 AROS_UFP3(void, AROS_SLIB_ENTRY(FreeFunc, AddDatatypes, 0),
162 AROS_UFPA(APTR , memory, A1),
163 AROS_UFPA(ULONG, size , D0),
164 AROS_UFPA(struct DosLibrary *, DOSBase, A6));
165
166 /********************************* CONSTANTS *********************************/
167
168 const TEXT Version[] = "$VER: AddDatatypes 42.1 (8.12.2007)\n";
169
170 #define EXCL_LEN 18
171 UBYTE ExcludePattern[] = "#?.(info|backdrop)";
172
173 UBYTE Template[] = "FILES/M,QUIET/S,REFRESH/S,LIST/S";
174
175 struct ArgArray
176 {
177 UBYTE **aa_Files;
178 IPTR aa_Quiet;
179 IPTR aa_Refresh;
180 IPTR aa_List;
181 };
182
183 #define ID_DTCD MAKE_ID('D','T','C','D')
184 #define ID_DTTL MAKE_ID('D','T','T','L')
185
186 #define NUM_PROP 2
187
188 LONG PropArray[2*NUM_PROP]=
189 {
190 ID_DTYP, ID_DTHD,
191 ID_DTYP, ID_DTCD
192 };
193
194 #define NUM_COLL 1
195
196 const LONG const CollArray[2*NUM_COLL]=
197 {
198 ID_DTYP, ID_DTTL
199 };
200
201
202 const LONG_FUNC const FunctionArray[]=
203 { /* Note! */
204 (LONG_FUNC)AROS_SLIB_ENTRY(ReadFunc, AddDatatypes, 0),
205 (LONG_FUNC)AROS_SLIB_ENTRY(AllocFunc, AddDatatypes, 0),
206 (LONG_FUNC)AROS_SLIB_ENTRY(FreeFunc, AddDatatypes, 0),
207 (LONG_FUNC)AROS_SLIB_ENTRY(SeekFunc, AddDatatypes, 0), /* For ELF */
208 };
209
210
211 struct StackVars
212 {
213 struct DataTypesList *DTList;
214 UBYTE ExclPat[2*EXCL_LEN+2+1];
215 struct ArgArray AA;
216 UBYTE *HookBuffer;
217 ULONG HookBufSize;
218 ULONG HookPosition;
219 };
220
221 #undef SysBase
222 #define DTList sv->DTList
223 #define ExclPat sv->ExclPat
224 #define AA sv->AA
225 #define HookBuffer sv->HookBuffer
226 #define HookBufSize sv->HookBufSize
227 #define HookPosition sv->HookPosition
228
229 /****** AddDatatypes/main *****************************************************
230 *
231 * NAME
232 * main - well... main
233 *
234 * SYNOPSIS
235 *
236 * FUNCTION
237 *
238 * INPUTS
239 *
240 * RETURNS
241 *
242 * EXAMPLE
243 *
244 * SEE ALSO
245 *
246 ******************************************************************************
247 *
248 */
249 int UtilityBase_version = 37;
250 int LocaleBase_version = 37;
251 int IFFParseBase_version = 37;
252
253 int __nocommandline = 1;
254
255 int main(void)
256 {
257 extern struct WBStartup *WBenchMsg;
258 struct StackVars vars;
259 struct StackVars *sv;
260 int result = RETURN_FAIL;
261
262 memset(&vars, 0, sizeof(struct StackVars));
263 sv = &vars;
264
265 if((DTList = CreateDTList(sv)))
266 {
267 ParsePatternNoCase(ExcludePattern, ExclPat, sizeof(ExclPat));
268
269 ObtainSemaphore(&DTList->dtl_Lock);
270
271 if(WBenchMsg)
272 {
273 UWORD num;
274 struct WBArg *wa = &WBenchMsg->sm_ArgList[1];
275
276 for(num = 1; num<WBenchMsg->sm_NumArgs; wa++)
277 {
278 BPTR olddir = CurrentDir(wa->wa_Lock);
279 LoadDatatype(sv, wa->wa_Name);
280 CurrentDir(olddir);
281 }
282
283 result = RETURN_OK;
284 }
285 else
286 {
287 struct RDArgs *RDArgs;
288
289 if(!(RDArgs = ReadArgs(Template, (SIPTR*)&AA, NULL)))
290 {
291 PrintFault(IoErr(), NULL);
292 }
293 else
294 {
295 if(AA.aa_Refresh)
296 {
297 if(DateScan(sv))
298 {
299 ScanDirectory(sv, "DEVS:DataTypes");
300 }
301 }
302 else
303 {
304 UBYTE **files = AA.aa_Files;
305
306 if(files)
307 {
308 while(*files)
309 {
310 ScanDirectory(sv, *files);
311 files++;
312 }
313 }
314 }
315
316 if(AA.aa_List)
317 {
318 struct DataTypesList *dtl = NULL;
319 struct NamedObject *no = NULL;
320 if((no = FindNamedObject(NULL, DATATYPESLIST, NULL)))
321 {
322 dtl = (struct DataTypesList*)no->no_Object;
323 ReleaseNamedObject(no);
324 if(dtl != NULL)
325 {
326 struct Node *node=dtl->dtl_SortedList.lh_Head;
327 while(node->ln_Succ != NULL)
328 {
329 // sorted list points to DT.dtn_Node2 ....
330 struct CompoundDatatype *cdt;
331 struct DataTypeHeader *dth;
332 STRPTR argarray[2];
333
334 if(CheckSignal(SIGBREAKF_CTRL_C))
335 {
336 Flush(Output());
337 PrintFault(ERROR_BREAK,0);
338 break;
339 }
340 cdt=(struct CompoundDatatype *)(node-1);
341 dth=cdt->DT.dtn_Header;
342
343 argarray[0] = dth->dth_BaseName;
344 argarray[1] = dth->dth_Name;
345
346 VPrintf("%s, \"%s\"\n", (IPTR *)argarray);
347 node = node->ln_Succ;
348 }
349 }
350 }
351
352 }
353
354 result = RETURN_OK;
355 FreeArgs(RDArgs);
356 }
357 }
358
359 ReleaseSemaphore(&DTList->dtl_Lock);
360 }
361
362 return result;
363 }
364
365
366
367 /****** AddDatatypes/DateScan *************************************************
368 *
369 * NAME
370 * DateScan - See if datatypes descriptors need updating
371 *
372 * SYNOPSIS
373 *
374 * FUNCTION
375 *
376 * INPUTS
377 *
378 * RETURNS
379 *
380 * EXAMPLE
381 *
382 * SEE ALSO
383 *
384 ******************************************************************************
385 *
386 */
387
388 BOOL DateScan(struct StackVars *sv)
389 {
390 BOOL result = TRUE;
391 BPTR lock;
392 struct FileInfoBlock *fib;
393
394 if((lock = Lock("DEVS:Datatypes", ACCESS_READ)))
395 {
396 if((fib = AllocDosObject(DOS_FIB, NULL)))
397 {
398 if(Examine(lock, fib))
399 {
400 if(!CompareDates(&fib->fib_Date, &DTList->dtl_DateStamp))
401 {
402 result = FALSE;
403 }
404 else
405 {
406 DTList->dtl_DateStamp = fib->fib_Date;
407 }
408 }
409
410 FreeDosObject(DOS_FIB,fib);
411 }
412
413 UnLock(lock);
414 }
415
416 return result;
417 }
418
419
420
421 /****** AddDatatypes/ScanDirectory ********************************************
422 *
423 * NAME
424 * ScanDirectory - Scan a directory recursively for DT descriptors
425 *
426 * SYNOPSIS
427 *
428 * FUNCTION
429 *
430 * INPUTS
431 *
432 * RETURNS
433 *
434 * EXAMPLE
435 *
436 * SEE ALSO
437 *
438 ******************************************************************************
439 *
440 */
441
442 void ScanDirectory(struct StackVars *sv, STRPTR pattern)
443 {
444 struct AnchorPath *AnchorPath;
445 LONG RetVal;
446 BPTR OldDir;
447
448 if((AnchorPath = (struct AnchorPath *)AllocVec(sizeof(struct AnchorPath),
449 MEMF_CLEAR)))
450 {
451 AnchorPath->ap_BreakBits = SIGBREAKF_CTRL_C;
452
453 RetVal = MatchFirst(pattern, AnchorPath);
454
455 while(!RetVal)
456 {
457 if(CheckSignal(SIGBREAKF_CTRL_C))
458 {
459 if(!AA.aa_Quiet)
460 {
461 PrintFault(ERROR_BREAK, NULL);
462 }
463
464 break;
465 }
466
467 if(AnchorPath->ap_Info.fib_DirEntryType > 0L)
468 {
469 if(!(AnchorPath->ap_Flags & APF_DIDDIR))
470 {
471 AnchorPath->ap_Flags |= APF_DODIR;
472 }
473
474 AnchorPath->ap_Flags &= ~APF_DIDDIR;
475 }
476 else
477 {
478 if(!MatchPatternNoCase(ExclPat,
479 AnchorPath->ap_Info.fib_FileName))
480 {
481 OldDir = CurrentDir(AnchorPath->ap_Current->an_Lock);
482
483 LoadDatatype(sv, AnchorPath->ap_Info.fib_FileName);
484
485 CurrentDir(OldDir);
486 }
487 }
488
489 RetVal = MatchNext(AnchorPath);
490 }
491
492 if(RetVal != ERROR_NO_MORE_ENTRIES)
493 {
494 if(!AA.aa_Quiet)
495 {
496 PrintFault(RetVal, NULL);
497 }
498 }
499
500 MatchEnd(AnchorPath);
501
502 FreeVec((APTR)AnchorPath);
503 }
504 }
505
506
507 /****** AddDatatypes/CreateDTList *********************************************
508 *
509 * NAME
510 * CreateDTList - Create and initialize the DataTypesList
511 *
512 * SYNOPSIS
513 *
514 * FUNCTION
515 *
516 * INPUTS
517 *
518 * RETURNS
519 *
520 * EXAMPLE
521 *
522 * SEE ALSO
523 *
524 ******************************************************************************
525 *
526 */
527
528 struct DataTypesList *CreateDTList(struct StackVars *sv)
529 {
530 struct DataTypesList *dtl = NULL;
531 struct NamedObject *no = NULL;
532 struct Library *DTBase;
533
534 /* We do this in order to force datatypes.library to get
535 loaded and initialized. During this process it will
536 create and install datatypes list object in memory. */
537 DTBase = OpenLibrary("datatypes.library", 0);
538 if (DTBase)
539 CloseLibrary(DTBase);
540
541 if((no = FindNamedObject(NULL, DATATYPESLIST, NULL)))
542 {
543 dtl = (struct DataTypesList*)no->no_Object;
544 }
545
546 if(dtl)
547 {
548 if(!__FindNameNoCase(sv, &dtl->dtl_BinaryList, "binary"))
549 {
550 CreateBasicType
551 (
552 sv, &dtl->dtl_BinaryList, &dtl->dtl_SortedList,
553 "binary", DTF_BINARY, ID_BINARY, GID_SYSTEM
554 );
555 }
556
557 if(!__FindNameNoCase(sv, &dtl->dtl_ASCIIList, "ascii"))
558 {
559 CreateBasicType
560 (
561 sv, &dtl->dtl_ASCIIList, &dtl->dtl_SortedList,
562 "ascii", DTF_ASCII, ID_ASCII, GID_TEXT
563 );
564 }
565
566 if(!__FindNameNoCase(sv, &dtl->dtl_IFFList, "iff"))
567 {
568 CreateBasicType
569 (
570 sv, &dtl->dtl_IFFList, &dtl->dtl_SortedList,
571 "iff", DTF_IFF, ID_IFF, GID_SYSTEM
572 );
573 }
574
575 if(!__FindNameNoCase(sv, &dtl->dtl_MiscList, "directory"))
576 {
577 CreateBasicType
578 (
579 sv, &dtl->dtl_MiscList, &dtl->dtl_SortedList,
580 "directory", DTF_MISC, ID_DIRECTORY, GID_SYSTEM
581 );
582 }
583 }
584
585 if(no)
586 {
587 ReleaseNamedObject(no);
588 }
589
590
591 return dtl;
592 }
593
594
595
596 /****** AddDatatypes/CreateBasicType ******************************************
597 *
598 * NAME
599 * CreateBasicType - Initialize one of the basic types
600 *
601 * SYNOPSIS
602 *
603 * FUNCTION
604 *
605 * INPUTS
606 *
607 * RETURNS
608 *
609 * EXAMPLE
610 *
611 * SEE ALSO
612 *
613 ******************************************************************************
614 *
615 */
616
617 struct CompoundDatatype *CreateBasicType(struct StackVars *sv,
618 struct List *list,
619 struct List *globallist, STRPTR name,
620 UWORD Flags, ULONG ID, ULONG GroupID)
621 {
622 struct CompoundDatatype *cdt;
623 ULONG AllocLen = sizeof(struct CompoundDatatype) + strlen(name) + 1;
624
625 if((cdt = AllocVec(AllocLen, MEMF_PUBLIC | MEMF_CLEAR)))
626 {
627 cdt->DT.dtn_Header = &cdt->DTH;
628
629 strcpy((UBYTE*)(cdt + 1), name);
630
631 cdt->DTH.dth_Name=
632 cdt->DTH.dth_BaseName=
633 cdt->DT.dtn_Node1.ln_Name=
634 cdt->DT.dtn_Node2.ln_Name=(UBYTE*)(cdt + 1);
635
636 cdt->DTH.dth_GroupID = GroupID;
637 cdt->DTH.dth_ID = ID;
638
639 cdt->DTH.dth_Flags = Flags;
640
641 NewList(&cdt->DT.dtn_ToolList);
642
643 cdt->DT.dtn_Length = AllocLen;
644
645 AddTail(list, &cdt->DT.dtn_Node1);
646
647 AlphaInsert(sv, globallist, &cdt->DT.dtn_Node2);
648 }
649
650 return cdt;
651 }
652
653
654
655 /****** AddDatatypes/LoadDatatype *********************************************
656 *
657 * NAME
658 * LoadDatatype - Load and install a single datatype descriptor
659 *
660 * SYNOPSIS
661 *
662 * FUNCTION
663 *
664 * INPUTS
665 *
666 * RETURNS
667 *
668 * EXAMPLE
669 *
670 * SEE ALSO
671 *
672 ******************************************************************************
673 *
674 */
675
676 void LoadDatatype(struct StackVars *sv, STRPTR name)
677 {
678 struct IFFHandle *iff;
679
680 if((iff = AllocIFF()))
681 {
682 if((iff->iff_Stream = (IPTR)Open(name, MODE_OLDFILE))) /* Why IPTR? */
683 {
684 InitIFFasDOS(iff);
685
686 if(!OpenIFF(iff, IFFF_READ))
687 {
688 if(!PropChunks(iff, PropArray, NUM_PROP))
689 {
690 if(!CollectionChunks(iff, CollArray, NUM_COLL))
691 {
692 if(!StopOnExit(iff, ID_DTYP, ID_FORM))
693 {
694 LONG error;
695
696 while((error = ParseIFF(iff, IFFPARSE_SCAN)) == IFFERR_EOC)
697 {
698 CreateDatatype(sv, iff);
699 /* FIXME: The while ParseIFF loop here crashes the 2nd time inside the loop, therefore the break below as temp fix */
700 break;
701 }
702 }
703 }
704 }
705
706 CloseIFF(iff);
707 }
708
709 Close((BPTR)iff->iff_Stream);
710 }
711
712 FreeIFF(iff);
713 }
714 else
715 {
716 SetIoErr(ERROR_NO_FREE_STORE);
717 }
718 }
719
720
721 /****** AddDatatypes/MemStreamHook *******************************************
722 *
723 * NAME
724 * MemStreamHook - needed by ReadStruct
725 *
726 * SYNOPSIS
727 *
728 * FUNCTION
729 *
730 * INPUTS
731 *
732 * RETURNS
733 *
734 * EXAMPLE
735 *
736 * SEE ALSO
737 *
738 ******************************************************************************
739 *
740 */
741
742 LONG MemStreamHook(struct Hook * hook, UBYTE **memptr, Msg msg)
743 {
744 LONG rc;
745
746 switch (msg->MethodID)
747 {
748 case BEIO_READ:
749 rc = **memptr;
750 (*memptr)++;
751 break;
752
753 default:
754 rc = -1;
755 break;
756 }
757
758 return rc;
759 }
760
761 /****** AddDatatypes/CreateDatatype *******************************************
762 *
763 * NAME
764 * CreateDatatype - create a datatype from IFF chunks
765 *
766 * SYNOPSIS
767 *
768 * FUNCTION
769 *
770 * INPUTS
771 *
772 * RETURNS
773 *
774 * EXAMPLE
775 *
776 * SEE ALSO
777 *
778 ******************************************************************************
779 *
780 */
781
782 struct CompoundDatatype *CreateDatatype(struct StackVars *sv,
783 struct IFFHandle *iff)
784 {
785 struct CompoundDatatype *cdt = NULL;
786 struct StoredProperty *prop;
787 ULONG AllocLen;
788 UBYTE *func;
789 LONG DefaultStack = AROS_STACKSIZE, i;
790 BPTR SegList;
791
792 if((prop = FindProp(iff, ID_DTYP, ID_DTHD)))
793 {
794 AllocLen = sizeof(struct CompoundDatatype) -
795 32 + /* was sizeof(struct DataTypeHeader), but we must use struct size as it would be on Amiga */
796 prop->sp_Size;
797
798 if(!(cdt = AllocVec(AllocLen, MEMF_PUBLIC | MEMF_CLEAR)))
799 {
800 SetIoErr(ERROR_NO_FREE_STORE);
801 }
802 else
803 {
804 struct FileDataTypeHeader *fdh;
805 UBYTE *memptr = (UBYTE *)prop->sp_Data;
806 struct Hook hook;
807
808 hook.h_Entry = (HOOKFUNC)HookEntry;
809 hook.h_SubEntry = (HOOKFUNC)MemStreamHook;
810
811 if (ReadStruct(&hook, (APTR *) &fdh, &memptr, FileDataTypeHeaderDesc))
812 {
813 IPTR extraoffset = sizeof(struct DataTypeHeader) - 32;
814
815 cdt->DT.dtn_Header= &cdt->DTH;
816
817 cdt->DTH.dth_Name = (STRPTR)(fdh->fdth_NameOffset + extraoffset + (IPTR)&cdt->DTH);
818 cdt->DTH.dth_BaseName = (STRPTR)(fdh->fdth_BaseNameOffset + extraoffset + (IPTR)&cdt->DTH);
819 cdt->DTH.dth_Pattern = (STRPTR)(fdh->fdth_PatternOffset + extraoffset + (IPTR)&cdt->DTH);
820 cdt->DTH.dth_Mask = (WORD *)(fdh->fdth_MaskOffset + extraoffset + (IPTR)&cdt->DTH);
821 cdt->DTH.dth_GroupID = fdh->fdth_GroupID;
822 cdt->DTH.dth_ID = fdh->fdth_ID;
823 cdt->DTH.dth_MaskLen = fdh->fdth_MaskLen;
824 cdt->DTH.dth_Pad = fdh->fdth_Pad;
825 cdt->DTH.dth_Flags = fdh->fdth_Flags;
826 cdt->DTH.dth_Priority = fdh->fdth_Priority;
827
828 CopyMem(prop->sp_Data + 32, cdt + 1, prop->sp_Size - 32);
829
830 for(i = 0; i < cdt->DTH.dth_MaskLen; i++)
831 {
832 cdt->DTH.dth_Mask[i] = AROS_BE2WORD(cdt->DTH.dth_Mask[i]);
833 #if 0
834 kprintf("mask[%d] = %04x (%c %c)\n", i,
835 cdt->DTH.dth_Mask[i],
836 cdt->DTH.dth_Mask[i] & 255,
837 (cdt->DTH.dth_Mask[i] >> 8) & 255);
838 #endif
839 }
840
841 #if 0
842 kprintf("groupid = %c%c%c%c\n", cdt->DTH.dth_GroupID >> 24,
843 cdt->DTH.dth_GroupID >> 16,
844 cdt->DTH.dth_GroupID >> 8,
845 cdt->DTH.dth_GroupID);
846 kprintf("id = %c%c%c%c\n", cdt->DTH.dth_ID >> 24,
847 cdt->DTH.dth_ID >> 16,
848 cdt->DTH.dth_ID >> 8,
849 cdt->DTH.dth_ID);
850 kprintf("flags = %x\n", cdt->DTH.dth_Flags);
851 kprintf("pri = %d\n", cdt->DTH.dth_Priority);
852 kprintf("name = %s\n", cdt->DTH.dth_Name);
853 kprintf("basename = %s\n", cdt->DTH.dth_BaseName);
854 kprintf("pattern = %s\n", cdt->DTH.dth_Pattern);
855 kprintf("masklen = %d\n", cdt->DTH.dth_MaskLen);
856 #endif
857
858 NewList(&cdt->DT.dtn_ToolList);
859
860 cdt->DT.dtn_Length = AllocLen;
861
862 if((prop = FindProp(iff, ID_DTYP, ID_DTCD)))
863 {
864 if((func = AllocVec(prop->sp_Size, MEMF_PUBLIC | MEMF_CLEAR)))
865 {
866 cdt->DTCDChunk = func;
867 cdt->DTCDSize = prop->sp_Size;
868
869 CopyMem(prop->sp_Data,func,prop->sp_Size);
870
871 HookBuffer = cdt->DTCDChunk;
872 HookBufSize = cdt->DTCDSize;
873 HookPosition = 0;
874
875 /* We use a cast to BPTR, since sv may not
876 * be ULONG aligned. Since only our ReadFunc
877 * is going to be looking at it, this is ok.
878 */
879 if((SegList = InternalLoadSeg((BPTR)(sv), BNULL,
880 (LONG_FUNC *)FunctionArray,
881 &DefaultStack)))
882 {
883 cdt->SegList = SegList;
884 cdt->Function = BADDR(SegList) + sizeof(BPTR);
885 }
886
887 } /* if((func = AllocVec(prop->sp_Size, MEMF_PUBLIC | MEMF_CLEAR))) */
888
889 } /* if((prop = FindProp(iff, ID_DTYP, ID_DTCD))) */
890
891 cdt = AddDatatype(sv, cdt);
892
893 FreeStruct(fdh, FileDataTypeHeaderDesc);
894
895 } /* if (ReadStruct(&hook, &fdh, &memptr, FileDataTypeHeaderDesc)) */
896
897 } /* cdt AllocVec okay */
898
899 } /* if((prop = FindProp(iff, ID_DTYP, ID_DTHD))) */
900
901 return cdt;
902 }
903
904
905
906 /****** AddDatatypes/AddDatatype **********************************************
907 *
908 * NAME
909 * AddDatatype - add a datatype to the system
910 *
911 * SYNOPSIS
912 *
913 * FUNCTION
914 *
915 * This subroutine tries to add a datatype to the system datatypes
916 * list. If the datatype already exists, it will be replaced or
917 * updated. In case of an error, the CompoundDatatype will be deleted
918 * and a NULL pointer is returned.
919 *
920 * The CompoundDatatype pointer you passed in will be invalid after
921 * calling this function. Use the returned handle instead.
922 * DO NOT USE THE OLD POINTER IN ANY MORE!
923 *
924 * INPUTS
925 *
926 * RETURNS
927 *
928 * A pointer to a CompoundDatatype in the system datatypes list
929 * or a NULL pointer for failure
930 *
931 * EXAMPLE
932 *
933 * SEE ALSO
934 *
935 ******************************************************************************
936 *
937 */
938
939 struct CompoundDatatype *AddDatatype(struct StackVars *sv,
940 struct CompoundDatatype *cdt)
941 {
942 struct List *typelist;
943 BOOL Success = FALSE;
944 ULONG AllocSize;
945 ULONG result;
946 struct CompoundDatatype *oldcdt;
947
948 switch(cdt->DTH.dth_Flags & DTF_TYPE_MASK)
949 {
950 case DTF_BINARY: typelist= &DTList->dtl_BinaryList; break;
951 case DTF_ASCII: typelist= &DTList->dtl_ASCIIList; break;
952 case DTF_IFF: typelist= &DTList->dtl_IFFList; break;
953 case DTF_MISC: typelist= &DTList->dtl_MiscList; break;
954 default: typelist= NULL;
955 }
956
957 if(typelist)
958 {
959 cdt->DT.dtn_Node1.ln_Name = cdt->DT.dtn_Node2.ln_Name = cdt->DTH.dth_Name;
960
961 Success = TRUE;
962
963 if((!Stricmp(cdt->DTH.dth_Pattern, "#?")) ||
964 (!strlen(cdt->DTH.dth_Pattern)) )
965 {
966 cdt->FlagLong |= CFLGF_PATTERN_UNUSED;
967 }
968 else
969 {
970 cdt->FlagLong &= ~(CFLGF_PATTERN_UNUSED);
971
972 AllocSize = 2*strlen(cdt->DTH.dth_Pattern) + 2;
973
974 if(!(cdt->ParsePatMem = AllocVec(AllocSize,
975 MEMF_PUBLIC | MEMF_CLEAR)))
976 {
977 Success = FALSE;
978 }
979 else
980 {
981 cdt->ParsePatSize = AllocSize;
982
983 result = ParsePatternNoCase(cdt->DTH.dth_Pattern,
984 cdt->ParsePatMem, AllocSize);
985
986 if(result == 1)
987 {
988 cdt->FlagLong |= CFLGF_IS_WILD;
989 }
990 else
991 {
992 FreeVec(cdt->ParsePatMem);
993 cdt->ParsePatMem = NULL;
994 cdt->ParsePatSize = 0;
995
996 if(result == 0)
997 {
998 cdt->FlagLong &= ~(CFLGF_IS_WILD);
999 }
1000 else
1001 {
1002 Success = FALSE;
1003 }
1004 }
1005 }
1006 }
1007
1008 if (Success)
1009 {
1010 if((oldcdt = (struct CompoundDatatype*)__FindNameNoCase(sv,
1011 typelist,
1012 cdt->DT.dtn_Node1.ln_Name)))
1013 {
1014 if (oldcdt->OpenCount)
1015 {
1016 Success = FALSE;
1017 }
1018 else
1019 {
1020 if((Stricmp(oldcdt->DTH.dth_Name, cdt->DTH.dth_Name)) ||
1021 (Stricmp(oldcdt->DTH.dth_BaseName, cdt->DTH.dth_BaseName)) ||
1022 (Stricmp(oldcdt->DTH.dth_Pattern, cdt->DTH.dth_Pattern)) ||
1023 (oldcdt->DTH.dth_Flags != cdt->DTH.dth_Flags) ||
1024 (oldcdt->DTH.dth_Priority != cdt->DTH.dth_Priority) ||
1025 (oldcdt->DTH.dth_MaskLen != cdt->DTH.dth_MaskLen))
1026 {
1027 DeleteDatatype(sv, oldcdt);
1028 oldcdt = NULL;
1029 }
1030 else
1031 {
1032 oldcdt->DTH.dth_GroupID = cdt->DTH.dth_GroupID;
1033 oldcdt->DTH.dth_ID = cdt->DTH.dth_ID;
1034 CopyMem(cdt->DTH.dth_Mask,cdt->DTH.dth_Mask,
1035 (ULONG)(sizeof(WORD)*cdt->DTH.dth_MaskLen));
1036 }
1037 }
1038 }
1039
1040 if(Success)
1041 {
1042 if(oldcdt)
1043 {
1044 DeleteDatatype(sv, cdt);
1045 cdt = oldcdt;
1046 }
1047 else
1048 {
1049 if(cdt->DT.dtn_FunctionName)
1050 {
1051 LONG DefaultStack = 4096;
1052 BPTR file;
1053 ULONG AllocLen;
1054 BPTR SegList;
1055
1056 if((file = Open(cdt->DT.dtn_FunctionName, MODE_OLDFILE)))
1057 {
1058 if(Seek(file, 0, OFFSET_END) >= 0)
1059 {
1060 if((AllocLen = Seek(file, 0,
1061 OFFSET_BEGINNING)) > 0)
1062 {
1063 if((cdt->DTCDChunk = AllocVec(AllocLen,
1064 MEMF_PUBLIC | MEMF_CLEAR)))
1065 {
1066 cdt->DTCDSize = AllocLen;
1067
1068 if(Read(file, cdt->DTCDChunk, AllocLen) == AllocLen)
1069 {
1070 HookBuffer = cdt->DTCDChunk;
1071 HookBufSize = cdt->DTCDSize;
1072 HookPosition = 0;
1073
1074 /* We use a cast to BPTR, since sv may not
1075 * be ULONG aligned. Since only our ReadFunc
1076 * is going to be looking at it, this is ok.
1077 */
1078 if((SegList = InternalLoadSeg((BPTR)(sv), BNULL, (LONG_FUNC *)FunctionArray, &DefaultStack)))
1079 {
1080 cdt->SegList = SegList;
1081 cdt->Function = BADDR(SegList) + sizeof(BPTR); // FIXME: is this portable?
1082 }
1083 }
1084 else
1085 {
1086 FreeVec(cdt->DTCDChunk);
1087 cdt->DTCDChunk = NULL;
1088 cdt->DTCDSize = 0;
1089 }
1090 }
1091 }
1092 }
1093 }
1094 cdt->DT.dtn_FunctionName=NULL;
1095 }
1096
1097 if(cdt->DTH.dth_MaskLen > DTList->dtl_LongestMask)
1098 {
1099 DTList->dtl_LongestMask = cdt->DTH.dth_MaskLen;
1100 }
1101
1102 PrioInsert(sv, typelist, cdt);
1103
1104 AlphaInsert(sv, &DTList->dtl_SortedList, &cdt->DT.dtn_Node2);
1105 }
1106 }
1107 }
1108 }
1109
1110 if(!Success)
1111 {
1112 DeleteDatatype(sv, cdt);
1113 cdt = NULL;
1114 }
1115
1116 return cdt;
1117 }
1118
1119
1120
1121 /****** AddDatatypes/DeleteDatatype *******************************************
1122 *
1123 * NAME
1124 * DeleteDatatype - unlink and deallocate a CompoundDatatype structure
1125 *
1126 * SYNOPSIS
1127 *
1128 * FUNCTION
1129 *
1130 * INPUTS
1131 *
1132 * RETURNS
1133 *
1134 * EXAMPLE
1135 *
1136 * SEE ALSO
1137 *
1138 ******************************************************************************
1139 *
1140 */
1141
1142 void DeleteDatatype(struct StackVars *sv, struct CompoundDatatype *cdt)
1143 {
1144 if(cdt)
1145 {
1146 if(cdt->ParsePatMem)
1147 {
1148 FreeVec(cdt->ParsePatMem);
1149 cdt->ParsePatMem = NULL;
1150 cdt->ParsePatSize = 0;
1151 }
1152
1153 if(cdt->DTCDChunk)
1154 {
1155 FreeVec(cdt->DTCDChunk);
1156 cdt->DTCDChunk = NULL;
1157 cdt->DTCDSize = 0;
1158 }
1159
1160 if(cdt->SegList)
1161 {
1162 UnLoadSeg(cdt->SegList);
1163 cdt->SegList = BNULL;
1164 cdt->Function = NULL;
1165 }
1166
1167 if(cdt->DT.dtn_Node1.ln_Succ && cdt->DT.dtn_Node1.ln_Pred)
1168 {
1169 Remove(&cdt->DT.dtn_Node1);
1170 Remove(&cdt->DT.dtn_Node2);
1171 cdt->DT.dtn_Node1.ln_Succ = cdt->DT.dtn_Node1.ln_Pred =
1172 cdt->DT.dtn_Node2.ln_Succ = cdt->DT.dtn_Node2.ln_Pred = NULL;
1173 }
1174
1175 FreeVec(cdt);
1176 }
1177 }
1178
1179
1180
1181 /****** AddDatatypes/AlphaInsert **********************************************
1182 *
1183 * NAME
1184 * AlphaInsert - enqueue a node alphabetically into a list
1185 *
1186 * SYNOPSIS
1187 *
1188 * FUNCTION
1189 *
1190 * INPUTS
1191 *
1192 * RETURNS
1193 *
1194 * EXAMPLE
1195 *
1196 * SEE ALSO
1197 *
1198 ******************************************************************************
1199 *
1200 */
1201
1202 void AlphaInsert(struct StackVars *sv, struct List *list, struct Node *node)
1203 {
1204 struct Node *cur,*prev=NULL;
1205
1206 for(cur = list->lh_Head; cur->ln_Succ; prev = cur, cur = cur->ln_Succ)
1207 {
1208 if(Stricmp(cur->ln_Name, node->ln_Name) > 0)
1209 break;
1210 }
1211
1212 Insert(list, node, prev);
1213 }
1214
1215
1216
1217 /****** AddDatatypes/PrioInsert **********************************************
1218 *
1219 * NAME
1220 * PrioInsert - enqueue a CompoundDatatype correctly in the type list
1221 *
1222 * SYNOPSIS
1223 *
1224 * FUNCTION
1225 *
1226 * INPUTS
1227 *
1228 * RETURNS
1229 *
1230 * EXAMPLE
1231 *
1232 * SEE ALSO
1233 *
1234 ******************************************************************************
1235 *
1236 */
1237
1238 void PrioInsert(struct StackVars *sv, struct List *list,
1239 struct CompoundDatatype *cdt)
1240 {
1241 struct CompoundDatatype *cur, *prev = NULL;
1242 WORD diff;
1243
1244 for(cur = (struct CompoundDatatype*)list->lh_Head;
1245 cur->DT.dtn_Node1.ln_Succ;
1246 prev = cur, cur = (struct CompoundDatatype*)cur->DT.dtn_Node1.ln_Succ)
1247 {
1248 diff = (cdt->Function ? 1 : 0) - (cur->Function ? 1 : 0);
1249
1250 if(diff > 0)
1251 break;
1252
1253 if(!diff)
1254 {
1255 UWORD MinMask = (cdt->DTH.dth_MaskLen < cur->DTH.dth_MaskLen) ?
1256 cdt->DTH.dth_MaskLen : cur->DTH.dth_MaskLen;
1257 WORD *cdtmask = cdt->DTH.dth_Mask;
1258 WORD *curmask=cur->DTH.dth_Mask;
1259
1260 while(!diff && MinMask--)
1261 diff= *(curmask++) - *(cdtmask++);
1262
1263 if(diff > 0)
1264 break;
1265
1266 if(!diff)
1267 {
1268 diff = cdt->DTH.dth_MaskLen - cur->DTH.dth_MaskLen;
1269
1270 if(diff > 0)
1271 break;
1272
1273 if(!diff)
1274 {
1275 diff = (((cdt->FlagLong & CFLGF_PATTERN_UNUSED) || cdt->DTH.dth_Pattern==NULL) ? 0 : 1) -
1276 (((cur->FlagLong & CFLGF_PATTERN_UNUSED) || cur->DTH.dth_Pattern==NULL) ? 0 : 1);
1277
1278 if(diff > 0)
1279 break;
1280
1281 if(!diff)
1282 {
1283 diff = cdt->DTH.dth_Priority - cur->DTH.dth_Priority;
1284
1285 if(diff > 0)
1286 break;
1287 }
1288 }
1289 }
1290 }
1291 }
1292
1293 Insert(list, &cdt->DT.dtn_Node1, (struct Node *)prev);
1294 }
1295
1296
1297
1298 /****** AddDatatypes/__FindNameNoCase *****************************************
1299 *
1300 * NAME
1301 * __FindNameNoCase - find a node in a list (case insensitive)
1302 *
1303 * SYNOPSIS
1304 *
1305 * FUNCTION
1306 *
1307 * INPUTS
1308 *
1309 * RETURNS
1310 *
1311 * EXAMPLE
1312 *
1313 * SEE ALSO
1314 *
1315 ******************************************************************************
1316 *
1317 */
1318
1319 struct Node *__FindNameNoCase(struct StackVars *sv, struct List *list,
1320 STRPTR name)
1321 {
1322 struct Node *node;
1323 struct Node *result = NULL;
1324
1325 for(node = list->lh_Head; node->ln_Succ; node = node->ln_Succ)
1326 {
1327 if(!Stricmp(node->ln_Name, name))
1328 {
1329 result = node;
1330 break;
1331 }
1332 }
1333
1334 return result;
1335 }
1336
1337
1338
1339 /****** AddDatatypes/ReadFunc *************************************************
1340 *
1341 * NAME
1342 * ReadFunc - data read hook for InternalLoadSeg
1343 *
1344 * SYNOPSIS
1345 *
1346 * FUNCTION
1347 *
1348 * INPUTS
1349 *
1350 * RETURNS
1351 *
1352 * EXAMPLE
1353 *
1354 * SEE ALSO
1355 *
1356 ******************************************************************************
1357 *
1358 */
1359
1360 AROS_UFH4(LONG, AROS_SLIB_ENTRY(ReadFunc, AddDatatypes, 0),
1361 AROS_UFHA(BPTR , fh , D1),
1362 AROS_UFHA(void * , buffer , D2),
1363 AROS_UFHA(LONG , length , D3),
1364 AROS_UFHA(struct DosLibrary *, DOSBase, A6))
1365 {
1366 AROS_USERFUNC_INIT
1367
1368 struct StackVars *sv = (APTR)fh;
1369 LONG maxlen = HookBufSize-HookPosition;
1370 LONG actual = length > maxlen ? maxlen : length;
1371
1372 CopyMem(HookBuffer+HookPosition, buffer, actual);
1373
1374 HookPosition += actual;
1375
1376 return actual;
1377
1378 AROS_USERFUNC_EXIT
1379 }
1380
1381 /****** AddDatatypes/SeekFunc *************************************************
1382 *
1383 * NAME
1384 * SeekFunc - seek hook for InternalLoadSeg (ELF only)
1385 *
1386 * SYNOPSIS
1387 *
1388 * FUNCTION
1389 *
1390 * INPUTS
1391 *
1392 * RETURNS
1393 *
1394 * EXAMPLE
1395 *
1396 * SEE ALSO
1397 *
1398 ******************************************************************************
1399 *
1400 */
1401
1402 AROS_UFH4(LONG, AROS_SLIB_ENTRY(SeekFunc, AddDatatypes, 0),
1403 AROS_UFHA(BPTR , fh , D1),
1404 AROS_UFHA(LONG , pos , D2),
1405 AROS_UFHA(LONG , mode , D3),
1406 AROS_UFHA(struct DosLibrary *, DOSBase, A6))
1407 {
1408 AROS_USERFUNC_INIT
1409
1410 struct StackVars *sv = (APTR)fh;
1411 LONG oldpos = HookPosition;
1412
1413 switch (mode) {
1414 case OFFSET_BEGINNING: break;
1415 case OFFSET_END: pos = HookBufSize - pos; break;
1416 case OFFSET_CURRENT: pos = HookPosition + pos; break;
1417 default: return -1;
1418 }
1419
1420 if (pos < 0 || pos >= HookBufSize)
1421 return -1;
1422
1423 HookPosition = pos;
1424
1425 return oldpos;
1426
1427 AROS_USERFUNC_EXIT
1428 }
1429
1430 /****** AddDatatypes/AllocFunc ************************************************
1431 *
1432 * NAME
1433 * AllocFunc - memory allocation hook for InternalLoadSeg
1434 *
1435 * SYNOPSIS
1436 *
1437 * FUNCTION
1438 *
1439 * INPUTS
1440 *
1441 * RETURNS
1442 *
1443 * EXAMPLE
1444 *
1445 * SEE ALSO
1446 *
1447 ******************************************************************************
1448 *
1449 */
1450
1451 AROS_UFH3(UBYTE *, AROS_SLIB_ENTRY(AllocFunc, AddDatatypes, 0),
1452 AROS_UFHA(ULONG, size, D0),
1453 AROS_UFHA(ULONG, flags,D1),
1454 AROS_UFHA(struct DosLibrary *, DOSBase, A6))
1455 {
1456 AROS_USERFUNC_INIT
1457
1458 return(AllocMem(size, flags));
1459
1460 AROS_USERFUNC_EXIT
1461 }
1462
1463
1464
1465 /****** AddDatatypes/FreeFunc *************************************************
1466 *
1467 * NAME
1468 * FreeFunc - memory freeing hook for InternalLoadSeg
1469 *
1470 * SYNOPSIS
1471 *
1472 * FUNCTION
1473 *
1474 * INPUTS
1475 *
1476 * RETURNS
1477 *
1478 * EXAMPLE
1479 *
1480 * SEE ALSO
1481 *
1482 ******************************************************************************
1483 *
1484 */
1485
1486 AROS_UFH3(void, AROS_SLIB_ENTRY(FreeFunc, AddDatatypes, 0),
1487 AROS_UFHA(APTR , memory, A1),
1488 AROS_UFHA(ULONG, size , D0),
1489 AROS_UFHA(struct DosLibrary *, DOSBase, A6))
1490 {
1491 AROS_USERFUNC_INIT
1492
1493 FreeMem(memory, size);
1494
1495 AROS_USERFUNC_EXIT
1496 }
1497
1498
1499
1500 /******************************* STUB ROUTINES ********************************/
1501
1502 struct NamedObject *allocnamedobject(struct StackVars *sv, STRPTR name,
1503 Tag FirstTag, ...)
1504 {
1505 return AllocNamedObjectA(name, (struct TagItem*)&FirstTag);
1506 }
Mirror of AROS' svn.