hg/stx-libbasic: comparison ExternalBytes.st

equal deleted inserted replaced

-:000d1c4aa7e6
+:324edacff5cc
 #  include <malloc.h>
 # endif
 #endif
 extern char *__stx_malloc(size_t);
 extern char *__stx_calloc(size_t, size_t);
 extern char *__stx_realloc(char *, size_t);
 extern void __stx_free(char *);
 extern void __stx_mallocStatistics(void);
 %}
 ! !
 !ExternalBytes primitiveFunctions!
 %{
 struct mallocList {
-char *chunk;
+	char *chunk;
-size_t size;
+	size_t size;
-struct mallocList *next;
+	struct mallocList *next;
 };
 static struct mallocList *mallocList = (struct mallocList *)0;
 static INT mallocCount = 0;
 static void
 int found = 0;
 if (@global(DebugMalloc) != true) return;
 if (ptr) {
-found = 0;
+	found = 0;
-for (this=mallocList, prev=0; this; this=next) {
+	for (this=mallocList, prev=0; this; this=next) {
-next = this->next;
+	    next = this->next;
-if (this->chunk == ptr) {
+	    if (this->chunk == ptr) {
-if (prev) {
+		if (prev) {
-prev->next = next;
+		    prev->next = next;
-} else {
+		} else {
-mallocList = next;
+		    mallocList = next;
-}
+		}
-free(this);
+		free(this);
-found++;
+		found++;
-mallocCount--;
+		mallocCount--;
-} else {
+	    } else {
-prev = this;
+		prev = this;
-}
+	    }
-}
+	}
-if (! found) {
+	if (! found) {
-console_printf("ExternalBytes [warning]: **** free: alien %"_lx_" (allocated somewhere else ?))\n", (INT)ptr);
+	    console_printf("ExternalBytes [warning]: **** free: alien %"_lx_" (allocated somewhere else ?))\n", (INT)ptr);
-}
+	}
 }
 }
 static void
 addToMallocList(char *ptr, size_t nBytes)
 int found;
 if (@global(DebugMalloc) != true) return;
 if (ptr) {
-found = 0;
+	found = 0;
-for (this=mallocList; this; this=this->next) {
+	for (this=mallocList; this; this=this->next) {
-if (this->chunk == ptr) {
+	    if (this->chunk == ptr) {
-console_printf("ExternalBytes [warning]: **** %016"_lx_" already allocated (freed somewhere else ?)\n", (INT)ptr);
+		console_printf("ExternalBytes [warning]: **** %016"_lx_" already allocated (freed somewhere else ?)\n", (INT)ptr);
-found++;
+		found++;
-}
+	    }
-}
+	}
-if (! found) {
+	if (! found) {
-e = (struct mallocList *) malloc(sizeof(struct mallocList));
+	    e = (struct mallocList *) malloc(sizeof(struct mallocList));
-e->next = mallocList;
+	    e->next = mallocList;
-e->chunk = ptr;
+	    e->chunk = ptr;
-e->size = nBytes;
+	    e->size = nBytes;
-mallocList = e;
+	    mallocList = e;
-mallocCount++;
+	    mallocCount++;
-}
+	}
 }
 }
 char *
 __stx_malloc(size_t nBytes) {
-char *ptr = malloc(nBytes);
+	char *ptr = malloc(nBytes);
-if (@global(TraceMalloc) == true) {
+	if (@global(TraceMalloc) == true) {
-console_printf("ExternalBytes [info]: allocated %d bytes at: %016"_lx_"\n", nBytes, (INT)ptr);
+	    console_printf("ExternalBytes [info]: allocated %d bytes at: %016"_lx_"\n", nBytes, (INT)ptr);
-}
+	}
-addToMallocList(ptr, nBytes);
+	addToMallocList(ptr, nBytes);
-return ptr;
+	return ptr;
 }
 char *
 __stx_calloc(size_t n, size_t size) {
-char *ptr = __stx_malloc(n * size);
+	char *ptr = __stx_malloc(n * size);
-if (ptr != 0) {
+	if (ptr != 0) {
-bzero(ptr, (n * size));
+	    bzero(ptr, (n * size));
-}
+	}
-return ptr;
+	return ptr;
 }
 char *
 __stx_realloc(char *ptr, size_t nBytes)
 {
-char *newPtr;
+	char *newPtr;
-removeFromMallocList(ptr);
+	removeFromMallocList(ptr);
-newPtr = realloc(ptr, nBytes);
+	newPtr = realloc(ptr, nBytes);
-addToMallocList(newPtr, nBytes);
+	addToMallocList(newPtr, nBytes);
-if (@global(TraceMalloc) == true) {
+	if (@global(TraceMalloc) == true) {
-console_printf("ExternalBytes [info]: realloc %d bytes for %"_lx_" at: %"_lx_"\n", nBytes, (INT)ptr, (INT)newPtr);
+	    console_printf("ExternalBytes [info]: realloc %d bytes for %"_lx_" at: %"_lx_"\n", nBytes, (INT)ptr, (INT)newPtr);
-}
+	}
-return newPtr;
+	return newPtr;
 }
 void
 __stx_free(char *ptr)
 {
-if (@global(TraceMalloc) == true) {
+	if (@global(TraceMalloc) == true) {
-console_printf("ExternalBytes: free bytes at: %"_lx_"\n", (INT)ptr);
+	    console_printf("ExternalBytes: free bytes at: %"_lx_"\n", (INT)ptr);
-}
+	}
-removeFromMallocList(ptr);
+	removeFromMallocList(ptr);
-free(ptr);
+	free(ptr);
 }
 void
 __stx_mallocStatistics() {
-struct mallocList *this;
+	struct mallocList *this;
-int amount = 0;
+	int amount = 0;
-int n = 0;
+	int n = 0;
-for (this=mallocList; this; this=this->next) {
+	for (this=mallocList; this; this=this->next) {
-n++;
+	    n++;
-amount += this->size;
+	    amount += this->size;
-}
+	}
-console_printf("ExternalBytes [info]: allocated %d blocks with %d bytes overall\n", n, amount);
+	console_printf("ExternalBytes [info]: allocated %d blocks with %d bytes overall\n", n, amount);
 }
 %}
 ! !
 !ExternalBytes class methodsFor:'instance creation'!
 address:anAddressInteger
 "return a new ExternalBytes object to access bytes starting at anAddressInteger.
 The memory at anAddressInteger has been allocated elsewhere.
 The size is not known, therefore byte accesses will NOT be checked for valid index.
 Use this, if you get a pointer from some external source (such as a
 C-callBack function) and you have to extract bytes from that.
 DANGER ALERT: this method allows very bad things to be done to the
-system - use with GREAT care (better: do not use it)"
+		   system - use with GREAT care (better: do not use it)"
 ^ self basicNew setAddress:anAddressInteger size:nil
 "Modified (comment): / 31-03-2016 / 11:05:07 / cg"
 !
 address:anAddressInteger size:size
 "return a new ExternalBytes object to access bytes starting at anAddressInteger.
 The memory at anAddressInteger has been allocated elsewhere.
 The size is known, which allows byte accesses to be checked for valid index.
 Use this, if you get a pointer to a structure from some external source
 (such as a C-callBack function) and you have to extract things from that.
 DANGER ALERT: this method allows very bad things to be done to the
-system - use with GREAT care (better: do not use it)"
+		   system - use with GREAT care (better: do not use it)"
 ^ self basicNew setAddress:anAddressInteger size:size
 "Modified (comment): / 31-03-2016 / 11:04:27 / cg"
 !
 nChars := aString size.
 self assert:(aString bitsPerCharacter <= 16).
 extBytes := self new:((nChars+1)*2).
 1 to:nChars do:[:i |
-extBytes unsignedInt16At:(i*2) put:(aString at:i) codePoint.
+	extBytes unsignedInt16At:(i*2) put:(aString at:i) codePoint.
 ].
 extBytes unsignedInt16At:((nChars+1)*2) put:0.
 ^ extBytes
 "Modified (comment): / 31-03-2016 / 11:05:37 / cg"
 sizeofLongDouble
 "return the number of bytes used by the machine's native longdouble.
 If the machine does not support them, return nil."
 %{  /* NOCONTEXT */
-#if defined(__GNUC__) || defined(WIN32)
+#if defined(__GNUC__) || defined(__CLANG__) || defined(__win32__)
 RETURN (__mkSmallInteger( sizeof(long double)));
 #endif
 %}.
 ^ nil
 |idx word s|
 idx := 1.
 s := WriteStream on:Unicode16String new.
 [(word := self unsignedInt16At:idx) ~~ 0] whileTrue:[
-s nextPut:(Character value:word).
+	s nextPut:(Character value:word).
-idx := idx + 2.
+	idx := idx + 2.
 ].
 ^ s contents
 !
 instVarAt:index
 replaceNullTerminatedFromString:aString
 "replace elements from aString, and add a 0-byte at the end"
 |nChars|
 nChars := aString size.
 self replaceBytesFrom:1 to:nChars with:aString startingAt:1.
 self at:nChars+1 put:0.
 ! !
 free the associated heap memory with it"
 %{  /* NOCONTEXT */
 char *mem = (char *)__INST(address_);
 if (mem && (OBJ)mem != nil) {
-__stx_free(mem);
+	__stx_free(mem);
 }
 __INST(address_) = __INST(size) = nil;
 %}
 ! !
 |addr|
 "/ what a kludge - Dolphin and Squeak mean: printOn: a stream;
 "/ ST/X (and some old ST80's) mean: draw-yourself on a GC.
 (aGCOrStream isStream) ifFalse:[
-^ super displayOn:aGCOrStream
+	^ super displayOn:aGCOrStream
 ].
 aGCOrStream nextPutAll:self className.
 addr := self address.
 addr isNil ifTrue:[
-aGCOrStream nextPutAll:'[free]'.
+	aGCOrStream nextPutAll:'[free]'.
 ] ifFalse:[
-size notNil ifTrue:[
+	size notNil ifTrue:[
-aGCOrStream nextPutAll:'[sz:'.
+	    aGCOrStream nextPutAll:'[sz:'.
-size printOn:aGCOrStream.
+	    size printOn:aGCOrStream.
-aGCOrStream space.
+	    aGCOrStream space.
-] ifFalse:[
+	] ifFalse:[
-aGCOrStream nextPut:$[.
+	    aGCOrStream nextPut:$[.
-].
+	].
-aGCOrStream nextPutAll:'@'.
+	aGCOrStream nextPutAll:'@'.
-addr printOn:aGCOrStream base:16.
+	addr printOn:aGCOrStream base:16.
-aGCOrStream nextPut:$].
+	aGCOrStream nextPut:$].
 ].
 "
-self new printString
+	self new printString
-(self new:5) displayString
+	(self new:5) displayString
 "
 "Modified: / 24.2.2000 / 19:02:19 / cg"
 ! !
 %{
 /*
 * Fail if already allocated
 */
 if (__INST(address_) == nil && __isSmallInteger(numberOfBytes)) {
-INT nBytes = __smallIntegerVal(numberOfBytes);
+	INT nBytes = __smallIntegerVal(numberOfBytes);
-if (nBytes > 0) {
+	if (nBytes > 0) {
-char *space = __stx_malloc(nBytes);
+	    char *space = __stx_malloc(nBytes);
-if (space) {
+	    if (space) {
-if (doClear == true) {
+		if (doClear == true) {
-bzero(space, nBytes);
+		    bzero(space, nBytes);
-}
+		}
-__INST(address_) = (OBJ)space;
+		__INST(address_) = (OBJ)space;
-__INST(size) = numberOfBytes;
+		__INST(size) = numberOfBytes;
-RETURN(self);
+		RETURN(self);
-} else {
+	    } else {
-mallocFailure = true;
+		mallocFailure = true;
-}
+	    }
-}
+	}
 }
 %}.
 mallocFailure == true ifTrue:[
-^ MallocFailure raiseRequestWith:numberOfBytes.
+	^ MallocFailure raiseRequestWith:numberOfBytes.
 ] ifFalse:[
-self primitiveFailed.
+	self primitiveFailed.
 ].
 ! !
 !ExternalBytes methodsFor:'queries'!
 size == numberOfBytes ifTrue:[^ self].
 %{
 if (__isSmallInteger(numberOfBytes)) {
-INT nBytes = __smallIntegerVal(numberOfBytes);
+	INT nBytes = __smallIntegerVal(numberOfBytes);
-if (nBytes > 0) {
+	if (nBytes > 0) {
-char *space;
+	    char *space;
-char *prevSpace = (char *)__INST(address_);
+	    char *prevSpace = (char *)__INST(address_);
-if (prevSpace == (char *)nil)
+	    if (prevSpace == (char *)nil)
-prevSpace = 0;  /* allocate from scratch */
+		prevSpace = 0;  /* allocate from scratch */
-space = __stx_realloc(prevSpace, nBytes);
+	    space = __stx_realloc(prevSpace, nBytes);
-if (space) {
+	    if (space) {
-__INST(address_) = (OBJ)space;
+		__INST(address_) = (OBJ)space;
-__INST(size) = numberOfBytes;
+		__INST(size) = numberOfBytes;
-if (space == prevSpace) {
+		if (space == prevSpace) {
-/* same address, no re-registration */
+		    /* same address, no re-registration */
-RETURN(self);
+		    RETURN(self);
-}
+		}
-mallocStatus = true;
+		mallocStatus = true;
-} else {
+	    } else {
-mallocStatus = false;
+		mallocStatus = false;
-}
+	    }
-}
+	}
 }
 %}.
 mallocStatus == true ifTrue:[
-Lobby registerChange:self.
+	Lobby registerChange:self.
 ] ifFalse:[mallocStatus == false ifTrue:[
-^ MallocFailure raiseRequestWith:numberOfBytes.
+	^ MallocFailure raiseRequestWith:numberOfBytes.
 ] ifFalse:[
-self primitiveFailed.
+	self primitiveFailed.
 ]].
 ! !
 !ExternalBytes methodsFor:'testing'!

changeset 19860	324edacff5cc
parent 19512	e31128e0b135
child 19863	513bd7237fe7
child 20138	cd6fdc7534e4