void InitThinkers(void) { ResetPlats(); /* Reset the platforms */ ResetCeilings(); /* Reset the ceilings */ if (mobjhead.next) { /* Initialized before? */ mobj_t *m,*NextM; m=mobjhead.next; while (m!=&mobjhead) { /* Any player object */ NextM = m->next; /* Get the next record */ DeallocAPointer(m); /* Delete the object from the list */ m=NextM; } } if (thinkercap.next) { thinker_t *t,*NextT; t = thinkercap.next; while (t!=&thinkercap) { /* Is there a think struct here? */ NextT = t->next; DeallocAPointer(t); /* Delete it from memory */ t = NextT; } } thinkercap.prev = thinkercap.next = &thinkercap; /* Loop around */ mobjhead.next = mobjhead.prev = &mobjhead; /* Loop around */ }
void BURGERCALL vorbis_comment_clear(vorbis_comment *vc){ if(vc){ long i; for(i=0;i<vc->comments;i++) if(vc->user_comments[i])DeallocAPointer(vc->user_comments[i]); if(vc->user_comments)DeallocAPointer(vc->user_comments); if(vc->comment_lengths)DeallocAPointer(vc->comment_lengths); if(vc->vendor)DeallocAPointer(vc->vendor); } FastMemSet(vc,0,sizeof(*vc)); }
void BURGERCALL JoystickDestroy(void) { MacInput_t *LocalPtr; LocalPtr = &MacInputLocals; MacInputDestroy(LocalPtr,MACINITINPUTJOYSTICK); DeallocAPointer(LocalPtr->JoystickDescriptionsArray); /* Release the input sources */ DeallocAPointer(LocalPtr->JoystickDeviceArray); /* Release the devices */ LocalPtr->JoystickDescriptionsArray = 0; LocalPtr->JoystickDeviceArray = 0; JoystickPresent = 0; /* No joysticks are present */ }
void BURGERCALL RedbookDelete(Redbook_t *Input) { if (Input) { RedbookDestroy(Input); /* Discard the contents */ DeallocAPointer(Input); /* Dispose of the pointer */ } }
void BURGERCALL LinkedListDeleteEntry(LinkedList_t *Input,LinkedListEntry_t *EntryPtr) { LinkedListEntry_t *Next; LinkedListEntry_t *Prev; Next = EntryPtr->Next; /* Prefetch the next entry */ Prev = EntryPtr->Prev; /* Prefetch the prev entry */ Input->Count--; /* 1 less */ if (Input->First == EntryPtr) { /* Was this the first one? */ Input->First = Next; /* Set the new root */ } if (Input->Last == EntryPtr) { /* Was this the last one? */ Input->Last = Prev; /* Set the new tail */ } if (Prev) { /* Shall I unlink? */ Prev->Next = Next; /* Set the new next link */ } if (Next) { Next->Prev = Prev; /* Set the new prev link */ } /* Now kill the data if needed */ if (EntryPtr->KillProc) { /* Is there a destructor? */ EntryPtr->KillProc(EntryPtr); /* Call the proc */ } else { DeallocAPointer(EntryPtr); /* Kill the entry itself */ } }
void BURGERCALL LinkedListDelete(LinkedList_t *Input) { if (Input) { LinkedListDestroy(Input); /* Kill the list */ DeallocAPointer(Input); /* Dispose of the structure */ } }
void PurgeLineSpecials(void) { if (linespeciallist) { /* Is there a valid pointer? */ DeallocAPointer(linespeciallist); /* Release it */ linespeciallist = 0; numlinespecials = 0; /* No lines */ } }
void BURGERCALL vorbis_comment_add_tag(vorbis_comment *vc, char *tag, char *contents){ char *comment=static_cast<char *>(AllocAPointer(strlen(tag)+strlen(contents)+2)); /* +2 for = and \0 */ strcpy(comment, tag); strcat(comment, "="); strcat(comment, contents); vorbis_comment_add(vc, comment); DeallocAPointer(comment); }
static void RemoveMeThink(thinker_t *Current) { thinker_t *Next; thinker_t *Prev; --Current; /* Index to the REAL pointer */ Next = Current->next; Prev = Current->prev; Next->prev = Prev; /* Unlink it */ Prev->next = Next; DeallocAPointer(Current); /* Release the memory */ }
void BURGERCALL MADSndClose(MADDriverRec *inMADDriver) { if (inMADDriver->MusicChannelPP) { SndDisposeChannel(inMADDriver->MusicChannelPP,TRUE); inMADDriver->MusicChannelPP = 0; } if (inMADDriver->CallBackUPP) { DisposeSndCallBackUPP(inMADDriver->CallBackUPP); inMADDriver->CallBackUPP = 0; } DeallocAPointer(inMADDriver->SndBuffer); inMADDriver->SndBuffer = 0; }
char *BURGERCALL vorbis_comment_query(vorbis_comment *vc, char *tag, int count) { long i; int found = 0; int taglen = strlen(tag)+1; /* +1 for the = we append */ char *fulltag = static_cast<char *>(AllocAPointer(taglen+ 1)); strcpy(fulltag, tag); strcat(fulltag, "="); for(i=0;i<vc->comments;i++){ if(!tagcompare(vc->user_comments[i], fulltag, taglen)){ if(count == found) { /* We return a pointer to the data, not a copy */ DeallocAPointer(fulltag); return vc->user_comments[i] + taglen; } else { found++; } } } DeallocAPointer(fulltag); return NULL; /* didn't find anything */ }
void BURGERCALL vorbis_info_clear(vorbis_info *vi){ codec_setup_info *ci=static_cast<codec_setup_info *>(vi->codec_setup); int i; if(ci){ for(i=0;i<ci->modes;i++) if(ci->mode_param[i])DeallocAPointer(ci->mode_param[i]); for(i=0;i<ci->maps;i++) /* unpack does the range checking */ _mapping_P[ci->map_type[i]]->free_info(ci->map_param[i]); for(i=0;i<ci->times;i++) /* unpack does the range checking */ _time_P[ci->time_type[i]]->free_info(ci->time_param[i]); for(i=0;i<ci->floors;i++) /* unpack does the range checking */ _floor_P[ci->floor_type[i]]->free_info(ci->floor_param[i]); for(i=0;i<ci->residues;i++) /* unpack does the range checking */ _residue_P[ci->residue_type[i]]->free_info(ci->residue_param[i]); for(i=0;i<ci->books;i++){ if(ci->book_param[i]){ /* knows if the book was not alloced */ vorbis_staticbook_destroy(ci->book_param[i]); } } for(i=0;i<ci->psys;i++) _vi_psy_free(ci->psy_param[i]); DeallocAPointer(ci); } FastMemSet(vi,0,sizeof(*vi)); }
int BURGERCALL vorbis_comment_query_count(vorbis_comment *vc, char *tag){ int i,count=0; int taglen = strlen(tag)+1; /* +1 for the = we append */ char *fulltag = static_cast<char *>(AllocAPointer(taglen+1)); strcpy(fulltag,tag); strcat(fulltag, "="); for(i=0;i<vc->comments;i++){ if(!tagcompare(vc->user_comments[i], fulltag, taglen)) { count++; } } DeallocAPointer(fulltag); return count; }
static pascal OSErr HandleOdoc(const AEDescList *aevt, AEDescList *reply,long refCon) { AEDesc FileListDescription; DescType MyFileType; long DataSize; AEKeyword MyKeyword; FSSpec TheFileSpec; Word i; Foo_t *FooPtr; /* First, I see if any files are present */ FileListDescription.descriptorType = typeWildCard; /* Any file */ FileListDescription.dataHandle = 0; /* No handle (Yet) */ if (!AEGetKeyDesc(aevt,keyDirectObject,typeAEList,&FileListDescription)) { /* Now load each and every file */ i = 1; FooPtr = (Foo_t *)refCon; while (!AEGetNthPtr(&FileListDescription,i,typeFSS,&MyKeyword,&MyFileType,(Ptr)&TheFileSpec,sizeof(FSSpec),&DataSize)) { char CurrentName[256]; char *DirName; if (TheFileSpec.name[0]) { /* Must have some name! */ PStr2CStr(CurrentName,(char *)TheFileSpec.name); /* Convert to "C" */ TheFileSpec.name[0] = 0; /* Zap the filename */ DirName = GetFullPathFromMacFSSpec(&TheFileSpec); /* Get the directory */ if (DirName) { SetAPrefix(8,DirName); /* Set my directory */ DeallocAPointer(DirName); FooPtr->Result = FALSE; /* Hit me! */ if (FooPtr->Proc(CurrentName)) { /* Process the file */ break; } } } ++i; /* Next */ } } AEDisposeDesc(&FileListDescription); /* Release the file list */ return noErr; }
void BURGERCALL LinkedListDestroy(LinkedList_t *Input) { LinkedListEntry_t *EntryPtr; EntryPtr = Input->First; /* Is there data here? */ if (EntryPtr) { /* Yep, kill it */ do { LinkedListEntry_t *Next; Next = EntryPtr->Next; /* Prefetch the next entry */ if (EntryPtr->KillProc) { /* Is there a destructor? */ EntryPtr->KillProc(EntryPtr); /* Call the proc */ } else { DeallocAPointer(EntryPtr); } EntryPtr = Next; /* Next entry */ } while (EntryPtr); /* Any more? */ } Input->First = 0; /* Zap the data */ Input->Last = 0; Input->Count = 0; }
Word BURGERCALL JoystickInit(void) { Word32 TempLong; Word i; MacInput_t *LocalPtr; LocalPtr = &MacInputLocals; if (!MacInputInit(LocalPtr,MACINITINPUTJOYSTICK)) { /* 1.3 or better? */ /* Discard any previous data from a previous call */ /* This will allow simple rescanning */ DeallocAPointer(LocalPtr->JoystickDescriptionsArray); DeallocAPointer(LocalPtr->JoystickDeviceArray); LocalPtr->JoystickDescriptionsArray = 0; LocalPtr->JoystickDeviceArray = 0; { Word *Boundaries; i = 0; Boundaries = &JoystickBoundaries[0][0]; /* Init pointer to struct */ do { Word j; j = 0; do { Boundaries[AXISMIN] = 0x100000; /* Init center point */ Boundaries[AXISMAX] = 0xF00000; Boundaries[AXISCENTER] = 0x800000; Boundaries+=AXISENTRIES; JoystickSetDigital(j,20,i); /* Create the digital bounds */ } while (++j<AXISCOUNT); } while (++i<MAXJOYNUM); /* All of them checked? */ } MacInputLockInputSprocket(); /* Don't allow mouse/keyboard IRQ's */ if (ISpDevices_Extract(0,&TempLong,0)) { /* How many devices are present? */ goto Abort; } i = TempLong; /* Save in register */ LocalPtr->JoystickDeviceArray = (ISpDeviceReference *)AllocAPointer(sizeof(ISpDeviceReference)*i); if (!LocalPtr->JoystickDeviceArray) { /* Memory allocation error? */ goto Abort; } if (ISpDevices_Extract(i,&TempLong,LocalPtr->JoystickDeviceArray)) { /* Get the devices */ goto Abort; } /* Now remove all devices that are not mice or keyboards */ JoystickPresent = i; /* Save the device count */ if (i) { ISpDeviceReference *ArrayPtr; ISpDeviceReference *ArrayPtr2; ArrayPtr = LocalPtr->JoystickDeviceArray; ArrayPtr2 = ArrayPtr; do { ISpDeviceDefinition ResultBuf; /* Get the device definition */ if (!ISpDevice_GetDefinition(ArrayPtr[0],sizeof(ISpDeviceDefinition),&ResultBuf)) { if (ResultBuf.theDeviceClass != kISpElementLabel_None) { if ((ResultBuf.theDeviceClass != kISpDeviceClass_Mouse) && (ResultBuf.theDeviceClass != kISpDeviceClass_Keyboard)) { ArrayPtr2[0] = ArrayPtr[0]; ++ArrayPtr2; } } } ++ArrayPtr; } while (--i); JoystickPresent = ArrayPtr2-LocalPtr->JoystickDeviceArray; } /* At this point I have all the devices I am going to use. Now */ /* I will get the actual input methods and create a map for each one */ i = JoystickPresent; if (i) { Word j; JoyDesc_t *JoyDevPtr; if (i>MAXJOYNUM) { /* I can only have 4 input devices */ i = MAXJOYNUM; JoystickPresent = MAXJOYNUM; } JoyDevPtr = (JoyDesc_t *)AllocAPointerClear(sizeof(JoyDesc_t)*i); if (!JoyDevPtr) { goto Abort; } j = 0; LocalPtr->JoystickDescriptionsArray = JoyDevPtr; do { /* For each device, scan the input elements and find a burgerlib */ /* match, assign it a button, pad or axis id */ ISpElementListReference MyElementList; if (!ISpDevice_GetElementList(LocalPtr->JoystickDeviceArray[j],&MyElementList)) { Word32 ElementCount; ISpElementReference ElementBuf[500]; if (!ISpElementList_Extract(MyElementList,500,&ElementCount,ElementBuf)) { if (ElementCount) { Word TempIndex; Word FooIndex; Word AxisIndex; Word ButtonIndex; TempIndex = 0; AxisIndex = 0; /* No axis' found */ ButtonIndex = 0; /* No buttons found */ do { ISpElementInfo ElementInfo; ISpElementReference CurrentRef; CurrentRef = ElementBuf[TempIndex]; if (!ISpElement_GetInfo(CurrentRef,&ElementInfo)) { /* I've got input, what kind of input is it? */ switch (ElementInfo.theKind) { case kISpElementKind_Button: /* Simple button */ if (ButtonIndex<20) { JoyDevPtr->Elements[ButtonIndex+ELEMENTBUTTON] = CurrentRef; ++ButtonIndex; } break; /* Hat or pad */ case kISpElementKind_DPad: /* Hat/Pad */ /* If the ID is a hat, place it in the hat slot first */ if (ElementInfo.theLabel==kISpElementLabel_Pad_POV || ElementInfo.theLabel==kISpElementLabel_Pad_POV_Horiz) { if (!JoyDevPtr->Elements[ELEMENTPAD+1]) { JoyDevPtr->Elements[ELEMENTPAD+1] = CurrentRef; break; } } FooIndex = 0; do { if (!JoyDevPtr->Elements[FooIndex+ELEMENTPAD]) { JoyDevPtr->Elements[FooIndex+ELEMENTPAD] = CurrentRef; break; } } while (++FooIndex<2); break; /* Handle joystick axis' */ case kISpElementKind_Axis: /* Joystick axis */ case kISpElementKind_Delta: if (ElementInfo.theLabel==kISpElementLabel_Axis_XAxis) { if (!JoyDevPtr->Elements[ELEMENTAXIS]) { JoyDevPtr->Elements[ELEMENTAXIS] = CurrentRef; JoyDevPtr->ElementData[ELEMENTAXIS] = 0x7FFFFFFF; break; } if (!JoyDevPtr->Elements[ELEMENTAXIS+4]) { JoyDevPtr->Elements[ELEMENTAXIS+4] = CurrentRef; JoyDevPtr->ElementData[ELEMENTAXIS+4] = 0x7FFFFFFF; break; } } else if (ElementInfo.theLabel==kISpElementLabel_Axis_YAxis) { if (!JoyDevPtr->Elements[ELEMENTAXIS+1]) { JoyDevPtr->Elements[ELEMENTAXIS+1] = CurrentRef; JoyDevPtr->ElementData[ELEMENTAXIS+1] = 0x7FFFFFFF; break; } if (!JoyDevPtr->Elements[ELEMENTAXIS+5]) { JoyDevPtr->Elements[ELEMENTAXIS+5] = CurrentRef; JoyDevPtr->ElementData[ELEMENTAXIS+5] = 0x7FFFFFFF; break; } } else if (ElementInfo.theLabel==kISpElementLabel_Axis_ZAxis) { if (!JoyDevPtr->Elements[ELEMENTAXIS+2]) { JoyDevPtr->Elements[ELEMENTAXIS+2] = CurrentRef; JoyDevPtr->ElementData[ELEMENTAXIS+2] = 0x7FFFFFFF; break; } } /* Insert in the generic list */ if (AxisIndex<AXISCOUNT) { do { if (!JoyDevPtr->Elements[AxisIndex+ELEMENTAXIS]) { JoyDevPtr->Elements[AxisIndex+ELEMENTAXIS] = CurrentRef; JoyDevPtr->ElementData[AxisIndex+ELEMENTAXIS] = 0x7FFFFFFF; break; } } while (++AxisIndex<AXISCOUNT); } break; } } } while (++TempIndex<ElementCount); } } } ++JoyDevPtr; } while (++j<i); /* All devices scanned */ } MacInputUnlockInputSprocket(); return JoystickPresent; } Abort:; MacInputUnlockInputSprocket(); JoystickDestroy(); return 0; }
void BURGERCALL LinkedListSort(LinkedList_t *Input,LinkedListSortProc Proc) { LinkedListEntry_t **ArrayPtr; LinkedListEntry_t *Internal[2000]; /* Simple sort? */ if (Input->Count>=2) { /* Should I even worry about a sort? */ /* Two entries? */ if (Input->Count==2) { /* I guess so... */ LinkedListEntry_t *First; LinkedListEntry_t *Second; First = Input->First; /* Just a two entry sort, trivial... */ Second = Input->Last; if (Proc(First->Data,Second->Data)>0) { /* Worry? */ Input->First = Second; /* Perform a swap */ Input->Last = First; Second->Next = First; /* New first entry */ Second->Prev = 0; First->Next = 0; /* New last entry */ First->Prev = Second; } return; /* I am sorted */ } /* Let's perform a merge sort */ /* First get the buffer for the sort */ if (Input->Count>1000) { ArrayPtr = (LinkedListEntry_t **)AllocAPointer(sizeof(LinkedListEntry_t *)*Input->Count*2); /* Yikes!! */ if (!ArrayPtr) { /* Memory error! */ return; /* Forget about the sort! */ } } else { ArrayPtr = Internal; /* Use my internal buffer */ } /* I need to first "flatten" the linked list */ { LinkedListEntry_t **WorkPtr1; LinkedListEntry_t *EntryPtr1; Word i1; WorkPtr1 = ArrayPtr; /* Pointer to the allocated buffer */ i1 = Input->Count; /* Number of entries to upload */ EntryPtr1 = Input->First; do { WorkPtr1[0] = EntryPtr1; /* Store the entry */ EntryPtr1 = EntryPtr1->Next; /* Next one in the chain */ ++WorkPtr1; } while (--i1); /* All done */ } /* Now, we perform the merge sort */ { LinkedListEntry_t **WorkPtr; { Word i; Word size; /* Entry size to sort with */ Word sort; /* Sort count */ LinkedListEntry_t **unsorted; i = Input->Count; /* How many entries are there? */ size = 1; /* source size (<<1 / loop)*/ sort = 1; /* iteration number (+1 / loop)*/ WorkPtr = ArrayPtr; unsorted = ArrayPtr+i; do { { Word remaining; /* Temp merge count */ LinkedListEntry_t **src1,**src2,**dest; /* Used by the sort */ remaining = i>>sort; /* How many times to try */ /* pointers incremented by the merge */ src1 = WorkPtr; /* Sorted array */ src2 = &WorkPtr[remaining<<(sort-1)]; /* Half point */ dest = unsorted; /* Dest array */ /* merge paired blocks*/ if (remaining) { /* Any to sort? */ do { LinkedListMerge(dest,src1,src2,size,size,Proc); /* All groups equal size */ dest = &dest[size+size]; src1 = &src1[size]; src2 = &src2[size]; } while (--remaining); } /* copy or merge the leftovers */ remaining = i&((size<<1)-1); /* Create mask (1 bit higher) */ if (remaining > size) { /* one complete block and one fragment */ LinkedListMerge(dest,&src2[size],src2,remaining-size,size,Proc); } else if (remaining) { /* just a single sorted fragment */ FastMemCpy(dest,src2,remaining*sizeof(LinkedListEntry_t *)); /* Copy it */ } } /* get ready to sort back to the other array */ size <<= 1; /* Double the entry size */ ++sort; /* Increase the shift size */ { LinkedListEntry_t **temp; temp = WorkPtr; /* Swap the pointers */ WorkPtr = unsorted; unsorted = temp; } } while (size<i); } /* Now that I have the sorted list, Let's create the */ /* new linked list */ { LinkedListEntry_t *EntryPtr2; LinkedListEntry_t *Prev; LinkedListEntry_t *Next; Word i3; EntryPtr2 = WorkPtr[0]; /* Get the new root pointer */ ++WorkPtr; Input->First = EntryPtr2; /* Set as the first one */ i3 = Input->Count-1; /* Traverse until the final link */ Prev = 0; /* Zap the previous link */ do { Next = WorkPtr[0]; ++WorkPtr; EntryPtr2->Next = Next; /* Store the links */ EntryPtr2->Prev = Prev; Prev = EntryPtr2; /* Follow the chains */ EntryPtr2 = Next; /* Next one */ } while (--i3); /* All done? */ EntryPtr2->Next = 0; /* The final link */ EntryPtr2->Prev = Prev; Input->Last = EntryPtr2; /* Save the ending link */ } } if (ArrayPtr!=Internal) { DeallocAPointer(ArrayPtr); /* Dispose of the linked list flattened data */ } } }
int BURGERCALL vorbis_analysis_headerout(vorbis_dsp_state *v, vorbis_comment *vc, ogg_packet *op, ogg_packet *op_comm, ogg_packet *op_code){ int ret=OV_EIMPL; vorbis_info *vi=v->vi; oggpack_buffer opb; backend_lookup_state *b=static_cast<backend_lookup_state *>(v->backend_state); if(!b){ ret=OV_EFAULT; goto err_out; } /* first header packet **********************************************/ oggpack_writeinit(&opb); if(_vorbis_pack_info(&opb,vi))goto err_out; /* build the packet */ if(b->header)DeallocAPointer(b->header); b->header=static_cast<Word8 *>(AllocAPointer(oggpack_bytes(&opb))); FastMemCpy(b->header,opb.buffer,oggpack_bytes(&opb)); op->packet=b->header; op->bytes=oggpack_bytes(&opb); op->b_o_s=1; op->e_o_s=0; op->granulepos=0; /* second header packet (comments) **********************************/ oggpack_reset(&opb); if(_vorbis_pack_comment(&opb,vc))goto err_out; if(b->header1)DeallocAPointer(b->header1); b->header1=static_cast<Word8 *>(AllocAPointer(oggpack_bytes(&opb))); FastMemCpy(b->header1,opb.buffer,oggpack_bytes(&opb)); op_comm->packet=b->header1; op_comm->bytes=oggpack_bytes(&opb); op_comm->b_o_s=0; op_comm->e_o_s=0; op_comm->granulepos=0; /* third header packet (modes/codebooks) ****************************/ oggpack_reset(&opb); if(_vorbis_pack_books(&opb,vi))goto err_out; if(b->header2)DeallocAPointer(b->header2); b->header2=static_cast<Word8 *>(AllocAPointer(oggpack_bytes(&opb))); FastMemCpy(b->header2,opb.buffer,oggpack_bytes(&opb)); op_code->packet=b->header2; op_code->bytes=oggpack_bytes(&opb); op_code->b_o_s=0; op_code->e_o_s=0; op_code->granulepos=0; oggpack_writeclear(&opb); return(0); err_out: oggpack_writeclear(&opb); FastMemSet(op,0,sizeof(*op)); FastMemSet(op_comm,0,sizeof(*op_comm)); FastMemSet(op_code,0,sizeof(*op_code)); if(b->header)DeallocAPointer(b->header); if(b->header1)DeallocAPointer(b->header1); if(b->header2)DeallocAPointer(b->header2); b->header=NULL; b->header1=NULL; b->header2=NULL; return(ret); }
void BURGERCALL LinkedListEntryDeallocProc(LinkedListEntry_t *Input) { DeallocAPointer(Input->Data); DeallocAPointer(Input); }