#define EXTERN /* allocate extern var's in this file */
#include "mas-slave.h"
#define NULL 0

int mas_slave_is_defined = 1; /* To catch mult. versions. */

int master_slave_trace = FALSE;
void (*master_slave_trace_cmd)() = NULL;/*takes two arg's: dest, task/result */
static void trace_cmd_default(dest, msg) { printf("0x%x (%d)", msg, msg); }
void init_master_slave() { return; }
void master_slave_stats() { return; }

static void *mas_slave_stack_loc; /* Initialized by master_slave() */
void error_if_msg_on_stack(msg)
void *msg;
{ int stack_loc2;
    if ( (msg < (void *)&stack_loc2) && (msg > mas_slave_stack_loc)
         || (msg > (void *)&stack_loc2) && (msg < mas_slave_stack_loc) ) {
     printf("TOPC: error(get_task/do_task): MSG() returned pointer into stack.\n");
     printf(" Buffer referenced by MSG() should either be static or global.\n");
     exit(1);
} }

int is_up_to_date() { return 1; }
void ms_barrier() { return; }

/* The user shouldn't be calling this on a slave, since it would
   always return 0 (for master).  So, 1 should usually be the right answer. */
int get_last_source() { return 1; }

/* This can be a lie.  We used this to avoid the space/time inefficiency of
   computing a data structure on all slaves. */
int is_master() { return 1; }
/* If master called this, is_master() should have been enough */
int myid() { return 1; }

void *cont_task = NULL;

int CONTINUATION(task)
void *task;
{ cont_task = task; return CONTINUE; }

void master_slave(get_task, do_task, get_task_result, update_environment)
     void *(*get_task)(), *(*do_task)(), (*update_environment)();
     int (*get_task_result)();
{ void *task, *result;
  int action;
  if (master_slave_trace_cmd == NULL)
    master_slave_trace_cmd = trace_cmd_default; /* else user trace */
  mas_slave_stack_loc = &task; /* Used by error_if_msg_on_stack() */
  while ( (mas_slave_is_task = TRUE,
           task = ( cont_task == NULL ? (*get_task)() : cont_task),
           mas_slave_is_task) ) {
    cont_task = NULL;
    if (master_slave_trace == TRUE)
      { printf("TRACE: 0 -> 1: ");
        (*master_slave_trace_cmd)(1, task); /* dest is 1 */
        printf("\n"); }
    result = (*do_task)(task);
  if (master_slave_trace == TRUE)
    { printf("TRACE: 1 -> 0: ");
      (*master_slave_trace_cmd)(0, result); /* dest is 0 */
      printf("\n"); }
    action = (*get_task_result)(result, task);
    switch (action) {
      default: printf("illegal return value of GetTaskResult\n"); exit(1);
      case REDO: printf("REDO isn't useful in sequential case\n"); exit(1);
      case UPDATE:
        if (update_environment != NULL) (*update_environment)(result, task);
      case NO_ACTION: ;
      case CONTINUE: ;
} } }