Expand tabs to spaces in rarely used (ancient) files

* extra/AmigaOS.c: Expand tabs to spaces.
* extra/MacOS.c: Likewise.
* extra/Mac_files/dataend.c: Likewise.
* extra/Mac_files/datastart.c: Likewise.
* extra/symbian.cpp: Likewise.
* cord/cordxtra.c: Likewise.

1 files changed, 268 insertions, 268 deletions

diff --git a/extra/AmigaOS.c b/extra/AmigaOS.c
index 759b3dfb..4c747abd 100644
--- a/extra/AmigaOS.c
+++ b/extra/AmigaOS.c
@@ -47,13 +47,13 @@ ptr_t GC_get_main_stack_base()
     /* Reference: Amiga Guru Book Pages: 42,567,574 */
     if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS
         && proc->pr_CLI != NULL) {
-	/* first ULONG is StackSize */
-	/*longPtr = proc->pr_ReturnAddr;
-	size = longPtr[0];*/
+        /* first ULONG is StackSize */
+        /*longPtr = proc->pr_ReturnAddr;
+        size = longPtr[0];*/
 
-	return (char *)proc->pr_ReturnAddr + sizeof(ULONG);
+        return (char *)proc->pr_ReturnAddr + sizeof(ULONG);
     } else {
-	return (char *)proc->pr_Task.tc_SPUpper;
+        return (char *)proc->pr_Task.tc_SPUpper;
     }
 }
 
@@ -69,16 +69,16 @@ ptr_t GC_get_stack_base()
     long size;
 
     if ((task = FindTask(0)) == 0) {
-	GC_err_puts("Cannot find own task structure\n");
-	ABORT("task missing");
+        GC_err_puts("Cannot find own task structure\n");
+        ABORT("task missing");
     }
     proc = (struct Process *)task;
     cli = BADDR(proc->pr_CLI);
 
     if (_WBenchMsg != 0 || cli == 0) {
-	size = (char *)task->tc_SPUpper - (char *)task->tc_SPLower;
+        size = (char *)task->tc_SPUpper - (char *)task->tc_SPLower;
     } else {
-	size = cli->cli_DefaultStack * 4;
+        size = cli->cli_DefaultStack * 4;
     }
     return (ptr_t)(__base + GC_max(size, __stack));
 }
@@ -95,96 +95,96 @@ ptr_t GC_get_stack_base()
 
    void GC_register_data_segments()
    {
-     struct Process	*proc;
+     struct Process     *proc;
      struct CommandLineInterface *cli;
      BPTR myseglist;
      ULONG *data;
 
-     int	num;
+     int        num;
 
 
 #    ifdef __GNUC__
         ULONG dataSegSize;
         GC_bool found_segment = FALSE;
-	extern char __data_size[];
+        extern char __data_size[];
 
-	dataSegSize=__data_size+8;
-	/* Can`t find the Location of __data_size, because
+        dataSegSize=__data_size+8;
+        /* Can`t find the Location of __data_size, because
            it`s possible that is it, inside the segment. */
 
 #     endif
 
-	proc= (struct Process*)SysBase->ThisTask;
-
-	/* Reference: Amiga Guru Book Pages: 538ff,565,573
-		     and XOper.asm */
-	if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS) {
-	  if (proc->pr_CLI == NULL) {
-	    myseglist = proc->pr_SegList;
-	  } else {
-	    /* ProcLoaded	'Loaded as a command: '*/
-	    cli = BADDR(proc->pr_CLI);
-	    myseglist = cli->cli_Module;
-	  }
-	} else {
-	  ABORT("Not a Process.");
- 	}
-
-	if (myseglist == NULL) {
-	    ABORT("Arrrgh.. can't find segments, aborting");
- 	}
-
-	/* xoper hunks Shell Process */
-
-	num=0;
+        proc= (struct Process*)SysBase->ThisTask;
+
+        /* Reference: Amiga Guru Book Pages: 538ff,565,573
+                     and XOper.asm */
+        if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS) {
+          if (proc->pr_CLI == NULL) {
+            myseglist = proc->pr_SegList;
+          } else {
+            /* ProcLoaded       'Loaded as a command: '*/
+            cli = BADDR(proc->pr_CLI);
+            myseglist = cli->cli_Module;
+          }
+        } else {
+          ABORT("Not a Process.");
+        }
+
+        if (myseglist == NULL) {
+            ABORT("Arrrgh.. can't find segments, aborting");
+        }
+
+        /* xoper hunks Shell Process */
+
+        num=0;
         for (data = (ULONG *)BADDR(myseglist); data != NULL;
              data = (ULONG *)BADDR(data[0])) {
-	  if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
-	      ((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
+          if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
+              ((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
 #             ifdef __GNUC__
-		if (dataSegSize == data[-1]) {
-		  found_segment = TRUE;
-		}
-# 	      endif
-	      GC_add_roots_inner((char *)&data[1],
-				 ((char *)&data[1]) + data[-1], FALSE);
+                if (dataSegSize == data[-1]) {
+                  found_segment = TRUE;
+                }
+#             endif
+              GC_add_roots_inner((char *)&data[1],
+                                 ((char *)&data[1]) + data[-1], FALSE);
           }
           ++num;
         } /* for */
-# 	ifdef __GNUC__
-	   if (!found_segment) {
-	     ABORT("Can`t find correct Segments.\nSolution: Use an newer version of ixemul.library");
-	   }
-# 	endif
+#       ifdef __GNUC__
+           if (!found_segment) {
+             ABORT("Can`t find correct Segments.\nSolution: Use an newer version of ixemul.library");
+           }
+#       endif
   }
 
 #if 0 /* old version */
   void GC_register_data_segments()
   {
     extern struct WBStartup *_WBenchMsg;
-    struct Process	*proc;
+    struct Process      *proc;
     struct CommandLineInterface *cli;
     BPTR myseglist;
     ULONG *data;
 
     if ( _WBenchMsg != 0 ) {
-	if ((myseglist = _WBenchMsg->sm_Segment) == 0) {
-	    GC_err_puts("No seglist from workbench\n");
-	    return;
-	}
+        if ((myseglist = _WBenchMsg->sm_Segment) == 0) {
+            GC_err_puts("No seglist from workbench\n");
+            return;
+        }
     } else {
-	if ((proc = (struct Process *)FindTask(0)) == 0) {
-	    GC_err_puts("Cannot find process structure\n");
-	    return;
-	}
-	if ((cli = BADDR(proc->pr_CLI)) == 0) {
-	    GC_err_puts("No CLI\n");
-	    return;
-	}
-	if ((myseglist = cli->cli_Module) == 0) {
-	    GC_err_puts("No seglist from CLI\n");
-	    return;
-	}
+        if ((proc = (struct Process *)FindTask(0)) == 0) {
+            GC_err_puts("Cannot find process structure\n");
+            return;
+        }
+        if ((cli = BADDR(proc->pr_CLI)) == 0) {
+            GC_err_puts("No CLI\n");
+            return;
+        }
+        if ((myseglist = cli->cli_Module) == 0) {
+            GC_err_puts("No seglist from CLI\n");
+            return;
+        }
     }
 
     for (data = (ULONG *)BADDR(myseglist); data != 0;
@@ -192,11 +192,11 @@ ptr_t GC_get_stack_base()
 #        ifdef AMIGA_SKIP_SEG
            if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
            ((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
-#	 else
-      	   {
-#	 endif /* AMIGA_SKIP_SEG */
+#        else
+           {
+#        endif /* AMIGA_SKIP_SEG */
           GC_add_roots_inner((char *)&data[1],
-          		     ((char *)&data[1]) + data[-1], FALSE);
+                             ((char *)&data[1]) + data[-1], FALSE);
          }
     }
   }
@@ -212,11 +212,11 @@ ptr_t GC_get_stack_base()
 #ifndef GC_AMIGA_FASTALLOC
 
 void *GC_amiga_allocwrapper(size_t size,void *(*AllocFunction)(size_t size2)){
-	return (*AllocFunction)(size);
+        return (*AllocFunction)(size);
 }
 
 void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2))
-	=GC_amiga_allocwrapper;
+        =GC_amiga_allocwrapper;
 
 #else
 
@@ -226,13 +226,13 @@ void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size
 void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2));
 
 void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2))
-	=GC_amiga_allocwrapper_firsttime;
+        =GC_amiga_allocwrapper_firsttime;
 
 
 /******************************************************************
    Amiga-spesific routines to obtain memory, and force GC to give
    back fast-mem whenever possible.
-	These hacks makes gc-programs go many times faster when
+        These hacks makes gc-programs go many times faster when
    the amiga is low on memory, and are therefore strictly necesarry.
 
    -Kjetil S. Matheussen, 2000.
@@ -243,8 +243,8 @@ void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size
 /* List-header for all allocated memory. */
 
 struct GC_Amiga_AllocedMemoryHeader{
-	ULONG size;
-	struct GC_Amiga_AllocedMemoryHeader *next;
+        ULONG size;
+        struct GC_Amiga_AllocedMemoryHeader *next;
 };
 struct GC_Amiga_AllocedMemoryHeader *GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(int)~(NULL);
 
@@ -285,42 +285,42 @@ int ncur151=0;
 /* Free everything at program-end. */
 
 void GC_amiga_free_all_mem(void){
-	struct GC_Amiga_AllocedMemoryHeader *gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(GC_AMIGAMEM));
-	struct GC_Amiga_AllocedMemoryHeader *temp;
+        struct GC_Amiga_AllocedMemoryHeader *gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(GC_AMIGAMEM));
+        struct GC_Amiga_AllocedMemoryHeader *temp;
 
 #ifdef GC_AMIGA_PRINTSTATS
-	printf("\n\n"
-		"%d bytes of chip-mem, and %d bytes of fast-mem where allocated from the OS.\n",
-		allochip,allocfast
-	);
-	printf(
-		"%d bytes of chip-mem were returned from the GC_AMIGA_FASTALLOC supported allocating functions.\n",
-		chipa
-	);
-	printf("\n");
-	printf("GC_gcollect was called %d times to avoid returning NULL or start allocating with the MEMF_ANY flag.\n",numcollects);
-	printf("%d of them was a success. (the others had to use allocation from the OS.)\n",nullretries);
-	printf("\n");
-	printf("Succeded forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",succ,succ2);
-	printf("Failed forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",nsucc,nsucc2);
-	printf("\n");
-	printf(
-		"Number of retries before succeding a chip->fast force:\n"
-		"0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
-		cur0,cur1,cur10,cur50,cur150,cur151
-	);
-	printf(
-		"Number of retries before giving up a chip->fast force:\n"
-		"0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
-		ncur0,ncur1,ncur10,ncur50,ncur150,ncur151
-	);
+        printf("\n\n"
+                "%d bytes of chip-mem, and %d bytes of fast-mem where allocated from the OS.\n",
+                allochip,allocfast
+        );
+        printf(
+                "%d bytes of chip-mem were returned from the GC_AMIGA_FASTALLOC supported allocating functions.\n",
+                chipa
+        );
+        printf("\n");
+        printf("GC_gcollect was called %d times to avoid returning NULL or start allocating with the MEMF_ANY flag.\n",numcollects);
+        printf("%d of them was a success. (the others had to use allocation from the OS.)\n",nullretries);
+        printf("\n");
+        printf("Succeded forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",succ,succ2);
+        printf("Failed forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",nsucc,nsucc2);
+        printf("\n");
+        printf(
+                "Number of retries before succeding a chip->fast force:\n"
+                "0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
+                cur0,cur1,cur10,cur50,cur150,cur151
+        );
+        printf(
+                "Number of retries before giving up a chip->fast force:\n"
+                "0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
+                ncur0,ncur1,ncur10,ncur50,ncur150,ncur151
+        );
 #endif
 
-	while(gc_am!=NULL){
-		temp=gc_am->next;
-		FreeMem(gc_am,gc_am->size);
-		gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(temp));
-	}
+        while(gc_am!=NULL){
+                temp=gc_am->next;
+                FreeMem(gc_am,gc_am->size);
+                gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(temp));
+        }
 }
 
 #ifndef GC_AMIGA_ONLYFAST
@@ -346,36 +346,36 @@ size_t latestsize;
  */
 
 void *GC_amiga_get_mem(size_t size){
-	struct GC_Amiga_AllocedMemoryHeader *gc_am;
+        struct GC_Amiga_AllocedMemoryHeader *gc_am;
 
 #ifndef GC_AMIGA_ONLYFAST
-	if(GC_amiga_dontalloc==TRUE){
-//		printf("rejected, size: %d, latestsize: %d\n",size,latestsize);
-		return NULL;
-	}
+        if(GC_amiga_dontalloc==TRUE){
+//              printf("rejected, size: %d, latestsize: %d\n",size,latestsize);
+                return NULL;
+        }
 
-	// We really don't want to use chip-mem, but if we must, then as little as possible.
-	if(GC_AMIGA_MEMF==(MEMF_ANY|MEMF_CLEAR) && size>100000 && latestsize<50000) return NULL;
+        // We really don't want to use chip-mem, but if we must, then as little as possible.
+        if(GC_AMIGA_MEMF==(MEMF_ANY|MEMF_CLEAR) && size>100000 && latestsize<50000) return NULL;
 #endif
 
-	gc_am=AllocMem((ULONG)(size + sizeof(struct GC_Amiga_AllocedMemoryHeader)),GC_AMIGA_MEMF);
-	if(gc_am==NULL) return NULL;
+        gc_am=AllocMem((ULONG)(size + sizeof(struct GC_Amiga_AllocedMemoryHeader)),GC_AMIGA_MEMF);
+        if(gc_am==NULL) return NULL;
 
-	gc_am->next=GC_AMIGAMEM;
-	gc_am->size=size + sizeof(struct GC_Amiga_AllocedMemoryHeader);
-	GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(gc_am));
+        gc_am->next=GC_AMIGAMEM;
+        gc_am->size=size + sizeof(struct GC_Amiga_AllocedMemoryHeader);
+        GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(gc_am));
 
-//	printf("Allocated %d (%d) bytes at address: %x. Latest: %d\n",size,tot,gc_am,latestsize);
+//      printf("Allocated %d (%d) bytes at address: %x. Latest: %d\n",size,tot,gc_am,latestsize);
 
 #ifdef GC_AMIGA_PRINTSTATS
-	if((char *)gc_am<chipmax){
-		allochip+=size;
-	}else{
-		allocfast+=size;
-	}
+        if((char *)gc_am<chipmax){
+                allochip+=size;
+        }else{
+                allocfast+=size;
+        }
 #endif
 
-	return gc_am+1;
+        return gc_am+1;
 
 }
 
@@ -391,40 +391,40 @@ void *GC_amiga_get_mem(size_t size){
  */
 #ifdef GC_AMIGA_RETRY
 void *GC_amiga_rec_alloc(size_t size,void *(*AllocFunction)(size_t size2),const int rec){
-	void *ret;
+        void *ret;
 
-	ret=(*AllocFunction)(size);
+        ret=(*AllocFunction)(size);
 
 #ifdef GC_AMIGA_PRINTSTATS
-	if((char *)ret>chipmax || ret==NULL){
-		if(ret==NULL){
-			nsucc++;
-			nsucc2+=size;
-			if(rec==0) ncur0++;
-			if(rec==1) ncur1++;
-			if(rec>1 && rec<10) ncur10++;
-			if(rec>=10 && rec<50) ncur50++;
-			if(rec>=50 && rec<150) ncur150++;
-			if(rec>=150) ncur151++;
-		}else{
-			succ++;
-			succ2+=size;
-			if(rec==0) cur0++;
-			if(rec==1) cur1++;
-			if(rec>1 && rec<10) cur10++;
-			if(rec>=10 && rec<50) cur50++;
-			if(rec>=50 && rec<150) cur150++;
-			if(rec>=150) cur151++;
-		}
-	}
+        if((char *)ret>chipmax || ret==NULL){
+                if(ret==NULL){
+                        nsucc++;
+                        nsucc2+=size;
+                        if(rec==0) ncur0++;
+                        if(rec==1) ncur1++;
+                        if(rec>1 && rec<10) ncur10++;
+                        if(rec>=10 && rec<50) ncur50++;
+                        if(rec>=50 && rec<150) ncur150++;
+                        if(rec>=150) ncur151++;
+                }else{
+                        succ++;
+                        succ2+=size;
+                        if(rec==0) cur0++;
+                        if(rec==1) cur1++;
+                        if(rec>1 && rec<10) cur10++;
+                        if(rec>=10 && rec<50) cur50++;
+                        if(rec>=50 && rec<150) cur150++;
+                        if(rec>=150) cur151++;
+                }
+        }
 #endif
 
-	if (((char *)ret)<=chipmax && ret!=NULL && (rec<(size>500000?9:size/5000))){
-		ret=GC_amiga_rec_alloc(size,AllocFunction,rec+1);
-//		GC_free(ret2);
-	}
+        if (((char *)ret)<=chipmax && ret!=NULL && (rec<(size>500000?9:size/5000))){
+                ret=GC_amiga_rec_alloc(size,AllocFunction,rec+1);
+//              GC_free(ret2);
+        }
 
-	return ret;
+        return ret;
 }
 #endif
 
@@ -435,81 +435,81 @@ void *GC_amiga_rec_alloc(size_t size,void *(*AllocFunction)(size_t size2),const
 
 
 void *GC_amiga_allocwrapper_any(size_t size,void *(*AllocFunction)(size_t size2)){
-	void *ret,*ret2;
+        void *ret,*ret2;
 
-	GC_amiga_dontalloc=TRUE;	// Pretty tough thing to do, but its indeed necesarry.
-	latestsize=size;
+        GC_amiga_dontalloc=TRUE;        // Pretty tough thing to do, but its indeed necesarry.
+        latestsize=size;
 
-	ret=(*AllocFunction)(size);
+        ret=(*AllocFunction)(size);
 
-	if(((char *)ret) <= chipmax){
-		if(ret==NULL){
-			//Give GC access to allocate memory.
+        if(((char *)ret) <= chipmax){
+                if(ret==NULL){
+                        //Give GC access to allocate memory.
 #ifdef GC_AMIGA_GC
-			if(!GC_dont_gc){
-				GC_gcollect();
+                        if(!GC_dont_gc){
+                                GC_gcollect();
 #ifdef GC_AMIGA_PRINTSTATS
-				numcollects++;
+                                numcollects++;
 #endif
-				ret=(*AllocFunction)(size);
-			}
+                                ret=(*AllocFunction)(size);
+                        }
 #endif
-			if(ret==NULL){
-				GC_amiga_dontalloc=FALSE;
-				ret=(*AllocFunction)(size);
-				if(ret==NULL){
-					WARN("Out of Memory!  Returning NIL!\n", 0);
-				}
-			}
+                        if(ret==NULL){
+                                GC_amiga_dontalloc=FALSE;
+                                ret=(*AllocFunction)(size);
+                                if(ret==NULL){
+                                        WARN("Out of Memory!  Returning NIL!\n", 0);
+                                }
+                        }
 #ifdef GC_AMIGA_PRINTSTATS
-			else{
-				nullretries++;
-			}
-			if(ret!=NULL && (char *)ret<=chipmax) chipa+=size;
+                        else{
+                                nullretries++;
+                        }
+                        if(ret!=NULL && (char *)ret<=chipmax) chipa+=size;
 #endif
-		}
+                }
 #ifdef GC_AMIGA_RETRY
-		else{
-			/* We got chip-mem. Better try again and again and again etc., we might get fast-mem sooner or later... */
-			/* Using gctest to check the effectiviness of doing this, does seldom give a very good result. */
-			/* However, real programs doesn't normally rapidly allocate and deallocate. */
-//			printf("trying to force... %d bytes... ",size);
-			if(
-				AllocFunction!=GC_malloc_uncollectable
+                else{
+                        /* We got chip-mem. Better try again and again and again etc., we might get fast-mem sooner or later... */
+                        /* Using gctest to check the effectiviness of doing this, does seldom give a very good result. */
+                        /* However, real programs doesn't normally rapidly allocate and deallocate. */
+//                      printf("trying to force... %d bytes... ",size);
+                        if(
+                                AllocFunction!=GC_malloc_uncollectable
 #ifdef ATOMIC_UNCOLLECTABLE
-				&& AllocFunction!=GC_malloc_atomic_uncollectable
+                                && AllocFunction!=GC_malloc_atomic_uncollectable
 #endif
-			){
-				ret2=GC_amiga_rec_alloc(size,AllocFunction,0);
-			}else{
-				ret2=(*AllocFunction)(size);
+                        ){
+                                ret2=GC_amiga_rec_alloc(size,AllocFunction,0);
+                        }else{
+                                ret2=(*AllocFunction)(size);
 #ifdef GC_AMIGA_PRINTSTATS
-				if((char *)ret2<chipmax || ret2==NULL){
-					nsucc++;
-					nsucc2+=size;
-					ncur0++;
-				}else{
-					succ++;
-					succ2+=size;
-					cur0++;
-				}
+                                if((char *)ret2<chipmax || ret2==NULL){
+                                        nsucc++;
+                                        nsucc2+=size;
+                                        ncur0++;
+                                }else{
+                                        succ++;
+                                        succ2+=size;
+                                        cur0++;
+                                }
 #endif
-			}
-			if(((char *)ret2)>chipmax){
-//				printf("Succeeded.\n");
-				GC_free(ret);
-				ret=ret2;
-			}else{
-				GC_free(ret2);
-//				printf("But did not succeed.\n");
-			}
-		}
+                        }
+                        if(((char *)ret2)>chipmax){
+//                              printf("Succeeded.\n");
+                                GC_free(ret);
+                                ret=ret2;
+                        }else{
+                                GC_free(ret2);
+//                              printf("But did not succeed.\n");
+                        }
+                }
 #endif
-	}
+        }
 
-	GC_amiga_dontalloc=FALSE;
+        GC_amiga_dontalloc=FALSE;
 
-	return ret;
+        return ret;
 }
 
 
@@ -517,52 +517,52 @@ void *GC_amiga_allocwrapper_any(size_t size,void *(*AllocFunction)(size_t size2)
 void (*GC_amiga_toany)(void)=NULL;
 
 void GC_amiga_set_toany(void (*func)(void)){
-	GC_amiga_toany=func;
+        GC_amiga_toany=func;
 }
 
 #endif // !GC_AMIGA_ONLYFAST
 
 
 void *GC_amiga_allocwrapper_fast(size_t size,void *(*AllocFunction)(size_t size2)){
-	void *ret;
+        void *ret;
 
-	ret=(*AllocFunction)(size);
+        ret=(*AllocFunction)(size);
 
-	if(ret==NULL){
-		// Enable chip-mem allocation.
-//		printf("ret==NULL\n");
+        if(ret==NULL){
+                // Enable chip-mem allocation.
+//              printf("ret==NULL\n");
 #ifdef GC_AMIGA_GC
-		if(!GC_dont_gc){
-			GC_gcollect();
+                if(!GC_dont_gc){
+                        GC_gcollect();
 #ifdef GC_AMIGA_PRINTSTATS
-			numcollects++;
+                        numcollects++;
 #endif
-			ret=(*AllocFunction)(size);
-		}
+                        ret=(*AllocFunction)(size);
+                }
 #endif
-		if(ret==NULL){
+                if(ret==NULL){
 #ifndef GC_AMIGA_ONLYFAST
-			GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
-			if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
-			GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
-			return GC_amiga_allocwrapper_any(size,AllocFunction);
+                        GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
+                        if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
+                        GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
+                        return GC_amiga_allocwrapper_any(size,AllocFunction);
 #endif
-		}
+                }
 #ifdef GC_AMIGA_PRINTSTATS
-		else{
-			nullretries++;
-		}
+                else{
+                        nullretries++;
+                }
 #endif
-	}
+        }
 
-	return ret;
+        return ret;
 }
 
 void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2)){
-	atexit(&GC_amiga_free_all_mem);
-	chipmax=(char *)SysBase->MaxLocMem;		// For people still having SysBase in chip-mem, this might speed up a bit.
-	GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_fast;
-	return GC_amiga_allocwrapper_fast(size,AllocFunction);
+        atexit(&GC_amiga_free_all_mem);
+        chipmax=(char *)SysBase->MaxLocMem;             // For people still having SysBase in chip-mem, this might speed up a bit.
+        GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_fast;
+        return GC_amiga_allocwrapper_fast(size,AllocFunction);
 }
 
 
@@ -576,45 +576,45 @@ void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t
  */
 void *GC_amiga_realloc(void *old_object,size_t new_size_in_bytes){
 #ifndef GC_AMIGA_FASTALLOC
-	return GC_realloc(old_object,new_size_in_bytes);
+        return GC_realloc(old_object,new_size_in_bytes);
 #else
-	void *ret;
-	latestsize=new_size_in_bytes;
-	ret=GC_realloc(old_object,new_size_in_bytes);
-	if(ret==NULL && GC_AMIGA_MEMF==(MEMF_FAST | MEMF_CLEAR)){
-		/* Out of fast-mem. */
+        void *ret;
+        latestsize=new_size_in_bytes;
+        ret=GC_realloc(old_object,new_size_in_bytes);
+        if(ret==NULL && GC_AMIGA_MEMF==(MEMF_FAST | MEMF_CLEAR)){
+                /* Out of fast-mem. */
 #ifdef GC_AMIGA_GC
-		if(!GC_dont_gc){
-			GC_gcollect();
+                if(!GC_dont_gc){
+                        GC_gcollect();
 #ifdef GC_AMIGA_PRINTSTATS
-			numcollects++;
+                        numcollects++;
 #endif
-			ret=GC_realloc(old_object,new_size_in_bytes);
-		}
+                        ret=GC_realloc(old_object,new_size_in_bytes);
+                }
 #endif
-		if(ret==NULL){
+                if(ret==NULL){
 #ifndef GC_AMIGA_ONLYFAST
-			GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
-			if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
-			GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
-			ret=GC_realloc(old_object,new_size_in_bytes);
+                        GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
+                        if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
+                        GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
+                        ret=GC_realloc(old_object,new_size_in_bytes);
 #endif
-		}
+                }
 #ifdef GC_AMIGA_PRINTSTATS
-		else{
-			nullretries++;
-		}
+                else{
+                        nullretries++;
+                }
 #endif
-	}
-	if(ret==NULL){
-		WARN("Out of Memory!  Returning NIL!\n", 0);
-	}
+        }
+        if(ret==NULL){
+                WARN("Out of Memory!  Returning NIL!\n", 0);
+        }
 #ifdef GC_AMIGA_PRINTSTATS
-	if(((char *)ret)<chipmax && ret!=NULL){
-		chipa+=new_size_in_bytes;
-	}
+        if(((char *)ret)<chipmax && ret!=NULL){
+                chipa+=new_size_in_bytes;
+        }
 #endif
-	return ret;
+        return ret;
 #endif
 }