void freealiasmem(void) { struct Alias *pekare; while(pekare=(struct Alias *)RemHead((struct List *)&aliaslist)) FreeMem(pekare,sizeof(struct Alias)); }
/* ================ MakeFaceEdges ================ */ int MakeFaceEdges(mapentity_t *entity, node_t *headnode) { int i, firstface; struct lumpdata *surfedges = &entity->lumps[LUMP_SURFEDGES]; struct lumpdata *edges = &entity->lumps[LUMP_EDGES]; struct lumpdata *vertices = &entity->lumps[LUMP_VERTEXES]; struct lumpdata *faces = &entity->lumps[LUMP_FACES]; Message(msgProgress, "MakeFaceEdges"); cStartEdge = 0; for (i = 0; i < entity - map.entities; i++) cStartEdge += map.entities[i].lumps[LUMP_EDGES].count; CountData_r(entity, headnode); /* * Remember edges are +1 in BeginBSPFile. Often less than half * the vertices actually are unique, although heavy use of skip * faces will break that assumption. 2/3 should be safe most of * the time without wasting too much memory... */ surfedges->count = vertices->count; edges->count += surfedges->count; vertices->data = AllocMem(BSP_VERTEX, vertices->count, true); edges->data = AllocMem(BSP_EDGE, edges->count, true); // Accessory data pHashverts = AllocMem(HASHVERT, vertices->count, true); pEdgeFaces0 = AllocMem(OTHER, sizeof(face_t *) * edges->count, true); pEdgeFaces1 = AllocMem(OTHER, sizeof(face_t *) * edges->count, true); InitHash(); firstface = map.cTotal[LUMP_FACES]; MakeFaceEdges_r(entity, headnode, 0); FreeMem(pHashverts, HASHVERT, vertices->count); FreeMem(pEdgeFaces0, OTHER, sizeof(face_t *) * edges->count); FreeMem(pEdgeFaces1, OTHER, sizeof(face_t *) * edges->count); /* Free any excess allocated memory */ if (vertices->index < vertices->count) { dvertex_t *temp = AllocMem(BSP_VERTEX, vertices->index, true); memcpy(temp, vertices->data, sizeof(*temp) * vertices->index); FreeMem(vertices->data, BSP_VERTEX, vertices->count); vertices->data = temp; vertices->count = vertices->index; } if (edges->index < edges->count) { void *temp = AllocMem(BSP_EDGE, edges->index, true); memcpy(temp, edges->data, MemSize[BSP_EDGE] * edges->index); FreeMem(edges->data, BSP_EDGE, edges->count); edges->data = temp; edges->count = edges->index; } if (map.cTotal[LUMP_VERTEXES] > 65535 && options.BSPVersion == BSPVERSION) Error("Too many vertices (%d > 65535). Recompile with the \"-bsp2\" flag to lift this restriction.", map.cTotal[LUMP_VERTEXES]); surfedges->data = AllocMem(BSP_SURFEDGE, surfedges->count, true); faces->data = AllocMem(BSP_FACE, faces->count, true); Message(msgProgress, "GrowRegions"); if (options.BSPVersion == BSPVERSION) GrowNodeRegion_BSP29(entity, headnode); else GrowNodeRegion_BSP2(entity, headnode); return firstface; }
void fastPoll( void ) { RANDOM_STATE randomState; BYTE buffer[ RANDOM_BUFSIZE + 8 ]; /* BatteryTimeRec batteryTimeInfo; */ SMStatus soundStatus; ThreadID threadID; ThreadState threadState; EventRecord eventRecord; Point point; WindowPtr windowPtr; PScrapStuff scrapInfo; UnsignedWide usSinceStartup; BYTE dataBuffer[ 2 + 8 ]; /* short driverRefNum; */ UInt32 dateTime; /* int count, dummy; */ NumVersion version; initRandomData( randomState, buffer, RANDOM_BUFSIZE ); /* Get the status of the last alert, how much battery time is remaining and the voltage from all batteries, the internal battery status, the current date and time and time since system startup in ticks, the application heap limit and current and heap zone, free memory in the current and system heap, microseconds since system startup, whether QuickDraw has finished drawing, modem status, SCSI status information, maximum block allocatable without compacting, available stack space, the last QuickDraw error code */ /* addRandomValue( randomState, GetAlertStage() ); count = BatteryCount(); while( count-- > 0 ) { addRandomValue( randomState, GetBatteryVoltage( count ) ); GetBatteryTimes( count, &batteryTimeInfo ); addRandomData( randomState, &batteryTimeInfo, sizeof( BatteryTimeRec ) ); } if( !BatteryStatus( buffer, dataBuffer + 1 ) ) addRandomValue( randomState, dataBuffer ); */ GetDateTime( &dateTime ); addRandomValue( randomState, dateTime ); addRandomValue( randomState, TickCount() ); #if !defined CALL_NOT_IN_CARBON || CALL_NOT_IN_CARBON addRandomValue( randomState, GetApplLimit() ); addRandomValue( randomState, GetZone() ); addRandomValue( randomState, SystemZone() ); addRandomValue( randomState, FreeMem() ); addRandomValue( randomState, FreeMemSys() ); #endif /* MicroSeconds( &usSinceStartup ); addRandomData( randomState, &usSinceStartup, sizeof( UnsignedWide ) ); */ addRandomValue( randomState, QDDone( NULL ) ); /* ModemStatus( dataBuffer ); addRandomValue( randomState, dataBuffer[ 0 ] ); */ #if !defined CALL_NOT_IN_CARBON || CALL_NOT_IN_CARBON addRandomValue( randomState, SCSIStat() ); #endif addRandomValue( randomState, MaxBlock() ); addRandomValue( randomState, StackSpace() ); addRandomValue( randomState, QDError() ); /* Get the event code and message, time, and mouse location for the next event in the event queue and the OS event queue */ if( EventAvail( everyEvent, &eventRecord ) ) addRandomData( randomState, &eventRecord, sizeof( EventRecord ) ); #if !defined CALL_NOT_IN_CARBON || CALL_NOT_IN_CARBON if( OSEventAvail( everyEvent, &eventRecord ) ) addRandomData( randomState, &eventRecord, sizeof( EventRecord ) ); #endif /* Get all sorts of information such as device-specific info, grafport information, visible and clipping region, pattern, pen, text, and colour information, and other details, on the topmost window. Also get the window variant. If there's a colour table record, add the colour table as well */ if( ( windowPtr = FrontWindow() ) != NULL ) { /* CTabHandle colourHandle; */ #if !defined OPAQUE_TOOLBOX_STRUCTS || !OPAQUE_TOOLBOX_STRUCTS addRandomData( randomState, windowPtr, sizeof( GrafPort ) ); #endif addRandomValue( randomState, GetWVariant( windowPtr ) ); /* if( GetAuxWin( windowPtr, colourHandle ) ) { CTabPtr colourPtr; HLock( colourHandle ); colourPtr = *colourHandle; addRandomData( randomState, colourPtr, sizeof( ColorTable ) ); HUnlock( colourHandle ); } */ } /* Get mouse-related such as the mouse button status and mouse position, information on the window underneath the mouse */ addRandomValue( randomState, Button() ); GetMouse( &point ); addRandomData( randomState, &point, sizeof( Point ) ); FindWindow( point, &windowPtr ); #if !defined OPAQUE_TOOLBOX_STRUCTS || !OPAQUE_TOOLBOX_STRUCTS if( windowPtr != NULL ) addRandomData( randomState, windowPtr, sizeof( GrafPort ) ); #endif /* Get the size, handle, and location of the desk scrap/clipboard */ #if !defined CALL_NOT_IN_CARBON || CALL_NOT_IN_CARBON scrapInfo = InfoScrap(); addRandomData( randomState, scrapInfo, sizeof( ScrapStuff ) ); #endif /* Get information on the current thread */ threadID = kCurrentThreadID; /*GetThreadID( &threadID ); */ GetThreadState( threadID, &threadState ); addRandomData( randomState, &threadState, sizeof( ThreadState ) ); /* Get the sound mananger status. This gets the number of allocated sound channels and the current CPU load from these channels */ SndManagerStatus( sizeof( SMStatus ), &soundStatus ); addRandomData( randomState, &soundStatus, sizeof( SMStatus ) ); /* Get the speech manager version and status */ /* version = SpeechManagerVersion(); addRandomData( randomState, &version, sizeof( NumVersion ) ); addRandomValue( randomState, SpeechBusy() ); */ /* Get the status of the serial port. This gets information on recent errors, read and write pending status, and flow control values */ /* if( !OpenDriver( "\p.AIn", &driverRefNum ) ) { SerStaRec serialStatus; SetStatus( driverRefNum, &serialStatus ); addRandomData( randomState, &serialStatus, sizeof( SerStaRec ) ); } if( !OpenDriver( "\p.AOut", &driverRefNum ) ) { SerStaRec serialStatus; SetStatus( driverRefNum, &serialStatus ); addRandomData( randomState, &serialStatus, sizeof( SerStaRec ) ); } */ /* Flush any remaining data through */ endRandomData( randomState, 10 ); }
void readTextInfo(void) { struct FileInfoBlock *fib; BPTR lock, fh; ULONG high=0, low=-1L, nr; char filename[40]; struct Header readhead; if(!(fib=(struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock), MEMF_CLEAR))) { cleanup(EXIT_ERROR, "Couldn't allocate a FileInfoBlock"); } if(!(lock=Lock("NiKom:Moten",ACCESS_READ))) { FreeMem(fib,sizeof(struct FileInfoBlock)); cleanup(EXIT_ERROR, "Couldn't lock NiKom:Moten."); } if(!Examine(lock,fib)) { FreeMem(fib,sizeof(struct FileInfoBlock)); UnLock(lock); cleanup(EXIT_ERROR, "Couldn't Examine() NiKom:Moten."); } while(ExNext(lock, fib)) { if(strncmp(fib->fib_FileName, "Head", 4)) { continue; } nr = atoi(&fib->fib_FileName[4]); if(nr > high) { high = nr; } if(nr < low) { low=nr; } } UnLock(lock); FreeMem(fib,sizeof(struct FileInfoBlock)); if(low == -1L) { printf("No Head.dat files found. Assuming system has no texts yet.\n"); Servermem->info.hightext = -1L; Servermem->info.lowtext = 0L; return; } sprintf(filename, "NiKom:Moten/Head%d.dat", low); if(!(fh = Open(filename, MODE_OLDFILE))) { printf("Can't open %s.\n", filename); cleanup(EXIT_ERROR, "Couldn't get lowest textnumber."); } if(Seek(fh,0,OFFSET_BEGINNING) == -1) { Close(fh); cleanup(EXIT_ERROR, "Couldn't Seek() in Head.dat (1)"); } if(Read(fh, &readhead, sizeof(struct Header)) != sizeof(struct Header)) { Close(fh); cleanup(EXIT_ERROR, "Couldn't read Head.dat (1)"); } Servermem->info.lowtext = readhead.nummer; Close(fh); sprintf(filename,"NiKom:Moten/Head%d.dat", high); if(!(fh = Open(filename,MODE_OLDFILE))) { printf("Can't open %s.\n", filename); cleanup(EXIT_ERROR, "Couldn't get highest textnumber."); } if(Seek(fh, -sizeof(struct Header), OFFSET_END) == -1) { Close(fh); cleanup(EXIT_ERROR, "Couldn't Seek() in Head.dat (2)"); } if(Read(fh, &readhead, sizeof(struct Header)) != sizeof(struct Header)) { Close(fh); cleanup(EXIT_ERROR, "Couldn't read Head.dat (2)"); } Servermem->info.hightext = readhead.nummer; Close(fh); printf("Lowtext: %d Hightext: %d\n", Servermem->info.lowtext, Servermem->info.hightext); }
/* * copy a device to a FILE*. */ static int raw_copy(char *dev_name, int dev_unit, FILE *dst) { struct MsgPort *port = NULL; struct IOStdReq *ioreq = NULL; int tracklen = 512*11; int retstatus = 1; int inhibited = 0; char *buffer = NULL; static char name[] = {'D','F','0','\0'}; if(!strcmp(dev_name, "trackdisk.device")) { inhibited = 1; name[2] = '0'+dev_unit; } /* allocate system stuff */ if((port = CreatePort(0, 0))) { if((ioreq = CreateStdIO(port))) { if((buffer = AllocMem(tracklen, MEMF_CHIP))) { /* gain access to the device */ if(!OpenDevice(dev_name, dev_unit, (struct IORequest*)ioreq, 0)) { /* check if a disk is present */ myDoIO(ioreq, TD_CHANGESTATE, 0, -1, -1, -1); if(!ioreq->io_Error && ioreq->io_Actual) { fprintf(stderr,"No disk in %s unit %d !\n", dev_name, dev_unit); retstatus = 0; } else { int tr = 0; int write_protected = 0; /* check if disk is write-protected: myDoIO(ioreq, TD_PROTSTATUS, 0, -1, -1, -1); if(!ioreq->io_Error && ioreq->io_Actual) write_protected = 1; */ /* inhibit device */ if(inhibited) inhibited = dev_inhibit(name,1); /* read tracks */ for(tr = 0; tr < 160; ++tr) { printf("Reading track %2d side %d of %s unit %d \r", tr/2, tr%2, dev_name, dev_unit); fflush(stdout); myDoIO(ioreq, CMD_READ, -1, tracklen*tr, tracklen, (LONG)buffer); if(ioreq->io_Error) printf("Err. on\n"); if(fwrite(buffer, 1, tracklen, dst) != (unsigned int)tracklen) { retstatus = 0; break; } } /* ok everything done! */ printf(" \r"); fflush(stdout); /* stop motor */ myDoIO(ioreq, TD_MOTOR, 0, -1, 0, -1); /* uninhibit */ if(inhibited) dev_inhibit(name,0); } CloseDevice((struct IORequest*)ioreq); } else retstatus = 0; FreeMem(buffer,tracklen); } else retstatus = 0; DeleteStdIO(ioreq); } else retstatus = 0; DeletePort(port); } else retstatus = 0; return retstatus; }
void * mem_malloc( unsigned int size, char * var, char * filename, int line, int fill_zero ) { int i, id; void *ptr; char * pc; if (Initialized==0) mem_init(); #if MEMSTATS { unsigned long theFreeMem = 0; if (sMemStatsFileInitialized) { theFreeMem = FreeMem(); fprintf(sMemStatsFile, "\n%9u bytes free before attempting: MALLOC %9u bytes.", theFreeMem, size); } } #endif // end of ifdef memstats if ( num_blocks >= MAX_INDEX ) { con_printf(CON_CRITICAL,"\nMEM_OUT_OF_SLOTS: Not enough space in mem.c to hold all the mallocs.\n" ); con_printf(CON_CRITICAL, "\tBlock '%s' created in %s, line %d.\n", var, filename, line ); Error( "MEM_OUT_OF_SLOTS" ); } id = free_list[ num_blocks++ ]; if (id > LargestIndex ) LargestIndex = id; if (id==-1) { con_printf(CON_CRITICAL,"\nMEM_OUT_OF_SLOTS: Not enough space in mem.c to hold all the mallocs.\n" ); //con_printf(CON_CRITICAL, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], LineNum[id] ); Error( "MEM_OUT_OF_SLOTS" ); } ptr = malloc( size+CHECKSIZE ); if (ptr==NULL) { out_of_memory = 1; con_printf(CON_CRITICAL, "\nMEM_OUT_OF_MEMORY: Malloc returned NULL\n" ); con_printf(CON_CRITICAL, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], LineNum[id] ); Error( "MEM_OUT_OF_MEMORY" ); } MallocBase[id] = ptr; MallocSize[id] = size; Varname[id] = var; Filename[id] = filename; LineNum[id] = line; Present[id] = 1; pc = (char *)ptr; BytesMalloced += size; for (i=0; i<CHECKSIZE; i++ ) pc[size+i] = CHECKBYTE; if (fill_zero) memset( ptr, 0, size ); return ptr; }
///ImageBackFill__MUIM_IconWindow_BackFill_ProcessBackground() IPTR ImageBackFill__MUIM_IconWindow_BackFill_ProcessBackground ( Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_ProcessBackground *message ) { LONG Depth = 0; Object *_IconWindows_PrefsObj = NULL, *_IconWindows_WindowObj = NULL; Object *_IconWindows_IconListObj = NULL; BOOL options_changed = FALSE; IPTR prefs_processing = 0; IPTR BackGround_Attrib = 0, BackGround_Base = 0, BackGround_RenderMode = 0, BackGround_TileMode = 0, BackGround_XOffset = 0, BackGround_YOffset = 0; struct BackFillInfo *this_BFI =(struct BackFillInfo *) message->BackFill_Data; UBYTE *this_bgtype; char *this_ImageName; D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground()\n")); GET(_app(self), MUIA_Wanderer_Prefs, &_IconWindows_PrefsObj); D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: PrefsObj @ %x\n", _IconWindows_PrefsObj)); GET(self, MUIA_IconWindow_Window, &_IconWindows_WindowObj); GET(self, MUIA_IconWindow_IconList, &_IconWindows_IconListObj); D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: MUIA_IconWindow_Window = %x\n", _IconWindows_WindowObj)); if ((_IconWindows_PrefsObj == NULL) || (_IconWindows_WindowObj == NULL) || (_IconWindows_IconListObj == NULL)) return FALSE; GET(_IconWindows_PrefsObj, MUIA_WandererPrefs_Processing, &prefs_processing); #if defined(DEBUG) if (prefs_processing) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Wanderer Prefs (re)loading detected\n")); } #endif GET(_IconWindows_WindowObj, MUIA_IconWindow_BackgroundAttrib, &BackGround_Attrib); D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Background Attrib = '%s'\n", BackGround_Attrib)); if (BackGround_Attrib == (IPTR) NULL) return FALSE; if ((BackGround_Base = DoMethod(_IconWindows_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute, BackGround_Attrib, MUIA_Background)) == -1) return FALSE; if ((BackGround_RenderMode = DoMethod(_IconWindows_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute, BackGround_Attrib, MUIA_IconWindowExt_ImageBackFill_BGRenderMode)) == -1) BackGround_RenderMode = IconWindowExt_ImageBackFill_RenderMode_Tiled; this_bgtype = (UBYTE *)BackGround_Base; this_ImageName = (char *)(BackGround_Base + 2); D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: BackFillInfo @ %x\n", this_BFI)); D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Background '%s', mode %d\n", BackGround_Base, BackGround_RenderMode)); if ((this_bgtype[0] - 48) != 5) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Background is NOT an image - letting our windoclass handle it ..\n")); goto pb_cleanup_buffer; } GET(self, MUIA_Window_Screen, &this_BFI->bfi_Screen); GET(_IconWindows_IconListObj, MUIA_IconList_BufferRastport, &this_BFI->bfi_RastPort); D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Wanderers Screen @ %x, Using RastPort @ %x\n", this_BFI->bfi_Screen, this_BFI->bfi_RastPort)); if (this_BFI->bfi_Source) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: BackFillInfo has existing source record @ %x\n", this_BFI->bfi_Source)); if ((strcmp(this_BFI->bfi_Source->bfsir_SourceImage, this_ImageName) == 0) && (this_BFI->bfi_Source->bfsir_BackGroundRenderMode == BackGround_RenderMode)) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: existing BackFillInfo Using the same background / mode\n")); goto check_imagebuffer; } else { if (this_BFI->bfi_Buffer) { ImageBackFill_CloseSourceBuffer(this_BFI->bfi_Source, this_BFI->bfi_Buffer); this_BFI->bfi_Buffer = NULL; } ImageBackFill_CloseSourceRecord(this_BFI->bfi_Source); this_BFI->bfi_Source = NULL; } } if (!(this_BFI->bfi_Source)) this_BFI->bfi_Source = ImageBackFill_FindSourceRecord(this_ImageName, BackGround_RenderMode); if (!(this_BFI->bfi_Source)) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Creating NEW ImageSource Record\n")); if (!(this_BFI->bfi_Source = AllocMem(sizeof(struct BackFillSourceImageRecord), MEMF_CLEAR|MEMF_PUBLIC))) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Couldnt allocate enough mem for source record!\n")); return FALSE; } if (!(this_BFI->bfi_Source->bfsir_SourceImage = AllocVec(strlen(this_ImageName) +1, MEMF_CLEAR|MEMF_PUBLIC))) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Couldnt allocate enough mem for source image name store\n")); FreeMem(this_BFI->bfi_Source, sizeof(struct BackFillSourceImageRecord)); return FALSE; } strcpy(this_BFI->bfi_Source->bfsir_SourceImage, this_ImageName); if ((this_BFI->bfi_Source->bfsir_DTPictureObject = NewDTObject(this_BFI->bfi_Source->bfsir_SourceImage, DTA_SourceType, DTST_FILE, DTA_GroupID, GID_PICTURE, PDTA_DestMode, PMODE_V43, PDTA_Remap, TRUE, PDTA_Screen, this_BFI->bfi_Screen, PDTA_FreeSourceBitMap, TRUE, OBP_Precision, PRECISION_IMAGE, TAG_DONE))) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Opened Datatype Object @ %x for image '%s'\n", this_BFI->bfi_Source->bfsir_DTPictureObject, this_BFI->bfi_Source->bfsir_SourceImage)); if (DoMethod(this_BFI->bfi_Source->bfsir_DTPictureObject, DTM_PROCLAYOUT, NULL, 1)) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Caused Datatype Object LAYOUT\n")); GetDTAttrs(this_BFI->bfi_Source->bfsir_DTPictureObject, PDTA_BitMapHeader, &this_BFI->bfi_Source->bfsir_DTBitMapHeader, TAG_DONE); GetDTAttrs(this_BFI->bfi_Source->bfsir_DTPictureObject, PDTA_DestBitMap, &this_BFI->bfi_Source->bfsir_DTBitMap, TAG_DONE); if (!this_BFI->bfi_Source->bfsir_DTBitMap) GetDTAttrs(this_BFI->bfi_Source->bfsir_DTPictureObject, PDTA_BitMap, &this_BFI->bfi_Source->bfsir_DTBitMap, TAG_DONE); if (this_BFI->bfi_Source->bfsir_DTBitMap) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Datatype Object BitMap @ %x\n", this_BFI->bfi_Source->bfsir_DTBitMap)); if ((this_BFI->bfi_Source->bfsir_DTRastPort = CreateRastPort())) { this_BFI->bfi_Source->bfsir_DTRastPort->BitMap = this_BFI->bfi_Source->bfsir_DTBitMap; this_BFI->bfi_Source->bfsir_BackGroundRenderMode = BackGround_RenderMode; this_BFI->bfi_Source->bfsir_OpenerCount = 0x01; NewList(&this_BFI->bfi_Source->bfsir_Buffers); AddTail(&image_backfill_images, &this_BFI->bfi_Source->bfsir_Node); goto check_imagebuffer; } } /* Failed to obtain datatype object's BM */ } /* Failed to Layout datatype object */ } /* Failed to open datatype object */ #if defined(DEBUG) if (!this_BFI->bfi_Source->bfsir_DTRastPort) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Failed to create ImageSource RastPort\n")); } #endif if (this_BFI->bfi_Source->bfsir_DTBitMap) { FreeBitMap(this_BFI->bfi_Source->bfsir_DTBitMap); this_BFI->bfi_Source->bfsir_DTBitMap = NULL; } #if defined(DEBUG) else { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Failed to create ImageSource BitMap\n")); } #endif if (this_BFI->bfi_Source->bfsir_DTPictureObject) { DisposeDTObject(this_BFI->bfi_Source->bfsir_DTPictureObject); this_BFI->bfi_Source->bfsir_DTPictureObject = NULL; } #if defined(DEBUG) else { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Failed to create ImageSource Datatype Object\n")); } #endif D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Failed to create ImageSource Record\n")); if (this_BFI->bfi_Source->bfsir_SourceImage) FreeVec(this_BFI->bfi_Source->bfsir_SourceImage); FreeMem(this_BFI->bfi_Source, sizeof(struct BackFillSourceImageRecord)); this_BFI->bfi_Source = NULL; return FALSE; } else { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Using existing ImageSource Record\n")); this_BFI->bfi_Source->bfsir_OpenerCount += 1; } check_imagebuffer: Depth = GetBitMapAttr(this_BFI->bfi_Source->bfsir_DTBitMap, BMA_DEPTH); this_BFI->bfi_CopyWidth = this_BFI->bfi_Source->bfsir_DTBitMapHeader->bmh_Width; this_BFI->bfi_CopyHeight = this_BFI->bfi_Source->bfsir_DTBitMapHeader->bmh_Height; switch (BackGround_RenderMode) { case IconWindowExt_ImageBackFill_RenderMode_Scale: { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: SCALED mode\n")); this_BFI->bfi_Options.bfo_TileMode = IconWindowExt_ImageBackFill_TileMode_Fixed; SET(_IconWindows_IconListObj, MUIA_IconListview_FixedBackground, TRUE); SET(_IconWindows_IconListObj, MUIA_IconListview_ScaledBackground, TRUE); if ((BOOL)XGET(self, MUIA_IconWindow_IsRoot)) { struct BackFillSourceImageBuffer *this_Buffer; D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: SCALED - Root Window = TRUE!\n")); this_BFI->bfi_CopyWidth = GetBitMapAttr(this_BFI->bfi_Screen->RastPort.BitMap, BMA_WIDTH); this_BFI->bfi_CopyHeight = GetBitMapAttr(this_BFI->bfi_Screen->RastPort.BitMap, BMA_HEIGHT); D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: SCALED - Base Dimensions (%d x %d)\n", this_BFI->bfi_CopyWidth, this_BFI->bfi_CopyHeight)); if (!((BOOL)XGET(self, MUIA_IconWindow_IsBackdrop))) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: SCALED - Adjusting for window border Dimensions ..\n")); D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: SCALED - WBorTop %d, WBorLeft %d, WBorRight %d, WBorBottom %d\n", this_BFI->bfi_Screen->WBorTop, this_BFI->bfi_Screen->WBorLeft, this_BFI->bfi_Screen->WBorRight, this_BFI->bfi_Screen->WBorBottom)); this_BFI->bfi_CopyWidth -= (this_BFI->bfi_Screen->WBorLeft + this_BFI->bfi_Screen->WBorRight); this_BFI->bfi_CopyHeight -= (this_BFI->bfi_Screen->WBorTop + this_BFI->bfi_Screen->WBorBottom);; } this_BFI->bfi_CopyHeight -= (this_BFI->bfi_Screen->BarHeight + 1); this_Buffer = NULL; if (this_BFI->bfi_Buffer) { if ((this_BFI->bfi_Buffer->bfsib_BitMapWidth == this_BFI->bfi_CopyWidth) && (this_BFI->bfi_Buffer->bfsib_BitMapHeight == this_BFI->bfi_CopyHeight)) { goto pb_backfillsetup_complete; } else { ImageBackFill_CloseSourceBuffer(this_BFI->bfi_Source, this_BFI->bfi_Buffer); this_BFI->bfi_Buffer = NULL; } } if (!(this_Buffer = ImageBackFill_FindBufferRecord(this_BFI->bfi_Source, this_BFI->bfi_CopyWidth, this_BFI->bfi_CopyHeight))) { this_Buffer = AllocMem(sizeof(struct BackFillSourceImageBuffer), MEMF_CLEAR|MEMF_PUBLIC); this_Buffer->bfsib_BitMapWidth = this_BFI->bfi_CopyWidth; this_Buffer->bfsib_BitMapHeight = this_BFI->bfi_CopyHeight; if (!(this_Buffer->bfsib_BitMapRastPort = CreateRastPort())) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: SCALED - Failed to create RastPort for BackFill BitMap\n")); break; } if ((this_Buffer->bfsib_BitMap = AllocBitMap(this_BFI->bfi_CopyWidth, this_BFI->bfi_CopyHeight, Depth, Depth == 8 ? BMF_MINPLANES : 0L, this_BFI->bfi_Screen->RastPort.BitMap))) { struct Rectangle CopyBounds; D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: SCALED - Scale Dimensions (%d x %d)\n", this_BFI->bfi_CopyWidth, this_BFI->bfi_CopyHeight)); this_Buffer->bfsib_BitMapRastPort->BitMap = this_Buffer->bfsib_BitMap; this_BFI->bfi_Buffer = this_Buffer; CopyBounds.MinX = 0; CopyBounds.MinY = 0; CopyBounds.MaxX = this_BFI->bfi_CopyWidth - 1; CopyBounds.MaxY = this_BFI->bfi_CopyHeight - 1; ImageBackFill_CopyScaledBitMap(this_BFI->bfi_Source->bfsir_DTRastPort, 0, 0, this_BFI->bfi_Source->bfsir_DTBitMapHeader->bmh_Width, this_BFI->bfi_Source->bfsir_DTBitMapHeader->bmh_Height, this_Buffer->bfsib_BitMapRastPort, &CopyBounds, &CopyBounds, blit_MODE_Blit); this_Buffer->bfsib_OpenerCount = 0x01; AddTail(&this_BFI->bfi_Source->bfsir_Buffers, &this_Buffer->bfsib_Node); goto pb_backfillsetup_complete; } break; } else { this_BFI->bfi_Buffer = this_Buffer; this_Buffer->bfsib_OpenerCount += 1; goto pb_backfillsetup_complete; } } // We arent the "ROOT" (desktop) window so only tile ... D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: SCALED - Drawer window scaling unsupported ...\n")); } default: { struct BackFillSourceImageBuffer *this_Buffer; D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: TILED mode\n")); if ((BackGround_TileMode = DoMethod(_IconWindows_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute, BackGround_Attrib, MUIA_IconWindowExt_ImageBackFill_BGTileMode)) == -1) BackGround_TileMode = IconWindowExt_ImageBackFill_TileMode_Float; if ((BackGround_XOffset = DoMethod(_IconWindows_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute, BackGround_Attrib, MUIA_IconWindowExt_ImageBackFill_BGXOffset)) == -1) BackGround_XOffset = 0; if ((BackGround_YOffset = DoMethod(_IconWindows_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute, BackGround_Attrib, MUIA_IconWindowExt_ImageBackFill_BGYOffset)) == -1) this_BFI->bfi_Options.bfo_OffsetY = 0; if (this_BFI->bfi_Options.bfo_TileMode != BackGround_TileMode) { this_BFI->bfi_Options.bfo_TileMode = BackGround_TileMode; options_changed = TRUE; } if (this_BFI->bfi_Options.bfo_OffsetX != BackGround_XOffset) { this_BFI->bfi_Options.bfo_OffsetX = BackGround_XOffset; options_changed = TRUE; } if (this_BFI->bfi_Options.bfo_OffsetY != BackGround_YOffset) { this_BFI->bfi_Options.bfo_OffsetY = BackGround_YOffset; options_changed = TRUE; } if (this_BFI->bfi_Options.bfo_TileMode == IconWindowExt_ImageBackFill_TileMode_Float) SET(_IconWindows_IconListObj, MUIA_IconListview_FixedBackground, FALSE); else SET(_IconWindows_IconListObj, MUIA_IconListview_FixedBackground, TRUE); SET(_IconWindows_IconListObj, MUIA_IconListview_ScaledBackground, FALSE); this_Buffer = NULL; if (this_BFI->bfi_Buffer) { if ((this_BFI->bfi_Buffer->bfsib_BitMapWidth == this_BFI->bfi_CopyWidth) && (this_BFI->bfi_Buffer->bfsib_BitMapHeight == this_BFI->bfi_CopyHeight)) { goto pb_backfillsetup_complete; } else { ImageBackFill_CloseSourceBuffer(this_BFI->bfi_Source, this_BFI->bfi_Buffer); this_BFI->bfi_Buffer = NULL; } } D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Dimensions Width %d, Height %d\n", this_BFI->bfi_CopyWidth, this_BFI->bfi_CopyHeight)); if (!(this_Buffer = ImageBackFill_FindBufferRecord(this_BFI->bfi_Source, this_BFI->bfi_CopyWidth, this_BFI->bfi_CopyHeight))) { this_Buffer = AllocMem(sizeof(struct BackFillSourceImageBuffer), MEMF_CLEAR|MEMF_PUBLIC); this_Buffer->bfsib_BitMapWidth = this_BFI->bfi_CopyWidth; this_Buffer->bfsib_BitMapHeight = this_BFI->bfi_CopyHeight; if ((this_Buffer->bfsib_BitMap = AllocBitMap(this_BFI->bfi_CopyWidth, this_BFI->bfi_CopyHeight, Depth, Depth == 8 ? BMF_MINPLANES : 0L, this_BFI->bfi_Screen->RastPort.BitMap))) { struct Rectangle CopyBounds; if (!(this_Buffer->bfsib_BitMapRastPort = CreateRastPort())) { D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: TILED - Failed to create RastPort for BackFill BitMap\n")); break; } this_Buffer->bfsib_BitMapRastPort->BitMap = this_Buffer->bfsib_BitMap; this_BFI->bfi_Buffer = this_Buffer; CopyBounds.MinX = 0; CopyBounds.MinY = 0; CopyBounds.MaxX = this_BFI->bfi_CopyWidth - 1; CopyBounds.MaxY = this_BFI->bfi_CopyHeight - 1; ImageBackFill_CopyTiledBitMap(this_BFI->bfi_Source->bfsir_DTRastPort, 0, 0, this_BFI->bfi_Source->bfsir_DTBitMapHeader->bmh_Width, this_BFI->bfi_Source->bfsir_DTBitMapHeader->bmh_Height, this_BFI->bfi_Buffer->bfsib_BitMapRastPort, &CopyBounds, &CopyBounds, blit_MODE_Blit); this_Buffer->bfsib_OpenerCount = 0x01; AddTail(&this_BFI->bfi_Source->bfsir_Buffers, &this_BFI->bfi_Buffer->bfsib_Node); goto pb_backfillsetup_complete; } break; } else { this_BFI->bfi_Buffer = this_Buffer; this_Buffer->bfsib_OpenerCount += 1; goto pb_backfillsetup_complete; } } } D(bug("[IconWindow.ImageBackFill] MUIM_IconWindow_BackFill_ProcessBackground: Failed to create image datatype object\n")); return FALSE; pb_cleanup_buffer: if (this_BFI->bfi_Buffer) { ImageBackFill_CloseSourceBuffer(this_BFI->bfi_Source, this_BFI->bfi_Buffer); this_BFI->bfi_Buffer = NULL; } pb_cleanup_source: if (this_BFI->bfi_Source) { ImageBackFill_CloseSourceRecord(this_BFI->bfi_Source); this_BFI->bfi_Source = NULL; } return FALSE; pb_backfillsetup_complete: if ((prefs_processing) && (options_changed)) SET(self, MUIA_IconWindow_Changed, TRUE); return TRUE; }
int main(int argc, char* argv[]) { struct MsgPort *port1; struct Task *t; port1=CreateMsgPort(); if(port1!=NULL) { port1->mp_Node.ln_Name="message test port"; Forbid(); if(FindPort(port1->mp_Node.ln_Name)==NULL) { AddPort(port1); Permit(); t=(struct Task *)AllocMem(sizeof(struct Task), MEMF_PUBLIC|MEMF_CLEAR); if(t!=NULL) { UBYTE *s; s=(UBYTE *)AllocMem(STACKSIZE, MEMF_PUBLIC|MEMF_CLEAR); if(s!=NULL) { t->tc_Node.ln_Type=NT_TASK; t->tc_Node.ln_Pri=1; t->tc_Node.ln_Name="new task"; t->tc_SPLower=s; t->tc_SPUpper=s+STACKSIZE; #if AROS_STACK_GROWS_DOWNWARDS t->tc_SPReg=(UBYTE *)t->tc_SPUpper-SP_OFFSET; #else t->tc_SPReg=(UBYTE *)t->tc_SPLower-SP_OFFSET; #endif NEWLIST(&t->tc_MemEntry); AddTask(t,&entry,NULL); Wait(1<<port1->mp_SigBit); if(port1->mp_MsgList.lh_Head->ln_Succ!=NULL) { int i; for(i=0;i<10;i++) { struct Message *msg; WaitPort(port1); msg=GetMsg(port1); printf("%d\n",(int)msg->mn_Node.ln_Name); ReplyMsg(msg); } Wait(1<<port1->mp_SigBit); RemTask(t); } FreeMem(s,STACKSIZE); } FreeMem(t,sizeof(struct Task)); } RemPort(port1); }else Permit(); DeleteMsgPort(port1); } return 0; }
LONG main(VOID) { struct DosLibrary *DOSBase; struct RDArgs *readargs; LONG rargs[5], vargs[5]; UBYTE *source, *target; ULONG buffersize = 0; UBYTE *sourcedir, *targetdir; UBYTE *textbuffer, *tmp, *tmp1, *tmp2; struct AnchorPath *anchorpath; struct FileInfoBlock *fib, *targetfib; struct Process *process; APTR wptr; BPTR dirlock, filelock; BOOL checkdatestamp, all; LONG date, error, rc = 0; /* Fail silently if < 37 */ if (DOSBase = (struct DosLibrary *) OpenLibrary("dos.library", 37)) { rargs[0] = 0L; rargs[1] = 0L; rargs[2] = 0L; rargs[3] = 0L; rargs[4] = 0L; if (readargs = ReadArgs("SOURCE/A,TARGET/A,DATE/S,ALL/S,BUFFER/K/N", rargs, NULL)) { source = (UBYTE *) rargs[0]; target = (UBYTE *) rargs[1]; checkdatestamp = (BOOL) rargs[2]; all = (BOOL) rargs[3]; if (!(sourcedir = AllocMem(StrLen(source) + 129, MEMF_CLEAR))) error = ERROR_NO_FREE_STORE; else { /* 128 bytes to print informative text */ textbuffer = sourcedir + StrLen(source) + 1; /* use user specified buffersize if indicated */ if (rargs[4]) buffersize = *((LONG *) rargs[4]); if (buffersize < BUFFERSIZE || buffersize > 4096) buffersize = BUFFERSIZE; if (!(targetdir = AllocMem(buffersize, MEMF_CLEAR))) error = ERROR_NO_FREE_STORE; else { if (!(targetfib = AllocDosObject(DOS_FIB, NULL))) error = ERROR_NO_FREE_STORE; else { /* * Check if source and target are valid. * * Separate source path from pattern (if any). Use the source path figure * out what to append to the target. */ /* No requesters */ process = (struct Process *) FindTask(NULL); wptr = process->pr_WindowPtr; process->pr_WindowPtr = (APTR) - 1L; if ((error = GetPath(source, sourcedir, StrLen(source) + 1) == 0)) { if (!(dirlock = Lock(sourcedir, SHARED_LOCK))) error = IoErr(); else { UnLock(dirlock); if (!(dirlock = Lock(target, SHARED_LOCK))) error = IoErr(); else { UnLock(dirlock); if (anchorpath = AllocMem(sizeof(struct AnchorPath) + buffersize, MEMF_CLEAR)) { anchorpath->ap_Strlen = buffersize; /* Allow to break on CTRL-C */ anchorpath->ap_BreakBits = SIGBREAKF_CTRL_C; if ((error = MatchFirst(source, anchorpath)) == 0) { do { fib = &(anchorpath->ap_Info); /* * APF_DIDDIR indicates that we used returned from a * directory. In that case we clear both APF_DIDDIR and * APF_DODIR, so we can start afresh with the next one. */ if (anchorpath->ap_Flags & APF_DIDDIR) anchorpath->ap_Flags &= ~(APF_DODIR | APF_DIDDIR); else { /* * Make a filename for the target directory. First copy * targetname into buffer. */ targetdir[0] = '\0'; tmp = targetdir; tmp1 = target; while (*tmp++ = *tmp1++); /* Skip sourcename in ap_Buf */ tmp1 = sourcedir; tmp2 = anchorpath->ap_Buf; while (*tmp1++ == *tmp2++); /* Skip back 1 if not after a separator */ if (*(tmp2 - 1) != '/') tmp2--; /* * We hit the source itself, don't compare it, but enter * it. */ if (*tmp2 == 0) { anchorpath->ap_Flags |= APF_DODIR; continue; } /* Build it */ if (AddPart(targetdir, tmp2, buffersize - 1)) vargs[0] = (LONG) targetdir; else { PrintFault(ERROR_NO_FREE_STORE, NULL); break; } /* Lock it and check it out */ if (filelock = Lock(targetdir, SHARED_LOCK)) { if ((Examine(filelock, targetfib)) == DOSTRUE) { textbuffer[0] = '\0'; /* * To get nice output without work I use AddPart() to * add differences to the textbuffer. */ if (targetfib->fib_DirEntryType != fib->fib_DirEntryType) AddPart(textbuffer, "of different type", 128); else { if (targetfib->fib_Size < fib->fib_Size) AddPart(textbuffer, "smaller", 128); else if (targetfib->fib_Size > fib->fib_Size) AddPart(textbuffer, "larger", 128); if (checkdatestamp) { date = CompareDates((struct DateStamp *) & (fib->fib_Date), (struct DateStamp *) & (targetfib->fib_Date)); if (date < 0) AddPart(textbuffer, "older", 128); else if (date > 0) AddPart(textbuffer, "newer", 128); } } if (*textbuffer != NULL) { vargs[1] = (LONG) textbuffer; VFPrintf(Output(), "%s: object %s\n", vargs); } } else PrintFault(IoErr(), targetdir); UnLock(filelock); } else { PrintFault(IoErr(), targetdir); /* * If and error occured on a directory name, don't enter * it. */ if (fib->fib_DirEntryType > 0) continue; } /* * If the ALL keyword has been used and this is a directory * enter it by setting the APF_DODIR flag. */ if (fib->fib_DirEntryType > 0 && all != FALSE) anchorpath->ap_Flags |= APF_DODIR; } } while ((error = MatchNext(anchorpath)) == 0); } MatchEnd(anchorpath); if (error == ERROR_NO_MORE_ENTRIES) error = 0; FreeMem(anchorpath, sizeof(struct AnchorPath) + buffersize); } } } /* Reset windowpointer */ process->pr_WindowPtr = wptr; } else PrintFault(error, NULL); FreeDosObject(DOS_FIB, targetfib); } FreeMem(targetdir, buffersize); } FreeMem(sourcedir, StrLen(sourcedir) + 129); } FreeArgs(readargs); } else error = IoErr(); SetIoErr(error); if (error) { PrintFault(error, NULL); if (error = ERROR_BREAK) rc = RETURN_WARN; else error = RETURN_FAIL; } CloseLibrary((struct Library *) DOSBase); } return (rc); }
BOOL CM__Hidd_ColorMap__SetColors(OOP_Class *cl, OOP_Object *o, struct pHidd_ColorMap_SetColors *msg) { struct colormap_data *data; ULONG numnew; ULONG i, col_idx; HIDDT_Color *col; HIDDT_PixelFormat *pf; data = OOP_INST_DATA(cl, o); numnew = msg->firstColor + msg->numColors; /* See if there is enough space in the array */ if (numnew > data->clut.entries) { /* Reallocate and copy */ HIDDT_Color *newmap; newmap = AllocMem(sizeof (*newmap) * numnew, MEMF_ANY); if (NULL == newmap) return FALSE; memcpy(newmap, data->clut.colors, sizeof (*newmap) * data->clut.entries); FreeMem(data->clut.colors, sizeof (*newmap) * data->clut.entries); data->clut.colors = newmap; data->clut.entries = numnew; } /* Insert the new colors */ col_idx = msg->firstColor; col = &data->clut.colors[msg->firstColor]; pf = (HIDDT_PixelFormat *)msg->pixFmt; for (i = 0; i < msg->numColors; i ++) { /* Set the color */ *col = msg->colors[i]; /* Set the pixval using the supplied pixel format */ if (IS_TRUECOLOR(pf)) { /* Map the color to a HIDDT_Pixel */ msg->colors[i].pixval = col->pixval = int_map_truecolor(col, pf); } else { msg->colors[i].pixval = col->pixval = (HIDDT_Pixel)col_idx; } /* bug("ColMap::SetColors: col %d (%x %x %x %x) mapped to %x\n" , col_idx , col->red, col->green, col->blue, col->alpha , msg->colors[i].pixval); */ col ++; col_idx ++; } return TRUE; }
LONG GetPath(UBYTE * path, UBYTE * buffer, LONG buffersize) { UBYTE *pathpart, *filepart; UBYTE *tmp1, *tmp2; BPTR lock; struct FileInfoBlock *fib; LONG error = 0; /* Open own copy of dos.library if pragmas are used so it's standalone */ #ifdef PRAGMAS struct Library *DOSBase; if (!(DOSBase = OpenLibrary("dos.library", 36))) return (1); #endif /* * If there seems to be no path, the pathpart will point to the filepart too, so we * need to check for that. */ filepart = FilePart(path); pathpart = PathPart(path); /* * This also handles cases where there is only a volume/device name, only a * directory name or a combo of those. */ if (pathpart == path) { /* * There seems to be only one component. Copy it if it is not wild. Caller will * have to check whether if it exists and if it is a file or directory. */ if (!(ItsWild(pathpart))) pathpart = NULL; } if (pathpart != path) { /* * If pathpart equals filepart (pointer wise) then there is only one component * (possible preceeded by a volume name). */ if (pathpart == filepart) { if (!(ItsWild(pathpart))) pathpart = NULL; } else { /* Try to lock it to determine if the last component is a directory. */ if (lock = Lock(path, SHARED_LOCK)) { if (fib = AllocMem(sizeof(struct FileInfoBlock), MEMF_CLEAR)) { if ((Examine(lock, fib)) == DOSTRUE) { /* Hey it's a directory after all */ if (fib->fib_DirEntryType > 0) pathpart = NULL; } FreeMem(fib, sizeof(struct FileInfoBlock)); } UnLock(lock); } /* else treat it as a filename */ } /* Copy the pathpart in the buffer */ tmp1 = buffer; tmp2 = path; while ((*tmp1++ = *tmp2++) && (tmp2 != pathpart)) { if (tmp1 == (buffer + buffersize)) { error = ERROR_NO_FREE_STORE; break; } } *tmp1 = '\0'; /* NULL terminate. */ } #ifdef PRAGMAS CloseLibrary(DOSBase); #endif return (error); }
/******************************************* Name : initVolume Descr.: maybe a better name would be mountVolume allocate resources for a new mounted device Input : device - device pointer blockdevice - name of blockdevice unit - unit number of blockdevice devicedef - medium geometry data error - return error code Output: 0 on error (error set dos dos error); pointer to struct Volume on success ********************************************/ struct Volume *initVolume ( struct AFSBase *afsbase, struct Device *device, CONST_STRPTR blockdevice, ULONG unit, struct DosEnvec *devicedef, ULONG *error ) { struct Volume *volume; volume = AllocMem(sizeof(struct Volume),MEMF_PUBLIC | MEMF_CLEAR); if (volume != NULL) { volume->device = device; volume->ioh.blockdevice = blockdevice; volume->ioh.unit = unit; volume->ioh.flags = 0; volume->SizeBlock=devicedef->de_SizeBlock; if (devicedef->de_TableSize>=20) volume->bootblocks=devicedef->de_BootBlocks; else volume->bootblocks=devicedef->de_Reserved; volume->blockcache=initCache(afsbase, volume, devicedef->de_NumBuffers); if (volume->blockcache != NULL) { if (openBlockDevice(afsbase, &volume->ioh)!= NULL) { volume->countblocks = ( ( devicedef->de_HighCyl-devicedef->de_LowCyl+1 )*devicedef->de_Surfaces*devicedef->de_BlocksPerTrack ); volume->rootblock =(volume->countblocks-1+devicedef->de_Reserved)/2; volume->startblock= devicedef->de_LowCyl* devicedef->de_Surfaces* devicedef->de_BlocksPerTrack; volume->lastblock= ( (devicedef->de_HighCyl+1) *devicedef->de_Surfaces *devicedef->de_BlocksPerTrack )-1; check64BitSupport(afsbase, volume); volume->ah.volume=volume; if (mediumPresent(&volume->ioh)) { *error = newMedium(afsbase, volume); } else *error = 0; if ((*error == 0) || (*error == ERROR_NOT_A_DOS_DISK)) { D(bug("[afs] initVolume: BootBlocks=%d\n",volume->bootblocks)); D(bug("[afs] initVolume: RootBlock=%ld\n",volume->rootblock)); volume->ah.header_block = volume->rootblock; return volume; } } else { *error=ERROR_NO_FREE_STORE; } freeCache(afsbase, volume->blockcache); } else { *error=ERROR_NO_FREE_STORE; } FreeMem(volume,sizeof(struct Volume)); } else *error=ERROR_NO_FREE_STORE; return NULL; }
// edit or display a file with vertical & horizontal scrolling & text searching int _near List_Cmd( LPTSTR pszCmdLine ) { int nFVal, nReturn = 0, argc; TCHAR szSource[MAXFILENAME+1], szFileName[MAXFILENAME+1], *pszArg; FILESEARCH dir; memset( &dir, '\0', sizeof(FILESEARCH) ); // check for and remove switches if ( GetRange( pszCmdLine, &(dir.aRanges), 0 ) != 0 ) return ERROR_EXIT; // check for /T"search string" GetMultiCharSwitch( pszCmdLine, _TEXT("T"), szSource, 255 ); if ( szSource[0] == _TEXT('"') ) sscanf( szSource+1, _TEXT("%79[^\"]"), szListFindWhat ); else if ( szSource[0] ) sprintf( szListFindWhat, FMT_PREC_STR, 79, szSource ); if ( GetSwitches( pszCmdLine, _TEXT("*HIRSWX"), &lListFlags, 0 ) != 0 ) return ( Usage( LIST_USAGE )); if ( szSource[0] ) lListFlags |= LIST_SEARCH; // check for pipe to LIST w/o explicit /S switch if ( first_arg( pszCmdLine ) == NULL ) { if ( _isatty( STDIN ) == 0 ) lListFlags |= LIST_STDIN; else if (( lListFlags & LIST_STDIN ) == 0 ) return ( Usage( LIST_USAGE )); } // initialize buffers & globals if ( ListInit() ) return ERROR_EXIT; nCurrent = nStart = 0; // ^C handling if ( setjmp( cv.env ) == -1 ) { list_abort: FindClose( dir.hdir ); Cls_Cmd( NULL ); nReturn = CTRLC; goto list_bye; } RestartFileSearch: for ( argc = 0; ; argc++ ) { // break if at end of arg list, & not listing STDIN if (( pszArg = ntharg( pszCmdLine, argc )) == NULL ) { if (( lListFlags & LIST_STDIN ) == 0 ) break; } else strcpy( szSource, pszArg ); for ( nFVal = FIND_FIRST; ; ) { szClip[0] = _TEXT('\0'); // if not reading from STDIN, get the next matching file if (( lListFlags & LIST_STDIN ) == 0 ) { // qualify filename if ( nFVal == FIND_FIRST ) { mkfname( szSource, 0 ); if ( is_dir( szSource )) mkdirname( szSource, WILD_FILE ); } if ( stricmp( szSource, CLIP ) == 0 ) { RedirToClip( szClip, 99 ); if ( CopyFromClipboard( szClip ) != 0 ) break; strcpy( szFileName, szClip ); } else if ( QueryIsPipeName( szSource )) { // only look for pipe once if ( nFVal == FIND_NEXT ) break; copy_filename( szFileName, szSource ); } else if ( find_file( nFVal, szSource, ( FIND_BYATTS | FIND_RANGE | FIND_EXCLUDE | 0x07), &dir, szFileName ) == NULL ) { nReturn = (( nFVal == FIND_FIRST ) ? ERROR_EXIT : 0 ); break; } else if ( nStart < nCurrent ) { nStart++; nFVal = FIND_NEXT; continue; } else if ( dir.ulSize > 0L ) LFile.lSize = dir.ulSize; } // clear the screen (scrolling the buffer first to save the current screen) Cls_Cmd( NULL ); if (( nReturn = _list( szFileName )) == CTRLC ) goto list_abort; if ( szClip[0] ) remove( szClip ); if ( nReturn != 0 ) break; SetCurPos( nScreenRows, 0 ); if (( szClip[0] ) || ( lListFlags & LIST_STDIN )) break; if ( LFile.hHandle > 0 ) _close( LFile.hHandle ); LFile.hHandle = -1; // increment index to current file if ( nCurrent < nStart ) { FindClose( dir.hdir ); nStart = 0; goto RestartFileSearch; } else { nFVal = FIND_NEXT; nCurrent++; nStart++; } } // we can only read STDIN once! lListFlags &= ~LIST_STDIN; } crlf(); list_bye: FreeMem( LFile.lpBufferStart ); if ( LFile.hHandle > 0 ) _close( LFile.hHandle ); LFile.hHandle = -1; return nReturn; }
static int _fastcall _list( LPTSTR pszFileName ) { register int c, i; TCHAR szDescription[512], szHeader[132], szLine[32]; long lTemp, lRow; POPWINDOWPTR wn = NULL; FILESEARCH dir; // get default normal and inverse attributes if ( gpIniptr->ListColor != 0 ) { SetScrColor( nScreenRows, nScreenColumns, gpIniptr->ListColor ); } // set colors GetAtt( (unsigned int *)&nNormal, (unsigned int *)&nInverse ); if ( gpIniptr->ListStatusColor != 0 ) nInverse = gpIniptr->ListStatusColor; // flip the first line to inverse video clear_header(); // open the file & initialize buffers if ( ListOpenFile( pszFileName )) return ERROR_EXIT; // kludge for empty files or pipes if ( LFile.lSize == 0L ) LFile.lSize = 1L; for ( ; ; ) { // display header if ( fDirtyHeader ) { clear_header(); sprintf( szHeader, LIST_HEADER, fname_part(LFile.szName), gchVerticalBar, gchVerticalBar, gchVerticalBar ); WriteStrAtt( 0, 0, nInverse, szHeader ); fDirtyHeader = 0; } // display location within file // (don't use color_printf() so we won't have // problems with windowed sessions) i = sprintf( szHeader, LIST_LINE, LFile.nListHorizOffset, LFile.lCurrentLine + gpIniptr->ListRowStart, (int)((( LFile.lViewPtr + 1 ) * 100 ) / LFile.lSize )); WriteStrAtt( 0, ( nScreenColumns - i ), nInverse, szHeader ); SetCurPos( 0, 0 ); if ( lListFlags & LIST_SEARCH ) { lListFlags &= ~LIST_SEARCH; fSearchFlags = 0; if ( lListFlags & LIST_REVERSE ) { c = LIST_FIND_CHAR_REVERSE; fSearchFlags |= FFIND_REVERSE_SEARCH; // goto the last row while ( ListMoveLine( 1 ) != 0 ) ; } else c = LIST_FIND_CHAR; if ( lListFlags & LIST_NOWILDCARDS ) fSearchFlags |= FFIND_NOWILDCARDS; bListSkipLine = 0; goto FindNext; } // get the key from the BIOS, because // STDIN might be redirected if ((( c = cvtkey( GetKeystroke( EDIT_NO_ECHO | EDIT_BIOS_KEY | EDIT_UC_SHIFT), MAP_GEN | MAP_LIST)) == (TCHAR)ESC )) break; switch ( c ) { case CTRLC: return CTRLC; case CUR_LEFT: case CTL_LEFT: if (( lListFlags & LIST_WRAP ) || ( LFile.nListHorizOffset == 0 )) goto bad_key; if (( LFile.nListHorizOffset -= (( c == CUR_LEFT ) ? 8 : 40 )) < 0 ) LFile.nListHorizOffset = 0; break; case CUR_RIGHT: case CTL_RIGHT: if (( lListFlags & LIST_WRAP ) || ( LFile.nListHorizOffset >= MAXLISTLINE + 1 )) goto bad_key; if ((LFile.nListHorizOffset += ((c == CUR_RIGHT) ? 8 : 40 )) > MAXLISTLINE + 1 ) LFile.nListHorizOffset = MAXLISTLINE+1; break; case CUR_UP: if ( ListMoveLine( -1 ) == 0 ) goto bad_key; Scroll(1, 0, nScreenRows, nScreenColumns, -1, nNormal); DisplayLine( 1, LFile.lViewPtr ); continue; case CUR_DOWN: if ( ListMoveLine( 1 ) == 0 ) goto bad_key; Scroll( 1, 0, nScreenRows, nScreenColumns, 1, nNormal ); // display last line lTemp = LFile.lViewPtr; lRow = (nScreenRows - 1); lTemp += MoveViewPtr( lTemp, &lRow ); if ( lRow == ( nScreenRows - 1 )) DisplayLine( nScreenRows, lTemp ); continue; case HOME: ListHome(); break; case END: // goto the last row list_wait( LIST_WAIT ); while ( ListMoveLine( 1 ) != 0 ) ; case PgUp: // already at TOF? if ( LFile.lViewPtr == 0L ) goto bad_key; for ( i = 1; (( i < nScreenRows ) && ( ListMoveLine( -1 ) != 0 )); i++ ) ; break; case PgDn: case SPACE: if ( ListMoveLine( nScreenRows - 1 ) == 0 ) goto bad_key; break; case F1: // help // don't allow a ^X exit from HELP _help( gpInternalName, HELP_NX ); continue; case TAB: // change tab size // disable ^C / ^BREAK handling HoldSignals(); wn = wOpen( 2, 5, 4, strlen( LIST_TABSIZE ) + 10, nInverse, LIST_TABSIZE_TITLE, NULL ); wn->nAttrib = nNormal; wClear(); wWriteListStr( 0, 1, wn, LIST_TABSIZE ); egets( szLine, 2, (EDIT_DIALOG | EDIT_BIOS_KEY | EDIT_NO_CRLF | EDIT_DIGITS)); wRemove( wn ); if (( i = atoi( szLine )) > 0 ) TABSIZE = i; // enable ^C / ^BREAK handling EnableSignals(); break; case DEL: // delete this file if (( lListFlags & LIST_STDIN ) == 0 ) { // disable ^C / ^BREAK handling HoldSignals(); wn = wOpen( 2, 5, 4, strlen( LIST_DELETE ) + 10, nInverse, LIST_DELETE_TITLE, NULL ); wn->nAttrib = nNormal; wClear(); wWriteListStr( 0, 1, wn, LIST_DELETE ); i = GetKeystroke( EDIT_ECHO | EDIT_BIOS_KEY | EDIT_UC_SHIFT ); wRemove( wn ); // enable ^C / ^BREAK handling EnableSignals(); if ( i == (TCHAR)YES_CHAR ) { if ( LFile.hHandle > 0 ) _close( LFile.hHandle ); LFile.hHandle = -1; remove( pszFileName ); return 0; } } break; case INS: // save to a file ListSaveFile(); break; case LIST_INFO_CHAR: { unsigned int uSize = 1024; TCHAR _far *lpszText, _far *lpszArg; int fFSType, fSFN = 1; TCHAR szBuf[16]; DOSFILEDATE laDir, crDir; // disable ^C / ^BREAK handling HoldSignals(); memset( &dir, '\0', sizeof(FILESEARCH) ); if (( lListFlags & LIST_STDIN ) == 0 ) { if ( find_file( FIND_FIRST, LFile.szName, 0x07 | FIND_CLOSE | FIND_EXACTLY, &dir, NULL ) == NULL ) { honk(); continue; } } // display info on the current file i = (( lListFlags & LIST_STDIN ) ? 5 : 10 ); if (( fFSType = ifs_type( LFile.szName )) != FAT ) i = 11; wn = wOpen( 2, 1, i, 77, nInverse, gpInternalName, NULL ); wn->nAttrib = nNormal; wClear(); i = 0; if ( lListFlags & LIST_STDIN ) wWriteStrAtt( 0, 1, nNormal, LIST_INFO_PIPE ); else { szDescription[0] = _TEXT('\0'); process_descriptions( LFile.szName, szDescription, DESCRIPTION_READ ); lpszText = lpszArg = (TCHAR _far *)AllocMem( &uSize ); strcpy(szBuf, FormatDate( dir.fd.file_date.months, dir.fd.file_date.days, dir.fd.file_date.years + 80, 0 )); if (fFSType != FAT) { FileTimeToDOSTime( &(dir.ftLastAccessTime), &( laDir.ft.wr_time), &( laDir.fd.wr_date) ); FileTimeToDOSTime( &(dir.ftCreationTime), &(crDir.ft.wr_time), &(crDir.fd.wr_date) ); strcpy( szLine, FormatDate( laDir.fd.file_date.months, laDir.fd.file_date.days, laDir.fd.file_date.years + 80, 0 )); sprintf_far( lpszText, LIST_INFO_LFN, LFile.szName, szDescription, dir.ulSize, szBuf, dir.ft.file_time.hours, gaCountryInfo.szTimeSeparator[0],dir.ft.file_time.minutes, szLine, laDir.ft.file_time.hours, gaCountryInfo.szTimeSeparator[0], laDir.ft.file_time.minutes, FormatDate( crDir.fd.file_date.months, crDir.fd.file_date.days, crDir.fd.file_date.years + 80, 0 ), crDir.ft.file_time.hours, gaCountryInfo.szTimeSeparator[0], crDir.ft.file_time.minutes); } else { sprintf_far( lpszText, LIST_INFO_FAT, LFile.szName, szDescription, dir.ulSize, szBuf, dir.ft.file_time.hours, gaCountryInfo.szTimeSeparator[0],dir.ft.file_time.minutes ); } // print the text for ( ; ( *lpszArg != _TEXT('\0') ); i++ ) { sscanf_far( lpszArg, _TEXT("%[^\n]%*c%n"), szHeader, &uSize ); // allow for long filenames ... if (( i == 0 ) && ( strlen( szHeader ) > 73 )) { c = szHeader[73]; szHeader[73] = _TEXT('\0'); wWriteStrAtt( i++, 1, nNormal, szHeader ); szHeader[73] = (TCHAR)c; wWriteStrAtt( i, 15, nNormal, szHeader+73 ); fSFN = 0; } else wWriteStrAtt( i, 1, nNormal, szHeader ); lpszArg += uSize; } FreeMem( lpszText ); } wWriteListStr( i+fSFN, 1, wn, PAUSE_PROMPT ); GetKeystroke( EDIT_NO_ECHO | EDIT_BIOS_KEY ); wRemove( wn ); // enable ^C / ^BREAK handling EnableSignals(); continue; } case LIST_GOTO_CHAR: // goto the specified line / hex offset // disable ^C / ^BREAK handling HoldSignals(); wn = wOpen( 2, 5, 4, strlen( LIST_GOTO_OFFSET ) + 20, nInverse, LIST_GOTO_TITLE, NULL ); wn->nAttrib = nNormal; wClear(); wWriteListStr( 0, 1, wn, (( lListFlags & LIST_HEX) ? LIST_GOTO_OFFSET : LIST_GOTO)); i = egets( szLine, 10, (EDIT_DIALOG | EDIT_BIOS_KEY | EDIT_NO_CRLF)); wRemove( wn ); // enable ^C / ^BREAK handling EnableSignals(); if ( i == 0 ) break; list_wait( LIST_WAIT ); // if in hex mode, jump to offset if ( lListFlags & LIST_HEX ) { strupr( szLine ); sscanf( szLine, _TEXT("%lx"), &lRow ); lRow = lRow / 0x10; } else if ( sscanf( szLine, FMT_LONG, &lRow ) == 0 ) continue; lRow -= gpIniptr->ListRowStart; if ( lRow >= 0 ) { LFile.lViewPtr = MoveViewPtr( 0L, &lRow ); LFile.lCurrentLine = lRow; } else { LFile.lViewPtr += MoveViewPtr( LFile.lViewPtr, &lRow ); LFile.lCurrentLine += lRow; } break; case LIST_HIBIT_CHAR: // toggle high bit filter lListFlags ^= LIST_HIBIT; break; case LIST_WRAP_CHAR: // toggle line wrap lListFlags ^= LIST_WRAP; nRightMargin = (( lListFlags & LIST_WRAP ) ? GetScrCols() : MAXLISTLINE ); // recalculate current line list_wait( LIST_WAIT ); // get start of line LFile.nListHorizOffset = 0; // line number probably changed, so recompute everything LFile.lCurrentLine = ComputeLines( 0L, LFile.lViewPtr ); LFile.lViewPtr = MoveViewPtr( 0L, &(LFile.lCurrentLine )); break; case LIST_HEX_CHAR: // toggle hex display lListFlags ^= LIST_HEX; // if hex, reset to previous 16-byte // boundary if ( lListFlags & LIST_HEX ) { LFile.lViewPtr -= ( LFile.lViewPtr % 16 ); } else { // if not hex, reset to start of line ListMoveLine( 1 ); ListMoveLine( -1 ); } // recalculate current line list_wait( LIST_WAIT ); LFile.lCurrentLine = ComputeLines( 0L, LFile.lViewPtr ); break; case LIST_FIND_CHAR: case LIST_FIND_CHAR_REVERSE: // find first matching string bListSkipLine = 0; //lint -fallthrough case LIST_FIND_NEXT_CHAR: case LIST_FIND_NEXT_CHAR_REVERSE: // find next matching string if (( c == LIST_FIND_CHAR ) || ( c == LIST_FIND_CHAR_REVERSE )) { // disable ^C / ^BREAK handling HoldSignals(); fSearchFlags = 0; wn = wOpen( 2, 1, 4, 75, nInverse, (( c == LIST_FIND_NEXT_CHAR_REVERSE ) ? LIST_FIND_TITLE_REVERSE : LIST_FIND_TITLE ), NULL ); wn->nAttrib = nNormal; wClear(); if ( lListFlags & LIST_HEX ) { wWriteListStr( 0, 1, wn, LIST_FIND_HEX ); if ( GetKeystroke( EDIT_ECHO | EDIT_BIOS_KEY | EDIT_UC_SHIFT ) == YES_CHAR ) fSearchFlags |= FFIND_HEX_SEARCH; wClear(); } wWriteListStr( 0, 1, wn, LIST_FIND ); egets( szListFindWhat, 64, (EDIT_DIALOG | EDIT_BIOS_KEY | EDIT_NO_CRLF)); wRemove( wn ); // enable ^C / ^BREAK handling EnableSignals(); } else { FindNext: // a "Next" has to be from current position fSearchFlags &= ~FFIND_TOPSEARCH; } if ( szListFindWhat[0] == _TEXT('\0') ) continue; sprintf( szDescription, LIST_FIND_WAIT, szListFindWhat ); list_wait( szDescription ); // save start position lTemp = LFile.lViewPtr; lRow = LFile.lCurrentLine; if (( c == LIST_FIND_CHAR_REVERSE ) || ( c == LIST_FIND_NEXT_CHAR_REVERSE )) { // start on the previous line fSearchFlags |= FFIND_REVERSE_SEARCH; } else { fSearchFlags &= ~FFIND_REVERSE_SEARCH; // skip the first line (except on /T"xxx") if ( bListSkipLine ) ListMoveLine( 1 ); } bListSkipLine = 1; if ( SearchFile( fSearchFlags ) != 1 ) { ListSetCurrent( lTemp ); LFile.lViewPtr = lTemp; LFile.lCurrentLine = lRow; } else LFile.fDisplaySearch = (( fSearchFlags & FFIND_CHECK_CASE ) ? 2 : 1 ); break; case LIST_PRINT_CHAR: // print the file ListPrintFile(); continue; case LIST_CONTINUE_CHAR: case CTL_PgDn: return 0; case LIST_PREVIOUS_CHAR: case CTL_PgUp: // previous file if ( nCurrent > 0 ) { nCurrent--; return 0; } //lint -fallthrough default: bad_key: honk(); continue; } // rewrite the display ListUpdateScreen(); } return 0; }
BOOL AppMemSeemsLow(Size size) { return ( FreeMem() < kAppMemSafetyMargin + size ) ; }