Mercurial Mercurial > hg > stx-libbasic / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ExternalStream.st
changeset 436 b891da8db89c
parent 423 7a4bfd3cc267
child 437 a005e97d261e
equal deleted inserted replaced
435:ff583b2bb958 436:b891da8db89c 
    22 
    22 
    23 ExternalStream comment:'
 
    23 ExternalStream comment:'
 
    24 COPYRIGHT (c) 1988 by Claus Gittinger
 
    24 COPYRIGHT (c) 1988 by Claus Gittinger
 
    25 	      All Rights Reserved
 
    25 	      All Rights Reserved
 
    26 
    26 
    27 $Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.50 1995-09-08 16:45:40 claus Exp $
 
    27 $Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.51 1995-09-15 14:54:57 claus Exp $
 
    28 '!
 
    28 '!
 
    29 
    29 
    30 !ExternalStream primitiveDefinitions!
 
    30 !ExternalStream primitiveDefinitions!
 
    31 
    31 
    32 %{
 
    32 %{
 
    84 "
 
    84 "
 
    85 !
 
    85 !
 
    86 
    86 
    87 version
 
    87 version
 
    88 "
 
    88 "
 
    89 $Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.50 1995-09-08 16:45:40 claus Exp $
 
    89 $Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.51 1995-09-15 14:54:57 claus Exp $
 
    90 "
 
    90 "
 
    91 !
 
    91 !
 
    92 
    92 
    93 documentation
 
    93 documentation
 
    94 "
 
    94 "
 
  2679 		goto bad;
 
  2679 		goto bad;
 
  2680 	    }
 
  2680 	    }
 
  2681 	}
 
  2681 	}
 
  2682 
  2682 
  2683 	f = MKFD(fp);
 
  2683 	f = MKFD(fp);
 
       
  2684 
       
  2685 	if (feof(f)) {
 
       
  2686 	    _INST(hitEOF) = true;
 
       
  2687 	    RETURN (false);
 
       
  2688 	}
 
       
  2689 
  2684 	__READING__(f)
 
  2690 	__READING__(f)
 
       
  2691 
  2685 	errno = 0;
 
  2692 	errno = 0;
 
  2686 	__BEGIN_INTERRUPTABLE__
 
  2693 	__BEGIN_INTERRUPTABLE__
 
  2687 	do {
 
  2694 	do {
 
       
  2695 	    if (feof(f)) {
 
       
  2696 		break;
 
       
  2697 	    }
 
  2688 	    c = getc(f);
 
  2698 	    c = getc(f);
 
  2689 	} while ((c < 0) && (errno == EINTR));
 
  2699 	} while ((c < 0) && (errno == EINTR));
 
  2690 	__END_INTERRUPTABLE__
 
  2700 	__END_INTERRUPTABLE__
 
  2691 
  2701 
       
  2702 	if (feof(f)) {
 
       
  2703 	    _INST(hitEOF) = true;
 
       
  2704 	}
 
       
  2705 
  2692 	if (c == peekValue) {
 
  2706 	if (c == peekValue) {
 
  2693 	    OBJ pos;
 
  2707 	    OBJ pos;
 
  2694 
  2708 
  2695 	    if ((pos = _INST(position)) != nil) {
 
  2709 	    if ((pos = _INST(position)) != nil) {
 
  2696 		_INST(position) = __MKSMALLINT(__intVal(pos) + 1);
 
  2710 		_INST(position) = __MKSMALLINT(__intVal(pos) + 1);
 
  2701 	if (c != EOF) {
 
  2715 	if (c != EOF) {
 
  2702 	    ungetc(c, f);
 
  2716 	    ungetc(c, f);
 
  2703 	    RETURN (false);
 
  2717 	    RETURN (false);
 
  2704 	}
 
  2718 	}
 
  2705 
  2719 
       
  2720 	_INST(hitEOF) = true;
 
  2706 	if (ferror(f) && (errno != 0)) {
 
  2721 	if (ferror(f) && (errno != 0)) {
 
  2707 	    _INST(lastErrorNumber) = __MKSMALLINT(errno);
 
  2722 	    _INST(lastErrorNumber) = __MKSMALLINT(errno);
 
  2708 	} else {
 
  2723 	} else {
 
  2709 	    _INST(hitEOF) = true;
 
       
  2710 	    RETURN (false);
 
  2724 	    RETURN (false);
 
  2711 	}
 
  2725 	}
 
  2712     }
 
  2726     }
 
  2713 bad: ;
 
  2727 bad: ;
 
  2714 %}.
 
  2728 %}.
 
  2976     if (((fp = _INST(filePointer)) != nil)
 
  2990     if (((fp = _INST(filePointer)) != nil)
 
  2977      && (_INST(mode) != @symbol(writeonly))) {
 
  2991      && (_INST(mode) != @symbol(writeonly))) {
 
  2978 	if (_INST(binary) != true) {
 
  2992 	if (_INST(binary) != true) {
 
  2979 	    f = MKFD(fp);
 
  2993 	    f = MKFD(fp);
 
  2980             
  2994             
       
  2995             if (feof(f)) {
 
       
  2996 		_INST(hitEOF) = true;
 
       
  2997 		RETURN ( nil );
 
       
  2998 	    }
 
       
  2999 
  2981 	    __READING__(f)
 
  3000 	    __READING__(f)
 
  2982 
  3001 
  2983 	    __BEGIN_INTERRUPTABLE__
 
  3002 	    __BEGIN_INTERRUPTABLE__
 
  2984 	    while (1) {
 
  3003 	    while (1) {
 
  2985 		if (feof(f)) {
 
       
  2986 		    __END_INTERRUPTABLE__
 
       
  2987 		    _INST(hitEOF) = true;
 
       
  2988 		    RETURN ( nil );
 
       
  2989 		}
 
       
  2990 
       
  2991 		do {
 
  3004 		do {
 
       
  3005 		    if (feof(f)) {
 
       
  3006 			__END_INTERRUPTABLE__
 
       
  3007 			_INST(hitEOF) = true;
 
       
  3008 			RETURN ( nil );
 
       
  3009 		    }
 
  2992 		    c = getc(f);
 
  3010 		    c = getc(f);
 
  2993 		} while ((c < 0) && (errno == EINTR));
 
  3011 		} while ((c < 0) && (errno == EINTR));
 
  2994 
  3012 
  2995 		switch (c) {
 
  3013 		switch (c) {
 
  2996 		    case ' ':
 
  3014 		    case ' ':
 
  2997 		    case '\t':
 
  3015 		    case '\t':
 
  2998 		    case '\n':
 
  3016 		    case '\n':
 
  2999 		    case '\r':
 
  3017 		    case '\r':
 
  3000 		    case '\b':
 
  3018 		    case '\b':
 
  3001 		    case '\014':
 
  3019 		    case '\014':
 
       
  3020 			break;
 
       
  3021 
       
  3022 		    default:
 
       
  3023 			__END_INTERRUPTABLE__
 
       
  3024 			if (c < 0) {
 
       
  3025 			    _INST(hitEOF) = true;
 
       
  3026 			    if (ferror(f) && (errno != 0)) {
 
       
  3027 				_INST(lastErrorNumber) = __MKSMALLINT(errno);
 
       
  3028 				goto err;
 
       
  3029 			    }
 
       
  3030 			    RETURN ( nil );
 
       
  3031 			}
 
       
  3032 			ungetc(c, f);
 
       
  3033 			RETURN ( _MKCHARACTER(c & 0xFF) );
 
       
  3034 		}
 
       
  3035 	    }
 
       
  3036 	}
 
       
  3037     }
 
       
  3038 err: ;
 
       
  3039 %}.
 
       
  3040     lastErrorNumber notNil ifTrue:[^ self readError].
 
       
  3041     filePointer isNil ifTrue:[^ self errorNotOpen].
 
       
  3042     (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 
       
  3043     ^ self errorBinary.
 
       
  3044 !
 
       
  3045 
       
  3046 skipSeparatorsExceptCR
 
       
  3047     "skip all whitespace but no newlines;
 
       
  3048      next will return next non-white-space character
 
       
  3049      or nil if endOfFile reached. Not allowed in binary mode.
 
       
  3050      - reimplemented for speed"
 
       
  3051 
       
  3052 %{  /* NOCONTEXT */
 
       
  3053 
       
  3054     FILE *f;
 
       
  3055     int c;
 
       
  3056     OBJ fp;
 
       
  3057 
       
  3058     _INST(lastErrorNumber) = nil;
 
       
  3059     if (((fp = _INST(filePointer)) != nil)
 
       
  3060      && (_INST(mode) != @symbol(writeonly))) {
 
       
  3061 	if (_INST(binary) != true) {
 
       
  3062 	    f = MKFD(fp);
 
       
  3063 	    __READING__(f)
 
       
  3064 
       
  3065 	    __BEGIN_INTERRUPTABLE__
 
       
  3066 	    while (1) {
 
       
  3067                 
       
  3068 		if (feof(f)) {
 
       
  3069 		    __END_INTERRUPTABLE__
 
       
  3070 		    _INST(hitEOF) = true;
 
       
  3071 		    RETURN ( nil );
 
       
  3072 		}
 
       
  3073 
       
  3074 		do {
 
       
  3075 		    c = getc(f);
 
       
  3076 		} while ((c < 0) && (errno == EINTR));
 
       
  3077 
       
  3078 		switch (c) {
 
       
  3079 		    case ' ':
 
       
  3080 		    case '\t':
 
       
  3081 		    case '\b':
 
  3002 			break;
 
  3082 			break;
 
  3003 
  3083 
  3004 		    default:
 
  3084 		    default:
 
  3005 			__END_INTERRUPTABLE__
 
  3085 			__END_INTERRUPTABLE__
 
  3006 			if (c < 0) {
 
  3086 			if (c < 0) {
 
  3020 err: ;
 
  3100 err: ;
 
  3021 %}.
 
  3101 %}.
 
  3022     lastErrorNumber notNil ifTrue:[^ self readError].
 
  3102     lastErrorNumber notNil ifTrue:[^ self readError].
 
  3023     filePointer isNil ifTrue:[^ self errorNotOpen].
 
  3103     filePointer isNil ifTrue:[^ self errorNotOpen].
 
  3024     (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 
  3104     (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 
  3025     ^ self errorBinary.
 
       
  3026 !
 
       
  3027 
       
  3028 skipSeparatorsExceptCR
 
       
  3029     "skip all whitespace but no newlines;
 
       
  3030      next will return next non-white-space character
 
       
  3031      or nil if endOfFile reached. Not allowed in binary mode.
 
       
  3032      - reimplemented for speed"
 
       
  3033 
       
  3034 %{  /* NOCONTEXT */
 
       
  3035 
       
  3036     FILE *f;
 
       
  3037     int c;
 
       
  3038     OBJ fp;
 
       
  3039 
       
  3040     _INST(lastErrorNumber) = nil;
 
       
  3041     if (((fp = _INST(filePointer)) != nil)
 
       
  3042      && (_INST(mode) != @symbol(writeonly))) {
 
       
  3043 	if (_INST(binary) != true) {
 
       
  3044 	    f = MKFD(fp);
 
       
  3045 	    __READING__(f)
 
       
  3046 
       
  3047 	    __BEGIN_INTERRUPTABLE__
 
       
  3048 	    while (1) {
 
       
  3049                 
       
  3050 		if (feof(f)) {
 
       
  3051 		    __END_INTERRUPTABLE__
 
       
  3052 		    _INST(hitEOF) = true;
 
       
  3053 		    RETURN ( nil );
 
       
  3054 		}
 
       
  3055 
       
  3056 		do {
 
       
  3057 		    c = getc(f);
 
       
  3058 		} while ((c < 0) && (errno == EINTR));
 
       
  3059 
       
  3060 		switch (c) {
 
       
  3061 		    case ' ':
 
       
  3062 		    case '\t':
 
       
  3063 		    case '\b':
 
       
  3064 			break;
 
       
  3065 
       
  3066 		    default:
 
       
  3067 			__END_INTERRUPTABLE__
 
       
  3068 			if (c < 0) {
 
       
  3069 			    if (ferror(f) && (errno != 0)) {
 
       
  3070 				_INST(lastErrorNumber) = __MKSMALLINT(errno);
 
       
  3071 				goto err;
 
       
  3072 			    }
 
       
  3073 			    _INST(hitEOF) = true;
 
       
  3074 			    RETURN ( nil );
 
       
  3075 			}
 
       
  3076 			ungetc(c, f);
 
       
  3077 			RETURN ( _MKCHARACTER(c & 0xFF) );
 
       
  3078 		}
 
       
  3079 	    }
 
       
  3080 	}
 
       
  3081     }
 
       
  3082 err: ;
 
       
  3083 %}.
 
       
  3084     lastErrorNumber notNil ifTrue:[^ self readError].
 
       
  3085     filePointer isNil ifTrue:[^ self errorNotOpen].
 
       
  3086     (mode == #writeonly) ifTrue:[^ self errorWriteOnly].
 
       
  3087     ^ self errorBinary
 
  3105     ^ self errorBinary
 
  3088 !
 
  3106 !
 
  3089 
  3107 
  3090 nextAlphaNumericWord
 
  3108 nextAlphaNumericWord
 
  3091     "read the next word (i.e. up to non letter-or-digit) after first
 
  3109     "read the next word (i.e. up to non letter-or-digit) after first
 
  3226     _INST(lastErrorNumber) = nil;
 
  3244     _INST(lastErrorNumber) = nil;
 
  3227     f = MKFD(_INST(filePointer));
 
  3245     f = MKFD(_INST(filePointer));
 
  3228     
  3246     
  3229     __READING__(f)
 
  3247     __READING__(f)
 
  3230 
  3248 
  3231 #ifdef SYSV
 
       
  3232     if (feof(f)) {
 
  3249     if (feof(f)) {
 
  3233 	_INST(hitEOF) = true;
 
  3250 	_INST(hitEOF) = true;
 
  3234 	RETURN (nil);
 
  3251 	RETURN (nil);
 
  3235     }
 
  3252     }
 
  3236 #endif
 
  3253 
  3237     /*
 
  3254     /*
 
  3238      * skip spaces
 
  3255      * skip spaces
 
  3239      */
 
  3256      */
 
  3240     while (! done) {
 
  3257     while (! done) {
 
  3241 	__BEGIN_INTERRUPTABLE__
 
  3258 	__BEGIN_INTERRUPTABLE__
 
  3332 		}
 
  3349 		}
 
  3333 	    }
 
  3350 	    }
 
  3334 	}
 
  3351 	}
 
  3335 
  3352 
  3336 	if (c < 0) {
 
  3353 	if (c < 0) {
 
       
  3354 	    _INST(hitEOF) = true;
 
  3337 	    if (ferror(f) && (errno != 0)) {
 
  3355 	    if (ferror(f) && (errno != 0)) {
 
  3338 		_INST(lastErrorNumber) = __MKSMALLINT(errno);
 
  3356 		_INST(lastErrorNumber) = __MKSMALLINT(errno);
 
  3339 		goto err;
 
  3357 		goto err;
 
  3340 	    }
 
  3358 	    }
 
  3341 	    _INST(hitEOF) = true;
 
       
  3342 	    break;
 
  3359 	    break;
 
  3343 	}
 
  3360 	}
 
  3344 	buffer[index++] = c;
 
  3361 	buffer[index++] = c;
 
  3345     }
 
  3362     }
 
  3346 
  3363
hg/stx-libbasic