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