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