#import "grid.h"
#import <defobj/Create.h>
@interface GridTurtle_c : CreateDrop_s
{
@public
int x_coord;
int y_coord;
direction_t direction;
member_t listMembership;
}
@end |
#import "GridTurtle.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
@implementation GridTurtle_c
- (void) move: (int) distance
{
switch (direction) {
case north: y_coord += distance; break;
case east: x_coord += distance; break;
case south: y_coord -= distance; break;
case west: x_coord -= distance; break;
}
}
- (void) turn: (int) angle
{
direction = ( direction - angle ) % 4;
}
- (void) print
{
printf( "x coord: %d y coord: %d direction: %d\n",
x_coord, y_coord, direction );
}
@end |
ifeq ($(SWARMHOME),)
SWARMHOME=../../../swarm
endif
include $(SWARMHOME)/etc/swarm/Makefile.common
OTHERINCDIRS=-I.
INCLUDES+=$(OTHERINCDIRS)
LIBS_C= -lcollections -ldefobj -lmisc $(SYSLIBS)
LIBS_A= -lactivity $(LIBS_C)
TARGETS_C= strtest grid0 grid1a grid1b grid1c grid2 grid2b grid3 grid3b \
grid4 grid4b
TARGETS_A= grid5 grid6 grid7 grid8 grid9
TARGETS_M= mousetraps mousetraps2
OBJECTS= grid.o GridTurtle.o
all: $(TARGETS_C) $(TARGETS_A) $(TARGETS_M)
grid.o: grid/classes.h grid.xm
grid.xm: grid.h
OBJC="$(OBJC)" OBJCFLAGS="$(OTHERINCDIRS) -I$(includedir) $(CPPFLAGS) \
$(OBJCFLAGS)" OBJECTS="$(OBJECTS)" $(bindir)/make-h2x $@ .
grid/classes.h:
if [ ! -x grid ]; then mkdir grid; fi
cd grid; ln -s ../grid.xc classes.h
install:
echo "no default install"
clean:
- rm -f grid.x[cmt] *.o $(TARGETS_C) $(TARGETS_A) $(TARGETS_M) core
- rm grid/classes.h; rmdir grid
c: $(TARGETS_C)
a: $(TARGETS_A)
m: $(TARGETS_M)
$(TARGETS_C): %: grid.o %.o $(OBJECTS)
$(CC) $(LDFLAGS) $@.o $(OBJECTS) -o $@ $(LIBS_C)
$(TARGETS_A): %: grid.o %.o $(OBJECTS)
$(CC) $(LDFLAGS) $@.o $(OBJECTS) -o $@ $(LIBS_A)
mousetraps: grid.o mousetraps.o Mousetrap.o
$(CC) $(LDFLAGS) $@.o Mousetrap.o -o $@ $(LIBS_A)
mousetraps2: grid.o mousetraps2.o Mousetrap2.o
$(CC) $(LDFLAGS) $@.o Mousetrap2.o -o $@ $(LIBS_A)
|
#import <activity.h>
#import <defobj/Create.h>
@interface Mousetrap : CreateDrop
{
int xCoord;
int yCoord;
int triggered;
id displayWidget;
}
+ create: aZone setXCoord: (int)x setYCoord: (int)y;
- (int) getXCoord;
- (int) getYCoord;
- (void) trigger;
- (BOOL) getTriggered;
- (void) printTriggered;
/*
- setDisplayWidget: w;
*/
@end
@interface Grid2D : CreateDrop
{
int gridSize;
id *cells; // array of gridSize X gridSize cells
}+ create: aZone setGridSize: (int)size;
- (int) getGridSize;
- atX: (int)xCoord atY: (int)yCoord;
- (void) atX: (int)xCoord atY: (int)yCoord put: anObject;
@end
// global variables currently used as world parameters
//
extern int triggerLikelihood;
extern int numberOutputTriggers;
extern int maxTriggerDistance;
extern int maxTriggerTime;
extern int gridSize;
extern int printTriggerEvents;
extern int printSameTickTriggers;
// (trigger distance and trigger time are currently uncorrelated.)
// global variable containing root object for world (eventually in context?)
//
extern id grid; |
#import "Mousetrap.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
#include <stdlib.h>
extern id grid, worldSchedule;
extern unsigned numTriggered;
@implementation Mousetrap
+ create: aZone setXCoord: (int)x setYCoord: (int)y
{
Mousetrap *newTrap;
newTrap = [self create: aZone];
newTrap->xCoord = x;
newTrap->yCoord = y;
return newTrap;
}
- (void) trigger
{
int n, xTrigger, yTrigger;
unsigned bits, xbits, ybits, tbits, currentTick, triggerTick;
if ( ! triggered ) {
currentTick = getCurrentTime();
if ( printTriggerEvents ) {
printf( "mousetrap at x: %.2d, y: %.2d triggered at time: %d\n",
xCoord, yCoord, currentTick );
}
// nelson hacks
// [displayWidget drawPointX: xCoord Y: yCoord Color: 2];
numTriggered++;
bits = rand();
if ( ( ( bits & 0xff ) ) < triggerLikelihood ) {
triggered = 1;
for ( n = numberOutputTriggers; n > 0; n-- ) {
bits = rand();
xbits = bits & 0xff;
ybits = bits >> 8 & 0xff;
bits = rand();
tbits = bits & 0xff;
bits >>= 8;
if ( bits & 1 ) {
xTrigger = ( xCoord + ( xbits & ( maxTriggerDistance - 1 ) ) )
% gridSize;
} else {
xTrigger = ( xCoord - ( xbits & ( maxTriggerDistance - 1 ) )
+ gridSize ) % gridSize;
}
if ( bits & 2 ) {
yTrigger = ( yCoord + ( ybits & (maxTriggerDistance - 1) ) )
% gridSize;
} else {
yTrigger = ( yCoord - ( ybits & (maxTriggerDistance - 1) )
+ gridSize ) % gridSize;
}
triggerTick = currentTick + ( tbits & (maxTriggerTime - 1) );
if ( printSameTickTriggers && triggerTick == currentTick )
printf( "triggering mousetrap at same timestep at time: %d\n",
currentTick );
[worldSchedule at: triggerTick
createActionTo: [grid atX: xTrigger atY: yTrigger]
message: M( trigger )];
}
}
}
}
- (int) getXCoord
{
return xCoord;
}
- (int) getYCoord
{
return yCoord;
}
- (BOOL) getTriggered
{
return triggered;
}
- (void) printTriggered
{
timeval_t currentTime;
currentTime = getCurrentTime();
printf( "trigger status of mousetrap at x: %.2d, y: %.2d at time: %lu is %d\n",
xCoord, yCoord, currentTime, triggered );
}
/*
- setDisplayWidget: w {
displayWidget = w;
}
*/
@end
@implementation Grid2D
+ create: aZone setGridSize: (int)size
{
Grid2D *newGrid;
newGrid = [aZone allocIVars: self];
newGrid->gridSize = size;
newGrid->cells = [aZone allocBlock:
newGrid->gridSize * newGrid->gridSize * sizeof (id)];
return newGrid;
}
- (int) getGridSize
{
return gridSize;
}
- atX: (int)xCoord atY: (int)yCoord
{
return cells[ xCoord + yCoord * gridSize];
}
- (void) atX: (int)xCoord atY: (int)yCoord put: anObject
{
cells[ xCoord + yCoord * gridSize] = anObject;
}
@end |
#import "Mousetrap.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
#include <stdlib.h>
extern id grid, worldSchedule;
extern unsigned numTriggered;
@implementation Mousetrap
+ create: aZone setXCoord: (int)x setYCoord: (int)y
{
Mousetrap *newTrap;
newTrap = [self create: aZone];
newTrap->xCoord = x;
newTrap->yCoord = y;
return newTrap;
}
- (void) trigger
{
int n, xTrigger, yTrigger;
unsigned bits, xbits, ybits, tbits, currentTick, ownerTick, triggerTick;
id subgroup, ownerActivity;
if ( ! triggered ) {
// get subclock schedule and its current time
// (Could still have a concurrent group within the subclock schedule,
// but the initial getCurrentScheduleActivity() will skip over this
// to get the running activity of the subclock schedule.)
ownerActivity = getCurrentScheduleActivity();
currentTick = [ownerActivity getCurrentTime];
// get activity running the subclock schedule activity, and its time
ownerActivity = [ownerActivity getOwnerActivity];
ownerTick = [ownerActivity getCurrentTime];
if ( printTriggerEvents ) {
printf( "mousetrap at x: %.2d, y: %.2d triggered at time: %d,%d\n",
xCoord, yCoord, ownerTick, currentTick );
}
// nelson hacks
// [displayWidget drawPointX: xCoord Y: yCoord Color: 2];
numTriggered++;
bits = rand();
if ( ( ( bits & 0xff ) ) < triggerLikelihood ) {
triggered = 1;
for ( n = numberOutputTriggers; n > 0; n-- ) {
bits = rand();
xbits = bits & 0xff;
ybits = bits >> 8 & 0xff;
bits = rand();
tbits = bits & 0xff;
bits >>= 8;
if ( bits & 1 ) {
xTrigger = ( xCoord + ( xbits & ( maxTriggerDistance - 1 ) ) )
% gridSize;
} else {
xTrigger = ( xCoord - ( xbits & ( maxTriggerDistance - 1 ) )
+ gridSize ) % gridSize;
}
if ( bits & 2 ) {
yTrigger = ( yCoord + ( ybits & (maxTriggerDistance - 1) ) )
% gridSize;
} else {
yTrigger = ( yCoord - ( ybits & (maxTriggerDistance - 1) )
+ gridSize ) % gridSize;
}
triggerTick = ( ownerTick * 10 ) + currentTick +
( tbits & (maxTriggerTime - 1) );
if ( printSameTickTriggers && triggerTick == currentTick )
printf( "triggering mousetrap at same timestep at time: %d\n",
currentTick );
subgroup = [worldSchedule insertGroup: (id)( triggerTick / 10 )];
[subgroup
at: (triggerTick % 10)
createActionTo: [grid atX: xTrigger atY: yTrigger]
message: M( trigger )];
}
}
}
}
- (int) getXCoord
{
return xCoord;
}
- (int) getYCoord
{
return yCoord;
}
- (BOOL) getTriggered
{
return triggered;
}
- (void) printTriggered
{
timeval_t currentTime;
currentTime = getCurrentTime();
printf("trigger status of mousetrap at x: %.2d, y: %.2d at time: %lu is %d\n",
xCoord, yCoord, currentTime, triggered );
}
/*
- setDisplayWidget: w {
displayWidget = w;
}
*/
@end
@implementation Grid2D
+ create: aZone setGridSize: (int)size
{
Grid2D *newGrid;
newGrid = [aZone allocIVars: self];
newGrid->gridSize = size;
newGrid->cells = [aZone allocBlock:
newGrid->gridSize * newGrid->gridSize * sizeof (id)];
return newGrid;
}
- (int) getGridSize
{
return gridSize;
}
- atX: (int)xCoord atY: (int)yCoord
{
return cells[ xCoord + yCoord * gridSize];
}
- (void) atX: (int)xCoord atY: (int)yCoord put: anObject
{
cells[ xCoord + yCoord * gridSize] = anObject;
}
@end |
#import <collections.h>
@protocol GridTurtle <Create, Drop, CREATABLE>
- (void) move: (int)distance;
- (void) turn: (int)angle; /* angle measured in units of pi/2 */
- (void) print;
@end
typedef enum direction { north, east, south, west } direction_t;
extern id <Symbol> S1;
extern id <Warning> W1;
extern id <Error> E1;
#import "grid.xt" |
#import "grid.xm"
void _grid_implement( void )
{
initModule( collections );
[id_GridTurtle_c setTypeImplemented: GridTurtle];
}
void _grid_initialize( void )
{
defsymbol( S1 );
defwarning( W1, 0 );
deferror( E1, 0 );
} |
#import "GridTurtle.h"
int main(void)
{
id aZone, t1;
initModule( grid );
aZone = [Zone create: globalZone];
t1 = [GridTurtle create: aZone];
[t1 drop];
t1 = [GridTurtle create: aZone];
[t1 move: 10];
[t1 turn: -1];
[t1 move: 10];
[t1 print];
[t1 turn: 23];
[t1 move: 10];
[t1 print];
[aZone xprint];
[aZone xfprint];
[aZone drop];
return 0;
} |
#import "grid.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int main(void)
{
id aZone, anArray, newArray, aTurtle, aMember, index;
int i;
initModule( grid );
aZone = [Zone create: globalZone];
anArray = [Array create: aZone setCount: 12];
printf( "count: %d\n", [anArray getCount] );
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: aZone];
[aTurtle turn: -1];
[aTurtle move: i * 10];
[anArray atOffset: i put: aTurtle];
}
printf( "count: %d\n", [anArray getCount] );
index = [anArray begin: scratchZone];
while ( (aMember = [index next]) || [index getLoc] != End ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
while ( (aMember = [index prev]) || [index getLoc] != Start ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[anArray setCount: 15];
index = [anArray begin: scratchZone];
while ( (aMember = [index next]) || [index getLoc] != End ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[index setLoc: Start];
[anArray setCount: 8];
index = [anArray begin: scratchZone];
while ( (aMember = [index next]) || [index getLoc] != End ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[anArray atOffset: 2 put: nil];
newArray = [anArray copy: aZone];
index = [newArray begin: scratchZone];
[newArray atOffset: 3 put: nil];
while ( (aMember = [index next]) || [index getLoc] != End ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[newArray drop];
[anArray atOffset: 5 put: nil];
newArray = [Array createBegin: aZone];
[newArray setInitialValue: anArray];
newArray = [newArray createEnd];
[newArray atOffset: 6 put: nil];
index = [newArray begin: scratchZone];
while ( (aMember = [index next]) || [index getLoc] != End ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[index drop];
index = [anArray begin: scratchZone];
while ( (aMember = [index next]) || [index getLoc] != End ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
for ( i = 0; i < 8; i++ ) {
aMember = [anArray atOffset: i];
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[anArray xprint];
[aZone xprint];
[anArray drop];
[newArray drop];
[aZone xprint];
[aZone xfprint];
[aZone drop];
exit(0);
} |
#import "grid.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int main(void)
{
id aZone, anArray, aTurtle, aMember, index;
int i;
initModule( grid );
aZone = [Zone create: globalZone];
anArray = [Array createBegin: aZone];
[anArray setCount: 12];
[anArray setDefaultMember: Member];
anArray = [anArray createEnd];
printf( "count: %d\n", [anArray getCount] );
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: aZone];
[aTurtle turn: -1];
[aTurtle move: i * 10];
[anArray atOffset: i put: aTurtle];
}
printf( "count: %d\n", [anArray getCount] );
index = [anArray begin: scratchZone];
while ( (aMember = [index next]) ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
while ( (aMember = [index prev]) ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[anArray setCount: 15];
index = [anArray begin: scratchZone];
while ( (aMember = [index next]) ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[index setLoc: Start];
[anArray setCount: 8];
index = [anArray begin: scratchZone];
while ( (aMember = [index next]) ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
for ( i = 0; i < 8; i++ ) {
[[anArray atOffset: i] print];
}
[anArray xprint];
[anArray drop];
[aZone xprint];
[aZone drop];
exit(0);
} |
#import "grid.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int main(void)
{
id aZone, anArray, aTurtle, aMember, index, newArray;
int i;
initModule( grid );
aZone = [Zone create: globalZone];
anArray = [Array createBegin: aZone];
[anArray setCount: 10];
[anArray setDefaultMember: Member];
anArray = [anArray createEnd];
printf( "count: %d\n", [anArray getCount] );
for ( i = 0; i < 5; i++ ) {
aTurtle = [GridTurtle create: aZone];
[aTurtle turn: -1];
[aTurtle move: i * 10];
[anArray atOffset: i put: aTurtle];
}
printf( "count: %d\n", [anArray getCount] );
index = [anArray begin: scratchZone];
while ( (aMember = [index next]) ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
newArray = [Array createBegin: aZone];
[newArray setMemberBlock: (id *)[anArray getMemberBlock] + 2 setCount: 6];
newArray = [newArray createEnd];
index = [newArray begin: scratchZone];
while ( (aMember = [index next]) ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[newArray setMemberBlock: [anArray getMemberBlock] setCount: 6];
index = [newArray begin: scratchZone];
while ( (aMember = [index next]) ) {
if ( ! aMember ) {
printf( "member is nil\n" );
} else if ( [aMember respondsTo: M(print)] ) {
[aMember print];
} else {
printf( "%s\n", [aMember getName] );
}
}
[newArray xprint];
[anArray drop];
[newArray drop];
[aZone xprint];
[aZone drop];
exit(0);
} |
#import "grid.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
#import <collections/List_linked.h>
#import <defobj/defalloc.h>
extern id _obj_sessionZone; // to confirm cleanup of display names
@interface MyList : List_linked
+ create: aZone;
@end
@implementation MyList
+ create: aZone
{
List_linked *newList;
newList = [aZone allocIVars: [List_linked self]];
setMappedAlloc( newList );
return newList;
}
@end
int main(void)
{
id aZone, aList, aTurtle, index, newList;
int i;
char buffer[50];
initModule( grid );
aZone = [Zone create: globalZone];
aList = [MyList create: aZone];
printf( "count: %d\n", [aList getCount] );
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: aZone];
[aTurtle turn: -1];
[aTurtle move: i * 10];
[aList addLast: aTurtle];
if ( i % 2 ) {
sprintf( buffer, "turtle number %d", i );
[aTurtle setDisplayName: buffer];
}
}
printf( "count: %d\n", [aList getCount] );
printf( "\n[aZone xfprintid]\n" );
[aZone xfprintid];
printf( "\n" );
index = [aList begin: scratchZone];
while ( (aTurtle = [index next]) ) {
[aTurtle print];
}
[index drop];
[aList addFirst: [aList removeLast]];
[aList addFirst: [aList removeLast]];
[aList addLast: [aList removeFirst]];
printf( "count: %d\n", [aList getCount] );
index = [aList begin: scratchZone];
for ( [index setLoc: End]; (aTurtle = [index prev]); ) {
[aTurtle print];
}
printf( "turtle located at offset 3: " );
[[index setOffset: 3] print];
printf( "turtle removed at offset 3: " );
[[index remove] print];
[index setLoc: Start];
while ( (aTurtle = [index next]) );
[aList forEach: @selector( print )];
newList = [List createBegin: aZone];
[newList setInitialValue: aList];
newList = [newList createEnd];
[aList drop];
printf( "new list count: %d\n", [newList getCount] );
[newList forEach: @selector( print )];
aList = [newList copy: aZone];
printf( "copied list count: %d\n", [aList getCount] );
[aList forEach: @selector( print )];
printf( "\nsession zone before drop of all turtles\n" );
[_obj_sessionZone xprint];
[aList deleteAll];
[aList drop];
printf( "\nsession zone after drop\n" );
[_obj_sessionZone xprint];
printf( "\n" );
[newList drop];
[aZone xprint];
[aZone drop];
return 0;
} |
// This is an old test program for safe indexes mode on a list, which is
// not currently supported. Now it shows how indexes can be affected by
// remove.
#import "grid.h"
#import "GridTurtle.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int main(void)
{
id aZone, listType, aList, aTurtle, index, index2;
int i;
initModule( grid );
aZone = [Zone create: globalZone];
listType = [List customizeBegin: aZone];
[listType setIndexFromMemberLoc: offsetof( GridTurtle_c, listMembership )];
// [listType setSafeIndexes: 1];
listType = [listType customizeEnd];
aList = [listType create: aZone];
printf( "count: %d\n", [aList getCount] );
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: aZone];
[aTurtle turn: -1];
[aTurtle move: i * 10];
[aList addLast: aTurtle];
}
printf( "count: %d\n", [aList getCount] );
index = [aList begin: scratchZone];
while ( (aTurtle = [index next]) ) {
[aTurtle print];
}
[index drop];
[aList addFirst: [aList removeLast]];
[aList addFirst: [aList removeLast]];
[aList addLast: [aList removeFirst]];
index = [aList begin: scratchZone];
while ( (aTurtle = [index next]) ) {
[aTurtle print];
}
[aList addLast: [aList removeFirst]];
printf( "count: %d\n", [aList getCount] );
index = [aList createIndex: scratchZone fromMember: [aList atOffset: 8]];
printf( "offset after createIndex:fromMember: %d\n", [index getOffset] );
[index next];
[index next];
[index prev];
printf( "offset after next to End then prev: %d\n", [index getOffset] );
index = [aList createIndex: scratchZone fromMember: [aList atOffset: 1]];
[index setOffset: 1];
index2 = [aList createIndex: scratchZone fromMember: [aList atOffset: 0]];
[index remove];
[index2 remove];
printf( "offset after remove on both index and lesser index: %d\n",
[index getOffset] );
printf( "member after removed offsets 0 and 1:\n " );
[[index next] print];
index = [aList createIndex: scratchZone fromMember: [aList atOffset: 0]];
index2 = [aList createIndex: scratchZone fromMember: [aList atOffset: 1]];
[index remove];
[index2 remove];
printf( "offset after remove on both index and greater index: %d\n",
[index getOffset] );
printf( "member after removed offsets 0 and 1:\n " );
[[index next] print];
index = [aList createIndex: scratchZone fromMember: [aList atOffset: 1]];
index2 = [aList createIndex: scratchZone fromMember: [aList atOffset: 0]];
[index2 remove];
printf( "offset after remove on lesser index: %d\n",
[index getOffset] );
printf( "member after removed offset 0 and original offset 1:\n " );
[[index next] print];
index = [aList createIndex: scratchZone fromMember: [aList atOffset: 1]];
index2 = [aList createIndex: scratchZone fromMember: [aList atOffset: 1]];
[index2 remove];
printf( "offset after remove on same index: %d\n",
[index getOffset] );
printf( "member after removed offset 1:\n " );
[[index next] print];
index = [aList createIndex: scratchZone fromMember: [aList atOffset: 0]];
index2 = [aList createIndex: scratchZone fromMember: [aList atOffset: 1]];
[index2 remove];
printf( "offset after remove on greater index: %d\n",
[index getOffset] );
printf( "member after original offset 0 and removed offset 1:\n " );
[[index next] print];
index = [aList createIndex: scratchZone fromMember: [aList atOffset: 0]];
[index setLoc: Start];
index2 = [aList createIndex: scratchZone fromMember: [aList atOffset: 0]];
[index2 remove];
printf( "offset after move to Start and remove on other index: %d\n",
[index getOffset] );
printf( "member after removed offset 0:\n " );
[[index next] print];
printf( "remaining members of list:\n" );
index = [aList begin: scratchZone];
while ( (aTurtle = [index next]) ) {
[aTurtle print];
}
printf( "location of index at End: %s\n", [[index getLoc] getName] );
[index setOffset: 1];
printf( "location of index at offset 1: %s\n", [[index getLoc] getName] );
[index remove];
printf( "location of index after remove: %s\n", [[index getLoc] getName] );
[index prev];
printf( "location of index after prev: %s\n", [[index getLoc] getName] );
[index setOffset: 0];
printf( "location of index at offset 0: %s\n", [[index getLoc] getName] );
[index remove];
printf( "location of index after remove: %s\n", [[index getLoc] getName] );
[index next];
printf( "location of index after next: %s\n", [[index getLoc] getName] );
[aList xprint];
[aList drop];
[aZone xprint];
[aZone drop];
return 0;
} |
#import "grid.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int main(void)
{
id aZone, aMap, aTurtle, key, index;
int i;
char buffer[10];
initModule( grid );
aZone = [Zone create: globalZone];
aMap = [Map create: aZone];
printf( "count: %d\n", [aMap getCount] );
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: aZone];
[aTurtle turn: -1];
[aTurtle move: i * 10];
sprintf( buffer, "%d", i );
key = [String create: aZone setC: buffer];
[aMap at: key insert: aTurtle];
}
printf( "count: %d\n", [aMap getCount] );
index = [aMap begin: scratchZone];
while ( (aTurtle = [index next]) ) {
key = [index getKey];
printf( "%s: ", [key getC] );
[aTurtle print];
[key drop];
}
[[aMap getFirst] print];
[[aMap getLast] print];
[aMap xprint];
[aMap drop];
[aZone xprint];
[aZone drop];
return 0;
} |
#import "grid.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int main(void)
{
id aZone, aMap, aTurtle, index;
int i;
initModule( grid );
aZone = [Zone create: globalZone];
aMap = [Map createBegin: aZone];
[aMap setCompareFunction: compareIntegers];
aMap = [aMap createEnd];
printf( "count: %d\n", [aMap getCount] );
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: aZone];
[aTurtle turn: -1];
[aTurtle move: (10 - i) * 10];
[aMap at: (id)(10 - i) insert: aTurtle];
}
printf( "count: %d\n", [aMap getCount] );
index = [aMap begin: scratchZone];
while ( (aTurtle = [index next]) ) {
printf( "%d: ", (int)[index getKey] );
[aTurtle print];
}
[index drop];
[[aMap getFirst] print];
[[aMap getLast] print];
[aMap xprint];
[aMap drop];
[aZone xprint];
[aZone drop];
return 0;
} |
#import "grid.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int main(void)
{
id aZone, aSet, aTurtle, turtles[10], index;
int i;
initModule( grid );
aZone = [Zone create: globalZone];
aSet = [Set create: aZone];
printf( "count: %d\n", [aSet getCount] );
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: aZone];
turtles[i] = aTurtle;
[aTurtle turn: -1];
[aTurtle move: i * 10];
if ( i & 1 ) [aSet add: aTurtle];
}
printf( "count: %d\n", [aSet getCount] );
index = [aSet begin: aZone];
while ( (aTurtle = [index next]) ) {
[aTurtle print];
}
for ( i = 0; i < 10; i++ ) {
if ( [aSet at: turtles[i]] != turtles[i] ) {
printf( "turtle not found at %d\n", i );
}
}
for ( i = 0; i < 10; i++ ) {
if ( i & 1 ) {
[aSet remove: turtles[i]];
} else {
[aSet add: turtles[i]];
}
}
index = [aSet begin: scratchZone];
while ( (aTurtle = [index next]) ) {
[aTurtle print];
}
for ( i = 0; i < 10; i++ ) {
if ( [aSet at: turtles[i]] != turtles[i] ) {
printf( "turtle not found at %d\n", i );
}
}
[index drop];
[aSet xprint];
[aSet drop];
[aZone xprint];
[aZone drop];
return 0;
} |
#import "grid.h"
#import "GridTurtle.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int main(void)
{
id aZone, anOrderedSet, aTurtle, turtles[10], index;
int i;
initModule( grid );
aZone = [Zone create: globalZone];
anOrderedSet = [OrderedSet createBegin: aZone];
[anOrderedSet setIndexFromMemberLoc:
offsetof( GridTurtle_c, listMembership )];
anOrderedSet = [anOrderedSet createEnd];
printf( "count: %d\n", [anOrderedSet getCount] );
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: aZone];
turtles[i] = aTurtle;
[aTurtle turn: -1];
[aTurtle move: i * 10];
if ( i & 1 ) [anOrderedSet add: aTurtle];
}
printf( "count: %d\n", [anOrderedSet getCount] );
index = [anOrderedSet begin: scratchZone];
while ( (aTurtle = [index next]) ) {
[aTurtle print];
}
for ( i = 0; i < 10; i++ ) {
if ( ! [anOrderedSet contains: turtles[i]] ) {
printf( "turtle not found at %d\n", i );
}
}
for ( i = 0; i < 10; i++ ) {
if ( i % 2 ) {
[anOrderedSet remove: turtles[i]];
} else {
[anOrderedSet add: turtles[i]];
}
}
index = [anOrderedSet begin: scratchZone];
while ( (aTurtle = [index next]) ) {
[aTurtle print];
}
for ( i = 0; i < 10; i++ ) {
if ( ! [anOrderedSet contains: turtles[i]] ) {
printf( "turtle not found at %d\n", i );
}
}
[anOrderedSet xprint];
[anOrderedSet drop];
[aZone xprint];
[aZone drop];
return 0;
} |
#import "grid.h"
#import <activity.h>
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
static BOOL trace( id anActivity );
int main(void)
{
id aZone, aList, aTurtle;
id emptyActions, moveActions, printActions, moveAndPrint;
id groupActivity, swarm, swarmActivity, status;
int i, stepCount;
initModule( grid );
initModule( activity );
aZone = [Zone create: globalZone];
swarm = [SwarmProcess create: aZone];
_activity_zone = [Zone create: globalZone];
[_activity_zone xprint];
swarmActivity = [swarm activateIn: nil];
[swarmActivity drop];
[_activity_zone xprint];
// if ( _obj_debug ) exit(0);
aList = [List create: swarm];
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: swarm];
[aTurtle turn: -1];
[aTurtle move: i * 10];
[aTurtle turn: 1];
[aList addLast: aTurtle];
}
emptyActions = [ActionGroup create: swarm];
moveActions = [ActionGroup create: swarm];
for ( i = 0; i < 10; i++ ) {
if ( i % 2 )
[moveActions
createActionTo: [aList atOffset: i] message: M(move:) : (id)10 ];
}
printActions = [ActionGroup create: swarm];
for ( i = 0; i < 10; i++ ) {
[printActions createActionTo: [aList atOffset: i] message: M(print)];
}
moveAndPrint = [ActionGroup create: swarm];
[moveAndPrint createAction: emptyActions];
[moveAndPrint createAction: moveActions];
[moveAndPrint createAction: printActions];
for ( i = 0; i < 10; i++ ) {
if ( i % 2 )
[moveAndPrint
createActionTo: [aList atOffset: i] message: M(move:) : (id)10];
}
[moveAndPrint createActionForEach: aList message: M(print)];
groupActivity = [moveAndPrint activateIn: nil];
printf("about to start schedule\n");
while ( (status = [groupActivity run]) != Completed );
printf( "run return status: %s\n\n", [status getName] );
[groupActivity drop];
swarmActivity = [swarm activateIn: nil];
[swarm activate: moveAndPrint];
if ( swarmActivity != [swarm getSwarmActivity] )
raiseEvent( WarningMessage, nil );
_activity_trace = trace;
for ( stepCount = 1; [swarmActivity step] == Stopped; stepCount++ );
printf( "number of steps: %d\n", stepCount );
[swarmActivity drop];
[_activity_zone xprint];
[emptyActions drop];
[moveActions drop];
[printActions drop];
[moveAndPrint drop];
[aList deleteAll];
[aList drop];
[[swarm getInternalZone] xprint];
[swarm drop];
[aZone xprint];
return 0;
}
static BOOL trace( id anActivity )
{
char buffer[100];
if ( getCurrentAction() ) {
_obj_formatIDString( buffer, getCurrentAction() );
printf( "action trace: %s\n", buffer );
} else {
printf( "action trace: activity status %s\n",
[[anActivity getStatus] getName] );
}
return 0;
} |
#import "grid.h"
#import <activity.h>
#import <activity/SwarmProcess.h> // for activate: call
#import <defobj/DefObject.h> // for dropAllocations: of internal actions
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
static void terminateFunction( void )
{
[getTopLevelActivity() terminate];
}
static void nestedFunction( void )
{
char buf1[100], buf2[100];
_obj_formatIDString( buf1, getTopLevelActivity() );
_obj_formatIDString( buf2, [getTopLevelActivity() getControllingActivity] );
printf( "top level activity: %s\ncontrolling activity: %s\n", buf1, buf2 );
}
static void runFunction( void )
{
id group, groupActivity;
group = [ActionGroup create: globalZone];
[group createActionCall: (func_t)printf : (id)"nested group performed\n"];
[group createActionCall: nestedFunction];
groupActivity = [group activateIn: nil];
[groupActivity run];
[groupActivity drop];
[group drop];
}
int main(void)
{
id x, aZone, sched1, sched2, action1, action2;
id swarm, swarmActivity, status;
initModule( grid );
initModule( activity );
aZone = [Zone create: globalZone];
swarm = [SwarmProcess create: aZone];
_activity_zone = [Zone create: globalZone];
sched1 = [Schedule create: swarm];
[sched1 at: 1 createActionCall: terminateFunction];
x = [Schedule createBegin: swarm];
[x setRepeatInterval: 10];
sched2 = [x createEnd];
[sched2 createActionCall: (func_t)printf :
(id)"repeating action performed\n"];
[sched2 createActionCall: (func_t)runFunction];
// create a concurrent group just to make sure it goes away
action1 = [sched2 at: 1 createActionCall: (func_t)printf : (id)"action 1\n"];
action2 = [sched2 at: 1 createActionCall: (func_t)printf : (id)"action 2\n"];
[sched2 remove: action1];
[sched2 remove: action2];
swarmActivity = [swarm activateIn: nil];
[swarm activate: sched1];
[swarm activate: sched2];
while ( (status = [swarmActivity run]) != Stopped && status != Completed );
[swarmActivity drop];
[_activity_zone xprint];
[sched1 drop];
[sched2 drop];
[action1 drop];
[action2 drop];
[[swarm getInternalZone] xprint];
[swarm drop];
[aZone xprint];
return 0;
} |
#import "grid.h"
#import <activity.h>
#import <activity/XActivity.h>
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
extern BOOL respondsTo( id, SEL ); // from defobj
static BOOL trace( id anActivity );
static id newTurtle( void )
{
id aTurtle;
static int ycoord;
aTurtle = [GridTurtle create: globalZone];
[aTurtle move: ++ycoord];
return aTurtle;
}
int main(void)
{
id aZone, aList, aTurtle;
id emptyActions1, emptyActions2;
id moveAndPrint, moveActions, printActions;
id printRelative, printRepeat, startSchedule;
id swarm, swarmActivity, status;
int i;
initModule( grid );
initModule( activity );
aZone = [Zone create: globalZone];
swarm = [SwarmProcess create: aZone];
_activity_zone = [Zone create: globalZone];
aList = [List create: swarm];
for ( i = 0; i < 10; i++ ) {
aTurtle = [GridTurtle create: swarm];
[aTurtle turn: -1];
[aTurtle move: i * 10];
[aTurtle turn: 1];
[aList addLast: aTurtle];
}
moveActions = [ActionGroup create: swarm];
for ( i = 0; i < 10; i++ ) {
if ( i % 2 )
[moveActions
createActionTo: [aList atOffset: i] message: M(move:) : (id)10 ];
}
printActions = [ActionGroup create: swarm];
for ( i = 0; i < 10; i++ ) {
[printActions createActionTo: [aList atOffset: i] message: M(print)];
}
moveAndPrint = [Schedule createBegin: swarm];
[moveAndPrint setRepeatInterval: 10];
moveAndPrint = [moveAndPrint createEnd];
[moveAndPrint at: 0 createAction: moveActions];
[moveAndPrint at: 0 createAction: printActions];
emptyActions1 = [ActionGroup create: swarm];
emptyActions2 = [ActionGroup create: swarm];
printRelative = [Schedule createBegin: swarm];
[printRelative setRelativeTime: 1];
printRelative = [printRelative createEnd];
[printRelative at: 0 createActionTo: newTurtle() message: M(print)];
[printRelative at: 4 createAction: emptyActions1];
[printRelative at: 4 createActionTo: newTurtle() message: M(print)];
[printRelative at: 9 createActionTo: newTurtle() message: M(print)];
printRepeat = [Schedule createBegin: swarm];
[printRepeat setRepeatInterval: 10];
printRepeat = [printRepeat createEnd];
[printRepeat at: 0 createActionTo: newTurtle() message: M(print)];
[printRepeat at: 1 createActionTo: newTurtle() message: M(print)];
startSchedule = [Schedule create: swarm];
[startSchedule at: 1 createAction: printRepeat];
[startSchedule at: 2 createActionTo: newTurtle() message: M(print)];
[startSchedule at: 2 createAction: emptyActions2];
[startSchedule at: 2 createAction: printRelative];
[startSchedule at: 18 createAction: printRelative];
[startSchedule at: 21 createAction: printRelative];
[startSchedule at: 34 createAction: printRelative];
[startSchedule at: 5 createActionTo: newTurtle() message: M(print)];
[startSchedule at: 12 createActionTo: newTurtle() message: M(print)];
[startSchedule at: 18 createActionTo: newTurtle() message: M(print)];
[startSchedule at: 10 createActionTo: newTurtle() message: M(print)];
[startSchedule at: 20 createActionTo: newTurtle() message: M(print)];
_activity_trace = trace;
swarmActivity = [swarm activateIn: nil];
[swarm activate: startSchedule];
while ( (status = [swarmActivity run]) != Stopped && status != Completed );
printf( "run return status: %s\n", [status getName] );
[swarmActivity drop];
[_activity_zone xprint];
[moveActions drop];
[printActions drop];
[moveAndPrint drop];
[emptyActions1 drop];
[emptyActions2 drop];
[printRelative drop];
[printRepeat drop];
[startSchedule drop];
[aList deleteAll];
[aList drop];
[[swarm getInternalZone] xprint];
[swarm drop];
return 0;
}
static BOOL trace( id anActivity )
{
id swarmActivity, string;
int level;
timeval_t currentTime = 999999;
char buffer[100];
for ( swarmActivity = anActivity, level = 0;
! respondsTo( swarmActivity, @selector( getSynchronizationSchedule ) );
swarmActivity = [swarmActivity getOwnerActivity], level++ );
currentTime = getCurrentTime();
if ( swarmActivity != getCurrentSwarmActivity() ||
currentTime != [getCurrentScheduleActivity() getCurrentTime] )
raiseEvent( SourceMessage, "context macro mismatch\n" );
_obj_formatIDString( buffer, anActivity );
if ( [anActivity getStatus] == Running ) {
[getCurrentAction() describe: (string = [String create: scratchZone])];
printf( "at time: %lu, level %d, %s, %s",
currentTime, level, buffer, [string getC] );
[string drop];
} else {
printf( "at time: %lu, level %d, %s is %s\n",
currentTime, level, buffer, [[anActivity getStatus] getName] );
}
if ( currentTime < 100 ) return 0;
((Activity_c *)anActivity)->status = Stopped;
return 1;
} |
#import "grid.h"
#import <activity/SwarmProcess.h>
#import <activity.h>
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
static void terminateFunction( void )
{
[getTopLevelActivity() terminate];
}
static void stopFunction( void )
{
printf( "stopping activity at time: %lu\n", getCurrentTime() );
[getTopLevelActivity() stop];
}
int main(void)
{
id aZone, aTurtle;
id simSched1, simSched2, displaySchedule, terminateSchedule;
id simSwarm, obsSwarm, obsSwarmActivity;
// initialize
initModule( grid );
initModule( activity );
aZone = [Zone create: globalZone];
obsSwarm = [SwarmProcess create: aZone];
simSwarm = [SwarmProcess create: obsSwarm];
_activity_zone = [Zone create: globalZone];
// create a turtle to turn and move during simulation
aTurtle = [GridTurtle create: simSwarm];
// create a pair of simulation schedules (repeat intervals of 2 and 4)
simSched1 = [Schedule createBegin: simSwarm];
[simSched1 setRepeatInterval: 2];
simSched1 = [simSched1 createEnd];
[simSched1 at: 0 createActionTo: aTurtle message: M(move:) : (id)10];
simSched2 = [Schedule createBegin: simSwarm];
[simSched2 setRepeatInterval: 4];
simSched2 = [simSched2 createEnd];
[simSched2 at: 0 createActionTo: aTurtle message: M(turn:) : (id)1];
// create a display schedule to print turtle at every time step
displaySchedule = [Schedule createBegin: obsSwarm];
[displaySchedule setRepeatInterval: 1];
displaySchedule = [displaySchedule createEnd];
[displaySchedule at: 0 createActionTo: aTurtle message: M(print)];
// create a schedule to terminate all activity at timestep 32
terminateSchedule = [Schedule create: obsSwarm];
[terminateSchedule at: 8 createActionCall: stopFunction];
[terminateSchedule at: 11 createActionCall: terminateFunction];
obsSwarmActivity = [obsSwarm activateIn: nil];
[obsSwarm activate: terminateSchedule];
[obsSwarm activate: displaySchedule];
[obsSwarm activate: simSwarm];
[simSwarm activate: simSched1];
[simSwarm activate: simSched2];
// run the top-level swarm to completion
while ( [obsSwarmActivity next] != Completed );
[obsSwarmActivity drop];
[_activity_zone xprint];
[aTurtle drop];
[simSched1 drop];
[simSched2 drop];
[simSwarm drop];
[displaySchedule drop];
[terminateSchedule drop];
[[obsSwarm getInternalZone] xprint];
[[obsSwarm getInternalZone] xfprint];
[obsSwarm drop];
[aZone xprint];
[aZone drop];
return 0;
} |
#import "grid.h"
#import <activity.h>
#import <activity/SwarmProcess.h>
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
static void testTerminate( timeval_t terminateTime )
{
if ( getCurrentTime() >= terminateTime )
[getTopLevelActivity() terminate];
}
@interface MySwarm : CSwarmProcess
{
int myVar;
}
- (void) setMyVar: (int)value;
- (void) printMyVar;
@end
@implementation MySwarm
- (void) setMyVar: (int)value
{
myVar = value;
}
- (void) printMyVar
{
printf( "value is %d\n", myVar );
}
@end
int main(void)
{
id aZone, aTurtle;
id simSched1, action1, action2, action3, moveGroup;
id simSched2, displaySchedule, terminateSchedule;
id displaySwarm, simSwarm, swarmActivity;
// initialize
initModule( grid );
initModule( activity );
aZone = [Zone create: globalZone];
displaySwarm = [SwarmProcess create: aZone];
simSwarm = [MySwarm create: displaySwarm];
_activity_zone = [Zone create: globalZone];
// create a turtle to turn and move during simulation
aTurtle = [GridTurtle create: simSwarm];
// create a pair of simulation schedules (repeat intervals of 2 and 4)
simSched1 = [Schedule createBegin: simSwarm];
[simSched1 setRepeatInterval: 2];
simSched1 = [simSched1 createEnd];
action1 = [simSched1 at: 0 createActionTo: aTurtle message: M(move:):(id)10];
moveGroup = [ActionGroup create: simSwarm];
action2 = [moveGroup createActionTo: aTurtle message: M(move:) : (id)-5];
[simSched1 at: 0 createAction: moveGroup];
[simSched1 at: 0 createActionCall: (func_t)testTerminate : (id)20];
simSched2 = [Schedule createBegin: simSwarm];
[simSched2 setRepeatInterval: 4];
simSched2 = [simSched2 createEnd];
[simSched2 at: 0 createActionTo: aTurtle message: M(turn:) : (id)1];
action3 = [simSched2 at: 0 createActionCall: (func_t)testTerminate : (id)10];
// create a display schedule to print turtle at every time step
displaySchedule = [Schedule createBegin: displaySwarm];
[displaySchedule setRepeatInterval: 1];
displaySchedule = [displaySchedule createEnd];
[displaySchedule createActionTo: aTurtle message: M(print)];
// create a schedule to terminate after a while
terminateSchedule = [Schedule create: displaySwarm];
[terminateSchedule at: 10
createActionTo: moveGroup message: M(remove:) : action2];
[terminateSchedule at: 4
createActionTo: simSched2 message: M(remove:) : action3];
[terminateSchedule at: 16 createActionCall: (func_t)testTerminate : (id)16];
// activate top-level swarm
swarmActivity = [displaySwarm activateIn: nil];
// manipulate custom swarm and then activate it
[simSwarm setMyVar: 99];
[simSwarm printMyVar];
[simSwarm activateIn: displaySwarm];
[[[simSwarm getSwarmActivity] getSwarm] printMyVar];
// activate simulation schedules in simulation swarm
[simSched1 activateIn: simSwarm];
[simSched2 activateIn: simSwarm];
// activate display schedules to mix in with simulation swarm
[displaySchedule activateIn: displaySwarm];
[terminateSchedule activateIn: displaySwarm];
// run the top-level swarm to completion
while ( [swarmActivity next] != Completed );
[swarmActivity drop];
[_activity_zone xprint];
return 0;
} |
#import "Mousetrap.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int gridSize = 40;
int printTriggerEvents = 1;
int printSameTickTriggers = 0;
// simulation parameters (these need to be a power of 2)
int triggerLikelihood = 256;
int numberOutputTriggers = 2;
int maxTriggerDistance = 4;
int maxTriggerTime = 16;
// data from the mousetrap world
unsigned numTriggered = 0;
id grid, worldSchedule;
static void testTerminate( void )
{
if ( ! [worldSchedule getCount] ) [getTopLevelActivity() terminate];
}
int main(int argc, char ** argv)
{
id aMousetrap, worldSwarm;
id displaySchedule, observerSwarm, observerActivity, status;
int x, y, stepCount;
initModule( activity );
observerSwarm = [SwarmProcess create: globalZone];
worldSwarm = [SwarmProcess create: observerSwarm];
_activity_zone = [Zone create: globalZone];
// put a mousetrap on every grid point
grid = [Grid2D create: worldSwarm setGridSize: gridSize];
for ( y = 0; y < gridSize; y ++ ) {
for ( x = 0; x < gridSize; x++ ) {
aMousetrap = [Mousetrap create: worldSwarm setXCoord: x setYCoord: y];
[grid atX: x atY: y put: aMousetrap];
}
}
// create the mousetrap world schedule and schedule its first action
worldSchedule = [Schedule createBegin: worldSwarm];
[worldSchedule setAutoDrop: 1];
worldSchedule = [worldSchedule createEnd];
aMousetrap = [grid atX: gridSize/2 atY: gridSize/2];
[worldSchedule at: 0 createActionTo: aMousetrap message: M(trigger)];
// create display schedule and schedule the display events
displaySchedule = [Schedule createBegin: observerSwarm];
[displaySchedule setRepeatInterval: 10];
displaySchedule = [displaySchedule createEnd];
[displaySchedule at: 0 createActionTo:
[grid atX: (gridSize + gridSize/2)/(gridSize/2) atY: gridSize/2]
message: M(printTriggered)];
[displaySchedule at: 0 createActionCall: (func_t)testTerminate];
// create a swarm to combine the display schedule and the world swarm
observerActivity = [observerSwarm activateIn: nil];
[displaySchedule activateIn: observerSwarm];
[worldSwarm activateIn: observerSwarm];
[worldSchedule activateIn: worldSwarm];
// [observerActivity run];
status = [observerActivity stepUntil: 12];
printf( "returned from stepUntil: 12 with status %s\n", [status getName] );
status = [observerActivity stepUntil: 2];
printf( "returned from stepUntil: 2 with status %s\n", [status getName] );
for ( stepCount = 0; [observerActivity step] == Stopped; stepCount++ );
printf( "number of steps: %d\n", stepCount );
printf( "total number of mousetraps triggered: %d\n", numTriggered );
return 0;
} |
#import "Mousetrap.h"
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int gridSize = 40;
int printTriggerEvents = 1;
int printSameTickTriggers = 0;
// simulation parameters (these need to be a power of 2)
int triggerLikelihood = 256;
int numberOutputTriggers = 2;
int maxTriggerDistance = 4;
int maxTriggerTime = 16;
// data from the mousetrap world
unsigned numTriggered = 0;
id grid, worldSchedule;
static void testTerminate( void )
{
int remainingCount;
remainingCount = [worldSchedule getCount];
if ( ! [worldSchedule getCount] ) [getTopLevelActivity() terminate];
}
int main(int argc, char ** argv)
{
id aZone, aMousetrap, subschedType, subgroup;
id displaySchedule, observerSwarm, observerActivity;
id worldSwarm, worldActivity;
int x, y, stepCount;
initModule( activity );
aZone = globalZone;
// put a mousetrap on every grid point
grid = [Grid2D create: aZone setGridSize: gridSize];
for ( y = 0; y < gridSize; y ++ ) {
for ( x = 0; x < gridSize; x++ ) {
aMousetrap = [Mousetrap create: aZone setXCoord: x setYCoord: y];
[grid atX: x atY: y put: aMousetrap];
}
}
// create the mousetrap world schedule and schedule its first action
subschedType = [ConcurrentSchedule customizeBegin: aZone];
[subschedType setAutoDrop: 1];
subschedType = [subschedType customizeEnd];
worldSchedule = [Schedule createBegin: aZone];
[worldSchedule setAutoDrop: 1];
[worldSchedule setConcurrentGroupType: subschedType];
worldSchedule = [worldSchedule createEnd];
aMousetrap = [grid atX: gridSize/2 atY: gridSize/2];
subgroup = [worldSchedule insertGroup: (id)0];
[subgroup at: 0 createActionTo: aMousetrap message: M(trigger)];
// create display schedule and schedule the display events
displaySchedule = [Schedule createBegin: aZone];
[displaySchedule setRepeatInterval: 1];
displaySchedule = [displaySchedule createEnd];
[displaySchedule at: 0 createActionTo:
[grid atX: (gridSize + gridSize/2)/(gridSize/2) atY: gridSize/2]
message: M(printTriggered)];
[displaySchedule at: 0 createActionCall: (func_t)testTerminate];
// create a swarm to combine the display schedule and the world swarm
observerSwarm = [SwarmProcess create: aZone];
observerActivity = [observerSwarm activateIn: nil];
[displaySchedule activateIn: observerSwarm];
worldSwarm = [SwarmProcess create: aZone];
worldActivity = [worldSwarm activateIn: observerSwarm];
subgroup = [worldSchedule activateIn: worldSwarm];
// [observerActivity run];
for ( stepCount = 0; [observerActivity step] == Stopped; stepCount++ );
printf( "number of steps: %d\n", stepCount );
printf( "total number of mousetraps triggered: %d\n", numTriggered );
return 0;
} |
#import <collections.h>
#define __USE_FIXED_PROTOTYPES__ // for gcc headers
#include <stdio.h>
int main( void )
{
id aZone, s1, s2, s3, t1, FooBarString, s4;
initModule( collections );
aZone = [Zone create: globalZone];
t1 = [String customizeBegin: aZone];
[t1 setC: "foobar"];
FooBarString = [t1 customizeEnd];
printf( "FooBarString id is: %0#8x\n", (unsigned int)FooBarString );
[FooBarString drop];
[aZone xprint];
if ( _obj_debug ) exit(0);
s1 = [String create: aZone setC: "abcdef"];
printf( "string is: %s\n", [s1 getC] );
[s1 setC: "foo"];
printf( "string is: %s\n", [s1 getC] );
[s1 catC: "bar"];
printf( "string is: %s\n", [s1 getC] );
[s1 drop];
s2 = [String create: aZone];
[s2 setC: ""];
printf( "string is: %s\n", [s2 getC] );
[s2 catC: "foo"];
printf( "string is: %s\n", [s2 getC] );
[s2 drop];
s3 = [String create: aZone];
printf( "string is: %s\n", [s3 getC] );
[s3 catC: "foo"];
printf( "string is: %s\n", [s3 getC] );
s4 = [s3 perform: @selector( copy: ) with: aZone];
[s4 catC: "FOO"];
printf( "string is: %s\n", [s4 getC] );
[s3 drop];
[s4 drop];
[aZone xprint];
t1 = [String customizeBegin: aZone];
[t1 setC: "foobar"];
FooBarString = [t1 customizeEnd];
printf( "FooBarString id is: %0#8x\n", (unsigned int)FooBarString );
[FooBarString drop];
[aZone xprint];
if ( _obj_debug ) exit(0);
s4 = [FooBarString create: aZone];
printf( "string is: %s id is: %0#8x\n", [s4 getC], (unsigned int)s4 );
[s4 catC: "foo"];
printf( "string is: %s\n", [s4 getC] );
s1 = [OutputStream create: scratchZone setFileStream: _obj_xdebug];
[s1 catC: "output string\n"];
[s1 drop];
s1 = [OutputStream createBegin: scratchZone];
[s1 setFileStream: _obj_xdebug];
s1 = [s1 createEnd];
[s1 catC: "output string\n"];
[s1 drop];
[s4 xprint];
[s4 setC: "long output string that just keeps going and going and going\n"];
[s4 xprint];
[s4 drop];
[FooBarString xprint];
[FooBarString drop];
[aZone xprint];
[aZone drop];
return 0;
} |