comparison stitch/pullable.c @ 0:5242703e91d3 tip

Initial checkin for AIM92 aimR8.2 (last updated May 1997).

+/*
+    pullable.c
+    ==========
+
+    sources who's native operation is receive pull commands.
+
+*/
+
+#include "stitch.h"
+#include "source.h"
+
+#ifndef  lint
+static char *sccs_id = "@(#)pullable.c	1.3 John Holdsworth (MRC-APU) 6/6/91" ;
+#endif
+
+#if 0
+#define DEBUG 1
+#endif
+
+/*
+    fill a users buffer from a process that returns it's own buffer
+
+*/
+
+static Pointer fillFromPullable( source, bytes, buffer )
+struct _pullable_source *source ;
+ByteCount *bytes ;
+Pointer buffer ;
+{
+    Pointer input = source->parent.pull( source, bytes ) ;
+
+    CopyArray( (char *) input, (char *) buffer, *bytes ) ;
+
+    return ( buffer ) ;
+}
+
+Source setPullableSource( source, puller, name )
+struct _pullable_source *source ;
+Pointer (*puller)() ;
+char *name ;
+{
+    return ( SetSource( source, puller, fillFromPullable, nonRoller, name ) ) ;
+}
+
+Pointer deletePullableSource( source )
+struct _pullable_source *source ;
+{
+    return ( DeleteSource( source ) ) ;
+}
+
+/*
+    simple slave source as example of derived source
+
+*/
+
+typedef struct { struct _pullable_source parent ; Source master ; } *SlaveSource ;
+
+static Pointer slavePull( source, bytes )
+SlaveSource source ;
+ByteCount *bytes ;
+{
+    register int last = *bytes == 0 ;
+
+    if( !last )
+	return ( _SPTR( source->master )->returned ) ;
+    else
+	return ( DeletePullableSource( source ) ) ;
+}
+
+Source newSlaveSource( master )
+Source master ;
+{
+    DeclareNew( SlaveSource, source ) ;
+
+    source->master = master ;
+
+    return ( SetPullableSource( source, slavePull, "pullable.c slave" ) ) ;
+}
+
+/*
+    the simplest Source is one direct from memory
+
+*/
+
+typedef struct {
+ struct _pullable_source parent ;
+ Pointer next ;
+ } *StaticSource ;
+
+static Pointer staticPull( source, bytes )
+StaticSource source ;
+ByteCount *bytes ;
+{
+    register int last = *bytes == 0 ;
+    register Pointer this = source->next ;
+
+    if( !last ) {
+
+	source->next += abs( *bytes ) ;
+
+	return ( this ) ;
+    }
+    else
+	return ( DeletePullableSource( source ) ) ;
+}
+
+Source newStaticSource( pointer )
+Pointer pointer ;
+{
+    DeclareNew( StaticSource, source ) ;
+
+    source->next = pointer ;
+
+    return ( SetPullableSource( source, staticPull, "pullable.c static" ) ) ;
+}
+
+typedef struct {
+ struct _pullable_source parent ;
+ Source input ; Pointer buffer ; ByteCount retained ;
+} *RetainingSource ;
+
+static Pointer retaining_callback( source, bytes )
+RetainingSource source ;
+ByteCount *bytes ;
+{
+    register int last = *bytes == 0 ;
+    Pointer buffer = RollSome( source->input, bytes, source->retained ) ;
+
+    if( !last )
+	return ( buffer ) ;
+    else
+	return ( DeletePullableSource( source ) ) ;
+}
+
+Source newRetainingSource( input, retained )
+Source input ;
+ByteCount retained ;
+{
+    DeclareNew( RetainingSource, source ) ;
+
+    source->retained = retained ;
+
+    source->input = NewRollableSource( input ) ;
+
+    return ( SetPullableSource( source, retaining_callback, "pullable.c retaining" ) ) ;
+}
+
+typedef struct {
+ struct _pullable_source parent ;
+ Source input ; ByteCount delay ;
+ } *DelayingSource  ;
+
+static Pointer delay_callback( source, bytes )
+DelayingSource source ;
+ByteCount *bytes ;
+{
+    register int last = *bytes == 0 ;
+    Pointer delayed = PullSome( source->input, bytes ) - source->delay ;
+
+    if( !last )
+	return ( delayed ) ;
+    else
+	return ( DeletePullableSource( source ) ) ;
+}
+
+Source newDelayingSource( input, delay )
+Source input ;
+ByteCount delay ;
+{
+    DeclareNew( DelayingSource, source ) ;
+
+    source->input = NewRetainingSource( input, delay ) ;
+
+    source->delay = delay ;
+
+    return ( SetPullableSource( source, delay_callback, "pullable.c delaying" ) ) ;
+}
+
+typedef struct {
+ struct _pullable_source parent ;
+ Source input ; Pointer buffer, position, end ; ByteCount segment ;
+} *BlockingSource ;
+
+static Pointer block_callback( source, bytes )
+BlockingSource source ;
+ByteCount *bytes ;
+{
+    register int last = *bytes == 0 ;
+    ByteCount segment = source->segment ;
+
+    if( source->position == source->end || last ) {
+
+	if( segment < *bytes || last )
+	    segment = *bytes ;
+
+	source->buffer = PullSome( source->input, &segment ) ;
+#if DEBUG
+printf( "pulled block at %x from %s\n", source->buffer, SourceName( source->input ) ) ;
+#endif
+	source->end  = source->buffer + segment ;
+
+	source->position = source->buffer ;
+    }
+
+    if( *bytes > source->end - source->position )
+	*bytes = source->end - source->position ;
+
+    source->position += *bytes ;
+
+    if( !last )
+	return ( source->position - *bytes ) ;
+    else
+	return ( DeletePullableSource( source ) ) ;
+}
+
+Source newBlockingSource( input, segment )
+Source input ;
+ByteCount segment ;
+{
+    DeclareNew( BlockingSource, source ) ;
+
+    source->input = input ;
+
+    source->position = source->end = (Pointer) 0 ;
+
+    source->segment = segment ;
+
+    return ( SetPullableSource( source, block_callback, "pullable.c blocking" ) ) ;
+}
+